diff --git a/README.md b/README.md
index 0519ecba..ff7ab329 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,38 @@
- 
\ No newline at end of file
+## Mechanica, a 2D Game Engine in Kotlin
+A powerful 2D Game Engine written in Kotlin. This project is still under development and it is not 
+thoroughly tested or documented but feel free to try it out nonetheless
+
+### Setting up the project with Gradle
+Clone or download the repository and build with gradle
+
+Create a new Project with gradle. In the `settings.gradle` file add:
+
+```kotlin
+includeBuild("C:/path/to/mechanica")
+```
+And in the `build.gradle` file add a dependency on the project:
+```kotlin
+dependencies {
+    implementation("com.mechanica.engine:mechanica:1.0")
+}
+```
+
+In the new project create a main method with something similar to the following:
+```kotlin
+fun main() {
+    Game.configure {
+        setViewport(height = 10.0)
+    }
+
+    // Create an instance of the Drawer class,
+    // it can be used to draw anything from rounded rectangles to custom shaders
+    val draw = Drawer.create()
+
+    // Start the game loop and draw text to the screen
+    Game.run {
+        draw.centered.grey.text("Hello, Mechanica")
+    }
+}
+```
+
+More samples can be seen in the `samples` module in Mechanica
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/audio/AudioFile.kt b/application-interface/src/main/kotlin/com/mechanica/engine/audio/AudioFile.kt
new file mode 100644
index 00000000..1ab8b1b3
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/audio/AudioFile.kt
@@ -0,0 +1,10 @@
+package com.mechanica.engine.audio
+
+import java.nio.ShortBuffer
+
+interface AudioFile {
+    val channels: Int
+    val sampleRate: Int
+    val buffer: ShortBuffer
+    val format: Int
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/audio/AudioObject.kt b/application-interface/src/main/kotlin/com/mechanica/engine/audio/AudioObject.kt
new file mode 100644
index 00000000..d5ba48c2
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/audio/AudioObject.kt
@@ -0,0 +1,9 @@
+package com.mechanica.engine.audio
+
+import org.joml.Vector3f
+
+interface AudioObject {
+    var gain: Float
+    var position: Vector3f
+    var velocity: Vector3f
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/audio/Listener.kt b/application-interface/src/main/kotlin/com/mechanica/engine/audio/Listener.kt
new file mode 100644
index 00000000..21dbe662
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/audio/Listener.kt
@@ -0,0 +1,24 @@
+package com.mechanica.engine.audio
+
+import com.mechanica.engine.context.loader.GLLoader
+import org.joml.Vector3f
+
+interface Listener : AudioObject {
+    var distanceModel: DistanceModel
+    val orientation: Orientaion
+
+    interface Orientaion {
+        var at: Vector3f
+        var up: Vector3f
+    }
+
+    companion object : Listener by GLLoader.audioLoader.listener()
+
+    enum class DistanceModel {
+        INVERSE,
+        LINEAR,
+        EXPONENTIAL;
+
+        var clamped: Boolean = false
+    }
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/audio/Sound.kt b/application-interface/src/main/kotlin/com/mechanica/engine/audio/Sound.kt
new file mode 100644
index 00000000..f44acd54
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/audio/Sound.kt
@@ -0,0 +1,7 @@
+package com.mechanica.engine.audio
+
+interface Sound : AudioFile {
+    val id: Int
+    val frequency: Int
+    fun destroy()
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/audio/SoundSource.kt b/application-interface/src/main/kotlin/com/mechanica/engine/audio/SoundSource.kt
new file mode 100644
index 00000000..9ed375a3
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/audio/SoundSource.kt
@@ -0,0 +1,21 @@
+package com.mechanica.engine.audio
+
+import com.mechanica.engine.context.loader.GLLoader
+import com.mechanica.engine.resources.AudioResource
+
+interface SoundSource : AudioObject {
+    val id: Int
+    val sound: Sound
+    var pitch: Float
+    var rolloff: Float
+    var maxDistance: Float
+    var referenceDistance: Float
+    fun play()
+    fun pause()
+    fun stop()
+    fun destroy()
+
+    companion object {
+        fun create(res: AudioResource) = GLLoader.audioLoader.source(res.sound)
+    }
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/configuration/Configurable.kt b/application-interface/src/main/kotlin/com/mechanica/engine/configuration/Configurable.kt
new file mode 100644
index 00000000..4625d7be
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/configuration/Configurable.kt
@@ -0,0 +1,7 @@
+package com.mechanica.engine.configuration
+
+import com.mechanica.engine.context.Application
+
+interface Configurable<T> {
+    fun configureAs(application: Application, setup: T.() -> Unit)
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/context/Application.kt b/application-interface/src/main/kotlin/com/mechanica/engine/context/Application.kt
new file mode 100644
index 00000000..4bafd922
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/context/Application.kt
@@ -0,0 +1,13 @@
+package com.mechanica.engine.context
+
+import com.mechanica.engine.display.Window
+
+interface Application {
+
+    fun initialize(window: Window)
+
+    fun terminate()
+
+    fun startFrame()
+
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/context/GLInitializer.kt b/application-interface/src/main/kotlin/com/mechanica/engine/context/GLInitializer.kt
index c67dd1ed..5de13231 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/context/GLInitializer.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/context/GLInitializer.kt
@@ -1,5 +1,7 @@
 package com.mechanica.engine.context
 
+import com.mechanica.engine.context.callbacks.EventCallbacks
+import com.mechanica.engine.context.loader.DisplayLoader
 import com.mechanica.engine.context.loader.GLLoader
 
 object GLInitializer {
@@ -7,9 +9,20 @@ object GLInitializer {
     internal val loader: GLLoader
         get() = _loader ?: throw UninitializedPropertyAccessException("The OpenGL context has not been initialized")
 
-    fun initialize(loader: GLLoader) {
+    private var _displayLoader: DisplayLoader? = null
+    internal val displayLoader: DisplayLoader
+        get() = _displayLoader ?: throw UninitializedPropertyAccessException("The OpenGL context has not been initialized")
+
+    fun initializeDisplay(loader: DisplayLoader) {
+        if (_loader == null) {
+            _displayLoader = loader
+        } else throw IllegalStateException("The Display context has already been initialized")
+    }
+
+    fun initialize(loader: GLLoader): EventCallbacks {
         if (_loader == null) {
             _loader = loader
+            return EventCallbacks.create()
         } else throw IllegalStateException("The OpenGl context has already been initialized")
     }
 }
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/context/callbacks/EventCallbacks.kt b/application-interface/src/main/kotlin/com/mechanica/engine/context/callbacks/EventCallbacks.kt
new file mode 100644
index 00000000..03528e88
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/context/callbacks/EventCallbacks.kt
@@ -0,0 +1,20 @@
+package com.mechanica.engine.context.callbacks
+
+import com.mechanica.engine.input.TextInput
+
+interface EventCallbacks {
+    val keyboardHandler: KeyboardHandler
+    val mouseHandler: MouseHandler
+
+    companion object {
+        fun prepare() {
+            TextInput.prepare()
+            MouseHandler.prepare()
+        }
+
+        internal fun create(): EventCallbacks = object : EventCallbacks {
+            override val keyboardHandler = KeyboardHandler.create()
+            override val mouseHandler = MouseHandler.create()
+        }
+    }
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/context/callbacks/KeyboardHandler.kt b/application-interface/src/main/kotlin/com/mechanica/engine/context/callbacks/KeyboardHandler.kt
new file mode 100644
index 00000000..2717c0c2
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/context/callbacks/KeyboardHandler.kt
@@ -0,0 +1,18 @@
+package com.mechanica.engine.context.callbacks
+
+import com.mechanica.engine.input.KeyInput
+import com.mechanica.engine.input.TextInput
+
+interface KeyboardHandler {
+    fun keyPressed(key: Int)
+    fun keyReleased(key: Int)
+    fun textInput(codepoint: Int)
+
+    companion object {
+        internal fun create(): KeyboardHandler = object : KeyboardHandler {
+            override fun keyPressed(key: Int) = KeyInput.addPressed(key)
+            override fun keyReleased(key: Int) = KeyInput.removePressed(key)
+            override fun textInput(codepoint: Int) = TextInput.addCodePoint(codepoint)
+        }
+    }
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/context/callbacks/MouseHandler.kt b/application-interface/src/main/kotlin/com/mechanica/engine/context/callbacks/MouseHandler.kt
new file mode 100644
index 00000000..59cd127d
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/context/callbacks/MouseHandler.kt
@@ -0,0 +1,57 @@
+package com.mechanica.engine.context.callbacks
+
+import com.mechanica.engine.input.KeyInput
+
+interface MouseHandler {
+    fun buttonPressed(key: Int)
+    fun buttonReleased(key: Int)
+    fun cursorMoved(x: Double, y: Double)
+    fun scroll(x: Double, y: Double)
+
+    companion object {
+        var cursorX: Double = 0.0
+            private set
+        var cursorY: Double = 0.0
+            private set
+
+        var scrollX: Double = 0.0
+            private set
+        var scrollY: Double = 0.0
+            private set
+
+        internal fun prepare() {
+            KeyInput.removePressed(1000)
+            KeyInput.removePressed(1001)
+            KeyInput.removePressed(1002)
+            scrollX = 0.0
+            scrollY = 0.0
+        }
+
+        internal fun create() = object : MouseHandler {
+            override fun buttonPressed(key: Int) {
+                KeyInput.addPressed(key)
+            }
+
+            override fun buttonReleased(key: Int) {
+                KeyInput.removePressed(key)
+            }
+
+            override fun cursorMoved(x: Double, y: Double) {
+                cursorX = x
+                cursorY = y
+            }
+
+            override fun scroll(x: Double, y: Double) {
+                if (y > 0.0) {
+                    KeyInput.addPressed(1000)
+                } else if (y < 0.0) {
+                    KeyInput.addPressed(1001)
+                }
+                KeyInput.addPressed(1002)
+                scrollX = x
+                scrollY = y
+            }
+
+        }
+    }
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/AudioLoader.kt b/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/AudioLoader.kt
new file mode 100644
index 00000000..57ee71c6
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/AudioLoader.kt
@@ -0,0 +1,11 @@
+package com.mechanica.engine.context.loader
+
+import com.mechanica.engine.audio.Listener
+import com.mechanica.engine.audio.Sound
+import com.mechanica.engine.audio.SoundSource
+
+interface AudioLoader {
+    fun sound(file: String): Sound
+    fun source(sound: Sound): SoundSource
+    fun listener(): Listener
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/BufferLoader.kt b/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/BufferLoader.kt
index b2deb82a..8b10824b 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/BufferLoader.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/BufferLoader.kt
@@ -1,5 +1,6 @@
 package com.mechanica.engine.context.loader
 
+import com.mechanica.engine.audio.AudioFile
 import java.nio.ByteBuffer
 import java.nio.FloatBuffer
 import java.nio.IntBuffer
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/DisplayLoader.kt b/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/DisplayLoader.kt
new file mode 100644
index 00000000..37ddd905
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/DisplayLoader.kt
@@ -0,0 +1,17 @@
+package com.mechanica.engine.context.loader
+
+import com.mechanica.engine.context.GLInitializer
+import com.mechanica.engine.display.Monitor
+import com.mechanica.engine.display.Window
+
+interface DisplayLoader {
+    fun createWindow(title: String, width: Int, height: Int): Window
+    fun createWindow(title: String, monitor: Monitor): Window
+    fun createWindow(title: String, width: Int, height: Int, monitor: Monitor): Window
+
+    val allMonitors: Array<out Monitor>
+
+    fun getPrimaryMonitor(): Monitor
+
+    companion object : DisplayLoader by GLInitializer.displayLoader
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/FontLoader.kt b/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/FontLoader.kt
index bfdd2f76..a9380c8e 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/FontLoader.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/FontLoader.kt
@@ -2,9 +2,10 @@ package com.mechanica.engine.context.loader
 
 import com.mechanica.engine.text.Font
 import com.mechanica.engine.resources.Resource
+import com.mechanica.engine.text.FontAtlasConfiguration
 
 interface FontLoader {
     val defaultFont: Font
-    fun font(res: Resource): Font
+    fun font(res: Resource, initializer: FontAtlasConfiguration.() -> Unit): Font
 
 }
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/GLLoader.kt b/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/GLLoader.kt
index a4089731..480ddfe0 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/GLLoader.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/GLLoader.kt
@@ -3,6 +3,8 @@ package com.mechanica.engine.context.loader
 import com.mechanica.engine.context.GLInitializer
 import com.mechanica.engine.shader.qualifiers.AttributeQualifier
 import com.mechanica.engine.shader.qualifiers.Qualifier
+import com.mechanica.engine.shader.script.Shader
+import com.mechanica.engine.shader.script.ShaderScript
 import com.mechanica.engine.vertices.ElementArrayType
 
 interface GLLoader {
@@ -11,10 +13,17 @@ interface GLLoader {
     val bufferLoader: BufferLoader
     val fontLoader: FontLoader
     val graphicsLoader: GraphicsLoader
+    val audioLoader: AudioLoader
+    val inputLoader: InputLoader
 
     fun createAttributeLoader(qualifier: AttributeQualifier): AttributeLoader
     fun createUniformLoader(qualifier: Qualifier): UniformLoader
     fun createElementArray(): ElementArrayType
+    fun defaultShader(
+            vertex: ShaderScript,
+            fragment: ShaderScript,
+            tessellation: ShaderScript?,
+            geometry: ShaderScript?): Shader
 
     companion object : GLLoader by GLInitializer.loader
 }
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/InputLoader.kt b/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/InputLoader.kt
new file mode 100644
index 00000000..04e44b1d
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/InputLoader.kt
@@ -0,0 +1,7 @@
+package com.mechanica.engine.context.loader
+
+import com.mechanica.engine.input.KeyIDs
+
+interface InputLoader {
+    fun keyIds(): KeyIDs
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/UniformLoader.kt b/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/UniformLoader.kt
index b197b05c..dcf7d5bf 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/UniformLoader.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/context/loader/UniformLoader.kt
@@ -1,7 +1,7 @@
 package com.mechanica.engine.context.loader
 
 import com.mechanica.engine.shader.qualifiers.Qualifier
-import com.mechanica.engine.shader.vars.uniforms.vars.*
+import com.mechanica.engine.shader.uniforms.vars.*
 import org.joml.Matrix4f
 
 interface UniformLoader {
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/display/Monitor.kt b/application-interface/src/main/kotlin/com/mechanica/engine/display/Monitor.kt
new file mode 100644
index 00000000..6f9114b9
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/display/Monitor.kt
@@ -0,0 +1,27 @@
+package com.mechanica.engine.display
+
+import com.mechanica.engine.context.loader.DisplayLoader
+import com.mechanica.engine.context.loader.GLLoader
+
+
+interface Monitor {
+    val id: Long
+    val name: String
+    val size: Size
+    val contentScale: ContentScale
+
+    val width: Int
+    val height: Int
+
+    data class Size(val width_mm: Int, val height_mm: Int)
+    data class ContentScale(val xScale: Float, val yScale: Float)
+
+    companion object {
+        val allMonitors: Array<out Monitor>
+            get() = DisplayLoader.allMonitors
+
+        fun getPrimaryMonitor(): Monitor {
+            return DisplayLoader.getPrimaryMonitor()
+        }
+    }
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/display/Window.kt b/application-interface/src/main/kotlin/com/mechanica/engine/display/Window.kt
new file mode 100644
index 00000000..c370ed12
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/display/Window.kt
@@ -0,0 +1,66 @@
+package com.mechanica.engine.display
+
+import com.mechanica.engine.context.loader.DisplayLoader
+import com.mechanica.engine.resources.Resource
+import java.nio.ByteBuffer
+
+interface Window {
+    val title: String
+    val id: Long
+    val width: Int
+    val height: Int
+    val aspectRatio: Double
+    var isFocused: Boolean
+    var isIconified: Boolean
+    var isMaximized: Boolean
+    val isHovered: Boolean
+    var isVisible: Boolean
+    var isResizable: Boolean
+    var isDecorated: Boolean
+    var isFloating: Boolean
+    var vSync: Boolean
+    var opacity: Float
+    val position: Position
+    val resolution: Dimension
+    val size: Dimension
+    val isResizing: Boolean
+    var shouldClose: Boolean
+    val isFullscreen: Boolean
+
+    fun addRefreshCallback(callback: (Window) -> Unit)
+    fun requestAttention()
+    fun setIcon(resource: Resource)
+    fun setIcon(width: Int, height: Int, imageBuffer: ByteBuffer)
+    fun setFullscreen()
+    fun setFullscreen(monitor: Monitor)
+    fun setFullscreen(monitor: Monitor, width: Int, height: Int, refreshRate: Int = 60)
+    fun exitFullscreen(width: Int = -1, height: Int = -1)
+    fun destroy()
+    fun update(): Boolean
+
+    interface Dimension {
+        val width: Int
+        val height: Int
+    }
+
+    interface Position {
+        var x: Int
+        var y: Int
+
+        fun set(x: Int, y: Int)
+    }
+
+    companion object {
+        fun create(title: String, width: Int, height: Int): Window {
+            return DisplayLoader.createWindow(title, width, height)
+        }
+
+        fun create(title: String, monitor: Monitor): Window {
+            return DisplayLoader.createWindow(title, monitor)
+        }
+
+        fun create(title: String, width: Int, height: Int, monitor: Monitor): Window {
+            return DisplayLoader.createWindow(title, width, height, monitor)
+        }
+    }
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/input/KeyID.kt b/application-interface/src/main/kotlin/com/mechanica/engine/input/KeyID.kt
new file mode 100644
index 00000000..fd7fb00e
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/input/KeyID.kt
@@ -0,0 +1,6 @@
+package com.mechanica.engine.input
+
+interface KeyID {
+    val id: Int
+    val label: String
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/input/KeyIDs.kt b/application-interface/src/main/kotlin/com/mechanica/engine/input/KeyIDs.kt
new file mode 100644
index 00000000..8e05518b
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/input/KeyIDs.kt
@@ -0,0 +1,141 @@
+package com.mechanica.engine.input
+
+import com.mechanica.engine.context.loader.GLLoader
+
+interface KeyIDs {
+    val UNKNOWN: KeyID
+    val M1: KeyID
+    val M2: KeyID
+    val M3: KeyID
+    val M4: KeyID
+    val M5: KeyID
+    val M6: KeyID
+    val M7: KeyID
+    val M8: KeyID
+    val SPACE: KeyID
+    val APOSTROPHE: KeyID
+    val COMMA: KeyID
+    val MINUS: KeyID
+    val PERIOD: KeyID
+    val SLASH: KeyID
+    val N0: KeyID
+    val N1: KeyID
+    val N2: KeyID
+    val N3: KeyID
+    val N4: KeyID
+    val N5: KeyID
+    val N6: KeyID
+    val N7: KeyID
+    val N8: KeyID
+    val N9: KeyID
+    val SEMICOLON: KeyID
+    val EQUAL: KeyID
+    val A: KeyID
+    val B: KeyID
+    val C: KeyID
+    val D: KeyID
+    val E: KeyID
+    val F: KeyID
+    val G: KeyID
+    val H: KeyID
+    val I: KeyID
+    val J: KeyID
+    val K: KeyID
+    val L: KeyID
+    val M: KeyID
+    val N: KeyID
+    val O: KeyID
+    val P: KeyID
+    val Q: KeyID
+    val R: KeyID
+    val S: KeyID
+    val T: KeyID
+    val U: KeyID
+    val V: KeyID
+    val W: KeyID
+    val X: KeyID
+    val Y: KeyID
+    val Z: KeyID
+    val LEFT_BRACKET: KeyID
+    val BACKSLASH: KeyID
+    val RIGHT_BRACKET: KeyID
+    val GRAVE_ACCENT: KeyID
+    val WORLD_1: KeyID
+    val WORLD_2: KeyID
+    val ESC: KeyID
+    val ENTER: KeyID
+    val TAB: KeyID
+    val BACKSPACE: KeyID
+    val INSERT: KeyID
+    val DELETE: KeyID
+    val RIGHT: KeyID
+    val LEFT: KeyID
+    val DOWN: KeyID
+    val UP: KeyID
+    val PAGE_UP: KeyID
+    val PAGE_DOWN: KeyID
+    val HOME: KeyID
+    val END: KeyID
+    val CAPS_LOCK: KeyID
+    val SCROLL_LOCK: KeyID
+    val NUM_LOCK: KeyID
+    val PRINT_SCREEN: KeyID
+    val PAUSE: KeyID
+    val F1: KeyID
+    val F2: KeyID
+    val F3: KeyID
+    val F4: KeyID
+    val F5: KeyID
+    val F6: KeyID
+    val F7: KeyID
+    val F8: KeyID
+    val F9: KeyID
+    val F10: KeyID
+    val F11: KeyID
+    val F12: KeyID
+    val F13: KeyID
+    val F14: KeyID
+    val F15: KeyID
+    val F16: KeyID
+    val F17: KeyID
+    val F18: KeyID
+    val F19: KeyID
+    val F20: KeyID
+    val F21: KeyID
+    val F22: KeyID
+    val F23: KeyID
+    val F24: KeyID
+    val F25: KeyID
+    val KP_0: KeyID
+    val KP_1: KeyID
+    val KP_2: KeyID
+    val KP_3: KeyID
+    val KP_4: KeyID
+    val KP_5: KeyID
+    val KP_6: KeyID
+    val KP_7: KeyID
+    val KP_8: KeyID
+    val KP_9: KeyID
+    val KP_DECIMAL: KeyID
+    val KP_DIVIDE: KeyID
+    val KP_MULTIPLY: KeyID
+    val KP_SUBTRACT: KeyID
+    val KP_ADD: KeyID
+    val KP_ENTER: KeyID
+    val KP_EQUAL: KeyID
+    val LSHIFT: KeyID
+    val LCTRL: KeyID
+    val LALT: KeyID
+    val LEFT_SUPER: KeyID
+    val RSHIFT: KeyID
+    val RCTRL: KeyID
+    val RALT: KeyID
+    val RIGHT_SUPER: KeyID
+    val MENU: KeyID
+
+    val SCROLL_UP: KeyID
+    val SCROLL_DOWN: KeyID
+    val SCROLL: KeyID
+
+    companion object : KeyIDs by GLLoader.inputLoader.keyIds()
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/input/KeyInput.kt b/application-interface/src/main/kotlin/com/mechanica/engine/input/KeyInput.kt
new file mode 100644
index 00000000..506b1acc
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/input/KeyInput.kt
@@ -0,0 +1,27 @@
+package com.mechanica.engine.input
+
+object KeyInput {
+
+    var pressedKeyCount: Int = 0
+        private set
+    val any: Boolean
+        get() = pressedKeyCount > 0
+    private val pressedKeys = BooleanArray(1500)
+
+    fun isPressed(keyId: Int) = pressedKeys[keyId]
+
+    internal fun addPressed(key: Int) {
+        pressedKeyCount++
+        if (key >= 0) {
+            pressedKeys[key] = true
+        }
+    }
+
+    internal fun removePressed(key: Int) {
+        if (pressedKeyCount > 0) pressedKeyCount--
+        if (key >= 0) {
+            pressedKeys[key] = false
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/input/TextInput.kt b/application-interface/src/main/kotlin/com/mechanica/engine/input/TextInput.kt
new file mode 100644
index 00000000..c51e40d9
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/input/TextInput.kt
@@ -0,0 +1,41 @@
+package com.mechanica.engine.input
+
+import com.mechanica.engine.context.callbacks.KeyboardHandler
+import com.mechanica.engine.util.NullTerminatedChars
+
+object TextInput {
+
+    @PublishedApi
+    internal val codepoints = NullTerminatedChars(10)
+    var textInputCount: Int = 0
+        private set
+    val hasTextInput: Boolean
+        get() = textInputCount != 0
+
+    internal fun prepare() {
+        codepoints.clear()
+        textInputCount = 0
+    }
+
+    fun getCodepoints(sb: StringBuilder, offset: Int = -1): Int {
+        return codepoints.get(sb, offset)
+    }
+
+    fun getCodepoints(charArray: CharArray) {
+        codepoints.get(charArray)
+    }
+
+    fun getCodepoints(chars: NullTerminatedChars) {
+        codepoints.get(chars)
+    }
+
+    internal fun addCodePoint(cp: Int) {
+        codepoints.addCodePoint(cp)
+        textInputCount++
+    }
+
+    inline fun forEachChar(operation: (Char) -> Unit) {
+        codepoints.forEach(operation)
+    }
+
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/models/ImageModel.kt b/application-interface/src/main/kotlin/com/mechanica/engine/models/ImageModel.kt
index 46c86093..3afdd947 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/models/ImageModel.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/models/ImageModel.kt
@@ -1,8 +1,16 @@
 package com.mechanica.engine.models
 
+import com.mechanica.engine.shader.qualifiers.Attribute
+
 class ImageModel(image: Image, vararg inputs: Bindable)
     : Model(image, *inputs) {
 
+    constructor(image: Image)
+            : this(image,
+            Attribute.location(0).vec3().createUnitQuad(),
+            Attribute.location(1).vec2().createInvertedUnitQuad()
+    )
+
     var image: Image
         get() = inputs[0] as Image
         set(value) {
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/models/Model.kt b/application-interface/src/main/kotlin/com/mechanica/engine/models/Model.kt
index d73270de..5243239b 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/models/Model.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/models/Model.kt
@@ -24,7 +24,11 @@ open class Model(vararg inputs: Bindable,
 
     fun bind() {
         for (vbo in inputs) {
-            vbo.bind()
+            if (vbo is VertexBuffer<*>) {
+                vbo.safeBind()
+            } else {
+                vbo.bind()
+            }
         }
     }
 
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/models/TextModel.kt b/application-interface/src/main/kotlin/com/mechanica/engine/models/TextModel.kt
index a935ab12..afc6bd85 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/models/TextModel.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/models/TextModel.kt
@@ -8,13 +8,14 @@ import com.mechanica.engine.utils.createIndicesArrayForQuads
 import com.mechanica.engine.vertices.AttributeArray
 import com.mechanica.engine.vertices.IndexArray
 import com.mechanica.engine.vertices.FloatBufferMaker
+import kotlin.math.max
 
 class TextModel(text: Text,
                 positionBufferMaker: FloatBufferMaker = Attribute(0).vec3(),
                 texCoordsBufferMaker: FloatBufferMaker = Attribute(1).vec2()) : Model(
         positionBufferMaker.createBuffer(text.positions),
         texCoordsBufferMaker.createBuffer(text.texCoords),
-        IndexArray.create(*createIndicesArrayForQuads(20)),
+        IndexArray.create(*createIndicesArrayForQuads(max(text.positions.size/2, 20))),
         Image.invoke(text.font.atlas.id),
         draw = { model ->
             GLLoader.graphicsLoader.drawElements(model)
@@ -24,13 +25,23 @@ class TextModel(text: Text,
     private val texCoordsAttribute = inputs[1] as AttributeArray
     private val indexArray = inputs[2] as IndexArray
 
-    private var textHolder: Text = text
+    private var atlas
+        get() = inputs[3] as Image
+        set(value) {
+            inputs[3] = value
+        }
 
-    var text: String = textHolder.text
+    var textHolder: Text = text
         set(value) {
+            atlas = value.font.atlas
             field = value
-            textHolder.text = value
-            updateTextHolder()
+        }
+
+    var string: String
+        get() = textHolder.string
+        set(value) {
+            textHolder.string = value
+            updateTextHolder(textHolder)
         }
 
     val lineCount: Int
@@ -44,20 +55,17 @@ class TextModel(text: Text,
     }
 
     fun setText(text: Text) {
-        if (text.text != this.text || textHolder != text) {
-            this.textHolder = text
-            this.text = textHolder.text
-            updateTextHolder()
-        }
+        this.textHolder = text
+        updateTextHolder(text)
     }
 
-    private fun updateTextHolder() {
-        positionAttribute.set(textHolder.positions, 0, textHolder.vertexCount)
-        texCoordsAttribute.set(textHolder.texCoords, 0, textHolder.vertexCount)
-        vertexCount = textHolder.vertexCount
+    private fun updateTextHolder(text: Text) {
+        positionAttribute.set(text.positions, 0, text.vertexCount)
+        texCoordsAttribute.set(text.texCoords, 0, text.vertexCount)
+        vertexCount = text.vertexCount
 
         if (vertexCount > indexArray.vertexCount) {
-            indexArray.set(createIndicesArrayForQuads(vertexCount*2/6))
+            indexArray.set(createIndicesArrayForQuads(vertexCount))
         }
     }
 
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/persistence/PersistenceMap.kt b/application-interface/src/main/kotlin/com/mechanica/engine/persistence/PersistenceMap.kt
new file mode 100644
index 00000000..6c8fe36c
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/persistence/PersistenceMap.kt
@@ -0,0 +1,68 @@
+package com.mechanica.engine.persistence
+
+import com.mechanica.engine.resources.ExternalResource
+import com.mechanica.engine.util.StringMapSerializer
+import kotlinx.serialization.UnstableDefault
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonConfiguration
+import java.io.FileNotFoundException
+
+class PersistenceMap private constructor(private val path: String, private val map: HashMap<String, Any>) : Map<String, Any> by map {
+    constructor(path: String) : this(path, HashMap())
+
+    private val serializer = StringMapSerializer()
+
+    fun store() {
+        val json = Json(JsonConfiguration.Stable)
+        val string = json.stringify(serializer, map)
+        val file = ExternalResource(path, true)
+        file.write(string)
+    }
+
+    @OptIn(UnstableDefault::class)
+    fun populate() {
+        val string = try {
+            val file = ExternalResource(path, false)
+            file.contents
+        } catch (ex: FileNotFoundException) {
+            "{}"
+        }
+
+        val map = Json.parse(serializer, string)
+        map.forEach {
+            this.map[it.key] = it.value
+        }
+    }
+
+    fun put(name: String, value: Any) {
+        map[name] = value
+    }
+
+    fun getDouble(name: String, default: Double = 0.0): Double {
+        return map[name] as? Double ?: default
+    }
+
+    fun getFloat(name: String, default: Float = 0f): Float {
+        return map[name] as? Float ?: default
+    }
+
+    fun getBoolean(name: String, default: Boolean = false): Boolean {
+        return map[name] as? Boolean ?: default
+    }
+
+    fun getInt(name: String, default: Int = 0): Int {
+        return map[name] as? Int ?: default
+    }
+
+    fun getLong(name: String, default: Long = 0): Long {
+        return map[name] as? Long ?: default
+    }
+
+    fun getString(name: String, default: String = ""): String {
+        return map[name] as? String ?: default
+    }
+
+    override fun toString() = map.toString()
+
+}
+
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/persistence/PersistenceUtil.kt b/application-interface/src/main/kotlin/com/mechanica/engine/persistence/PersistenceUtil.kt
new file mode 100644
index 00000000..84768d23
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/persistence/PersistenceUtil.kt
@@ -0,0 +1,21 @@
+package com.mechanica.engine.persistence
+
+private val map = PersistenceMap("res/data/persistence.json")
+
+fun persistent(default: Boolean, instance: String? = null) = PersistentVariable(map, default, instance)
+
+fun persistent(default: Int, instance: String? = null) = PersistentVariable(map, default, instance)
+fun persistent(default: Long, instance: String? = null) = PersistentVariable(map, default, instance)
+
+fun persistent(default: Float, instance: String? = null) = PersistentVariable(map, default, instance)
+fun persistent(default: Double, instance: String? = null) = PersistentVariable(map, default, instance)
+
+fun persistent(default: String, instance: String? = null) = PersistentVariable(map, default, instance)
+
+fun storeData() {
+    map.store()
+}
+
+fun populateData() {
+    map.populate()
+}
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/persistence/PersistentVariable.kt b/application-interface/src/main/kotlin/com/mechanica/engine/persistence/PersistentVariable.kt
new file mode 100644
index 00000000..4945b21f
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/persistence/PersistentVariable.kt
@@ -0,0 +1,64 @@
+package com.mechanica.engine.persistence
+
+import kotlin.properties.ReadWriteProperty
+import kotlin.reflect.KProperty
+
+class PersistentVariable<T:Any>(
+        private val map: PersistenceMap,
+        private val defaultValue: T,
+        private val instance: String? = null) : ReadWriteProperty<Any,T> {
+
+    private var hasRetrieved = false
+    private var value: T = defaultValue
+
+    private var fullPropertyName: String? = null
+
+    override fun getValue(thisRef: Any, property: KProperty<*>): T {
+        if (!hasRetrieved) {
+            val name = fullPropertyName(thisRef, property)
+            value = if (instance == null) {
+                map.retrieveSingleValue(name)
+            } else {
+                map.retrieveInstancedValue(instance, name)
+            }
+            hasRetrieved = true
+        }
+        return value
+    }
+
+    private fun Map<*, *>.retrieveSingleValue(name: String): T {
+        @Suppress("UNCHECKED_CAST")
+        return this[name] as? T ?: defaultValue
+    }
+
+    private fun Map<*, *>.retrieveInstancedValue(instance: String, name: String): T {
+        val subMap = subMap(name) ?: return defaultValue
+
+        return subMap.retrieveSingleValue(instance)
+    }
+
+    private fun Map<*, *>.subMap(name: String) : HashMap<String, Any>? {
+        @Suppress("UNCHECKED_CAST")
+        return this[name] as? HashMap<String, Any>
+    }
+
+    override fun setValue(thisRef: Any, property: KProperty<*>, value: T) {
+        this.value = value
+        val name = fullPropertyName(thisRef, property)
+        if (instance == null) {
+            map.put(name, value)
+        } else {
+            map.subMap(name)?.put(instance, value) ?: map.put(name, HashMap<String, Any>().also { it[instance] = value })
+        }
+    }
+
+    private fun fullPropertyName(ref: Any, property: KProperty<*>): String {
+        val fullName = this.fullPropertyName
+        return if (fullName != null) fullName
+        else {
+            val newName = ref::class.java.canonicalName + "." + property.name
+            fullPropertyName = newName
+            newName
+        }
+    }
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/resources/AudioResource.kt b/application-interface/src/main/kotlin/com/mechanica/engine/resources/AudioResource.kt
new file mode 100644
index 00000000..05e14bdf
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/resources/AudioResource.kt
@@ -0,0 +1,18 @@
+package com.mechanica.engine.resources
+
+import com.mechanica.engine.audio.AudioFile
+import com.mechanica.engine.audio.Sound
+import com.mechanica.engine.audio.SoundSource
+import com.mechanica.engine.context.loader.GLLoader
+import java.nio.ShortBuffer
+
+class AudioResource(res: Resource, val sound: Sound) : GenericResource by res, AudioFile by sound {
+
+    constructor(res: Resource) : this(res, GLLoader.audioLoader.sound(res.path))
+    constructor(file: String) : this(Resource(file))
+
+    override val buffer: ShortBuffer
+        get() = sound.buffer
+
+    fun createSource(): SoundSource = GLLoader.audioLoader.source(sound)
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/resources/ExternalResource.kt b/application-interface/src/main/kotlin/com/mechanica/engine/resources/ExternalResource.kt
index 1f52d9e9..f488830d 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/resources/ExternalResource.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/resources/ExternalResource.kt
@@ -68,7 +68,7 @@ class ExternalResource(filePath: String, createIfAbsent: Boolean = false) : Reso
         return if (createIfAbsent) {
             try {
                 Resource(filePath)
-            } catch (ex: java.lang.IllegalStateException) {
+            } catch (ex: FileNotFoundException) {
                 val newFile = File("${getResourceLocation()}/$filePath")
                 newFile.parentFile.mkdirs()
                 newFile.createNewFile()
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/resources/GenericResource.kt b/application-interface/src/main/kotlin/com/mechanica/engine/resources/GenericResource.kt
new file mode 100644
index 00000000..69e6cb53
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/resources/GenericResource.kt
@@ -0,0 +1,12 @@
+package com.mechanica.engine.resources
+
+import java.io.InputStream
+import java.nio.Buffer
+
+interface GenericResource {
+    val path: String
+    val stream: InputStream
+    val lines: List<String>
+    val contents: String
+    val buffer: Buffer
+}
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/resources/Resource.kt b/application-interface/src/main/kotlin/com/mechanica/engine/resources/Resource.kt
index bf89fb6a..872e79dc 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/resources/Resource.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/resources/Resource.kt
@@ -2,24 +2,24 @@ package com.mechanica.engine.resources
 
 import com.mechanica.engine.context.loader.GLLoader
 import java.io.BufferedReader
+import java.io.FileNotFoundException
 import java.io.InputStream
 import java.io.InputStreamReader
 import java.net.URI
 import java.net.URL
+import java.nio.Buffer
 import java.nio.ByteBuffer
 import kotlin.streams.toList
 
-interface Resource {
-    val path: String
-    val stream: InputStream
-    val lines: List<String>
+interface Resource : GenericResource {
+    override val lines: List<String>
         get() {
             val reader = BufferedReader(InputStreamReader(stream))
             val lines = reader.lines().toList()
             reader.close()
             return lines
         }
-    val contents: String
+    override val contents: String
         get() {
             val sb = StringBuilder()
             lines.forEach {
@@ -27,7 +27,7 @@ interface Resource {
             }
             return sb.toString()
         }
-    val buffer: ByteBuffer
+    override val buffer: ByteBuffer
         get() {
             val bytes = stream.readAllBytes()
             val buffer = GLLoader.bufferLoader.byteBuffer(bytes.size)
@@ -40,7 +40,7 @@ interface Resource {
 
         operator fun invoke(file: String): Resource {
             val fileForURL = file.replace("\\", "/")
-            val url = getResourceURL(fileForURL) ?: throw IllegalStateException("Resource not found at $fileForURL")
+            val url = getResourceURL(fileForURL) ?: throw FileNotFoundException("Resource not found at $fileForURL")
 
             return ResourceImpl(url)
         }
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/resources/ResourceDirectory.kt b/application-interface/src/main/kotlin/com/mechanica/engine/resources/ResourceDirectory.kt
index 2ef84494..43a2a7cf 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/resources/ResourceDirectory.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/resources/ResourceDirectory.kt
@@ -1,41 +1,73 @@
 package com.mechanica.engine.resources
 
+import java.io.FileNotFoundException
 import java.net.URI
 import java.nio.file.*
 import java.util.stream.Stream
 
+class ResourceDirectory(directory: String, recursive: Boolean = false) {
+    val resources: Array<Resource>
+    val folders: Array<ResourceDirectory>
 
-class ResourceDirectory(directory: String): Iterable<Resource> {
-    private val resources: Array<Resource>
     val fileCount: Int
         get() = resources.size
 
+    val folderCount: Int
+        get() = folders.size
+
+    val name: String
+
     init {
-        val list = ArrayList<Resource>()
+        val resourceList = ArrayList<Resource>()
+        val directoryList = ArrayList<ResourceDirectory>()
+
+        val pathString = directory.removeSuffix("\\").removeSuffix("/") + "\\"
 
-        val uri: URI = this::class.java.getResource(directory).toURI()
+        val uri: URI = this::class.java.getResource(pathString)?.toURI() ?: throw FileNotFoundException("No file or directory found at $directory")
 
         var fileSystem: FileSystem? = null
 
         val path = if (uri.scheme == "jar") {
             fileSystem = FileSystems.newFileSystem(uri, emptyMap<String, Any>())
-            fileSystem.getPath(directory)
+            fileSystem.getPath(pathString)
         } else {
             Paths.get(uri)
         }
 
+        name = path.fileName.toString()
+
         val walk: Stream<Path> = Files.walk(path, 1)
         for (e in walk) {
-            if (!Files.isDirectory(e))
-                list.add(Resource(e.toUri()))
+            if (!Files.isDirectory(e)) {
+                resourceList.add(Resource(e.toUri()))
+            } else if (Files.isDirectory(e)) {
+                val relative = path.relativize(e).toString()
+                if (relative.isNotEmpty() && relative != "." && relative != "..") {
+                    directoryList.add(ResourceDirectory(pathString + relative, recursive))
+                }
+            }
         }
 
         fileSystem?.close()
-        list.sortBy { it.path }
-        resources = list.toTypedArray()
+        resourceList.sortBy { it.path }
+        resources = resourceList.toTypedArray()
+
+        folders = directoryList.toTypedArray()
     }
 
-    override fun iterator() = resources.iterator()
+    fun getFile(index: Int) = resources[index]
+    fun getFolder(index: Int) = folders[index]
 
+    inline fun forEachFile(operation: (Resource) -> Unit) {
+        for (i in 0 until fileCount) {
+            operation(getFile(i))
+        }
+    }
+
+    inline fun forEachFolder(operation: (ResourceDirectory) -> Unit) {
+        for (i in 0 until folderCount) {
+            operation(getFolder(i))
+        }
+    }
 
 }
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/shader/qualifiers/Attribute.kt b/application-interface/src/main/kotlin/com/mechanica/engine/shader/qualifiers/Attribute.kt
index 93d273c3..381efb7e 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/shader/qualifiers/Attribute.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/shader/qualifiers/Attribute.kt
@@ -13,7 +13,7 @@ import com.mechanica.engine.vertices.FloatBufferMaker
 import org.joml.Vector3f
 import org.joml.Vector4f
 
-class Attribute(
+class Attribute internal constructor(
         override val location: Int,
         private val variables: ScriptVariables? = null) : AttributeQualifier, AttributeVars {
 
@@ -81,8 +81,19 @@ class Attribute(
     }
 
     companion object {
-        operator fun invoke(location: Int): AttributeVars {
-            return Attribute(location)
+        private val attributeLocations = Array<Attribute?>(20) { null}
+
+        fun location(location: Int): AttributeVars {
+            return if (location > attributeLocations.lastIndex) {
+                Attribute(location)
+            } else {
+                val nullable = attributeLocations[location]
+                if (nullable == null) {
+                    val attribute = Attribute(location)
+                    attributeLocations[location] = attribute
+                    attribute
+                } else nullable
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/shader/qualifiers/Uniform.kt b/application-interface/src/main/kotlin/com/mechanica/engine/shader/qualifiers/Uniform.kt
index d2712a4a..36bd9a4c 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/shader/qualifiers/Uniform.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/shader/qualifiers/Uniform.kt
@@ -3,11 +3,12 @@ package com.mechanica.engine.shader.qualifiers
 import com.mechanica.engine.context.loader.GLLoader
 import com.mechanica.engine.context.loader.UniformLoader
 import com.mechanica.engine.shader.script.ScriptVariables
+import com.mechanica.engine.shader.uniforms.UniformVars
+import com.mechanica.engine.shader.uniforms.vars.*
 import com.mechanica.engine.shader.vars.ShaderType
 import com.mechanica.engine.shader.vars.ShaderVariable
-import com.mechanica.engine.shader.vars.uniforms.*
-import com.mechanica.engine.shader.vars.uniforms.vars.*
 import org.joml.Matrix4f
+import kotlin.reflect.KProperty
 
 class Uniform(private val variables: ScriptVariables) : Qualifier, UniformVars {
     override val qualifierName: String = "uniform"
@@ -21,6 +22,9 @@ class Uniform(private val variables: ScriptVariables) : Qualifier, UniformVars {
             override val qualifier = this@Uniform
             override val type = ShaderType.get(type)
             override fun loadUniform() { load(value) }
+            override fun setValue(thisRef: Any, property: KProperty<*>, value: T) {
+                this.value = value
+            }
         }
         return addVariable(v)
     }
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/shader/script/ScriptVariables.kt b/application-interface/src/main/kotlin/com/mechanica/engine/shader/script/ScriptVariables.kt
index afd251f5..2454290e 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/shader/script/ScriptVariables.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/shader/script/ScriptVariables.kt
@@ -1,7 +1,7 @@
 package com.mechanica.engine.shader.script
 
 import com.mechanica.engine.shader.vars.ShaderVariable
-import com.mechanica.engine.shader.vars.uniforms.vars.UniformVar
+import com.mechanica.engine.shader.uniforms.vars.UniformVar
 
 class ScriptVariables(private val placeHolder: String): Iterable<ShaderVariable> {
     private val variables = ArrayList<ShaderVariable>()
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/script/Shader.kt b/application-interface/src/main/kotlin/com/mechanica/engine/shader/script/Shader.kt
similarity index 51%
rename from desktop-application/src/main/kotlin/com/mechanica/engine/shader/script/Shader.kt
rename to application-interface/src/main/kotlin/com/mechanica/engine/shader/script/Shader.kt
index e8099174..355441bb 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/script/Shader.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/shader/script/Shader.kt
@@ -1,29 +1,37 @@
 package com.mechanica.engine.shader.script
 
+import com.mechanica.engine.context.loader.GLLoader
 import com.mechanica.engine.models.Bindable
 import com.mechanica.engine.models.Model
-import org.lwjgl.opengl.GL20
 
 abstract class Shader {
+    abstract val id: Int
+
     abstract val vertex: ShaderScript
     abstract val fragment: ShaderScript
-    abstract val tessellation: ShaderScript?
-    abstract val geometry: ShaderScript?
+    open val tessellation: ShaderScript? = null
+    open val geometry: ShaderScript? = null
 
-    abstract val id: Int
+    private var locationsFound = false
 
     protected fun load() {
-        GL20.glUseProgram(id)
+        loadProgram(id)
         loadUniforms()
     }
 
+    protected abstract fun loadProgram(id: Int)
+
     private fun loadUniforms() {
+        if (!locationsFound) findLocations()
+
         vertex.loadVariables()
         fragment.loadVariables()
         tessellation?.loadVariables()
         geometry?.loadVariables()
     }
 
+    abstract fun loadUniformLocation(name: String): Int
+
     open fun render(inputs: Array<Bindable>, draw: () -> Unit) {
         load()
 
@@ -40,13 +48,28 @@ abstract class Shader {
         model.draw()
     }
 
+    private fun findLocations() {
+        vertex.loadUniformLocations(this)
+        geometry?.loadUniformLocations(this)
+        fragment.loadUniformLocations(this)
+        locationsFound = true
+    }
+
     companion object {
         operator fun invoke(
                 vertex: ShaderScript,
                 fragment: ShaderScript,
                 tessellation: ShaderScript? = null,
                 geometry: ShaderScript? = null): Shader {
-            return ShaderImpl(vertex, fragment, tessellation, geometry)
+            return create(vertex, fragment, tessellation, geometry)
+        }
+
+        fun create(
+                vertex: ShaderScript,
+                fragment: ShaderScript,
+                tessellation: ShaderScript? = null,
+                geometry: ShaderScript? = null): Shader {
+            return GLLoader.defaultShader(vertex, fragment, tessellation, geometry)
         }
     }
 }
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/script/ShaderDeclarations.kt b/application-interface/src/main/kotlin/com/mechanica/engine/shader/script/ShaderDeclarations.kt
similarity index 94%
rename from desktop-application/src/main/kotlin/com/mechanica/engine/shader/script/ShaderDeclarations.kt
rename to application-interface/src/main/kotlin/com/mechanica/engine/shader/script/ShaderDeclarations.kt
index bdb11bd3..c9474986 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/script/ShaderDeclarations.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/shader/script/ShaderDeclarations.kt
@@ -1,7 +1,7 @@
 package com.mechanica.engine.shader.script
 
 import com.mechanica.engine.shader.qualifiers.Attribute
-import com.mechanica.engine.shader.vars.uniforms.UniformVars
+import com.mechanica.engine.shader.uniforms.UniformVars
 import com.mechanica.engine.shader.qualifiers.Qualifier
 import com.mechanica.engine.shader.qualifiers.Uniform
 import com.mechanica.engine.shader.vars.ShaderVariable
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/script/ShaderScript.kt b/application-interface/src/main/kotlin/com/mechanica/engine/shader/script/ShaderScript.kt
similarity index 72%
rename from desktop-application/src/main/kotlin/com/mechanica/engine/shader/script/ShaderScript.kt
rename to application-interface/src/main/kotlin/com/mechanica/engine/shader/script/ShaderScript.kt
index bcfd8658..75bf6b3e 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/script/ShaderScript.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/shader/script/ShaderScript.kt
@@ -1,15 +1,12 @@
 package com.mechanica.engine.shader.script
 
 import com.mechanica.engine.models.Bindable
-import com.mechanica.engine.shader.vars.uniforms.vars.UniformVar
-import org.lwjgl.opengl.GL20
+import com.mechanica.engine.shader.uniforms.vars.UniformVar
 
 abstract class ShaderScript : ShaderDeclarations("autoVal") {
     val script: String
         get() = generateScript()
 
-    private var programId: Int = 0
-
     abstract val main: String
 
     private val inputs: Array<Bindable?> = Array(20) { null }
@@ -22,11 +19,10 @@ abstract class ShaderScript : ShaderDeclarations("autoVal") {
         return sb.toString()
     }
 
-    internal fun loadProgram(programId: Int) {
-        this.programId = programId
+    fun loadUniformLocations(shader: Shader) {
         for (v in iterator) {
             if (v is UniformVar<*>) {
-                v.location = GL20.glGetUniformLocation(programId, v.locationName)
+                v.location = shader.loadUniformLocation(v.locationName)
             }
         }
     }
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/UniformVars.kt b/application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/UniformVars.kt
similarity index 93%
rename from application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/UniformVars.kt
rename to application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/UniformVars.kt
index 96e0197d..468f47a7 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/UniformVars.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/UniformVars.kt
@@ -1,7 +1,7 @@
-package com.mechanica.engine.shader.vars.uniforms
+package com.mechanica.engine.shader.uniforms
 
 import com.mechanica.engine.color.Color
-import com.mechanica.engine.shader.vars.uniforms.vars.*
+import com.mechanica.engine.shader.uniforms.vars.*
 import com.mechanica.engine.unit.vector.Vector
 import org.joml.Matrix4f
 import org.joml.Vector3f
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/vars/UniformFloat.kt b/application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/vars/UniformFloat.kt
similarity index 57%
rename from application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/vars/UniformFloat.kt
rename to application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/vars/UniformFloat.kt
index 5fa2c417..bfce2497 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/vars/UniformFloat.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/vars/UniformFloat.kt
@@ -1,7 +1,9 @@
-package com.mechanica.engine.shader.vars.uniforms.vars
+package com.mechanica.engine.shader.uniforms.vars
 
 import com.mechanica.engine.shader.qualifiers.Qualifier
 import com.mechanica.engine.shader.vars.ShaderType
+import kotlin.properties.ReadWriteProperty
+import kotlin.reflect.KProperty
 
 abstract class UniformFloat(
         override var value: Float,
@@ -10,4 +12,7 @@ abstract class UniformFloat(
 ) : UniformVar<Float>() {
     override val type = ShaderType.float()
 
+    override fun setValue(thisRef: Any, property: KProperty<*>, value: Float) {
+        this.value = value
+    }
 }
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/vars/UniformMatrix4f.kt b/application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/vars/UniformMatrix4f.kt
similarity index 72%
rename from application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/vars/UniformMatrix4f.kt
rename to application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/vars/UniformMatrix4f.kt
index 7c134fd2..1fa1a0a1 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/vars/UniformMatrix4f.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/vars/UniformMatrix4f.kt
@@ -1,8 +1,9 @@
-package com.mechanica.engine.shader.vars.uniforms.vars
+package com.mechanica.engine.shader.uniforms.vars
 
 import com.mechanica.engine.shader.qualifiers.Qualifier
 import com.mechanica.engine.shader.vars.ShaderType
 import org.joml.Matrix4f
+import kotlin.reflect.KProperty
 
 abstract class UniformMatrix4f(
         var matrix: Matrix4f,
@@ -19,4 +20,8 @@ abstract class UniformMatrix4f(
     fun set(matrix: Matrix4f) {
         this.matrix.set(matrix)
     }
+
+    override fun setValue(thisRef: Any, property: KProperty<*>, value: Matrix4f) {
+        set(value)
+    }
 }
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/vars/UniformVar.kt b/application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/vars/UniformVar.kt
similarity index 55%
rename from application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/vars/UniformVar.kt
rename to application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/vars/UniformVar.kt
index 55378946..209e0dce 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/vars/UniformVar.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/vars/UniformVar.kt
@@ -1,10 +1,13 @@
-package com.mechanica.engine.shader.vars.uniforms.vars
+package com.mechanica.engine.shader.uniforms.vars
 
 import com.mechanica.engine.shader.qualifiers.Qualifier
 import com.mechanica.engine.shader.vars.ShaderType
 import com.mechanica.engine.shader.vars.ShaderVariable
+import kotlin.properties.ReadOnlyProperty
+import kotlin.properties.ReadWriteProperty
+import kotlin.reflect.KProperty
 
-abstract class UniformVar<T> : ShaderVariable {
+abstract class UniformVar<T> : ShaderVariable, ReadWriteProperty<Any, T> {
     abstract val value: T
     abstract override val name: String
     abstract override val qualifier: Qualifier
@@ -13,14 +16,21 @@ abstract class UniformVar<T> : ShaderVariable {
 
     var location = 0
 
-    private val regex = Regex("[^\\w\\d]")
     val locationName: String
-        get() {
+        get() = getLocationName(name)
+
+    override fun toString() = name
+
+    override fun getValue(thisRef: Any, property: KProperty<*>) = value
+
+    companion object {
+        private val regex = Regex("[^\\w\\d]")
+
+        fun getLocationName(name: String): String {
             val index = regex.find(name)?.range?.first
             return if (index != null) {
                 name.substring(0 until index)
             } else name
         }
-
-    override fun toString() = name
+    }
 }
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/vars/UniformVector2f.kt b/application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/vars/UniformVector2f.kt
similarity index 70%
rename from application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/vars/UniformVector2f.kt
rename to application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/vars/UniformVector2f.kt
index 52e619ec..29d46e35 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/vars/UniformVector2f.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/vars/UniformVector2f.kt
@@ -1,8 +1,9 @@
-package com.mechanica.engine.shader.vars.uniforms.vars
+package com.mechanica.engine.shader.uniforms.vars
 
 import com.mechanica.engine.shader.qualifiers.Qualifier
 import com.mechanica.engine.shader.vars.ShaderType
 import com.mechanica.engine.unit.vector.DynamicVector
+import kotlin.reflect.KProperty
 
 abstract class UniformVector2f(
         x: Number, y: Number,
@@ -11,4 +12,8 @@ abstract class UniformVector2f(
 ) : UniformVar<DynamicVector>(), DynamicVector by DynamicVector.create(x.toDouble(), y.toDouble()) {
     override val value: DynamicVector by lazy { this }
     override val type = ShaderType.vec2()
+
+    override fun setValue(thisRef: Any, property: KProperty<*>, value: DynamicVector) {
+        this.value.set(value)
+    }
 }
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/vars/UniformVector3f.kt b/application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/vars/UniformVector3f.kt
similarity index 73%
rename from application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/vars/UniformVector3f.kt
rename to application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/vars/UniformVector3f.kt
index 9ed2985c..88355450 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/vars/UniformVector3f.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/vars/UniformVector3f.kt
@@ -1,8 +1,9 @@
-package com.mechanica.engine.shader.vars.uniforms.vars
+package com.mechanica.engine.shader.uniforms.vars
 
 import com.mechanica.engine.shader.qualifiers.Qualifier
 import com.mechanica.engine.shader.vars.ShaderType
 import org.joml.Vector3f
+import kotlin.reflect.KProperty
 
 abstract class UniformVector3f(
         x: Number, y: Number, z: Number,
@@ -19,4 +20,8 @@ abstract class UniformVector3f(
         value.y = y.toFloat()
         value.z = z.toFloat()
     }
+
+    override fun setValue(thisRef: Any, property: KProperty<*>, value: Vector3f) {
+        this.value.set(value)
+    }
 }
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/vars/UniformVector4f.kt b/application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/vars/UniformVector4f.kt
similarity index 84%
rename from application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/vars/UniformVector4f.kt
rename to application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/vars/UniformVector4f.kt
index 5a99ad2e..84674ba4 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/vars/UniformVector4f.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/shader/uniforms/vars/UniformVector4f.kt
@@ -1,10 +1,11 @@
-package com.mechanica.engine.shader.vars.uniforms.vars
+package com.mechanica.engine.shader.uniforms.vars
 
 import com.mechanica.engine.color.Color
 import com.mechanica.engine.color.LightweightColor
 import com.mechanica.engine.shader.qualifiers.Qualifier
 import com.mechanica.engine.shader.vars.ShaderType
 import org.joml.Vector4f
+import kotlin.reflect.KProperty
 
 
 abstract class UniformVector4f (
@@ -37,4 +38,8 @@ abstract class UniformVector4f (
         value.z = z.toFloat()
         value.w = w.toFloat()
     }
+
+    override fun setValue(thisRef: Any, property: KProperty<*>, value: Vector4f) {
+        this.value.set(value)
+    }
 }
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/text/Font.kt b/application-interface/src/main/kotlin/com/mechanica/engine/text/Font.kt
index 73c71125..670373f8 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/text/Font.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/text/Font.kt
@@ -1,7 +1,7 @@
 package com.mechanica.engine.text
 
-import com.mechanica.engine.models.Image
 import com.mechanica.engine.context.loader.GLLoader
+import com.mechanica.engine.models.Image
 import com.mechanica.engine.resources.Resource
 import com.mechanica.engine.unit.vector.DynamicVector
 
@@ -17,8 +17,11 @@ abstract class Font {
     abstract fun addCharacterDataToArrays(cursor: CharacterCursor, positions: Array<DynamicVector>, texCoords: Array<DynamicVector>)
 
     companion object {
-        fun create(resource: Resource): Font {
-            return GLLoader.fontLoader.font(resource)
+
+        val defaultFont = GLLoader.fontLoader.defaultFont
+
+        fun create(resource: Resource, configureAtlas: FontAtlasConfiguration.() -> Unit = { }): Font {
+            return GLLoader.fontLoader.font(resource, configureAtlas)
         }
     }
 }
\ No newline at end of file
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/text/FontAtlasConfiguration.kt b/application-interface/src/main/kotlin/com/mechanica/engine/text/FontAtlasConfiguration.kt
new file mode 100644
index 00000000..04f2dc64
--- /dev/null
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/text/FontAtlasConfiguration.kt
@@ -0,0 +1,16 @@
+package com.mechanica.engine.text
+
+interface FontAtlasConfiguration {
+    var width: Int
+    var height: Int
+    var characterSize: Float
+    var padding: Float
+    var charRange: CharRange
+    fun configureSDF(block: SDFConfiguration.() -> Unit)
+
+    class SDFConfiguration {
+        var start = -20.0
+        var end = 20.0
+    }
+}
+
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/text/Text.kt b/application-interface/src/main/kotlin/com/mechanica/engine/text/Text.kt
index f782aeb0..3cb4fa03 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/text/Text.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/text/Text.kt
@@ -8,7 +8,7 @@ import kotlin.math.max
 
 class Text(text: String, val font: Font = GLLoader.fontLoader.defaultFont) {
 
-    var text = text
+    var string = text
         set(value) {
             field = value
             update(value, font)
diff --git a/application-interface/src/main/kotlin/com/mechanica/engine/vertices/VertexBufferObjects.kt b/application-interface/src/main/kotlin/com/mechanica/engine/vertices/VertexBufferObjects.kt
index a7b41c46..31a0cb1f 100644
--- a/application-interface/src/main/kotlin/com/mechanica/engine/vertices/VertexBufferObjects.kt
+++ b/application-interface/src/main/kotlin/com/mechanica/engine/vertices/VertexBufferObjects.kt
@@ -13,6 +13,16 @@ interface VertexBuffer<T> : Bindable {
     val vertexCount: Int
     val T.valueCount: Int
 
+    fun safeBind() {
+        if (vertexCount > 0) {
+            bind()
+        } else {
+            unbind()
+        }
+    }
+
+    fun unbind()
+
     fun set(array: T, from: Int = 0, length: Int = array.valueCount)
 }
 
@@ -21,7 +31,6 @@ interface AttributeArray : VertexBuffer<FloatArray> {
     fun set(array: Array<Vector3f>, from: Int = 0, length: Int = array.size)
     fun set(array: Array<Vector4f>, from: Int = 0, length: Int = array.size)
     fun set(array: Array<out Color>, from: Int = 0, length: Int = array.size)
-    fun disable()
 }
 
 interface IndexArray : VertexBuffer<ShortArray> {
diff --git a/build.gradle.kts b/build.gradle.kts
index e4270188..27f9b75e 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 val lwjglVersion = "3.2.3"
 val lwjglNatives = "natives-windows"
 
-val kotlinVersion = "1.3.50"
+val kotlinVersion = "1.3.70"
 
 buildscript {
     repositories {
@@ -18,7 +18,8 @@ buildscript {
 }
 
 plugins {
-    id("org.jetbrains.kotlin.jvm") version "1.3.61"
+    kotlin("jvm") version "1.3.70"
+    kotlin("plugin.serialization") version "1.3.70"
     `java-library`
     maven
 }
@@ -28,6 +29,7 @@ val commonDependencies: DependencyHandlerScope.() -> Unit = {
 
     // Align versions of all Kotlin components
     implementation(platform("org.jetbrains.kotlin:kotlin-bom"))
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-runtime:0.20.0")
 
     implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlinVersion")
     implementation("org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion")
@@ -69,6 +71,16 @@ allprojects {
 
     apply(plugin = "org.jetbrains.kotlin.jvm")
     dependencies(commonDependencies)
+    val compileKotlin: KotlinCompile by tasks
+    compileKotlin.kotlinOptions {
+        freeCompilerArgs = listOf("-XXLanguage:+InlineClasses")
+        jvmTarget = "12"
+    }
+
+    java {
+        sourceCompatibility = JavaVersion.VERSION_12
+        targetCompatibility = JavaVersion.VERSION_12
+    }
 }
 
 project(":desktop-application") {
@@ -88,14 +100,3 @@ project(":samples") {
     apply(plugin = "org.jetbrains.kotlin.jvm")
     dependencies(coreLwjgl)
 }
-
-java {
-    sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
-}
-
-val compileKotlin: KotlinCompile by tasks
-compileKotlin.kotlinOptions {
-    freeCompilerArgs = listOf("-XXLanguage:+InlineClasses")
-    jvmTarget = "1.8"
-}
\ No newline at end of file
diff --git a/common/build.gradle.kts b/common/build.gradle.kts
index 891ebe85..b556fdbe 100644
--- a/common/build.gradle.kts
+++ b/common/build.gradle.kts
@@ -2,9 +2,4 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
     kotlin("jvm")
-}
-
-val compileKotlin: KotlinCompile by tasks
-compileKotlin.kotlinOptions {
-    freeCompilerArgs = listOf("-XXLanguage:+InlineClasses")
 }
\ No newline at end of file
diff --git a/common/src/main/kotlin/com/mechanica/engine/color/ColorTools.kt b/common/src/main/kotlin/com/mechanica/engine/color/ColorTools.kt
index 72c894c3..b1e670bd 100644
--- a/common/src/main/kotlin/com/mechanica/engine/color/ColorTools.kt
+++ b/common/src/main/kotlin/com/mechanica/engine/color/ColorTools.kt
@@ -2,9 +2,9 @@
 
 package com.mechanica.engine.color
 
-import com.mechanica.engine.unit.angle.degrees
-import com.mechanica.engine.unit.angle.Angle
 import com.mechanica.engine.unit.angle.Degree
+import com.mechanica.engine.unit.angle.Radian
+import com.mechanica.engine.unit.angle.degrees
 import org.joml.Vector4f
 import kotlin.math.abs
 import kotlin.math.max
@@ -182,14 +182,22 @@ fun rgb2Lightness(r: Double, g: Double, b: Double): Double {
     return (max + min)/2.0
 }
 
-fun hsl(hue: Angle, saturation: Double, lightness: Double, alpha: Double = 1.0): LightweightColor {
+fun hsl(hue: Degree, saturation: Double, lightness: Double, alpha: Double = 1.0): LightweightColor {
+    return hsl(hue.toDouble(), saturation, lightness, alpha)
+}
+
+fun hsl(hue: Radian, saturation: Double, lightness: Double, alpha: Double = 1.0): LightweightColor {
+    return hsl(hue.toDegrees().toDouble(), saturation, lightness, alpha)
+}
+
+fun hsl(hue: Double, saturation: Double, lightness: Double, alpha: Double = 1.0): LightweightColor {
     fun f(n: Int, h: Double, s: Double, l: Double): Double {
         val a = s* min(l, 1.0-l)
         val k = (n + h/30.0)%12
         return (l - a* max(min(min(k-3.0, 9.0-k), 1.0),-1.0))
     }
 
-    val h = (hue.toDegrees().asDouble() + 360.0)%360.0
+    val h = (hue + 360.0)%360.0
     val s = saturation
     val l = lightness
 
diff --git a/common/src/main/kotlin/com/mechanica/engine/color/DynamicColor.kt b/common/src/main/kotlin/com/mechanica/engine/color/DynamicColor.kt
index 564be21f..e792c0a9 100644
--- a/common/src/main/kotlin/com/mechanica/engine/color/DynamicColor.kt
+++ b/common/src/main/kotlin/com/mechanica/engine/color/DynamicColor.kt
@@ -21,6 +21,14 @@ class DynamicColor(
         set(color.r, color.g, color.b, color.a)
     }
 
+    fun set(hex: Long) {
+        val r = hex2Red(hex)
+        val g = hex2Green(hex)
+        val b = hex2Blue(hex)
+        val a = hex2Alpha(hex)
+        set(r, g, b, a)
+    }
+
     override fun toLong(): Long {
         return rgba2Hex(r, g, b, a)
     }
diff --git a/common/src/main/kotlin/com/mechanica/engine/debug/DebugConfiguration.kt b/common/src/main/kotlin/com/mechanica/engine/debug/DebugConfiguration.kt
index b40bb568..4475d5e9 100644
--- a/common/src/main/kotlin/com/mechanica/engine/debug/DebugConfiguration.kt
+++ b/common/src/main/kotlin/com/mechanica/engine/debug/DebugConfiguration.kt
@@ -6,4 +6,6 @@ interface DebugConfiguration {
     val constructionDraws: Boolean
     val printWarnings: Boolean
     val lwjglDebug: Boolean
+    fun pauseUpdates(pause:  Boolean)
+    fun frameAdvance()
 }
\ No newline at end of file
diff --git a/common/src/main/kotlin/com/mechanica/engine/memory/BitmapBuffer.kt b/common/src/main/kotlin/com/mechanica/engine/memory/BitmapBuffer.kt
new file mode 100644
index 00000000..6f853029
--- /dev/null
+++ b/common/src/main/kotlin/com/mechanica/engine/memory/BitmapBuffer.kt
@@ -0,0 +1,110 @@
+package com.mechanica.engine.memory
+
+import com.mechanica.engine.unit.vector.DynamicIntVector
+import java.nio.ByteBuffer
+
+class BitmapBuffer(val buffer: ByteBuffer, val width: Int, val height: Int) {
+
+    val bufferPosition = object : DynamicIntVector {
+        private var _x = 0
+        override var x: Int
+            get() = _x
+            set(value) {
+                set(value, _y)
+            }
+        
+        private var _y = 0
+        override var y: Int
+            get() = _y
+            set(value) {
+                set(_x, value)
+            }
+
+        override fun set(x: Int, y: Int) {
+            _x = x
+            _y = y
+            val row = y*width
+            buffer.position(row+x)
+        }
+    }
+    
+    val stBufferPosition = STVector()
+    
+    fun advanceBy(advance: Int) {
+        buffer.position(buffer.position() + advance)
+    }
+    
+    fun insert(other: ByteBuffer, otherWidth: Int, s: Float, t: Float) {
+        stBufferPosition.set(s, t)
+        insert(other, otherWidth)
+    }
+    
+    fun insert(other: ByteBuffer, otherWidth: Int, x: Int, y: Int) {
+        bufferPosition.set(x, y)
+        insert(other, otherWidth)
+    }
+
+    fun insert(other: BitmapBuffer, s: Float, t: Float) {
+        stBufferPosition.set(s, t)
+        other.zero()
+
+        insert(other.buffer, other.width)
+    }
+
+    fun insert(other: BitmapBuffer, x: Int, y: Int) {
+        bufferPosition.set(x, y)
+        other.zero()
+
+        insert(other.buffer, other.width)
+    }
+
+    fun zero() {
+        buffer.position(0)
+    }
+
+    private fun insert(other: ByteBuffer, otherWidth: Int) {
+        var j = 0
+        val limit = other.limit()
+        while (other.position() < limit - otherWidth) {
+            other.limit((j + 1)*otherWidth - 1)
+            other.position(j++*otherWidth)
+            buffer.put(other)
+            advanceBy(width - otherWidth + 1)
+        }
+    }
+    private fun insertOld(other: ByteBuffer, otherWidth: Int) {
+        var j = 0
+        while (other.hasRemaining()) {
+            var i = 0
+            while (i++ < otherWidth) {
+                buffer.put(other.get())
+            }
+            advanceBy(width - otherWidth)
+            j++
+        }
+    }
+
+    inner class STVector {
+        private var _s = 0f
+        var s: Float
+            get() = _s
+            set(value) {
+                set(value, _t)
+            }
+
+        private var _t = 0f
+        var t: Float
+            get() = _t
+            set(value) {
+                set(_s, value)
+            }
+
+        fun set(s: Float, t: Float) {
+            _s = s
+            _t = t
+            val x = (s*width).toInt()
+            val y = (t*height).toInt()
+            bufferPosition.set(x, y)
+        }
+    }
+}
\ No newline at end of file
diff --git a/common/src/main/kotlin/com/mechanica/engine/unit/angle/Angle.kt b/common/src/main/kotlin/com/mechanica/engine/unit/angle/Angle.kt
index a8c8a292..d6f81781 100644
--- a/common/src/main/kotlin/com/mechanica/engine/unit/angle/Angle.kt
+++ b/common/src/main/kotlin/com/mechanica/engine/unit/angle/Angle.kt
@@ -1,7 +1,8 @@
 package com.mechanica.engine.unit.angle
 
 interface Angle {
-    fun asDouble(): Double
+    fun toDouble(): Double
+    fun toFloat(): Float
     fun toDegrees(): Degree
     fun toRadians(): Radian
 }
\ No newline at end of file
diff --git a/common/src/main/kotlin/com/mechanica/engine/unit/angle/AngleTools.kt b/common/src/main/kotlin/com/mechanica/engine/unit/angle/AngleTools.kt
index 51282eed..abd694c4 100644
--- a/common/src/main/kotlin/com/mechanica/engine/unit/angle/AngleTools.kt
+++ b/common/src/main/kotlin/com/mechanica/engine/unit/angle/AngleTools.kt
@@ -1,45 +1,52 @@
 package com.mechanica.engine.unit.angle
 
+import kotlin.math.PI
+
 inline val Number.degrees: Degree
     get() = Degree(this.toDouble())
 
 inline val Number.radians: Radian
     get() = Radian(this.toDouble())
 
-operator fun Angle.minus(other: Angle): Angle = (this.toRadians().asDouble() - other.toRadians().asDouble()).radians
+operator fun Angle.minus(other: Angle): Angle = (this.toRadians().toDouble() - other.toRadians().toDouble()).radians
 
-operator fun Degree.unaryMinus(): Degree = Degree(-(this.asDouble()))
+operator fun Degree.unaryMinus(): Degree = Degree(-(this.toDouble()))
 
-operator fun Radian.unaryMinus(): Radian = Radian(-(this.asDouble()))
+operator fun Radian.unaryMinus(): Radian = Radian(-(this.toDouble()))
 
 operator fun Degree.plus(other: Degree): Degree {
-    return (this.asDouble() + other.asDouble()).degrees
+    return (this.toDouble() + other.toDouble()).degrees
 }
 
 operator fun Radian.plus(other: Radian): Radian {
-    return (this.asDouble() + other.asDouble()).radians
+    return (this.toDouble() + other.toDouble()).radians
 }
 
 operator fun Degree.minus(other: Degree): Degree {
-    return (this.asDouble() - other.asDouble()).degrees
+    return (this.toDouble() - other.toDouble()).degrees
 }
 
 operator fun Radian.minus(other: Radian): Radian {
-    return (this.asDouble() - other.asDouble()).radians
+    return (this.toDouble() - other.toDouble()).radians
 }
 
 operator fun Degree.div(other: Degree): Double {
-    return (this.asDouble() / other.asDouble())
+    return (this.toDouble() / other.toDouble())
 }
 
 operator fun Radian.div(other: Radian): Double {
-    return (this.asDouble() / other.asDouble())
+    return (this.toDouble() / other.toDouble())
 }
 
 operator fun Degree.times(other: Number): Degree {
-    return (this.asDouble() * other.toDouble()).degrees
+    return (this.toDouble() * other.toDouble()).degrees
 }
 
 operator fun Radian.times(other: Number): Radian {
-    return (this.asDouble() * other.toDouble()).radians
+    return (this.toDouble() * other.toDouble()).radians
+}
+
+fun minimumDifference(angle1: Radian, angle2: Radian): Radian {
+    val diff = angle2 - angle1
+    return ((diff.toDouble() + PI) % (2.0* PI) - PI).radians
 }
diff --git a/common/src/main/kotlin/com/mechanica/engine/unit/angle/Degree.kt b/common/src/main/kotlin/com/mechanica/engine/unit/angle/Degree.kt
index 8b12a903..fcf47c0b 100644
--- a/common/src/main/kotlin/com/mechanica/engine/unit/angle/Degree.kt
+++ b/common/src/main/kotlin/com/mechanica/engine/unit/angle/Degree.kt
@@ -3,13 +3,15 @@ package com.mechanica.engine.unit.angle
 import kotlin.math.PI
 
 inline class Degree(private val degrees: Double) : Angle {
-    override fun toDegrees() = asDouble().degrees
+    override fun toDegrees() = toDouble().degrees
 
-    override fun toRadians() = (this.asDouble()*PI /180.0).radians
+    override fun toRadians() = (this.toDouble()*PI /180.0).radians
 
-    override fun asDouble() = degrees
+    override fun toDouble() = degrees
+
+    override fun toFloat() = degrees.toFloat()
 
     override fun toString(): String {
-        return asDouble().toString()
+        return toDouble().toString()
     }
 }
\ No newline at end of file
diff --git a/common/src/main/kotlin/com/mechanica/engine/unit/angle/Radian.kt b/common/src/main/kotlin/com/mechanica/engine/unit/angle/Radian.kt
index 7131f7a4..fe0320b0 100644
--- a/common/src/main/kotlin/com/mechanica/engine/unit/angle/Radian.kt
+++ b/common/src/main/kotlin/com/mechanica/engine/unit/angle/Radian.kt
@@ -3,13 +3,15 @@ package com.mechanica.engine.unit.angle
 import kotlin.math.PI
 
 inline class Radian(private val radians: Double) : Angle {
-    override fun toDegrees() = (this.asDouble()*180.0/ PI).degrees
+    override fun toDegrees() = (this.toDouble()*180.0/ PI).degrees
 
-    override fun toRadians() = asDouble().radians
+    override fun toRadians() = toDouble().radians
 
-    override fun asDouble() = radians
+    override fun toDouble() = radians
+
+    override fun toFloat() = radians.toFloat()
 
     override fun toString(): String {
-        return asDouble().toString()
+        return toDouble().toString()
     }
 }
\ No newline at end of file
diff --git a/common/src/main/kotlin/com/mechanica/engine/unit/vector/DynamicIntVector.kt b/common/src/main/kotlin/com/mechanica/engine/unit/vector/DynamicIntVector.kt
new file mode 100644
index 00000000..3eb4c4a8
--- /dev/null
+++ b/common/src/main/kotlin/com/mechanica/engine/unit/vector/DynamicIntVector.kt
@@ -0,0 +1,20 @@
+package com.mechanica.engine.unit.vector
+
+interface DynamicIntVector : IntVector {
+    override var x: Int
+    override var y: Int
+
+    fun set(x: Int, y: Int) {
+        this.x = x
+        this.y = y
+    }
+
+    fun set(other: IntVector) = set(other.x, other.y)
+
+    companion object {
+        fun create(x: Int = 0, y: Int = 0) = object : DynamicIntVector {
+            override var x = x
+            override var y = y
+        }
+    }
+}
\ No newline at end of file
diff --git a/common/src/main/kotlin/com/mechanica/engine/unit/vector/IntVector.kt b/common/src/main/kotlin/com/mechanica/engine/unit/vector/IntVector.kt
new file mode 100644
index 00000000..52c34953
--- /dev/null
+++ b/common/src/main/kotlin/com/mechanica/engine/unit/vector/IntVector.kt
@@ -0,0 +1,6 @@
+package com.mechanica.engine.unit.vector
+
+interface IntVector {
+    val x: Int
+    val y: Int
+}
\ No newline at end of file
diff --git a/common/src/main/kotlin/com/mechanica/engine/unit/vector/VectorTools.kt b/common/src/main/kotlin/com/mechanica/engine/unit/vector/VectorTools.kt
index 652d76d6..5ce3e100 100644
--- a/common/src/main/kotlin/com/mechanica/engine/unit/vector/VectorTools.kt
+++ b/common/src/main/kotlin/com/mechanica/engine/unit/vector/VectorTools.kt
@@ -2,7 +2,6 @@
 package com.mechanica.engine.unit.vector
 
 import com.mechanica.engine.unit.angle.Angle
-import com.mechanica.engine.unit.angle.radians
 import kotlin.math.*
 
 
@@ -19,8 +18,8 @@ fun vec(x: Number, y: Number): LightweightVector {
 }
 
 fun vec(r: Number, theta: Angle): LightweightVector {
-    val x = r.toDouble()*cos(theta.toRadians().asDouble())
-    val y = r.toDouble()*sin(theta.toRadians().asDouble())
+    val x = r.toDouble()*cos(theta.toRadians().toDouble())
+    val y = r.toDouble()*sin(theta.toRadians().toDouble())
     return vec(x, y)
 }
 
diff --git a/common/src/main/kotlin/com/mechanica/engine/util/GameBoolean.kt b/common/src/main/kotlin/com/mechanica/engine/util/EventBoolean.kt
similarity index 89%
rename from common/src/main/kotlin/com/mechanica/engine/util/GameBoolean.kt
rename to common/src/main/kotlin/com/mechanica/engine/util/EventBoolean.kt
index e44220b4..750ba889 100644
--- a/common/src/main/kotlin/com/mechanica/engine/util/GameBoolean.kt
+++ b/common/src/main/kotlin/com/mechanica/engine/util/EventBoolean.kt
@@ -1,11 +1,11 @@
 package com.mechanica.engine.util
 
-abstract class GameBoolean {
-    fun update(delta: Double) {
+open class EventBoolean(private val condition: () -> Boolean) {
+    fun update() {
         isTrue = condition()
     }
 
-    abstract fun condition() : Boolean
+    fun condition() : Boolean = condition.invoke()
 
     var isTrue: Boolean = false
         private set(value) {
diff --git a/common/src/main/kotlin/com/mechanica/engine/util/GenericGameBoolean.kt b/common/src/main/kotlin/com/mechanica/engine/util/GenericGameBoolean.kt
deleted file mode 100644
index 5922fea3..00000000
--- a/common/src/main/kotlin/com/mechanica/engine/util/GenericGameBoolean.kt
+++ /dev/null
@@ -1,7 +0,0 @@
-package com.mechanica.engine.util
-
-class GenericGameBoolean(private val condition: () -> Boolean) : GameBoolean() {
-    override fun condition(): Boolean {
-        return condition.invoke()
-    }
-}
\ No newline at end of file
diff --git a/common/src/main/kotlin/com/mechanica/engine/util/JsonUtil.kt b/common/src/main/kotlin/com/mechanica/engine/util/JsonUtil.kt
new file mode 100644
index 00000000..1c68c20a
--- /dev/null
+++ b/common/src/main/kotlin/com/mechanica/engine/util/JsonUtil.kt
@@ -0,0 +1,73 @@
+package com.mechanica.engine.util
+
+import kotlinx.serialization.*
+import kotlinx.serialization.json.*
+
+
+fun Map<*, *>.toJson(): JsonObject {
+    return json {
+        for (entry in this@toJson) {
+            addSupportedType(entry.key.toString(), entry.value)
+        }
+    }
+}
+
+fun JsonObject.toStringValueMap(): Map<String, Any> {
+    return this.mapNotNull {
+        val value = it.value.getSupportedType()
+
+        if (value != null) {
+            it.key to value
+        } else null
+
+    }.toHashMap()
+}
+
+fun List<Pair<String, Any>>.toHashMap(): HashMap<String, Any> {
+    val map = HashMap<String, Any>()
+    for (p in this) {
+        map[p.first] = p.second
+    }
+    return map
+}
+
+fun <V> JsonObjectBuilder.addSupportedType(key: String, value: V) {
+    when (value) {
+        is Number -> key to value
+        is String -> key to value
+        is Boolean -> key to value
+        is JsonElement -> key to value
+        is Map<*, *> -> key to value.toJson()
+    }
+}
+
+fun JsonElement.getSupportedType(): Any? {
+    return try {
+        booleanOrNull ?: intOrNull ?: longOrNull ?: floatOrNull ?: doubleOrNull ?: contentOrNull
+    } catch (ex: JsonException) {
+        if (this is JsonObject) {
+            return this.toStringValueMap()
+        } else null
+    }
+}
+
+fun Decoder.toJsonObject(): JsonObject {
+    val input = this as? JsonInput ?: throw SerializationException("Expected Json Input")
+    return input.decodeJson() as? JsonObject ?: throw SerializationException("Expected JsonArray")
+}
+
+
+class StringMapSerializer : DeserializationStrategy<Map<String, Any>>, SerializationStrategy<Map<String, Any>> {
+
+    override val descriptor = SerialDescriptor("PersistenceMap")
+
+    override fun deserialize(decoder: Decoder) = decoder.toJsonObject().toStringValueMap()
+
+    override fun serialize(encoder: Encoder, value: Map<String, Any>) {
+        JsonElementSerializer.serialize(encoder, value.toJson())
+    }
+
+    override fun patch(decoder: Decoder, old: Map<String, Any>): Map<String, Any> =
+            throw UpdateNotSupportedException("Update not supported")
+
+}
\ No newline at end of file
diff --git a/common/src/main/kotlin/com/mechanica/engine/util/NullTerminatedChars.kt b/common/src/main/kotlin/com/mechanica/engine/util/NullTerminatedChars.kt
new file mode 100644
index 00000000..b071375f
--- /dev/null
+++ b/common/src/main/kotlin/com/mechanica/engine/util/NullTerminatedChars.kt
@@ -0,0 +1,77 @@
+package com.mechanica.engine.util
+
+import kotlin.math.min
+
+class NullTerminatedChars(capacity: Int = 50) {
+    val chars = CharArray(capacity) { Character.MIN_VALUE }
+    var size: Int = 0
+
+    fun add(char: Char) {
+        var index = 0
+
+        while (index < chars.size) {
+            if (chars[index] == Character.MIN_VALUE) {
+                chars[index] = char
+                break
+            }
+            index++
+        }
+        size = index+1
+    }
+
+    fun addCodePoint(cp: Int) {
+        when {
+            Character.isBmpCodePoint(cp) -> {
+                add(cp.toChar())
+            }
+            Character.isValidCodePoint(cp) -> {
+                add(Character.highSurrogate(cp))
+                add(Character.lowSurrogate(cp))
+            }
+        }
+    }
+
+    fun get(other: NullTerminatedChars) {
+        get(other.chars)
+    }
+
+    fun get(other: CharArray) {
+        val endIndex = min(other.size, this.chars.size)
+        this.chars.copyInto(other, endIndex = endIndex)
+        if (endIndex < other.size) {
+            other.fill(Character.MIN_VALUE, endIndex, other.lastIndex)
+        }
+    }
+
+    fun get(sb: StringBuilder, offset: Int = -1): Int {
+        var count = 0
+        forEach {
+            if (offset < 0) {
+                sb.append(it)
+            } else {
+                sb.insert(offset+count, it)
+            }
+            count++
+        }
+        return count
+    }
+
+    fun clear() {
+        size = 0
+        set { Character.MIN_VALUE }
+    }
+
+    inline fun forEach(operation: (Char) -> Unit) {
+        set { operation(it); it }
+    }
+
+    inline fun set(operation: (Char) -> Char) {
+        var i = 0
+        var currentChar = chars.first()
+
+        while (currentChar != Character.MIN_VALUE && i < chars.size - 1) {
+            chars[i] = operation(currentChar)
+            currentChar = chars[++i]
+        }
+    }
+}
\ No newline at end of file
diff --git a/common/src/main/kotlin/com/mechanica/engine/util/extensions/Arrays.kt b/common/src/main/kotlin/com/mechanica/engine/util/extensions/Arrays.kt
index 98530a1f..a5e67492 100644
--- a/common/src/main/kotlin/com/mechanica/engine/util/extensions/Arrays.kt
+++ b/common/src/main/kotlin/com/mechanica/engine/util/extensions/Arrays.kt
@@ -118,6 +118,25 @@ fun FloatArray.fill(iterator: Iterator<Vector>) {
     }
 }
 
+
+/**
+ * A version of for each that should be more efficient for lists that
+ * are fast at getting element with random access
+ *
+ * @param action action that should be performed on each element
+ */
+inline fun <E> Array<E>.fori(action: (E) -> Unit) {
+    for (i in this.indices) {
+        action(this[i])
+    }
+}
+
+inline fun <E> Array<E>.foriIndexed(action: (E, Int) -> Unit) {
+    for (i in this.indices) {
+        action(this[i], i)
+    }
+}
+
 fun List<*>.indexLooped(index: Int): Int {
     return when {
         index < 0 -> this.size + index
diff --git a/common/src/main/kotlin/com/mechanica/engine/util/extensions/Iterables.kt b/common/src/main/kotlin/com/mechanica/engine/util/extensions/Iterables.kt
index 1a1071f6..4cfa5e58 100644
--- a/common/src/main/kotlin/com/mechanica/engine/util/extensions/Iterables.kt
+++ b/common/src/main/kotlin/com/mechanica/engine/util/extensions/Iterables.kt
@@ -14,4 +14,22 @@ fun Iterable<Vector>.containsPoint(point: Vector): Boolean {
         prev = vec
     }
     return result
+}
+
+/**
+ * A version of for each that should be more efficient for lists that
+ * are fast at getting element with random access
+ *
+ * @param action action that should be performed on each element
+ */
+inline fun <E> List<E>.fori(action: (E) -> Unit) {
+    for (i in this.indices) {
+        action(this[i])
+    }
+}
+
+inline fun <E> List<E>.foriIndexed(action: (E, Int) -> Unit) {
+    for (i in this.indices) {
+        action(this[i], i)
+    }
 }
\ No newline at end of file
diff --git a/common/src/main/kotlin/com/mechanica/engine/util/extensions/Numbers.kt b/common/src/main/kotlin/com/mechanica/engine/util/extensions/Numbers.kt
index 3a05f536..8436af64 100644
--- a/common/src/main/kotlin/com/mechanica/engine/util/extensions/Numbers.kt
+++ b/common/src/main/kotlin/com/mechanica/engine/util/extensions/Numbers.kt
@@ -3,6 +3,7 @@ package com.mechanica.engine.util.extensions
 
 import kotlin.math.max
 import kotlin.math.min
+import kotlin.math.sign
 
 fun Number.isHigher(other: Number): Boolean {
     return this.toDouble() > other.toDouble()
@@ -55,8 +56,29 @@ fun Number.isLower(other1: Number, other2: Number, other3: Number, vararg others
 }
 
 fun Double.constrain(lower: Double, higher: Double): Double {
-    val restrainLower = max(this, lower)
-    return min(restrainLower, higher)
+    val sign = sign(higher - lower)
+    if (sign == 0.0) return lower
+
+    val restrainLower = max(sign*this, sign*lower)
+    return sign*min(restrainLower, sign*higher)
+}
+
+fun Double.constrainLooped(lower: Double, higher: Double): Double {
+    val diff = (higher - lower)
+    val sign = sign(diff)
+
+    if (sign == 0.0) return lower
+
+    return when {
+        sign*this < sign*lower -> higher + sign * (sign * this - lower) % diff
+        sign*this > sign*higher -> lower + sign * (sign * this - higher) % diff
+        else -> this
+    }
+}
+
+fun main() {
+    val num = (7.0).constrain(5.0, 5.0)
+    println(num)
 }
 
 fun Int.constrain(lower: Int, higher: Int): Int {
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/audio/ALAudioObject.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/audio/ALAudioObject.kt
new file mode 100644
index 00000000..9f66548a
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/audio/ALAudioObject.kt
@@ -0,0 +1,39 @@
+package com.mechanica.engine.audio
+
+import com.mechanica.engine.memory.useMemoryStack
+import org.joml.Vector3f
+import org.lwjgl.openal.AL10
+
+abstract class ALAudioObject : AudioObject {
+    private val _position: Vector3f by lazy { createVector3fSetterInterept(AL10.AL_POSITION, this::set3f) }
+    override var position: Vector3f
+        get() {
+            getVector3f(AL10.AL_POSITION, _position)
+            return _position
+        }
+        set(value) {
+            _position.set(value)
+        }
+
+    private val _velocity: Vector3f by lazy { createVector3fSetterInterept(AL10.AL_VELOCITY, this::set3f) }
+    override var velocity: Vector3f
+        get() {
+            getVector3f(AL10.AL_VELOCITY, _velocity)
+            return _velocity
+        }
+        set(value) {
+            _velocity.set(value)
+        }
+
+    protected abstract fun getVector3f(property: Int, vec: Vector3f)
+
+    protected abstract fun set3f(property: Int, x: Float, y: Float, z: Float)
+
+
+    protected fun createVector3fSetterInterept(property: Int, setter: (Int, Float, Float, Float) -> Unit) = object : Vector3f() {
+        override fun set(x: Float, y: Float, z: Float): Vector3f {
+            setter(property, x, y, z)
+            return super.set(x, y, z)
+        }
+    }
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/audio/ALListener.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/audio/ALListener.kt
new file mode 100644
index 00000000..fe3f25cb
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/audio/ALListener.kt
@@ -0,0 +1,82 @@
+package com.mechanica.engine.audio
+
+import com.mechanica.engine.memory.useMemoryStack
+import org.joml.Vector3f
+import org.lwjgl.openal.AL10.*
+import java.nio.FloatBuffer
+
+class ALListener : ALAudioObject(), Listener {
+    override var gain: Float
+        get() = alGetListenerf(AL_GAIN)
+        set(value) { alListenerf(AL_GAIN, value )}
+
+    override val orientation = ALOrientation()
+
+    override var distanceModel: Listener.DistanceModel = Listener.DistanceModel.INVERSE.also { alDistanceModel(distanceModelEnumToALNum(it)) }
+        set(value) { alDistanceModel(distanceModelEnumToALNum(value)) }
+
+    override fun getVector3f(property: Int, vec: Vector3f) {
+        useMemoryStack {
+            val floats = floats(0f, 0f, 0f)
+            alGetListenerfv(property, floats)
+            vec.set(floats[0], floats[1], floats[2])
+        }
+    }
+
+    override fun set3f(property: Int, x: Float, y: Float, z: Float) {
+        alListener3f(property, x, y, z)
+    }
+
+    inner class ALOrientation : Listener.Orientaion {
+        private val _at: Vector3f = createVector3fSetterInterept(AL_ORIENTATION, this::setAt)
+        override var at: Vector3f
+            get() {
+                get()
+                return _at
+            }
+            set(value) {
+                _at.set(value)
+            }
+
+        private val _up: Vector3f = createVector3fSetterInterept(AL_ORIENTATION, this::setUp)
+        override var up: Vector3f
+            get() {
+                get()
+                return _up
+            }
+            set(value) {
+                _up.set(value)
+            }
+
+        private fun get() {
+            useMemoryStack {
+                val floats = mallocFloat(6)
+                alGetListenerfv(AL_ORIENTATION, floats)
+                getValues(floats)
+            }
+        }
+
+        private fun setUp(property: Int = AL_ORIENTATION, x: Float, y: Float, z: Float) = set(property, _at.x, _at.y, _at.z, x, y, z)
+        private fun setAt(property: Int = AL_ORIENTATION, x: Float, y: Float, z: Float) = set(property, x, y, z, _up.x, _up.y, _up.z)
+
+        private fun set(property: Int, atX: Float, atY: Float, atZ: Float, upX: Float, upY: Float, upZ: Float) {
+            useMemoryStack {
+                val floats = mallocFloat(6)
+                floats.put(atX).put(atY).put(atZ)
+                        .put(upX).put(upY).put(upZ)
+                alListenerfv(property, floats)
+            }
+        }
+
+        private fun getValues(buffer: FloatBuffer) {
+            buffer.getVector3f(at)
+            buffer.getVector3f(up)
+            buffer.position(0)
+        }
+
+        private fun FloatBuffer.getVector3f(vec: Vector3f) {
+            vec.set(get(), get(), get())
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/audio/ALSound.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/audio/ALSound.kt
new file mode 100644
index 00000000..957ee8c1
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/audio/ALSound.kt
@@ -0,0 +1,31 @@
+package com.mechanica.engine.audio
+
+import org.lwjgl.openal.AL10.*
+
+class ALSound(file: AudioFile) : Sound, AudioFile by file {
+    override val id: Int = generateBufferId()
+    override val frequency: Int
+        get() = alGetBufferi(id, AL_FREQUENCY)
+
+    constructor(file: String) : this(OggAudioFile(file))
+
+    init {
+        alBufferData(id, format, buffer, sampleRate)
+    }
+
+    override fun destroy() {
+        alDeleteBuffers(id)
+    }
+
+    companion object {
+        fun generateBufferId(): Int {
+            alGetError()
+            val id = alGenBuffers()
+            val error = alGetError()
+            if (error != AL_NO_ERROR) {
+                throw IllegalStateException("Error generating OpenAL buffer, ERROR_CODE: $error")
+            }
+            return id
+        }
+    }
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/audio/ALSource.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/audio/ALSource.kt
new file mode 100644
index 00000000..ed349345
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/audio/ALSource.kt
@@ -0,0 +1,65 @@
+package com.mechanica.engine.audio
+
+import com.mechanica.engine.memory.useMemoryStack
+import org.joml.Vector3f
+import org.lwjgl.openal.AL10.*
+import kotlin.reflect.KProperty
+
+class ALSource(override var sound: Sound) : ALAudioObject(), SoundSource {
+    override val id: Int = alGenSources()
+
+    private val properties = ALSourceProperty(id)
+
+    override var gain: Float by properties.createProperty(AL_GAIN)
+    override var pitch: Float by properties.createProperty(AL_PITCH)
+    override var rolloff: Float by properties.createProperty(AL_ROLLOFF_FACTOR)
+    override var maxDistance: Float by properties.createProperty(AL_MAX_DISTANCE)
+    override var referenceDistance: Float by properties.createProperty(AL_REFERENCE_DISTANCE)
+
+    init {
+        alSourcei(id, AL_BUFFER, sound.id)
+    }
+
+    override fun play() {
+        alSourcePlay(id)
+    }
+
+    override fun pause() {
+        alSourcePause(id)
+    }
+
+    override fun stop() {
+        alSourceStop(id)
+    }
+
+    override fun destroy() {
+        alDeleteSources(id)
+    }
+
+
+    override fun getVector3f(property: Int, vec: Vector3f) {
+        useMemoryStack {
+            val floats = floats(0f, 0f, 0f)
+            alGetSourcefv(id, property, floats)
+            vec.set(floats[0], floats[1], floats[2])
+        }
+    }
+
+    override fun set3f(property: Int, x: Float, y: Float, z: Float) {
+        alSource3f(id, property, x, y, z)
+    }
+
+
+    private inner class ALFloatProperty(private val property: Int) {
+        operator fun getValue(thisRef: SoundSource, property: KProperty<*>): Float {
+            return getFloat(this.property)
+        }
+
+        operator fun setValue(thisRef: SoundSource, property: KProperty<*>, value: Float) {
+            setFloat(this.property, value)
+        }
+
+        private fun getFloat(property: Int) = alGetSourcef(id, property)
+        private fun setFloat(property: Int, float: Float) = alSourcef(id, property, float)
+    }
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/audio/ALSourceProperty.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/audio/ALSourceProperty.kt
new file mode 100644
index 00000000..c87c2d47
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/audio/ALSourceProperty.kt
@@ -0,0 +1,22 @@
+package com.mechanica.engine.audio
+
+import org.lwjgl.openal.AL10
+import kotlin.reflect.KProperty
+
+class ALSourceProperty(private val sourceId: Int) {
+
+    fun createProperty(property: Int) = DelegatedProperty(property)
+
+    private fun getFloat(property: Int) = AL10.alGetSourcef(sourceId, property)
+    private fun setFloat(property: Int, float: Float) = AL10.alSourcef(sourceId, property, float)
+
+    inner class DelegatedProperty(private val property: Int) {
+        operator fun getValue(thisRef: SoundSource, property: KProperty<*>): Float {
+            return getFloat(this.property)
+        }
+
+        operator fun setValue(thisRef: SoundSource, property: KProperty<*>, value: Float) {
+            setFloat(this.property, value)
+        }
+    }
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/audio/AudioUtils.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/audio/AudioUtils.kt
new file mode 100644
index 00000000..73f75388
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/audio/AudioUtils.kt
@@ -0,0 +1,23 @@
+package com.mechanica.engine.audio
+
+import org.lwjgl.openal.AL11.*
+
+fun distanceModelEnumToALNum(dm: Listener.DistanceModel): Int {
+    return when(dm) {
+        Listener.DistanceModel.INVERSE -> if (dm.clamped) AL_INVERSE_DISTANCE_CLAMPED else AL_INVERSE_DISTANCE
+        Listener.DistanceModel.LINEAR -> if (dm.clamped) AL_LINEAR_DISTANCE_CLAMPED else AL_LINEAR_DISTANCE
+        Listener.DistanceModel.EXPONENTIAL -> if (dm.clamped) AL_EXPONENT_DISTANCE_CLAMPED else AL_EXPONENT_DISTANCE
+    }
+}
+
+fun distanceModelALNumToEnum(dm: Int): Listener.DistanceModel {
+    return when(dm) {
+        AL_INVERSE_DISTANCE -> Listener.DistanceModel.INVERSE.also { it.clamped = false }
+        AL_INVERSE_DISTANCE_CLAMPED -> Listener.DistanceModel.INVERSE.also { it.clamped = true }
+        AL_EXPONENT_DISTANCE -> Listener.DistanceModel.EXPONENTIAL.also { it.clamped = false }
+        AL_EXPONENT_DISTANCE_CLAMPED -> Listener.DistanceModel.EXPONENTIAL.also { it.clamped = true }
+        AL_LINEAR_DISTANCE -> Listener.DistanceModel.LINEAR.also { it.clamped = false }
+        AL_LINEAR_DISTANCE_CLAMPED -> Listener.DistanceModel.LINEAR.also { it.clamped = true }
+        else -> Listener.DistanceModel.INVERSE
+    }
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/audio/OggAudioFile.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/audio/OggAudioFile.kt
new file mode 100644
index 00000000..eabb75b9
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/audio/OggAudioFile.kt
@@ -0,0 +1,55 @@
+package com.mechanica.engine.audio
+
+import com.mechanica.engine.memory.useMemoryStack
+import org.lwjgl.BufferUtils
+import org.lwjgl.openal.AL10
+import org.lwjgl.stb.STBVorbis
+import org.lwjgl.system.libc.LibCStdlib
+import java.nio.ShortBuffer
+
+class OggAudioFile(fileName: String) : AudioFile {
+    override val channels: Int
+    override val sampleRate: Int
+    override val buffer: ShortBuffer
+    override val format: Int
+        get() = when (channels) {
+            1 -> AL10.AL_FORMAT_MONO16
+            2 -> AL10.AL_FORMAT_STEREO16
+            else -> -1
+        }
+
+    init {
+        var channels = -1
+        var sampleRate = -1
+        var ogg: ShortBuffer? = null
+        useMemoryStack {
+            val channelBuffer = ints(0)
+            val sampleRateBuffer = ints(0)
+            ogg = STBVorbis.stb_vorbis_decode_filename(fileName.removePrefix("/"), channelBuffer, sampleRateBuffer)
+            channels = channelBuffer[0]
+            sampleRate = sampleRateBuffer[0]
+        }
+
+        this.buffer = convertToGCBuffer(ogg) ?: throw IllegalStateException("Unable to load audio file: $fileName")
+
+        this.channels = channels
+        this.sampleRate = sampleRate
+    }
+
+    /**
+     * Convert from a ShortBuffer generated by the STBVorbis call to a ShortBuffer that can be garbage collected
+     */
+    private fun convertToGCBuffer(ogg: ShortBuffer?): ShortBuffer? {
+        return if (ogg != null) {
+            val buffer = BufferUtils.createShortBuffer(ogg.remaining())
+            buffer.put(ogg).position(0)
+            freeVorbis(ogg)
+            buffer
+        } else null
+    }
+
+    private fun freeVorbis(buffer: ShortBuffer) {
+        buffer.position(0)
+        LibCStdlib.free(buffer)
+    }
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/config/BackendDebugConfiguration.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/config/BackendDebugConfiguration.kt
index 2326c6db..e25130a8 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/config/BackendDebugConfiguration.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/config/BackendDebugConfiguration.kt
@@ -19,4 +19,12 @@ object BackendDebugConfiguration : DebugConfiguration {
         get() = configuration?.printWarnings ?: false
     override val lwjglDebug: Boolean
         get() = configuration?.lwjglDebug ?: false
+
+    override fun pauseUpdates(pause: Boolean) {
+        configuration?.pauseUpdates(pause)
+    }
+
+    override fun frameAdvance() {
+        configuration?.frameAdvance()
+    }
 }
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/config/ConfigUtils.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/config/ConfigUtils.kt
new file mode 100644
index 00000000..ca301d19
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/config/ConfigUtils.kt
@@ -0,0 +1,8 @@
+package com.mechanica.engine.config
+
+import com.mechanica.engine.configuration.Configurable
+import com.mechanica.engine.context.DesktopApplication
+
+fun <T> Configurable<T>.configure(setup: T.() -> Unit) {
+    this.configureAs(DesktopApplication(), setup)
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/context/ALContext.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/context/ALContext.kt
new file mode 100644
index 00000000..1fbd2308
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/context/ALContext.kt
@@ -0,0 +1,35 @@
+package com.mechanica.engine.context
+
+import org.lwjgl.openal.AL
+import org.lwjgl.openal.ALC
+import org.lwjgl.openal.ALC10.*
+import java.nio.ByteBuffer
+import java.nio.IntBuffer
+
+object ALContext {
+    val device by lazy { getDefaultDevice() }
+    val context by lazy { createContext() }
+
+    fun initialize() {
+        val capabilities = ALC.createCapabilities(device)
+
+        alcMakeContextCurrent(context)
+
+        AL.createCapabilities(capabilities)
+    }
+
+    fun destroy() {
+        alcDestroyContext(context)
+        alcCloseDevice(device)
+    }
+
+    private fun getDefaultDevice(): Long {
+        val specifier: ByteBuffer? = null
+        return alcOpenDevice(specifier)
+    }
+
+    private fun createContext(): Long {
+        val attrs: IntBuffer? = null
+        return alcCreateContext(device, attrs)
+    }
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/context/DesktopApplication.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/context/DesktopApplication.kt
new file mode 100644
index 00000000..b48c782f
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/context/DesktopApplication.kt
@@ -0,0 +1,23 @@
+package com.mechanica.engine.context
+
+import com.mechanica.engine.context.loader.LwjglLoader
+import com.mechanica.engine.display.Window
+
+class DesktopApplication : Application {
+    override fun initialize(window: Window) {
+        GLContext.initialize(window)
+        val callbacks = GLInitializer.initialize(LwjglLoader())
+        GLContext.setCallbacks(window, callbacks)
+        ALContext.initialize()
+    }
+
+    override fun terminate() {
+        GLContext.free()
+        GLFWContext.terminate()
+        ALContext.destroy()
+    }
+
+    override fun startFrame() {
+        GLContext.startFrame()
+    }
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/context/GLContext.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/context/GLContext.kt
index 86533d47..a13dd4ed 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/context/GLContext.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/context/GLContext.kt
@@ -1,6 +1,8 @@
 package com.mechanica.engine.context
 
+import com.mechanica.engine.context.callbacks.EventCallbacks
 import com.mechanica.engine.display.Window
+import com.mechanica.engine.input.*
 import com.mechanica.engine.utils.enableAlphaBlending
 import org.lwjgl.glfw.GLFW
 import org.lwjgl.opengl.*
@@ -20,6 +22,9 @@ object GLContext : Version {
     override val version: Double
         get() = parsedVersionString?.version ?: throw IllegalStateException(errorMessage)
 
+    var initialized = false
+        private set
+
     fun isExtensionSupported(extension: String): Boolean {
         return extensionMap.containsKey(extension)
     }
@@ -45,6 +50,7 @@ object GLContext : Version {
         GL11.glEnable(GL11.GL_STENCIL_TEST)
 
         enableAlphaBlending()
+        initialized = true
     }
 
     private fun initContext(windowId: Long) {
@@ -52,6 +58,17 @@ object GLContext : Version {
         GL.createCapabilities()
     }
 
+
+    fun setCallbacks(window: Window, callbacks: EventCallbacks) {
+        GLFW.glfwSetKeyCallback(window.id, GLFWKeyHandler(callbacks.keyboardHandler))
+        GLFW.glfwSetCharCallback(window.id, GLFWTextInputHandler(callbacks.keyboardHandler))
+
+        GLFW.glfwSetMouseButtonCallback(window.id, GLFWMouseButtonHandler(callbacks.mouseHandler))
+        GLFW.glfwSetCursorPosCallback(window.id, GLFWMouseCursorHandler(callbacks.mouseHandler))
+        GLFW.glfwSetScrollCallback(window.id, GLFWScrollHandler(callbacks.mouseHandler))
+
+    }
+
     private fun parseVersionString(): GLVersionStringParser {
         val versionString: String = GL11.glGetString(GL11.GL_VERSION) ?:
         throw IllegalStateException("Unable to get the version of OpenGL")
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/context/GLFWContext.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/context/GLFWContext.kt
index 59a72dc3..329d3e3a 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/context/GLFWContext.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/context/GLFWContext.kt
@@ -8,7 +8,8 @@ object GLFWContext : Version {
     override val minorVersion: Int
     override val version: Double
 
-    private var initialized = false
+    var initialized = false
+        private set
 
     private var _samples = 4
     val samples: Int
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglAudioLoader.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglAudioLoader.kt
new file mode 100644
index 00000000..b8584091
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglAudioLoader.kt
@@ -0,0 +1,11 @@
+package com.mechanica.engine.context.loader
+
+import com.mechanica.engine.audio.*
+
+class LwjglAudioLoader : AudioLoader {
+    override fun sound(file: String) = ALSound(file)
+
+    override fun source(sound: Sound) = ALSource(sound)
+
+    override fun listener() = ALListener()
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglBufferLoader.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglBufferLoader.kt
index 90b81eee..d399e01e 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglBufferLoader.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglBufferLoader.kt
@@ -1,6 +1,6 @@
 package com.mechanica.engine.context.loader
 
-import com.mechanica.engine.context.loader.BufferLoader
+import com.mechanica.engine.audio.OggAudioFile
 import org.lwjgl.BufferUtils
 import org.lwjgl.system.MemoryUtil
 import java.nio.ByteBuffer
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglDisplayLoader.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglDisplayLoader.kt
new file mode 100644
index 00000000..2dc116f4
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglDisplayLoader.kt
@@ -0,0 +1,27 @@
+package com.mechanica.engine.context.loader
+
+import com.mechanica.engine.display.GLFWMonitor
+import com.mechanica.engine.display.GLFWWindow
+import com.mechanica.engine.display.Monitor
+import com.mechanica.engine.display.Window
+
+class LwjglDisplayLoader : DisplayLoader {
+    override fun createWindow(title: String, width: Int, height: Int): Window {
+        return GLFWWindow.create(title, width, height)
+    }
+
+    override fun createWindow(title: String, monitor: Monitor): Window {
+        return GLFWWindow.create(title, monitor)
+    }
+
+    override fun createWindow(title: String, width: Int, height: Int, monitor: Monitor): Window {
+        return GLFWWindow.create(title, width, height, monitor)
+    }
+
+    override val allMonitors: Array<out Monitor>
+        get() = GLFWMonitor.allMonitors
+
+    override fun getPrimaryMonitor(): Monitor {
+        return GLFWMonitor.getPrimaryMonitor()
+    }
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglFontLoader.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglFontLoader.kt
index 059d9898..1a6fca54 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglFontLoader.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglFontLoader.kt
@@ -1,12 +1,16 @@
 package com.mechanica.engine.context.loader
 
-import com.mechanica.engine.text.LwjglFont
+import com.mechanica.engine.text.LwjglStandardFont
 import com.mechanica.engine.text.Font
-import com.mechanica.engine.context.loader.FontLoader
 import com.mechanica.engine.resources.Resource
+import com.mechanica.engine.text.FontAtlasConfiguration
 
 class LwjglFontLoader : FontLoader {
-    override val defaultFont: Font by lazy { LwjglFont(Resource("res/fonts/Roboto-Regular.ttf")) }
+    override val defaultFont: Font by lazy { LwjglStandardFont(Resource("res/fonts/Roboto-Regular.ttf")) {
+        width = 1024
+        height = 1024
+        characterSize = 200f
+    } }
 
-    override fun font(res: Resource) = LwjglFont(res)
+    override fun font(res: Resource, initializer: FontAtlasConfiguration.() -> Unit) = LwjglStandardFont(res, initializer)
 }
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglInputLoader.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglInputLoader.kt
new file mode 100644
index 00000000..3d0cf566
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglInputLoader.kt
@@ -0,0 +1,8 @@
+package com.mechanica.engine.context.loader
+
+import com.mechanica.engine.input.GLFWKeyIDs
+import com.mechanica.engine.input.KeyIDs
+
+class LwjglInputLoader : InputLoader {
+    override fun keyIds() = GLFWKeyIDs()
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglLoader.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglLoader.kt
index 25cb78c5..3b1a3939 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglLoader.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglLoader.kt
@@ -1,18 +1,44 @@
 package com.mechanica.engine.context.loader
 
+import com.mechanica.engine.display.GLFWWindow
 import com.mechanica.engine.shader.qualifiers.AttributeQualifier
 import com.mechanica.engine.shader.qualifiers.Qualifier
+import com.mechanica.engine.shader.script.Shader
+import com.mechanica.engine.shader.script.ShaderLoader
+import com.mechanica.engine.shader.script.ShaderScript
 import com.mechanica.engine.shader.vbo.LwjglElementArrayType
+import org.lwjgl.opengl.GL20
 
 class LwjglLoader : GLLoader {
     override val constants = LwjglConstants()
     override val bufferLoader = LwjglBufferLoader()
     override val fontLoader = LwjglFontLoader()
     override val graphicsLoader = LwjglGraphicsLoader()
+    override val audioLoader = LwjglAudioLoader()
+    override val inputLoader = LwjglInputLoader()
 
     override fun createAttributeLoader(qualifier: AttributeQualifier) = LwjglAttributeLoader(qualifier)
 
     override fun createUniformLoader(qualifier: Qualifier) = LwjglUniformLoader(qualifier)
 
     override fun createElementArray() = LwjglElementArrayType()
+
+    override fun defaultShader(vertex: ShaderScript, fragment: ShaderScript, tessellation: ShaderScript?, geometry: ShaderScript?): Shader {
+        return object : Shader() {
+            override val vertex = vertex
+            override val fragment = fragment
+            override val tessellation = tessellation
+            override val geometry = geometry
+
+            private val loader: ShaderLoader by lazy { ShaderLoader(vertex, fragment, tessellation, geometry) }
+
+            override val id: Int get() = loader.id
+
+            override fun loadProgram(id: Int) {
+                GL20.glUseProgram(id)
+            }
+
+            override fun loadUniformLocation(name: String) = GL20.glGetUniformLocation(id, name)
+        }
+    }
 }
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglUniformLoader.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglUniformLoader.kt
index 5736d15e..0b0c7669 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglUniformLoader.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/context/loader/LwjglUniformLoader.kt
@@ -1,8 +1,7 @@
 package com.mechanica.engine.context.loader
 
-import com.mechanica.engine.context.loader.UniformLoader
 import com.mechanica.engine.shader.qualifiers.Qualifier
-import com.mechanica.engine.shader.vars.uniforms.*
+import com.mechanica.engine.shader.uniforms.*
 import org.joml.Matrix4f
 
 class LwjglUniformLoader(override val qualifier: Qualifier): UniformLoader {
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/display/Monitor.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/display/GLFWMonitor.kt
similarity index 79%
rename from desktop-application/src/main/kotlin/com/mechanica/engine/display/Monitor.kt
rename to desktop-application/src/main/kotlin/com/mechanica/engine/display/GLFWMonitor.kt
index dd0a3365..71270e5f 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/display/Monitor.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/display/GLFWMonitor.kt
@@ -7,9 +7,14 @@ import org.lwjgl.glfw.GLFWMonitorCallback
 import org.lwjgl.glfw.GLFWVidMode
 import org.lwjgl.system.MemoryStack
 
-class Monitor private constructor(val id: Long) {
+class GLFWMonitor private constructor(override val id: Long) : Monitor {
 
-    val name by lazy { glfwGetMonitorName(id) ?: "N/A" }
+    override val name by lazy { glfwGetMonitorName(id) ?: "N/A" }
+
+    override val width: Int
+        get() = currentVideoMode.width()
+    override val height: Int
+        get() = currentVideoMode.height()
 
     var monitorUserPointer: Long
         get() = glfwGetMonitorUserPointer(id)
@@ -19,6 +24,7 @@ class Monitor private constructor(val id: Long) {
 
     val currentVideoMode: GLFWVidMode
         get() = glfwGetVideoMode(id) ?: throw IllegalStateException("Error retrieving the current Vid Mode")
+
     val supportedVideoModes: Array<GLFWVidMode>
         get() {
             val vidmodes = glfwGetVideoModes(id)
@@ -29,7 +35,7 @@ class Monitor private constructor(val id: Long) {
             }
         }
 
-    val size: Size
+    override val size: Monitor.Size
         get() {
             var width = -1
             var height = -1
@@ -40,10 +46,10 @@ class Monitor private constructor(val id: Long) {
                 width = widthBuffer[0]
                 height = heightBuffer[0]
             }
-            return Size(width, height)
+            return Monitor.Size(width, height)
         }
 
-    val contentScale: ContentScale
+    override val contentScale: Monitor.ContentScale
         get() {
             var xScale = 1f
             var yScale = 1f
@@ -54,7 +60,7 @@ class Monitor private constructor(val id: Long) {
                 xScale = xBuffer[0]
                 yScale = yBuffer[0]
             }
-            return ContentScale(xScale, yScale)
+            return Monitor.ContentScale(xScale, yScale)
         }
 
     var gammaRamp: GLFWGammaRamp
@@ -71,10 +77,6 @@ class Monitor private constructor(val id: Long) {
             field = value
         }
 
-    data class Size(val width_mm: Int, val height_mm: Int)
-
-    data class ContentScale(val xScale: Float, val yScale: Float)
-
     companion object {
         var allMonitors = createMonitorsArray()
             private set
@@ -83,22 +85,22 @@ class Monitor private constructor(val id: Long) {
                 return field
             }
 
-        fun getPrimaryMonitor(): Monitor {
+        fun getPrimaryMonitor(): GLFWMonitor {
             GLFWContext.initialize()
-            return Monitor(glfwGetPrimaryMonitor())
+            return GLFWMonitor(glfwGetPrimaryMonitor())
         }
 
-        private fun createMonitorsArray(): Array<Monitor> {
+        private fun createMonitorsArray(): Array<GLFWMonitor> {
             GLFWContext.initialize()
             val pointers = glfwGetMonitors()
             return if (pointers != null) {
-                Array(pointers.limit()) {Monitor(pointers[it])}
+                Array(pointers.limit()) {GLFWMonitor(pointers[it])}
             } else {
                 emptyArray()
             }
         }
 
-        private fun checkMonitors(monitors: Array<Monitor>): Array<Monitor> {
+        private fun checkMonitors(monitors: Array<GLFWMonitor>): Array<GLFWMonitor> {
             val pointers = glfwGetMonitors()
             if (pointers != null) {
                 val pointerSize = pointers.limit()
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/display/Window.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/display/GLFWWindow.kt
similarity index 66%
rename from desktop-application/src/main/kotlin/com/mechanica/engine/display/Window.kt
rename to desktop-application/src/main/kotlin/com/mechanica/engine/display/GLFWWindow.kt
index 40f89506..0ac38f20 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/display/Window.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/display/GLFWWindow.kt
@@ -1,69 +1,75 @@
 package com.mechanica.engine.display
 
+import com.mechanica.engine.context.GLContext
 import com.mechanica.engine.context.GLFWContext
+import com.mechanica.engine.context.callbacks.EventCallbacks
+import com.mechanica.engine.resources.Resource
 import com.mechanica.engine.utils.ImageData
 import org.lwjgl.glfw.Callbacks
 import org.lwjgl.glfw.GLFW.*
 import org.lwjgl.glfw.GLFWImage
 import org.lwjgl.system.MemoryUtil
-import com.mechanica.engine.resources.Resource
 import java.nio.ByteBuffer
 
 
-class Window private constructor(width: Int, height: Int, val title: String, monitor: Monitor?) {
-    val id: Long= glfwCreateWindow(width, height, title, monitor?.id ?: MemoryUtil.NULL, MemoryUtil.NULL)
+class GLFWWindow private constructor(width: Int, height: Int, override val title: String, monitor: Monitor?) : Window {
+    override val id: Long= glfwCreateWindow(width, height, title, monitor?.id ?: MemoryUtil.NULL, MemoryUtil.NULL)
     var hasInitialized = false
         private set
 
-    val width: Int
+    override val width: Int
         get() = resolution.width
-    val height: Int
+    override val height: Int
         get() = resolution.height
-    val aspectRatio: Double
+    override val aspectRatio: Double
         get() = width.toDouble()/height.toDouble()
-    var isFocused: Boolean
+    override var isFocused: Boolean
         get() = glfwGetWindowAttrib(id, GLFW_FOCUSED) == GLFW_TRUE
         set(value) { if (value) glfwFocusWindow(id) }
 
-    var isIconified: Boolean
+    override var isIconified: Boolean
         get() = glfwGetWindowAttrib(id, GLFW_ICONIFIED ) == GLFW_TRUE
         set(value) {
             if (value) glfwIconifyWindow(id)
             else glfwRestoreWindow(id) }
-    var isMaximized: Boolean
+    override var isMaximized: Boolean
         get() = glfwGetWindowAttrib(id, GLFW_MAXIMIZED ) == GLFW_TRUE
         set(value) {
             if (value) glfwMaximizeWindow(id)
             else glfwRestoreWindow(id) }
 
-    val isHovered: Boolean
+    override val isHovered: Boolean
         get() = glfwGetWindowAttrib(id, GLFW_HOVERED ) == GLFW_TRUE
-    var isVisible: Boolean
+    override var isVisible: Boolean
         get() = glfwGetWindowAttrib(id, GLFW_VISIBLE ) == GLFW_TRUE
         set(value) {
             if (value) glfwShowWindow(id)
             else glfwHideWindow(id) }
-    var isResizable: Boolean
+    override var isResizable: Boolean
         get() = glfwGetWindowAttrib(id, GLFW_RESIZABLE ) == 1
         set(value) { glfwSetWindowAttrib(id, GLFW_RESIZABLE, if (value) GLFW_TRUE else GLFW_FALSE ) }
-    var isDecorated: Boolean
+    override var isDecorated: Boolean
         get() = glfwGetWindowAttrib(id, GLFW_DECORATED ) == 1
         set(value) { glfwSetWindowAttrib(id, GLFW_DECORATED, if (value) GLFW_TRUE else GLFW_FALSE ) }
-    var isFloating: Boolean
+    override var isFloating: Boolean
         get() = glfwGetWindowAttrib(id, GLFW_FLOATING ) == 1
         set(value) { glfwSetWindowAttrib(id, GLFW_FLOATING, if (value) GLFW_TRUE else GLFW_FALSE ) }
-    var shouldClose: Boolean
+    override var shouldClose: Boolean
         get() = glfwWindowShouldClose(id)
         set(value) { glfwSetWindowShouldClose(id, value) }
-    var vSync: Boolean = true
+    override var vSync: Boolean = true
         set(value) {
-            glfwSwapInterval(if (value) 1 else 0)
+            if (GLContext.initialized) {
+                glfwSwapInterval(if (value) 1 else 0)
+            }
             field = value
         }
+    override val isFullscreen: Boolean
+        get() = monitor != null
 
     private var finished = false
 
-    var opacity: Float
+    override var opacity: Float
         get() = glfwGetWindowOpacity(id)
         set(value) = glfwSetWindowOpacity(id, value)
 
@@ -71,7 +77,7 @@ class Window private constructor(width: Int, height: Int, val title: String, mon
         get() {
             val monitor = field
             val monitorId = glfwGetWindowMonitor(id)
-            val foundMonitor = Monitor.allMonitors.firstOrNull { it.id == monitorId }
+            val foundMonitor = GLFWMonitor.allMonitors.firstOrNull { it.id == monitorId }
             return if (monitorId == MemoryUtil.NULL){
                 field = null
                 null
@@ -88,17 +94,17 @@ class Window private constructor(width: Int, height: Int, val title: String, mon
             field = value
         }
 
-    val position: Position = Position()
+    override val position: PositionImpl = PositionImpl()
 
-    val resolution: Dimension by lazy {
+    override val resolution: Window.Dimension by lazy {
         setResolution(DimensionImpl(0, 0, false))
     }
 
-    val size: Dimension by lazy {
+    override val size: Window.Dimension by lazy {
         setWindowSize(DimensionImpl(0, 0, false))
     }
 
-    val isResizing: Boolean
+    override val isResizing: Boolean
         get() {
             val resolution = (resolution as DimensionImpl)
             val size = (size as DimensionImpl)
@@ -130,7 +136,7 @@ class Window private constructor(width: Int, height: Int, val title: String, mon
 
     }
 
-    fun addRefreshCallback(callback: (Window) -> Unit) {
+    override fun addRefreshCallback(callback: (Window) -> Unit) {
         callbackList.add(callback)
     }
 
@@ -157,8 +163,9 @@ class Window private constructor(width: Int, height: Int, val title: String, mon
         }
     }
 
-    fun update(): Boolean {
+    override fun update(): Boolean {
         swapBuffers()
+        EventCallbacks.prepare()
         pollEvents()
         val shouldClose = this.shouldClose
         if (finished) {
@@ -167,7 +174,7 @@ class Window private constructor(width: Int, height: Int, val title: String, mon
         return !shouldClose
     }
 
-    fun destroy() {
+    override fun destroy() {
         if (hasInitialized) {
             Callbacks.glfwFreeCallbacks(id)
             glfwDestroyWindow(id)
@@ -183,11 +190,11 @@ class Window private constructor(width: Int, height: Int, val title: String, mon
         glfwPollEvents()
     }
 
-    fun requestAttention() {
+    override fun requestAttention() {
         glfwRequestWindowAttention(id)
     }
 
-    private fun setWindowSize(out: DimensionImpl): Dimension {
+    private fun setWindowSize(out: DimensionImpl): Window.Dimension {
         val widthArray = IntArray(1)
         val heightArray = IntArray(1)
         glfwGetWindowSize(id, widthArray, heightArray)
@@ -196,7 +203,7 @@ class Window private constructor(width: Int, height: Int, val title: String, mon
         return out
     }
 
-    private fun setResolution(out: DimensionImpl): Dimension {
+    private fun setResolution(out: DimensionImpl): Window.Dimension {
         val widthArray = IntArray(1)
         val heightArray = IntArray(1)
         glfwGetFramebufferSize(id, widthArray, heightArray)
@@ -205,7 +212,7 @@ class Window private constructor(width: Int, height: Int, val title: String, mon
         return out
     }
 
-    fun setIcon(resource: Resource) {
+    override fun setIcon(resource: Resource) {
         val image = ImageData(resource)
 
         if (image.data != null) {
@@ -215,7 +222,7 @@ class Window private constructor(width: Int, height: Int, val title: String, mon
         image.free()
     }
 
-    fun setIcon(width: Int, height: Int, imageBuffer: ByteBuffer) {
+    override fun setIcon(width: Int, height: Int, imageBuffer: ByteBuffer) {
         val image: GLFWImage = GLFWImage.malloc()
         val imagebf: GLFWImage.Buffer = GLFWImage.malloc(1)
 
@@ -225,32 +232,55 @@ class Window private constructor(width: Int, height: Int, val title: String, mon
         glfwSetWindowIcon(id, imagebf)
     }
 
-    fun setFullscreen(monitor: Monitor) {
-        val vidMode = monitor.currentVideoMode
+    override fun setFullscreen() {
+        setFullscreen(Monitor.getPrimaryMonitor())
+    }
+
+    override fun setFullscreen(monitor: Monitor) {
+        val vidMode = if (monitor is GLFWMonitor) monitor.currentVideoMode else throw IllegalStateException("Unable to put window into fullscreen mode")
         glfwSetWindowMonitor(id, monitor.id, 0, 0, vidMode.width(), vidMode.height(), vidMode.refreshRate())
     }
 
-    fun setFullscreen(monitor: Monitor, width: Int, height: Int, refreshRate: Int = 60) {
+    override fun setFullscreen(monitor: Monitor, width: Int, height: Int, refreshRate: Int) {
         glfwSetWindowMonitor(id, monitor.id, 0, 0, width, height, refreshRate)
     }
 
-    fun exitFullscreen() {
+    override fun exitFullscreen(width: Int, height: Int) {
         if (this.monitor != null) {
-            val vidMode = Monitor.getPrimaryMonitor().currentVideoMode
-            glfwSetWindowMonitor(id, MemoryUtil.NULL, 0, 0, vidMode.width(), vidMode.height(), 0)
+            val vidMode = GLFWMonitor.getPrimaryMonitor().currentVideoMode
+            val screenWidth = vidMode.width()
+            val screenHeight = vidMode.height()
+
+            if (width < 0 || height < 0) {
+                setDefaultWindowDimensions(screenWidth, screenHeight)
+            } else {
+                val x = screenWidth - width/2
+                val y = screenHeight - height/2
+                glfwSetWindowMonitor(id, MemoryUtil.NULL, x, y, width, height, vidMode.refreshRate())
+
+            }
         }
     }
 
-    inner class Position {
+    private fun setDefaultWindowDimensions(screenWidth: Int, screenHeight: Int) {
+        val windowWidth = (0.75*screenWidth).toInt()
+        val windowHeight = (0.75*screenHeight).toInt()
+        val x = screenWidth/2 - windowWidth/2
+        val y = screenHeight/2 - windowHeight/2
+        glfwSetWindowMonitor(id, MemoryUtil.NULL, x, y, windowWidth, windowHeight, 0)
+
+    }
+
+    inner class PositionImpl : Window.Position {
         val xArray = IntArray(1)
         val yArray = IntArray(1)
-        var x: Int
+        override var x: Int
             set(value) = set(value, y)
             get() {
                 updatePosition()
                 return xArray[0]
             }
-        var y: Int
+        override var y: Int
             set(value) = set(x, value)
             get() {
                 updatePosition()
@@ -261,29 +291,25 @@ class Window private constructor(width: Int, height: Int, val title: String, mon
             glfwGetWindowPos(id, xArray, yArray)
         }
 
-        fun set(x: Int, y: Int) {
+        override fun set(x: Int, y: Int) {
             glfwSetWindowPos(id, x, y)
         }
     }
 
-    interface Dimension {
-        val width: Int
-        val height: Int
-    }
     private data class DimensionImpl(
             override var width: Int, 
             override var height: Int, 
-            var isChanging: Boolean) : Dimension
+            var isChanging: Boolean) : Window.Dimension
 
     companion object {
         fun create(title: String, width: Int, height: Int): Window {
             GLFWContext.initialize()
-            return Window(width, height, title, null)
+            return GLFWWindow(width, height, title, null)
         }
 
         fun create(title: String, monitor: Monitor): Window {
             GLFWContext.initialize()
-            val vidMode = monitor.currentVideoMode
+            val vidMode = if (monitor is GLFWMonitor) monitor.currentVideoMode else throw IllegalStateException("Unable to create window")
             val width = vidMode.width()
             val height = vidMode.height()
             glfwWindowHint(GLFW_RED_BITS, vidMode.redBits())
@@ -291,12 +317,12 @@ class Window private constructor(width: Int, height: Int, val title: String, mon
             glfwWindowHint(GLFW_BLUE_BITS, vidMode.blueBits())
             glfwWindowHint(GLFW_REFRESH_RATE, vidMode.refreshRate())
 
-            return Window(width, height, title, monitor)
+            return GLFWWindow(width, height, title, monitor)
         }
 
         fun create(title: String, width: Int, height: Int, monitor: Monitor): Window {
             GLFWContext.initialize()
-            return Window(width, height, title, monitor)
+            return GLFWWindow(width, height, title, monitor)
         }
 
     }
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/input/GLFWKeyHandler.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/input/GLFWKeyHandler.kt
new file mode 100644
index 00000000..312dd561
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/input/GLFWKeyHandler.kt
@@ -0,0 +1,15 @@
+package com.mechanica.engine.input
+
+import com.mechanica.engine.context.callbacks.KeyboardHandler
+import org.lwjgl.glfw.GLFW
+import org.lwjgl.glfw.GLFWKeyCallback
+
+class GLFWKeyHandler(private val handler: KeyboardHandler) : GLFWKeyCallback() {
+    override fun invoke(window: Long, key: Int, scancode: Int, action: Int, mods: Int) {
+        if (action == GLFW.GLFW_PRESS) {
+            handler.keyPressed(key)
+        } else if (action == GLFW.GLFW_RELEASE) {
+            handler.keyReleased(key)
+        }
+    }
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/input/GLFWKeyIDs.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/input/GLFWKeyIDs.kt
new file mode 100644
index 00000000..ad1d53d1
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/input/GLFWKeyIDs.kt
@@ -0,0 +1,148 @@
+package com.mechanica.engine.input
+
+import org.lwjgl.glfw.GLFW.*
+
+class GLFWKeyIDs : KeyIDs {
+    override val UNKNOWN = GLFWKey(GLFW_KEY_UNKNOWN)
+    override val M1 = GLFWKey(GLFW_MOUSE_BUTTON_1, "LEFT CLICK")
+    override val M2 = GLFWKey(GLFW_MOUSE_BUTTON_2, "RIGHT CLICK")
+    override val M3 = GLFWKey(GLFW_MOUSE_BUTTON_3)
+    override val M4 = GLFWKey(GLFW_MOUSE_BUTTON_4)
+    override val M5 = GLFWKey(GLFW_MOUSE_BUTTON_5)
+    override val M6 = GLFWKey(GLFW_MOUSE_BUTTON_6)
+    override val M7 = GLFWKey(GLFW_MOUSE_BUTTON_7)
+    override val M8 = GLFWKey(GLFW_MOUSE_BUTTON_8)
+    override val SPACE = GLFWKey(GLFW_KEY_SPACE, "SPACE")
+    override val APOSTROPHE = GLFWKey(GLFW_KEY_APOSTROPHE)
+    override val COMMA = GLFWKey(GLFW_KEY_COMMA)
+    override val MINUS = GLFWKey(GLFW_KEY_MINUS)
+    override val PERIOD = GLFWKey(GLFW_KEY_PERIOD)
+    override val SLASH = GLFWKey(GLFW_KEY_SLASH)
+    override val N0 = GLFWKey(GLFW_KEY_0)
+    override val N1 = GLFWKey(GLFW_KEY_1)
+    override val N2 = GLFWKey(GLFW_KEY_2)
+    override val N3 = GLFWKey(GLFW_KEY_3)
+    override val N4 = GLFWKey(GLFW_KEY_4)
+    override val N5 = GLFWKey(GLFW_KEY_5)
+    override val N6 = GLFWKey(GLFW_KEY_6)
+    override val N7 = GLFWKey(GLFW_KEY_7)
+    override val N8 = GLFWKey(GLFW_KEY_8)
+    override val N9 = GLFWKey(GLFW_KEY_9)
+    override val SEMICOLON = GLFWKey(GLFW_KEY_SEMICOLON)
+    override val EQUAL = GLFWKey(GLFW_KEY_EQUAL)
+    override val A = GLFWKey(GLFW_KEY_A)
+    override val B = GLFWKey(GLFW_KEY_B)
+    override val C = GLFWKey(GLFW_KEY_C)
+    override val D = GLFWKey(GLFW_KEY_D)
+    override val E = GLFWKey(GLFW_KEY_E)
+    override val F = GLFWKey(GLFW_KEY_F)
+    override val G = GLFWKey(GLFW_KEY_G)
+    override val H = GLFWKey(GLFW_KEY_H)
+    override val I = GLFWKey(GLFW_KEY_I)
+    override val J = GLFWKey(GLFW_KEY_J)
+    override val K = GLFWKey(GLFW_KEY_K)
+    override val L = GLFWKey(GLFW_KEY_L)
+    override val M = GLFWKey(GLFW_KEY_M)
+    override val N = GLFWKey(GLFW_KEY_N)
+    override val O = GLFWKey(GLFW_KEY_O)
+    override val P = GLFWKey(GLFW_KEY_P)
+    override val Q = GLFWKey(GLFW_KEY_Q)
+    override val R = GLFWKey(GLFW_KEY_R)
+    override val S = GLFWKey(GLFW_KEY_S)
+    override val T = GLFWKey(GLFW_KEY_T)
+    override val U = GLFWKey(GLFW_KEY_U)
+    override val V = GLFWKey(GLFW_KEY_V)
+    override val W = GLFWKey(GLFW_KEY_W)
+    override val X = GLFWKey(GLFW_KEY_X)
+    override val Y = GLFWKey(GLFW_KEY_Y)
+    override val Z = GLFWKey(GLFW_KEY_Z)
+    override val LEFT_BRACKET = GLFWKey(GLFW_KEY_LEFT_BRACKET)
+    override val BACKSLASH = GLFWKey(GLFW_KEY_BACKSLASH)
+    override val RIGHT_BRACKET = GLFWKey(GLFW_KEY_RIGHT_BRACKET)
+    override val GRAVE_ACCENT = GLFWKey(GLFW_KEY_GRAVE_ACCENT)
+    override val WORLD_1 = GLFWKey(GLFW_KEY_WORLD_1)
+    override val WORLD_2 = GLFWKey(GLFW_KEY_WORLD_2)
+    override val ESC = GLFWKey(GLFW_KEY_ESCAPE)
+    override val ENTER = GLFWKey(GLFW_KEY_ENTER)
+    override val TAB = GLFWKey(GLFW_KEY_TAB)
+    override val BACKSPACE = GLFWKey(GLFW_KEY_BACKSPACE)
+    override val INSERT = GLFWKey(GLFW_KEY_INSERT)
+    override val DELETE = GLFWKey(GLFW_KEY_DELETE)
+    override val RIGHT = GLFWKey(GLFW_KEY_RIGHT)
+    override val LEFT = GLFWKey(GLFW_KEY_LEFT)
+    override val DOWN = GLFWKey(GLFW_KEY_DOWN)
+    override val UP = GLFWKey(GLFW_KEY_UP)
+    override val PAGE_UP = GLFWKey(GLFW_KEY_PAGE_UP)
+    override val PAGE_DOWN = GLFWKey(GLFW_KEY_PAGE_DOWN)
+    override val HOME = GLFWKey(GLFW_KEY_HOME)
+    override val END = GLFWKey(GLFW_KEY_END)
+    override val CAPS_LOCK = GLFWKey(GLFW_KEY_CAPS_LOCK)
+    override val SCROLL_LOCK = GLFWKey(GLFW_KEY_SCROLL_LOCK)
+    override val NUM_LOCK = GLFWKey(GLFW_KEY_NUM_LOCK)
+    override val PRINT_SCREEN = GLFWKey(GLFW_KEY_PRINT_SCREEN)
+    override val PAUSE = GLFWKey(GLFW_KEY_PAUSE)
+    override val F1 = GLFWKey(GLFW_KEY_F1)
+    override val F2 = GLFWKey(GLFW_KEY_F2)
+    override val F3 = GLFWKey(GLFW_KEY_F3)
+    override val F4 = GLFWKey(GLFW_KEY_F4)
+    override val F5 = GLFWKey(GLFW_KEY_F5)
+    override val F6 = GLFWKey(GLFW_KEY_F6)
+    override val F7 = GLFWKey(GLFW_KEY_F7)
+    override val F8 = GLFWKey(GLFW_KEY_F8)
+    override val F9 = GLFWKey(GLFW_KEY_F9)
+    override val F10 = GLFWKey(GLFW_KEY_F10)
+    override val F11 = GLFWKey(GLFW_KEY_F11)
+    override val F12 = GLFWKey(GLFW_KEY_F12)
+    override val F13 = GLFWKey(GLFW_KEY_F13)
+    override val F14 = GLFWKey(GLFW_KEY_F14)
+    override val F15 = GLFWKey(GLFW_KEY_F15)
+    override val F16 = GLFWKey(GLFW_KEY_F16)
+    override val F17 = GLFWKey(GLFW_KEY_F17)
+    override val F18 = GLFWKey(GLFW_KEY_F18)
+    override val F19 = GLFWKey(GLFW_KEY_F19)
+    override val F20 = GLFWKey(GLFW_KEY_F20)
+    override val F21 = GLFWKey(GLFW_KEY_F21)
+    override val F22 = GLFWKey(GLFW_KEY_F22)
+    override val F23 = GLFWKey(GLFW_KEY_F23)
+    override val F24 = GLFWKey(GLFW_KEY_F24)
+    override val F25 = GLFWKey(GLFW_KEY_F25)
+    override val KP_0 = GLFWKey(GLFW_KEY_KP_0)
+    override val KP_1 = GLFWKey(GLFW_KEY_KP_1)
+    override val KP_2 = GLFWKey(GLFW_KEY_KP_2)
+    override val KP_3 = GLFWKey(GLFW_KEY_KP_3)
+    override val KP_4 = GLFWKey(GLFW_KEY_KP_4)
+    override val KP_5 = GLFWKey(GLFW_KEY_KP_5)
+    override val KP_6 = GLFWKey(GLFW_KEY_KP_6)
+    override val KP_7 = GLFWKey(GLFW_KEY_KP_7)
+    override val KP_8 = GLFWKey(GLFW_KEY_KP_8)
+    override val KP_9 = GLFWKey(GLFW_KEY_KP_9)
+    override val KP_DECIMAL = GLFWKey(GLFW_KEY_KP_DECIMAL)
+    override val KP_DIVIDE = GLFWKey(GLFW_KEY_KP_DIVIDE)
+    override val KP_MULTIPLY = GLFWKey(GLFW_KEY_KP_MULTIPLY)
+    override val KP_SUBTRACT = GLFWKey(GLFW_KEY_KP_SUBTRACT)
+    override val KP_ADD = GLFWKey(GLFW_KEY_KP_ADD)
+    override val KP_ENTER = GLFWKey(GLFW_KEY_KP_ENTER)
+    override val KP_EQUAL = GLFWKey(GLFW_KEY_KP_EQUAL)
+    override val LSHIFT = GLFWKey(GLFW_KEY_LEFT_SHIFT, "SHIFT")
+    override val LCTRL = GLFWKey(GLFW_KEY_LEFT_CONTROL)
+    override val LALT = GLFWKey(GLFW_KEY_LEFT_ALT)
+    override val LEFT_SUPER = GLFWKey(GLFW_KEY_LEFT_SUPER)
+    override val RSHIFT = GLFWKey(GLFW_KEY_RIGHT_SHIFT)
+    override val RCTRL = GLFWKey(GLFW_KEY_RIGHT_CONTROL)
+    override val RALT = GLFWKey(GLFW_KEY_RIGHT_ALT)
+    override val RIGHT_SUPER = GLFWKey(GLFW_KEY_RIGHT_SUPER)
+    override val MENU = GLFWKey(GLFW_KEY_MENU)
+    override val SCROLL_UP = GLFWKey(1000, "scroll up")
+    override val SCROLL_DOWN = GLFWKey(1001, "scroll down")
+    override val SCROLL = GLFWKey(1002, "scroll")
+
+    class GLFWKey(override val id: Int, label: String? = null) : KeyID {
+        private var _label: String? = label
+
+        override val label: String
+            get() {
+                val l = _label
+                return l ?: glfwGetKeyName(id, 0)?.also { _label = it } ?: "?"
+            }
+    }
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/input/GLFWMouseButtonHandler.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/input/GLFWMouseButtonHandler.kt
new file mode 100644
index 00000000..84369d26
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/input/GLFWMouseButtonHandler.kt
@@ -0,0 +1,15 @@
+package com.mechanica.engine.input
+
+import com.mechanica.engine.context.callbacks.MouseHandler
+import org.lwjgl.glfw.GLFW
+import org.lwjgl.glfw.GLFWMouseButtonCallback
+
+class GLFWMouseButtonHandler(private val handler: MouseHandler) : GLFWMouseButtonCallback() {
+    override fun invoke(window: Long, button: Int, action: Int, mods: Int) {
+        if (action == GLFW.GLFW_PRESS) {
+            handler.buttonPressed(button)
+        } else if (action == GLFW.GLFW_RELEASE) {
+            handler.buttonReleased(button)
+        }
+    }
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/input/GLFWMouseCursorHandler.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/input/GLFWMouseCursorHandler.kt
new file mode 100644
index 00000000..d3f5e3ed
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/input/GLFWMouseCursorHandler.kt
@@ -0,0 +1,10 @@
+package com.mechanica.engine.input
+
+import com.mechanica.engine.context.callbacks.MouseHandler
+import org.lwjgl.glfw.GLFWCursorPosCallback
+
+class GLFWMouseCursorHandler(private val handler: MouseHandler) : GLFWCursorPosCallback() {
+    override fun invoke(window: Long, x: Double, y: Double) {
+        handler.cursorMoved(x, y)
+    }
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/input/GLFWScrollHandler.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/input/GLFWScrollHandler.kt
new file mode 100644
index 00000000..96ec4bd5
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/input/GLFWScrollHandler.kt
@@ -0,0 +1,10 @@
+package com.mechanica.engine.input
+
+import com.mechanica.engine.context.callbacks.MouseHandler
+import org.lwjgl.glfw.GLFWScrollCallback
+
+class GLFWScrollHandler(private val handler: MouseHandler): GLFWScrollCallback() {
+    override fun invoke(window: Long, xoffset: Double, yoffset: Double) {
+        handler.scroll(xoffset, yoffset)
+    }
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/input/GLFWTextInputHandler.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/input/GLFWTextInputHandler.kt
new file mode 100644
index 00000000..4d917bf0
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/input/GLFWTextInputHandler.kt
@@ -0,0 +1,11 @@
+package com.mechanica.engine.input
+
+import com.mechanica.engine.context.callbacks.KeyboardHandler
+import org.lwjgl.glfw.GLFWCharCallback
+
+
+class GLFWTextInputHandler(private val handler: KeyboardHandler) : GLFWCharCallback() {
+    override fun invoke(window: Long, codepoint: Int) {
+        handler.textInput(codepoint)
+    }
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/memory/MemoryTools.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/memory/MemoryTools.kt
index 4887fd09..ad4e56ae 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/memory/MemoryTools.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/memory/MemoryTools.kt
@@ -4,4 +4,10 @@ import org.lwjgl.system.MemoryStack
 
 inline fun useMemoryStack(use: MemoryStack.() -> Unit) {
     MemoryStack.stackPush().use { use(it) }
+}
+
+
+fun Byte.toIntValue(): Int = when {
+    (this.toInt() < 0) -> 255 + this.toInt() + 1
+    else -> this.toInt()
 }
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/memory/RectangleFloatBuffers.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/memory/RectangleFloatBuffers.kt
new file mode 100644
index 00000000..b578af94
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/memory/RectangleFloatBuffers.kt
@@ -0,0 +1,12 @@
+package com.mechanica.engine.memory
+
+import org.lwjgl.system.MemoryStack
+import java.nio.FloatBuffer
+import java.nio.IntBuffer
+
+class RectangleFloatBuffers(stack: MemoryStack) {
+    val x: FloatBuffer = stack.floats(0f)
+    val y: FloatBuffer = stack.floats(0f)
+    val width: FloatBuffer = stack.floats(0f)
+    val height: FloatBuffer = stack.floats(0f)
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/memory/RectangleIntBuffers.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/memory/RectangleIntBuffers.kt
new file mode 100644
index 00000000..598e2947
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/memory/RectangleIntBuffers.kt
@@ -0,0 +1,11 @@
+package com.mechanica.engine.memory
+
+import org.lwjgl.system.MemoryStack
+import java.nio.IntBuffer
+
+class RectangleIntBuffers(stack: MemoryStack) {
+    val x: IntBuffer = stack.ints(0)
+    val y: IntBuffer = stack.ints(0)
+    val width: IntBuffer = stack.ints(0)
+    val height: IntBuffer = stack.ints(0)
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/memory/buffer/BufferTools.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/memory/buffer/BufferTools.kt
index f915831a..df88fc5c 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/memory/buffer/BufferTools.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/memory/buffer/BufferTools.kt
@@ -1,7 +1,9 @@
 package com.mechanica.engine.memory.buffer
 
+import com.mechanica.engine.memory.BitmapBuffer
 import com.mechanica.engine.memory.useMemoryStack
 import org.lwjgl.BufferUtils
+import org.lwjgl.stb.STBImageWrite
 import java.nio.FloatBuffer
 import java.nio.IntBuffer
 import java.nio.ShortBuffer
@@ -78,4 +80,9 @@ fun FloatBuffer.contentsToString(): String {
         sb.append(this.get()).append(", ")
     }
     return sb.toString()
+}
+
+
+fun BitmapBuffer.write(name: String) {
+    STBImageWrite.stbi_write_png(name, width, height, 1, buffer, width)
 }
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/persistence/PersistenceUtil.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/persistence/PersistenceUtil.kt
deleted file mode 100644
index 928224a9..00000000
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/persistence/PersistenceUtil.kt
+++ /dev/null
@@ -1,112 +0,0 @@
-package com.mechanica.engine.persistence
-
-import com.mechanica.engine.resources.ExternalResource
-import java.io.File
-import java.lang.reflect.Method
-import java.util.*
-import kotlin.collections.HashMap
-import kotlin.collections.forEach
-import kotlin.collections.set
-
-fun saveData(dataObj: Any) {
-    val getters = ArrayList<Method>()
-    for (method in dataObj.methods) {
-        if (method.name.startsWith("get") && method.name != "getClass") {
-            getters.add(method)
-        }
-    }
-
-    val contentBuilder = StringBuilder()
-
-    for (method in getters) {
-        contentBuilder
-                .append(method.camelCaseName).append(",")
-                .append(method.returnType.simpleName).append(",")
-                .append(method.invoke(dataObj)).append("\n")
-    }
-    val content = contentBuilder.toString()
-
-    val file = resource(dataObj.dataFile, true)
-    file.write(content)
-
-}
-
-fun loadData(dataObj: Any) {
-    data class Variable(val name: String, val type: String, val value: String, val setter: Method?, val getter: Method?)
-    fun Variable.set() {
-        if (this.setter != null) {
-            when (this.type) {
-                "int" -> setter.invoke(dataObj, value.toIntOrNull()?: getter?.invoke(dataObj)?: 0)
-                "double" -> setter.invoke(dataObj, value.toDoubleOrNull()?: getter?.invoke(dataObj)?: 0.0)
-                "float" -> setter.invoke(dataObj, value.toFloatOrNull()?: getter?.invoke(dataObj)?: 0f)
-                "long" -> setter.invoke(dataObj, value.toLongOrNull()?: getter?.invoke(dataObj)?: 0L)
-                "boolean" -> setter.invoke(dataObj, value.toBoolean())
-                "String" -> setter.invoke(dataObj, value)
-            }
-        }
-    }
-
-    val setters = getSetters(dataObj)
-    val getters = getGetters(dataObj)
-
-    val dataFile = resource(dataObj.dataFile, true)
-
-
-    dataFile.lines.forEach {
-        val params = it.split(",")
-        val name = params[0]
-        val v = Variable(name, params[1], params[2], setters[name], getters[name])
-        v.set()
-    }
-
-}
-
-private fun getGetters(dataObj: Any): HashMap<String, Method> {
-    val getters = HashMap<String, Method>()
-    for (method in dataObj.methods) {
-        if (method.name.startsWith("get") && method.name != "getClass") {
-            getters[method.camelCaseName] = method
-        }
-    }
-
-    return getters
-}
-
-
-private fun getSetters(dataObj: Any): HashMap<String, Method> {
-    val setters = HashMap<String, Method>()
-    for (method in dataObj.methods) {
-        if (method.name.startsWith("set")) {
-            setters[method.camelCaseName] = method
-        }
-    }
-
-    return setters
-}
-
-private fun resource(path: String, createIfAbsent: Boolean = false): ExternalResource {
-    val prefix = "res/"
-    return ExternalResource("$prefix$path", createIfAbsent)
-}
-
-private val Method.camelCaseName: String
-    get() = this.name
-            .replace("get", "")
-            .replace("set", "")
-            .replace(0..1) { it.toLowerCase() + this }
-
-private fun String.replace(range: IntRange, function: String.(String) -> String): String {
-    val rangeString = this.substring(range)
-    val removed = this.removeRange(range)
-    return removed.function(rangeString)
-}
-
-private const val directory: String = "data"
-
-private val Any.methods get() = this::class.java.methods
-
-private val Any.dataFile get() = directory + sep + this.name + ".txt"
-
-private val Any.name get() = this::class.java.name
-
-private val sep get() = File.separator
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/script/ShaderImpl.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/shader/script/ShaderImpl.kt
deleted file mode 100644
index 8ac411f7..00000000
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/script/ShaderImpl.kt
+++ /dev/null
@@ -1,14 +0,0 @@
-package com.mechanica.engine.shader.script
-
-internal class ShaderImpl(
-        override val vertex: ShaderScript,
-        override val fragment: ShaderScript,
-        override val tessellation: ShaderScript?,
-        override val geometry: ShaderScript?): Shader() {
-
-    private val loader: ShaderLoader by lazy { ShaderLoader(vertex, fragment, tessellation, geometry) }
-
-    override val id: Int
-        get() = loader.id
-
-}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/script/ShaderLoader.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/shader/script/ShaderLoader.kt
index 92835d8c..13c31302 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/script/ShaderLoader.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/shader/script/ShaderLoader.kt
@@ -47,10 +47,8 @@ class ShaderLoader(
                 val log = GL20.glGetProgramInfoLog(programId, GL20.GL_INFO_LOG_LENGTH)
                 val script = getShaderScriptFromLog(log, vertex, fragment, tessellation, geometry)
 
-                System.err.println(errorMessage(script))
-                System.err.println(log)
                 cleanUp()
-                exitProcess(-1)
+                throw IllegalStateException(errorMessage(script) + "\n" + log)
             }
         }
 
@@ -60,9 +58,6 @@ class ShaderLoader(
         GL20.glValidateProgram(id)
         checkProgram(id, GL20.GL_VALIDATE_STATUS) { "Shader validating failed" }
 
-        vertex.loadProgram(id)
-        geometry?.loadProgram(id)
-        fragment.loadProgram(id)
     }
 
     private fun loadShader(script: String, type: Int): Int {
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/LwjglFloat.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/shader/uniforms/LwjglFloat.kt
similarity index 72%
rename from desktop-application/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/LwjglFloat.kt
rename to desktop-application/src/main/kotlin/com/mechanica/engine/shader/uniforms/LwjglFloat.kt
index e10f4c46..75a26110 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/LwjglFloat.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/shader/uniforms/LwjglFloat.kt
@@ -1,7 +1,7 @@
-package com.mechanica.engine.shader.vars.uniforms
+package com.mechanica.engine.shader.uniforms
 
 import com.mechanica.engine.shader.qualifiers.Qualifier
-import com.mechanica.engine.shader.vars.uniforms.vars.UniformFloat
+import com.mechanica.engine.shader.uniforms.vars.UniformFloat
 import org.lwjgl.opengl.GL20.glUniform1f
 
 class LwjglFloat(
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/LwjglMatrix4f.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/shader/uniforms/LwjglMatrix4f.kt
similarity index 80%
rename from desktop-application/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/LwjglMatrix4f.kt
rename to desktop-application/src/main/kotlin/com/mechanica/engine/shader/uniforms/LwjglMatrix4f.kt
index 58cb422a..a9920796 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/LwjglMatrix4f.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/shader/uniforms/LwjglMatrix4f.kt
@@ -1,7 +1,7 @@
-package com.mechanica.engine.shader.vars.uniforms
+package com.mechanica.engine.shader.uniforms
 
 import com.mechanica.engine.shader.qualifiers.Qualifier
-import com.mechanica.engine.shader.vars.uniforms.vars.UniformMatrix4f
+import com.mechanica.engine.shader.uniforms.vars.UniformMatrix4f
 import org.joml.Matrix4f
 import org.lwjgl.BufferUtils
 import org.lwjgl.opengl.GL20.glUniformMatrix4fv
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/LwjglVector2f.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/shader/uniforms/LwjglVector2f.kt
similarity index 74%
rename from desktop-application/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/LwjglVector2f.kt
rename to desktop-application/src/main/kotlin/com/mechanica/engine/shader/uniforms/LwjglVector2f.kt
index 9c24284c..45e154f0 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/LwjglVector2f.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/shader/uniforms/LwjglVector2f.kt
@@ -1,7 +1,7 @@
-package com.mechanica.engine.shader.vars.uniforms
+package com.mechanica.engine.shader.uniforms
 
 import com.mechanica.engine.shader.qualifiers.Qualifier
-import com.mechanica.engine.shader.vars.uniforms.vars.UniformVector2f
+import com.mechanica.engine.shader.uniforms.vars.UniformVector2f
 import org.lwjgl.opengl.GL20.glUniform2f
 
 class LwjglVector2f(
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/LwjglVector3f.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/shader/uniforms/LwjglVector3f.kt
similarity index 74%
rename from desktop-application/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/LwjglVector3f.kt
rename to desktop-application/src/main/kotlin/com/mechanica/engine/shader/uniforms/LwjglVector3f.kt
index 842d30be..b876a3cd 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/LwjglVector3f.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/shader/uniforms/LwjglVector3f.kt
@@ -1,7 +1,7 @@
-package com.mechanica.engine.shader.vars.uniforms
+package com.mechanica.engine.shader.uniforms
 
 import com.mechanica.engine.shader.qualifiers.Qualifier
-import com.mechanica.engine.shader.vars.uniforms.vars.UniformVector3f
+import com.mechanica.engine.shader.uniforms.vars.UniformVector3f
 import org.lwjgl.opengl.GL20.glUniform3f
 
 class LwjglVector3f(
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/LwjglVector4f.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/shader/uniforms/LwjglVector4f.kt
similarity index 76%
rename from desktop-application/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/LwjglVector4f.kt
rename to desktop-application/src/main/kotlin/com/mechanica/engine/shader/uniforms/LwjglVector4f.kt
index 1e2b50a1..9c77da62 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/vars/uniforms/LwjglVector4f.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/shader/uniforms/LwjglVector4f.kt
@@ -1,7 +1,7 @@
-package com.mechanica.engine.shader.vars.uniforms
+package com.mechanica.engine.shader.uniforms
 
 import com.mechanica.engine.shader.qualifiers.Qualifier
-import com.mechanica.engine.shader.vars.uniforms.vars.UniformVector4f
+import com.mechanica.engine.shader.uniforms.vars.UniformVector4f
 import org.lwjgl.opengl.GL20.glUniform4f
 
 class LwjglVector4f (
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/vbo/LwjglAttributeBuffer.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/shader/vbo/LwjglAttributeBuffer.kt
index 6712a022..b7444e52 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/vbo/LwjglAttributeBuffer.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/shader/vbo/LwjglAttributeBuffer.kt
@@ -8,7 +8,7 @@ import com.mechanica.engine.vertices.AttributeArray
 import org.joml.Vector3f
 import org.joml.Vector4f
 import org.lwjgl.opengl.GL11.GL_FLOAT
-import org.lwjgl.opengl.GL15.*
+import org.lwjgl.opengl.GL15.glBufferSubData
 import org.lwjgl.opengl.GL20
 import org.lwjgl.opengl.GL40
 import java.nio.ByteBuffer
@@ -36,7 +36,7 @@ class LwjglAttributeBuffer(
         GL40.glEnableVertexAttribArray(location)
     }
 
-    override fun disable() {
+    override fun unbind() {
         GL20.glDisableVertexAttribArray(location)
     }
 
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/vbo/LwjglIndexArray.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/shader/vbo/LwjglIndexArray.kt
index a32e21d6..55f6454e 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/shader/vbo/LwjglIndexArray.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/shader/vbo/LwjglIndexArray.kt
@@ -16,7 +16,14 @@ class LwjglIndexArray(array: ShortArray) : LwjglVertexBuffer<ShortArray>(array.s
         GL40.glBufferData(bufferTarget, array, GL20.GL_STATIC_DRAW)
     }
 
-    override fun subData(offset: Long, array: ShortArray) = glBufferSubData(bufferTarget, offset, array)
+    override fun unbind() {
+        GL40.glBindBuffer(bufferTarget, 0)
+    }
 
+    override fun subData(offset: Long, array: ShortArray) = glBufferSubData(bufferTarget, offset, array)
 
+    override fun set(array: ShortArray, from: Int, length: Int) {
+        vertexCount = array.size
+        super.set(array, from, length)
+    }
 }
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/text/FontAtlas.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/text/FontAtlas.kt
index 07a28caf..166ab253 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/text/FontAtlas.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/text/FontAtlas.kt
@@ -1,83 +1,166 @@
 package com.mechanica.engine.text
 
+import com.mechanica.engine.memory.BitmapBuffer
+import com.mechanica.engine.memory.buffer.write
+import com.mechanica.engine.memory.useMemoryStack
 import com.mechanica.engine.models.Image
+import com.mechanica.engine.unit.vector.vec
+import com.mechanica.engine.util.extensions.constrain
 import com.mechanica.engine.utils.loadImage
 import org.lwjgl.BufferUtils
 import org.lwjgl.opengl.GL11
-import org.lwjgl.stb.STBTTBakedChar
-import org.lwjgl.stb.STBTTFontinfo
+import org.lwjgl.stb.STBTTAlignedQuad
+import org.lwjgl.stb.STBTTPackContext
+import org.lwjgl.stb.STBTTPackedchar
 import org.lwjgl.stb.STBTruetype
-import org.lwjgl.system.MemoryStack
 import java.nio.ByteBuffer
 import java.nio.IntBuffer
+import kotlin.math.*
 
-class FontAtlas(data: LwjglFont.FontData, val width: Int = 1024, val height: Int = 1024) : Image {
+class FontAtlas(private val data: LwjglStandardFont.FontData, private val config: LwjglFontAtlasConfiguration) : Image {
     private val image: Image
 
+    val width: Int = config.width
+    val height: Int = config.height
+
     override val id: Int
         get() = image.id
 
     val scale: Double
 
+    private val distanceFieldStart: Double
+    private val distanceFieldEnd: Double
+
+    private val distanceFieldPadding: Double
+        get() = max(distanceFieldStart, distanceFieldEnd)
+    val padding: Float
+        get() = config.padding + if (config.distanceFieldsWasSet) distanceFieldPadding.toFloat() else 0f
+
+    private val charRange = config.charRange.first.toInt()..config.charRange.last.toInt()
+    private val unknownIndex = 128 - charRange.first
+
     init {
         val bitmap = BufferUtils.createByteBuffer(width * height)
-        bakeFont(bitmap, data.ttf, data.cdata)
-        scale = getBakedQuadScale(data.info, data.cdata)
+
+        val correction = distanceFieldCorrection()
+        distanceFieldStart = config.sdfConfiguration.start + correction
+        distanceFieldEnd = config.sdfConfiguration.end + correction
+
+        packFont(bitmap, data.ttf, data.cdata)
+
+        if (config.distanceFieldsWasSet) {
+            insertCharacters(bitmap)
+        }
+
+        scale = getScale(data)
 
         image = loadImage(bitmap, width, height, 1, GL11.GL_ALPHA)
     }
 
+    private fun insertCharacters(bitmap: ByteBuffer) {
+        val bitmapBuffer = BitmapBuffer(bitmap, width, height)
+        for (char in charRange){
+            val glyph = createSDFGlyph(char.toChar())
+
+            val charAsInt = if (char in charRange) char - charRange.first else unknownIndex
+            val paddingVector = vec(padding/width.toFloat(), padding/height.toFloat())
+
+            if (glyph != null) {
+                useMemoryStack {
+                    val q = STBTTAlignedQuad.mallocStack(this)
+                    STBTruetype.stbtt_GetPackedQuad(data.cdata, width, height, charAsInt, floats(0f), floats(0f), q, false)
+                    bitmapBuffer.insert(glyph, q.s0() - paddingVector.x.toFloat(), q.t0() - paddingVector.y.toFloat())
+                }
+            }
+        }
+        bitmap.position(0)
+    }
+
+    private fun getScale(data: LwjglStandardFont.FontData): Double {
+        val c = config.charRange.first
+        val x = data.cdata[0].xadvance()
+        return getAtlasScale(data.info, c, if (x >= 1f) x else 1f)
+    }
+
     override fun bind() {
         image.bind()
     }
 
-    private fun bakeFont(bitmap: ByteBuffer, ttf: ByteBuffer, cdata: STBTTBakedChar.Buffer): Float {
-        var check: Int
-        var attempts = 0
-        var maxFontHeight = 100f
-        var maxRow = 0
-        var checkedFontHeight = maxFontHeight
-
-        while (true) {
-            check = STBTruetype.stbtt_BakeFontBitmap(ttf, checkedFontHeight, bitmap, width, height, 32, cdata)
-            if (check == 0) { maxFontHeight = checkedFontHeight; break }
-
-            if (attempts < 5) {
-                if (check > maxRow) {
-                    maxRow = check
-                    maxFontHeight = checkedFontHeight
-                }
+    private fun packFont(bitmap: ByteBuffer, ttf: ByteBuffer, cdata: STBTTPackedchar.Buffer) {
+        val characterHeight = config.characterSize
 
-                var error = 0f
-                if (check < 0) {
-                    error = -0.3f*(1f + (check.toFloat())/ LwjglFont.charRange.count().toFloat())
-                } else if (check > 0) {
-                    error = 0.8f*(1f - check.toFloat()/ height.toFloat())
-                }
+        STBTTPackContext.malloc().use { pc ->
+            STBTruetype.stbtt_PackBegin(pc, bitmap, width, height, 0, padding.toInt()*2)
 
-                checkedFontHeight *= (1f + error)
-                attempts++
-                continue
-            } else {
-                break
-            }
+            val success = STBTruetype.stbtt_PackFontRange(pc, ttf, 0, characterHeight, charRange.first, cdata)
+
+            if (!success) throw IllegalStateException("Error packing font into font atlas. The provided character size, ${config.characterSize}," +
+                        " is likely too big for the provided atlas size, ${width}x$height")
+
+            STBTruetype.stbtt_PackEnd(pc)
         }
-        STBTruetype.stbtt_BakeFontBitmap(ttf, maxFontHeight, bitmap, width, height, LwjglFont.charRange.first, cdata)
-        return maxFontHeight
+
+        config.characterSize = characterHeight
+    }
+
+    private fun checkPadding() {
+        val area = calculateAllowedCharacterArea()
+        val side = sqrt(area.toDouble())
+        val paddingArea = padding*4*(side - padding)
+        val characterArea = area - paddingArea
+
+        if (characterArea <= 0) throw IllegalStateException("Error packing font into font atlas. The provided padding, $padding," +
+                " is too much for the provided atlas size, ${width}x$height")
+
+    }
+
+    private fun calculateAllowedCharacterArea(): Int {
+        val bitmapArea = width*height
+        return bitmapArea/charRange.count()
     }
 
+    private fun distanceFieldCorrection(): Double {
+        val start = config.sdfConfiguration.start
+        val end = config.sdfConfiguration.end
 
-    private fun getBakedQuadScale(fontInfo: STBTTFontinfo, bakedFontData: STBTTBakedChar.Buffer): Double {
-        MemoryStack.stackPush().use { stack ->
-            val xAdvanceBuffer: IntBuffer = stack.mallocInt(1)
-            val lsbBuffer: IntBuffer = stack.mallocInt(1)
-            STBTruetype.stbtt_GetCodepointHMetrics(fontInfo, LwjglFont.charRange.first, xAdvanceBuffer, lsbBuffer)
+        return if (start*end > 0) {
+            val sign = sign(start)
+            -sign*min(abs(start), abs(end))
+        } else 0.0
+    }
+
+    private fun createSDFGlyph(char: Char): BitmapBuffer? {
+        var start = distanceFieldStart
+        var end = distanceFieldEnd
+
+        if (start*end > 0) {
+            val sign = sign(start)
+            val min = sign*min(abs(start), abs(end))
+            start -= min
+            end -= min
+        }
+
+        val edgeValue = getOnEdgeValue(start, end)
 
-            val xFromBakedData = bakedFontData[0].xadvance()
-            val xFromFontInfo = xAdvanceBuffer[0]
+        val pixelDistScale = 255f/(end - start).toFloat()
 
-            return xFromFontInfo.toDouble()/xFromBakedData
+        useMemoryStack {
+            val width: IntBuffer = ints(0)
+            val height: IntBuffer = ints(0)
+            val scale = STBTruetype.stbtt_ScaleForPixelHeight(data.info, config.characterSize)
+
+            val buffer = STBTruetype.stbtt_GetCodepointSDF(data.info, scale, char.toInt(), distanceFieldPadding.toInt(), edgeValue.toByte(), pixelDistScale,
+                    width, height, ints(0), ints(0))
+
+            if (buffer != null) return BitmapBuffer(buffer, width[0], height[0])
         }
+
+        return null
+    }
+
+    private fun getOnEdgeValue(start: Double, end: Double): Int {
+        val startRatio = start/(end - start)
+        return ((1.0 + startRatio)*255).constrain(0.0, 255.0).toInt()
     }
 
 }
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/text/FontMetrics.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/text/FontMetrics.kt
new file mode 100644
index 00000000..95b6cdc8
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/text/FontMetrics.kt
@@ -0,0 +1,31 @@
+package com.mechanica.engine.text
+
+import org.lwjgl.stb.STBTTFontinfo
+import org.lwjgl.stb.STBTruetype
+import org.lwjgl.system.MemoryStack
+
+class FontMetrics(info: STBTTFontinfo, scale: Float = STBTruetype.stbtt_ScaleForPixelHeight(info, 1f)) {
+    val ascent: Float
+    val descent: Float
+    val lineGap: Float
+
+    init {
+        var ascent = 0
+        var descent = 0
+        var lineGap = 0
+
+        MemoryStack.stackPush().use { stack ->
+            val ascentBuffer = stack.mallocInt(1)
+            val descentBuffer = stack.mallocInt(1)
+            val lineGapBuffer = stack.mallocInt(1)
+            STBTruetype.stbtt_GetFontVMetrics(info, ascentBuffer, descentBuffer, lineGapBuffer)
+            ascent = ascentBuffer[0]
+            descent = descentBuffer[0]
+            lineGap = lineGapBuffer[0]
+        }
+
+        this.ascent = ascent*scale
+        this.descent = descent*scale
+        this.lineGap = lineGap*scale
+    }
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/text/FontUtils.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/text/FontUtils.kt
new file mode 100644
index 00000000..2790a396
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/text/FontUtils.kt
@@ -0,0 +1,49 @@
+package com.mechanica.engine.text
+
+import com.mechanica.engine.unit.vector.DynamicVector
+import org.lwjgl.stb.STBTTAlignedQuad
+import org.lwjgl.stb.STBTTFontinfo
+import org.lwjgl.stb.STBTruetype
+import org.lwjgl.system.MemoryStack
+import java.nio.IntBuffer
+import kotlin.math.max
+
+fun STBTTAlignedQuad.copyToArrays(cursor: CharacterCursor, scale: Double, atlas: FontAtlas, p: Array<DynamicVector>, tc: Array<DynamicVector>) {
+    val i = max(cursor.nonWhiteSpaceIndex - 1, 0) *4
+
+    val padding = atlas.padding*1.01
+    val texPaddingX = padding/atlas.width.toDouble()
+    val texPaddingY = padding/atlas.height.toDouble()
+
+    tc[i + 0].x = s0().toDouble() - texPaddingX
+    tc[i + 0].y = t1().toDouble() + texPaddingY
+    tc[i + 1].x = s1().toDouble() + texPaddingX
+    tc[i + 1].y = t1().toDouble() + texPaddingY
+    tc[i + 2].x = s0().toDouble() - texPaddingX
+    tc[i + 2].y = t0().toDouble() - texPaddingY
+    tc[i + 3].x = s1().toDouble() + texPaddingX
+    tc[i + 3].y = t0().toDouble() - texPaddingY
+
+    val yAdvance = cursor.yAdvance
+    p[i + 0].x = (x0() - padding)*scale
+    p[i + 0].y = (-y1() - padding)*scale + yAdvance
+    p[i + 1].x = (x1() + padding)*scale
+    p[i + 1].y = (-y1() - padding)*scale + yAdvance
+    p[i + 2].x = (x0() - padding)*scale
+    p[i + 2].y = (-y0() + padding)*scale + yAdvance
+    p[i + 3].x = (x1() + padding)*scale
+    p[i + 3].y = (-y0() + padding)*scale + yAdvance
+}
+
+
+fun getAtlasScale(fontInfo: STBTTFontinfo, testChar: Char, testCharXAdvance: Float): Double {
+    MemoryStack.stackPush().use { stack ->
+        val xAdvanceBuffer: IntBuffer = stack.mallocInt(1)
+        val lsbBuffer: IntBuffer = stack.mallocInt(1)
+        STBTruetype.stbtt_GetCodepointHMetrics(fontInfo, testChar.toInt(), xAdvanceBuffer, lsbBuffer)
+
+        val xFromFontInfo = xAdvanceBuffer[0]
+
+        return xFromFontInfo.toDouble()/ testCharXAdvance
+    }
+}
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/text/LwjglFont.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/text/LwjglFont.kt
deleted file mode 100644
index 91f32a69..00000000
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/text/LwjglFont.kt
+++ /dev/null
@@ -1,117 +0,0 @@
-package com.mechanica.engine.text
-
-import com.mechanica.engine.resources.Resource
-import com.mechanica.engine.unit.vector.DynamicVector
-import org.lwjgl.stb.STBTTAlignedQuad
-import org.lwjgl.stb.STBTTBakedChar
-import org.lwjgl.stb.STBTTFontinfo
-import org.lwjgl.stb.STBTruetype
-import org.lwjgl.stb.STBTruetype.stbtt_GetCodepointKernAdvance
-import org.lwjgl.system.MemoryStack
-import java.nio.ByteBuffer
-import kotlin.math.max
-
-class LwjglFont(resource: Resource): Font() {
-
-    override val ascent: Float
-        get() = metrics.ascent
-    override val descent: Float
-        get() = metrics.descent
-    override val lineGap: Float
-        get() = metrics.lineGap
-
-    private val data = FontData(resource)
-    override val atlas = FontAtlas(data)
-
-    private val metrics = FontMetrics()
-
-    override fun addCharacterDataToArrays(cursor: CharacterCursor, positions: Array<DynamicVector>, texCoords: Array<DynamicVector>) {
-        val c = cursor.currentChar
-        val atlasScale = atlas.scale
-        val dataScale = data.scale
-        
-        val kern = stbtt_GetCodepointKernAdvance(data.info, cursor.previousChar.toInt(), c.toInt()).toFloat()/atlasScale.toFloat()
-        val charAsInt = if (c.toInt() in charRange) c.toInt() - charRange.first else unknownIndex
-        
-        MemoryStack.stackPush().use { stack ->
-            val x = stack.floats(cursor.xAdvance/(dataScale*atlasScale).toFloat() + kern)
-            val y = stack.floats(cursor.yAdvance)
-            val q = STBTTAlignedQuad.mallocStack(stack)
-
-            STBTruetype.stbtt_GetBakedQuad(data.cdata, atlas.width, atlas.height, charAsInt, x, y, q, true)
-            cursor.xAdvance = (x[0]*dataScale*atlasScale).toFloat()
-
-            if (c != ' ') copyToFloats(q, cursor, positions, texCoords)
-        }
-    }
-
-    private fun copyToFloats(q: STBTTAlignedQuad, cursor: CharacterCursor, p: Array<DynamicVector>, tc: Array<DynamicVector>) {
-        val i = max(cursor.nonWhiteSpaceIndex - 1, 0)*4
-        val atlasScale = atlas.scale
-        val dataScale = data.scale
-
-        tc[i + 0].x = q.s0().toDouble()
-        tc[i + 0].y = q.t1().toDouble()
-        tc[i + 1].x = q.s1().toDouble()
-        tc[i + 1].y = q.t1().toDouble()
-        tc[i + 2].x = q.s0().toDouble()
-        tc[i + 2].y = q.t0().toDouble()
-        tc[i + 3].x = q.s1().toDouble()
-        tc[i + 3].y = q.t0().toDouble()
-
-        val yAdvance = cursor.yAdvance
-        p[i + 0].x = (q.x0())*dataScale*atlasScale
-        p[i + 0].y = (-q.y1())*dataScale*atlasScale + yAdvance
-        p[i + 1].x = (q.x1())*dataScale*atlasScale
-        p[i + 1].y = (-q.y1())*dataScale*atlasScale + yAdvance
-        p[i + 2].x = (q.x0())*dataScale*atlasScale
-        p[i + 2].y = (-q.y0())*dataScale*atlasScale + yAdvance
-        p[i + 3].x = (q.x1())*dataScale*atlasScale
-        p[i + 3].y = (-q.y0())*dataScale*atlasScale + yAdvance
-    }
-
-    inner class FontData(resource: Resource) {
-        val ttf: ByteBuffer = resource.buffer
-        val info: STBTTFontinfo = STBTTFontinfo.create()
-        val cdata: STBTTBakedChar.Buffer
-        val scale: Float
-
-        init {
-            check(STBTruetype.stbtt_InitFont(info, ttf)) { "Failed to initialize font information." }
-            cdata = STBTTBakedChar.create(charRange.count())
-            scale = STBTruetype.stbtt_ScaleForPixelHeight(info, 1f)
-        }
-    }
-
-    private inner class FontMetrics {
-        val ascent: Float
-        val descent: Float
-        val lineGap: Float
-
-        init {
-            var ascent = 0
-            var descent = 0
-            var lineGap = 0
-
-            MemoryStack.stackPush().use { stack ->
-                val ascentBuffer = stack.mallocInt(1)
-                val descentBuffer = stack.mallocInt(1)
-                val lineGapBuffer = stack.mallocInt(1)
-                STBTruetype.stbtt_GetFontVMetrics(data.info, ascentBuffer, descentBuffer, lineGapBuffer)
-                ascent = ascentBuffer[0]
-                descent = descentBuffer[0]
-                lineGap = lineGapBuffer[0]
-            }
-
-            this.ascent = ascent*data.scale
-            this.descent = descent*data.scale
-            this.lineGap = lineGap*data.scale
-        }
-    }
-    companion object {
-
-        val charRange = 32..128
-        private val unknownIndex = 128 - charRange.first
-
-    }
-}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/text/LwjglFontAtlasConfiguration.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/text/LwjglFontAtlasConfiguration.kt
new file mode 100644
index 00000000..e4a1490a
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/text/LwjglFontAtlasConfiguration.kt
@@ -0,0 +1,57 @@
+package com.mechanica.engine.text
+
+
+class LwjglFontAtlasConfiguration(initializer: FontAtlasConfiguration.() -> Unit) : FontAtlasConfiguration {
+    val anyWasSet: Boolean
+        get() = dimensionsWereSet || paddingWasSet || characterSizeWasSet || distanceFieldsWasSet
+
+    var dimensionsWereSet = false
+        private set
+    override var width = 1024
+        set(value) {
+            field = value
+            dimensionsWereSet = true
+        }
+    override var height = 1024
+        set(value) {
+            field = value
+            dimensionsWereSet = true
+        }
+
+    var characterSizeWasSet = false
+        private set
+    override var characterSize = 100f
+        set(value) {
+            field = value
+            characterSizeWasSet = true
+        }
+
+    var paddingWasSet = false
+        private set
+    override var padding = 2f
+        set(value) {
+            field = value
+            paddingWasSet = true
+        }
+
+    override var charRange = 32.toChar()..128.toChar()
+
+    var distanceFieldsWasSet = false
+    val sdfConfiguration = FontAtlasConfiguration.SDFConfiguration()
+    override fun configureSDF(block: FontAtlasConfiguration.SDFConfiguration.() -> Unit) {
+        distanceFieldsWasSet = true
+        block(sdfConfiguration)
+    }
+
+    init {
+        initializer(this)
+    }
+
+    fun reset() {
+        paddingWasSet = false
+        characterSizeWasSet = false
+        distanceFieldsWasSet = false
+        dimensionsWereSet = false
+    }
+
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/text/LwjglStandardFont.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/text/LwjglStandardFont.kt
new file mode 100644
index 00000000..7a09f80b
--- /dev/null
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/text/LwjglStandardFont.kt
@@ -0,0 +1,65 @@
+package com.mechanica.engine.text
+
+import com.mechanica.engine.resources.Resource
+import com.mechanica.engine.unit.vector.DynamicVector
+import org.lwjgl.stb.STBTTAlignedQuad
+import org.lwjgl.stb.STBTTFontinfo
+import org.lwjgl.stb.STBTTPackedchar
+import org.lwjgl.stb.STBTruetype
+import org.lwjgl.stb.STBTruetype.stbtt_GetCodepointKernAdvance
+import org.lwjgl.system.MemoryStack
+import java.nio.ByteBuffer
+
+class LwjglStandardFont(resource: Resource, initializer: FontAtlasConfiguration.() -> Unit): Font() {
+
+    override val ascent: Float
+        get() = metrics.ascent
+    override val descent: Float
+        get() = metrics.descent
+    override val lineGap: Float
+        get() = metrics.lineGap
+
+    private val config = LwjglFontAtlasConfiguration(initializer)
+    private val charRange = config.charRange.first.toInt()..config.charRange.last.toInt()
+    private val unknownIndex = 128 - charRange.first
+
+    private val data = FontData(resource)
+
+    override val atlas = FontAtlas(data, config)
+
+    private val metrics = FontMetrics(data.info, data.scale)
+
+    override fun addCharacterDataToArrays(cursor: CharacterCursor, positions: Array<DynamicVector>, texCoords: Array<DynamicVector>) {
+        val c = cursor.currentChar
+        val atlasScale = atlas.scale
+        val dataScale = data.scale
+        
+        val kern = stbtt_GetCodepointKernAdvance(data.info, cursor.previousChar.toInt(), c.toInt()).toFloat()/atlasScale.toFloat()
+        val charAsInt = if (c.toInt() in charRange) c.toInt() - charRange.first else unknownIndex
+        
+        MemoryStack.stackPush().use { stack ->
+            val x = stack.floats(cursor.xAdvance/(dataScale*atlasScale).toFloat() + kern)
+            val y = stack.floats(cursor.yAdvance)
+            val q = STBTTAlignedQuad.mallocStack(stack)
+
+            STBTruetype.stbtt_GetPackedQuad(data.cdata, atlas.width, atlas.height, charAsInt, x, y, q, true)
+            cursor.xAdvance = (x[0]*dataScale*atlasScale).toFloat()
+
+            if (c != ' ') q.copyToArrays(cursor, dataScale*atlasScale, atlas, positions, texCoords)
+        }
+    }
+
+    inner class FontData(resource: Resource) {
+        val ttf: ByteBuffer = resource.buffer
+        val info: STBTTFontinfo = STBTTFontinfo.create()
+        val cdata: STBTTPackedchar.Buffer
+        val scale: Float
+
+        init {
+            check(STBTruetype.stbtt_InitFont(info, ttf)) { "Failed to initialize font information." }
+            cdata = STBTTPackedchar.create(charRange.count())
+            scale = STBTruetype.stbtt_ScaleForPixelHeight(info, 1f)
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/desktop-application/src/main/kotlin/com/mechanica/engine/utils/GLUtils.kt b/desktop-application/src/main/kotlin/com/mechanica/engine/utils/GLUtils.kt
index b19dcc39..052edcce 100644
--- a/desktop-application/src/main/kotlin/com/mechanica/engine/utils/GLUtils.kt
+++ b/desktop-application/src/main/kotlin/com/mechanica/engine/utils/GLUtils.kt
@@ -59,7 +59,7 @@ class ImageData(resource: Resource) {
         val heightBuffer = BufferUtils.createIntBuffer(1)
         val componentsBuffer = BufferUtils.createIntBuffer(1)
 
-        data = STBImage.stbi_load_from_memory(resource.buffer, widthBuffer, heightBuffer, componentsBuffer, 4)
+        data = STBImage.stbi_load_from_memory(resource.buffer as ByteBuffer, widthBuffer, heightBuffer, componentsBuffer, 4)
         width = widthBuffer.get()
         height = heightBuffer.get()
     }
diff --git a/mechanica-ui/build.gradle.kts b/mechanica-ui/build.gradle.kts
new file mode 100644
index 00000000..b7dd86a1
--- /dev/null
+++ b/mechanica-ui/build.gradle.kts
@@ -0,0 +1,14 @@
+
+plugins {
+    kotlin("jvm")
+    `java-library`
+}
+
+dependencies {
+    implementation(project(":application-interface"))
+    implementation(project(":desktop-application"))
+    implementation(project(":mechanica"))
+
+    api("com.dubulduke.ui:DukeUI:0.1")
+
+}
\ No newline at end of file
diff --git a/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/Events.kt b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/Events.kt
new file mode 100644
index 00000000..257b7e21
--- /dev/null
+++ b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/Events.kt
@@ -0,0 +1,67 @@
+package com.mechanica.engine.ui
+
+import com.dubulduke.ui.event.Event
+import com.dubulduke.ui.render.RenderDescription
+import com.mechanica.engine.input.mouse.Mouse
+import com.mechanica.engine.ui.style.Style
+import com.mechanica.engine.util.EventBoolean
+
+class Events(description: RenderDescription<Style>) : Event(description) {
+    private val booleans = ArrayList<EventBoolean>()
+
+    override fun update() {
+        for (i in booleans.indices) {
+            booleans[i].update()
+        }
+    }
+
+    val hoverEvent = UIEventBoolean { description.contains(Mouse.ui.x, Mouse.ui.y) }
+
+    private val click = UIEventBoolean { Mouse.MB1() }
+
+    val wasClicked: Boolean
+        get() = click.hasBeenTrue && hoverEvent()
+
+    val clickReleased: Boolean
+        get() = click.hasBeenFalse && hoverEvent()
+
+    val isHovering: Boolean
+        get() = hoverEvent()
+
+    inline fun ifHovering(action: () -> Unit) {
+        if (isHovering) action()
+    }
+
+    inline fun ifClicked(action: () -> Unit) {
+        if (wasClicked) action()
+    }
+
+    private var trackClicked = false
+    val clickedAndReleased: Boolean
+        get() {
+            if (wasClicked) trackClicked = true
+
+            if (click.hasBeenFalse) {
+                val trackClicked = trackClicked
+                this.trackClicked = false
+                if (trackClicked) {
+                    return hoverEvent()
+                }
+            }
+
+            return false
+        }
+
+    inline fun ifClickedAndReleased(action: () -> Unit) {
+        if (clickedAndReleased) {
+            action()
+        }
+    }
+
+
+    inner class UIEventBoolean(condition: () -> Boolean) : EventBoolean(condition) {
+        init {
+            booleans.add(this)
+        }
+    }
+}
\ No newline at end of file
diff --git a/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/GUIScene.kt b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/GUIScene.kt
new file mode 100644
index 00000000..37000cde
--- /dev/null
+++ b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/GUIScene.kt
@@ -0,0 +1,18 @@
+package com.mechanica.engine.ui
+
+import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.game.Game
+import com.mechanica.engine.game.view.View
+import com.mechanica.engine.scenes.scenes.Scene
+import com.mechanica.engine.ui.elements.DrawerElement
+
+abstract class GUIScene(final override val view: View = Game.ui, order: Int = 10) : Scene(order) {
+    val ui = createUI(view)
+
+    override fun render(draw: Drawer) {
+        ui(draw) { ui(draw) }
+    }
+
+    abstract fun DrawerElement.ui(draw: Drawer)
+
+}
\ No newline at end of file
diff --git a/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/MechanicaUI.kt b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/MechanicaUI.kt
new file mode 100644
index 00000000..167b4d6f
--- /dev/null
+++ b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/MechanicaUI.kt
@@ -0,0 +1,31 @@
+package com.mechanica.engine.ui
+
+import com.dubulduke.ui.UIContext
+import com.dubulduke.ui.element.Element
+import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.ui.elements.BoxElement
+import com.mechanica.engine.ui.elements.DrawerElement
+import com.mechanica.engine.ui.style.Style
+
+class MechanicaUI(private val context: UIContext<Style, Events>) {
+    private val element: UIContext<Style, Events>.BaseElement by lazy { context.createBaseElement() }
+    val baseElement: Element<Style, Events>
+        get() = element
+    val baseDrawer: DrawerElement = BoxElement(context)
+
+    inline operator fun invoke(draw: Drawer, block: DrawerElement.() -> Unit) {
+        setDrawer(draw)
+        val element = baseElement.addChildElement { baseDrawer }
+        block(element)
+
+        renderLayout()
+    }
+
+    fun setDrawer(draw: Drawer) {
+        context.setUserData(draw)
+    }
+
+    fun renderLayout() {
+        element.renderLayout(0)
+    }
+}
\ No newline at end of file
diff --git a/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/Sample.kt b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/Sample.kt
new file mode 100644
index 00000000..b8933d05
--- /dev/null
+++ b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/Sample.kt
@@ -0,0 +1,83 @@
+package com.mechanica.engine.ui
+
+import com.mechanica.engine.context.DesktopApplication
+import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.game.Game
+import com.mechanica.engine.scenes.scenes.MainUIScene
+import com.mechanica.engine.ui.elements.*
+
+fun main() {
+    Game.configureAs(DesktopApplication()) {
+        setViewport(height = 10.0)
+        setStartingScene { object : MainUIScene() { init {
+            addScene(GUI())
+        }} }
+        configureDebugMode { screenLog = true }
+    }
+
+    Game.run()
+}
+
+class GUI : GUIScene() {
+    override fun DrawerElement.ui(draw: Drawer) {
+        box {
+            layout.edit { p, s ->
+                top = p.top
+                width = 0.5*p.width
+                center.x = p.center.x
+                height = 5.0
+            }
+            style {
+                color.set(0xFF00FFFF)
+                textColor.set(0x00FF00FF)
+            }
+
+            text("Hello, UI")
+
+            box {
+                layout.edit { p, s ->
+                    left = p.left
+                    center.y = p.center.y
+                    width = 1.0
+                    height = 1.0
+                }
+                style { color.set(0xFF0000FF) }
+            }
+            box {
+                layout.edit { p, s ->
+                    width = 1.0
+                    bottom = p.bottom - 0.5
+                    left = s.right + 0.5
+                    top = s.top
+                }
+                style { color.set(0xFF0000FF) }
+            }
+            box {
+                layout.edit { p, s ->
+                    left = s.right
+                    right = p.right
+                    top = s.top
+                    height = 6.0
+
+                    padding(horizontal = 0.5)
+                }
+                style { color.set(0xFF0000FF) }
+
+                customListItem("list item 1")
+                customListItem("list item 2")
+                customListItem("list item 3")
+                customListItem("list item 4")
+            }
+        }
+    }
+
+    fun DrawerElement.customListItem(label: String) {
+        listItem(0.5) {
+            style {
+                textColor.set(0x40CC60FF)
+                fontSize = 0.4
+            }
+            text(label)
+        }
+    }
+}
\ No newline at end of file
diff --git a/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/UIUtils.kt b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/UIUtils.kt
new file mode 100644
index 00000000..70153e6e
--- /dev/null
+++ b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/UIUtils.kt
@@ -0,0 +1,25 @@
+package com.mechanica.engine.ui
+
+import com.dubulduke.ui.UIContext
+import com.dubulduke.ui.Viewport
+import com.dubulduke.ui.Window
+import com.dubulduke.ui.element.ElementData
+import com.dubulduke.ui.render.RenderDescription
+import com.mechanica.engine.game.view.View
+import com.mechanica.engine.ui.style.Style
+
+fun createUI(view: View): MechanicaUI {
+
+    val window = Window(-view.width/2.0, -view.height/2.0, view.width, view.height)
+    val viewport = Viewport(0.0, 0.0, view.width, -view.height)
+    val options = UIContext(window, viewport, GameElementData())
+
+    return MechanicaUI(options)
+}
+
+
+class GameElementData : ElementData<Style, Events>() {
+    override fun createEvent(description: RenderDescription<Style>) = Events(description)
+
+    override fun createStyle() = Style()
+}
diff --git a/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/elements/ElementSetters.kt b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/elements/ElementSetters.kt
new file mode 100644
index 00000000..ab51d01c
--- /dev/null
+++ b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/elements/ElementSetters.kt
@@ -0,0 +1,37 @@
+package com.mechanica.engine.ui.elements
+
+import com.dubulduke.ui.layout.EditLayout
+import com.dubulduke.ui.layout.Layout
+import com.mechanica.engine.models.Image
+import com.mechanica.engine.text.Font
+import com.mechanica.engine.text.Text
+
+
+inline fun DrawerElement.box(block: DrawerElement.() -> Unit) {
+    val boxElement = addChildElement { BoxElement(context) }
+    block(boxElement)
+}
+
+fun DrawerElement.text(string: String, layout: EditLayout.(p: Layout, s: Layout) -> Unit = {_, _ -> }) {
+    val text = addChildElement { TextElement(Text(string, this.style.font ?: Font.defaultFont), context) }
+    text.layout.edit(layout)
+    text.copyStyle(this.style)
+}
+
+fun DrawerElement.image(image: Image, layout: EditLayout.(p: Layout, s: Layout) -> Unit = {_, _ -> }) {
+    val element = addChildRenderer { ImageElementRenderer(image) }
+    element.layout.edit(layout)
+}
+
+inline fun DrawerElement.listItem(height: Double = 1.0, block: DrawerElement.() -> Unit) {
+    val listItem = addChildElement { BoxElement(context) }
+    listItem.layout.add(listLayout)
+    listItem.layout.edit { _, _ -> this.height = height }
+    block(listItem)
+}
+
+inline fun DrawerElement.tileItem(block: DrawerElement.() -> Unit) {
+    val tileItem = addChildElement { BoxElement(context) }
+    tileItem.layout.add(tileLayout)
+    block(tileItem)
+}
\ No newline at end of file
diff --git a/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/elements/Elements.kt b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/elements/Elements.kt
new file mode 100644
index 00000000..e099ce0f
--- /dev/null
+++ b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/elements/Elements.kt
@@ -0,0 +1,43 @@
+package com.mechanica.engine.ui.elements
+
+import com.dubulduke.ui.UIContext
+import com.dubulduke.ui.element.Element
+import com.mechanica.engine.text.Text
+import com.mechanica.engine.ui.Events
+import com.mechanica.engine.ui.style.Style
+
+open class DrawerElement(context: UIContext<Style, Events>, renderer: ElementDrawer)
+    : Element<Style, Events>(context, renderer) {
+
+    operator fun String.unaryPlus() {
+        text(this)
+    }
+
+}
+
+open class BoxElement(context: UIContext<Style, Events>) : DrawerElement(context, BoxRenderer())
+
+
+class TextElement(context: UIContext<Style, Events>, textElementRenderer: TextElementRenderer) : DrawerElement(context, textElementRenderer) {
+
+    constructor(text: Text, context: UIContext<Style, Events>) : this(context, TextElementRenderer(text))
+    constructor(string: String, context: UIContext<Style, Events>) : this(Text(string), context)
+
+    override val renderer: TextElementRenderer
+        get() = super.renderer as TextElementRenderer
+
+    var string: String
+        get() = renderer.string
+        set(value) {
+            renderer.string = value
+        }
+
+
+    fun copyStyle(style: Style) {
+        style {
+            textColor.set(style.textColor)
+            fontSize = style.fontSize
+            this.font = style.font
+        }
+    }
+}
\ No newline at end of file
diff --git a/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/elements/Layouts.kt b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/elements/Layouts.kt
new file mode 100644
index 00000000..20a9a1bd
--- /dev/null
+++ b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/elements/Layouts.kt
@@ -0,0 +1,131 @@
+package com.mechanica.engine.ui.elements
+
+import com.dubulduke.ui.layout.EditLayout
+import com.dubulduke.ui.layout.Layout
+import com.dubulduke.ui.layout.LayoutSetter
+
+val listLayout = Layout.invoke { _, sibling ->
+    this.top = sibling.bottom
+}
+
+val tileLayout = Layout.invoke { parent, sibling ->
+    if (sibling.right + sibling.width <= parent.right) {
+        this.left = sibling.right
+        this.top = sibling.top
+    } else {
+        this.left = parent.left
+        this.top = sibling.bottom
+    }
+}
+
+private val _paddingLayout = PaddingLayout()
+val DrawerElement.paddingLayout: PaddingLayout
+    get() = _paddingLayout
+class PaddingLayout : LayoutSetter {
+
+    private var left: Double = 0.0
+    private var top: Double = 0.0
+    private var right: Double = 0.0
+    private var bottom: Double = 0.0
+
+    override fun EditLayout.perform(parent: Layout, sibling: Layout) {
+        val left = this@PaddingLayout.left
+        val right = this@PaddingLayout.right
+        val top = this@PaddingLayout.top
+        val bottom = this@PaddingLayout.bottom
+
+        padding(left, top, right, bottom)
+
+        reset()
+    }
+
+    private fun reset() {
+        left = 0.0
+        top = 0.0
+        right = 0.0
+        bottom = 0.0
+    }
+
+    operator fun invoke(size: Double = 0.0): LayoutSetter {
+        left = size
+        top = size
+        right = size
+        bottom = size
+        return this
+    }
+
+    operator fun invoke(horizontal: Double = 0.0, vertical: Double = 0.0): LayoutSetter {
+        left = horizontal
+        right = horizontal
+        top = vertical
+        bottom = vertical
+        return this
+    }
+
+    operator fun invoke(left: Double = 0.0, top: Double = 0.0, right: Double = 0.0, bottom: Double = 0.0): LayoutSetter {
+        this.left = left
+        this.right = right
+        this.top = top
+        this.bottom = bottom
+        return this
+    }
+}
+
+private val _scaleToParent = ScaleToParentLayout()
+val DrawerElement.scaleToParent: ScaleToParentLayout
+    get() = _scaleToParent
+
+class ScaleToParentLayout : LayoutSetter {
+    private var widthScale = 1.0
+    private var heightScale = 1.0
+
+    override fun EditLayout.perform(parent: Layout, sibling: Layout) {
+        this.width = parent.width*widthScale
+        this.height = parent.height*heightScale
+        reset()
+    }
+
+    operator fun invoke(widthScale: Double = 1.0, heightScale: Double = 1.0): LayoutSetter {
+        this.widthScale = widthScale
+        this.heightScale = heightScale
+        return this
+    }
+
+    private fun reset() {
+        this.widthScale = 1.0
+        this.heightScale = 1.0
+    }
+}
+
+val alignRight = Layout.invoke { p, _ ->
+    this.right = p.right
+}
+
+val alignLeft = Layout.invoke { p, _ ->
+    this.left = p.left
+}
+
+val centerHorizontal = Layout.invoke { p, _ ->
+    this.center.x = p.center.x
+}
+
+fun EditLayout.padding(horizontal: Double = 0.0, vertical: Double = 0.0) {
+    left += horizontal
+    width -= 2*horizontal
+    top += vertical
+    height -= 2*vertical
+}
+
+fun EditLayout.padding(left: Double = 0.0, top: Double = 0.0, right: Double = 0.0, bottom: Double = 0.0) {
+    this.left += left
+    this.width -= (right + left)
+    this.top += top
+    this.height -= (bottom + top)
+}
+
+fun EditLayout.padding(size: Double = 0.0) {
+    this.left += size
+    this.width -= 2*size
+    this.top += size
+    this.height -= 2*size
+}
diff --git a/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/elements/Renderers.kt b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/elements/Renderers.kt
new file mode 100644
index 00000000..bfeb7eed
--- /dev/null
+++ b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/elements/Renderers.kt
@@ -0,0 +1,58 @@
+package com.mechanica.engine.ui.elements
+
+import com.dubulduke.ui.UIContext
+import com.dubulduke.ui.render.ElementRenderer
+import com.dubulduke.ui.render.RenderDescription
+import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.models.Image
+import com.mechanica.engine.text.Text
+import com.mechanica.engine.ui.Events
+import com.mechanica.engine.ui.style.Style
+
+
+interface ElementDrawer : ElementRenderer<Style, Events, DrawerElement> {
+    override fun draw(description: RenderDescription<Style>, data: Any?) {
+        if (data != null && data is Drawer) {
+            description.draw(data.ui)
+        }
+    }
+
+    override fun createElement(context: UIContext<Style, Events>): DrawerElement {
+        return DrawerElement(context, this)
+    }
+
+    fun RenderDescription<Style>.draw(draw: Drawer)
+}
+
+class BoxRenderer : ElementDrawer {
+    override fun RenderDescription<Style>.draw(draw: Drawer) {
+        draw.ui.color(style.color).rectangle(x, y, width, height)
+    }
+}
+
+
+class TextElementRenderer(private var text: Text) : ElementDrawer {
+    var string: String
+        get() = text.string
+        set(value) {
+            text.string = value
+        }
+
+    override fun RenderDescription<Style>.draw(draw: Drawer) {
+        draw.ui.color(style.textColor).origin.relative(0.0, 1.0).text(text, style.fontSize, x, y)
+    }
+
+    override fun createElement(context: UIContext<Style, Events>): DrawerElement {
+        return TextElement(context, this)
+    }
+}
+
+class ImageElementRenderer(private val image: Image): ElementDrawer {
+    override fun createElement(context: UIContext<Style, Events>): DrawerElement {
+        return DrawerElement(context, this)
+    }
+
+    override fun RenderDescription<Style>.draw(draw: Drawer) {
+        draw.ui.image(image, x, y + height, width, -height)
+    }
+}
diff --git a/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/style/Style.kt b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/style/Style.kt
new file mode 100644
index 00000000..0f793298
--- /dev/null
+++ b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/style/Style.kt
@@ -0,0 +1,44 @@
+package com.mechanica.engine.ui.style
+
+import com.mechanica.engine.color.DynamicColor
+import com.mechanica.engine.text.Font
+
+class Style {
+    val color: DynamicColor = DynamicColor(1.0, 1.0, 1.0, 0.0)
+    val textColor: DynamicColor = DynamicColor(0.0, 0.0, 0.0, 1.0)
+    var text: String = ""
+    var fontSize: Double = 1.0
+    var font: Font? = null
+    var radius: Double = 0.0
+
+    fun add(styleSetter: StyleSetter) {
+        styleSetter.set(this)
+    }
+
+    fun add(styleSetter1: StyleSetter, styleSetter2: StyleSetter) {
+        add(styleSetter1)
+        add(styleSetter2)
+    }
+
+    fun add(styleSetter1: StyleSetter, styleSetter2: StyleSetter, styleSetter3: StyleSetter) {
+        add(styleSetter1)
+        add(styleSetter2)
+        add(styleSetter3)
+    }
+
+    fun add(styleSetter1: StyleSetter, styleSetter2: StyleSetter, styleSetter3: StyleSetter, styleSetter4: StyleSetter) {
+        add(styleSetter1)
+        add(styleSetter2)
+        add(styleSetter3)
+        add(styleSetter4)
+    }
+
+    companion object {
+        operator fun invoke(setter: Style.() -> Unit) = object : StyleSetter {
+            override fun set(style: Style) {
+                setter.invoke(style)
+            }
+
+        }
+    }
+}
\ No newline at end of file
diff --git a/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/style/StyleSetter.kt b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/style/StyleSetter.kt
new file mode 100644
index 00000000..7bb41489
--- /dev/null
+++ b/mechanica-ui/src/main/kotlin/com/mechanica/engine/ui/style/StyleSetter.kt
@@ -0,0 +1,5 @@
+package com.mechanica.engine.ui.style
+
+interface StyleSetter {
+    fun set(style: Style)
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/animation/AnimationController.kt b/mechanica/src/main/kotlin/com/mechanica/engine/animation/AnimationController.kt
new file mode 100644
index 00000000..699ba9ca
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/animation/AnimationController.kt
@@ -0,0 +1,40 @@
+package com.mechanica.engine.animation
+
+import com.mechanica.engine.scenes.processes.Updateable
+
+interface AnimationController : Updateable {
+
+    val startTime: Double
+    val endTime: Double
+    val length: Double
+        get() = endTime - startTime
+
+    val time: Double
+
+    var looped: Boolean
+    var paused: Boolean
+
+    val isPlaying: Boolean
+        get() = !paused
+
+    fun goTo(time: Double)
+
+    fun restart() {
+        goTo(startTime)
+        val pauseState = paused
+        paused = false
+        update(0.0)
+        paused = pauseState
+    }
+
+    fun pause() {
+        paused = true
+    }
+
+    fun play() {
+        paused = false
+        if (looped && time == endTime) {
+            restart()
+        }
+    }
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/animation/AnimationFormula.kt b/mechanica/src/main/kotlin/com/mechanica/engine/animation/AnimationFormula.kt
new file mode 100644
index 00000000..4adf0f8f
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/animation/AnimationFormula.kt
@@ -0,0 +1,65 @@
+package com.mechanica.engine.animation
+
+import com.mechanica.engine.util.extensions.constrain
+import com.mechanica.engine.util.extensions.constrainLooped
+
+class AnimationFormula(
+        startTime: Double, endTime: Double,
+        private var formula: AnimationFormulas.(Double) -> Double): AnimationController {
+
+    private val formulas = AnimationFormulas(this)
+
+    override var startTime: Double = startTime
+        private set
+    override var endTime: Double = endTime
+        private set
+    override var length: Double
+        get() = super.length
+        set(value) = length(value)
+
+    override var looped = false
+    override var paused = false
+
+    var value = formula(formulas, 0.0)
+        private set
+
+    override var time = startTime
+        private set(value) {
+            field = if (looped) {
+                value.constrainLooped(startTime, endTime)
+            } else {
+                if (value >= endTime) {
+                    paused = true
+                }
+                value.constrain(startTime, endTime)
+            }
+        }
+    private val relativeTime: Double
+        get() = time - startTime
+
+    constructor(length: Double, formula: AnimationFormulas.(Double) -> Double) : this(0.0, length, formula)
+
+    override fun goTo(time: Double) {
+        this.time = time
+    }
+
+    fun start(start: Double) {
+        this.startTime = start
+    }
+
+    fun length(length: Double) {
+        endTime = startTime + length
+    }
+
+    fun end(end: Double) {
+        this.endTime = end
+    }
+
+    override fun update(delta: Double) {
+        if (!paused) {
+            time += delta
+            value = formula(formulas, relativeTime)
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/animation/AnimationFormulas.kt b/mechanica/src/main/kotlin/com/mechanica/engine/animation/AnimationFormulas.kt
new file mode 100644
index 00000000..39c17161
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/animation/AnimationFormulas.kt
@@ -0,0 +1,79 @@
+package com.mechanica.engine.animation
+
+class AnimationFormulas(private val formula: AnimationFormula) {
+    val startTime: Double
+        get() = formula.startTime
+    val endTime: Double
+        get() = formula.endTime
+    val length: Double
+        get() = endTime - startTime
+
+    fun progress(time: Double): Double {
+        return time / length
+    }
+
+    fun absoluteTime(time: Double): Double = time + startTime
+
+    fun linear(time: Double, start: Double, end: Double, timeSpan: Double = length): Double {
+        val slope = (end - start)/timeSpan
+        return lineEquation(time, slope, start)
+    }
+
+    fun lineEquation(time: Double, slope: Double, yIntercept: Double): Double {
+        return slope*time + yIntercept
+    }
+
+    fun sin(time: Double, frequency: Double = 1.0, amplitude: Double = 1.0, phase: Double = 0.0): Double {
+        return amplitude* kotlin.math.sin(frequency * time + phase)
+    }
+
+    fun quadratic(time: Double, a: Double = 1.0, b: Double = 1.0, c: Double = 1.0): Double {
+        return time*time*a + time*b + c
+    }
+
+    fun quadraticDescending(time: Double, start: Double, end: Double, timeSpan: Double = length): Double {
+        return quadratic(time, -(start-end)/(timeSpan*timeSpan), 0.0, start)
+    }
+
+    fun quadraticAscending(time: Double, start: Double, end: Double, timeSpan: Double = length): Double {
+        val diff = (start-end)
+        val a = diff/(timeSpan*timeSpan)
+        val b = -2*diff/timeSpan
+        val c = start
+        return quadratic(time, a, b, c)
+    }
+
+    fun quadraticBump(time: Double, base: Double, bumpSize: Double, timeSpan: Double = length): Double {
+        val constant = 4*bumpSize
+
+        val a = -constant/(timeSpan*timeSpan)
+        val b = constant/timeSpan
+        val c = base
+
+        return quadratic(time, a, b, c)
+    }
+
+    companion object {
+        fun linear(start: Double, end: Double): AnimationFormulas.(Double) -> Double = { linear(it, start, end) }
+
+        fun sin(frequency: Double = 1.0, amplitude: Double = 1.0, phase: Double = 0.0): AnimationFormulas.(Double) -> Double {
+            return { sin(it, frequency, amplitude, phase) }
+        }
+
+        fun quadratic(a: Double = 1.0, b: Double = 1.0, c: Double = 1.0): AnimationFormulas.(Double) -> Double {
+            return { quadratic(it, a, b, c) }
+        }
+
+        fun quadraticDescending(start: Double, end: Double): AnimationFormulas.(Double) -> Double {
+            return { quadraticDescending(it, start, end) }
+        }
+
+        fun quadraticAscending(start: Double, end: Double): AnimationFormulas.(Double) -> Double {
+            return { quadraticAscending(it, start, end) }
+        }
+
+        fun quadraticBump(base: Double, bumpSize: Double): AnimationFormulas.(Double) -> Double {
+            return { quadraticBump(it, base, bumpSize) }
+        }
+    }
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/animation/AnimationSequence.kt b/mechanica/src/main/kotlin/com/mechanica/engine/animation/AnimationSequence.kt
new file mode 100644
index 00000000..e72d91e3
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/animation/AnimationSequence.kt
@@ -0,0 +1,67 @@
+package com.mechanica.engine.animation
+
+import com.mechanica.engine.util.extensions.fori
+
+class AnimationSequence(private vararg val animations: AnimationController): AnimationController {
+    override val startTime: Double
+    override val endTime: Double
+
+    override var looped: Boolean = false
+
+    override var time: Double = 0.0
+        private set
+
+    override var paused = false
+        set(value) {
+            field = value
+        }
+
+    init {
+        var startTime = 0.0
+        var endTime = 0.0
+        for (a in animations) {
+            if (a.startTime < startTime) {
+                startTime = a.startTime
+            }
+            if (a.endTime > endTime) {
+                endTime = a.endTime
+            }
+        }
+        this.startTime = startTime
+        this.endTime = endTime
+
+        time = startTime
+    }
+
+    override fun pause() {
+        super.pause()
+        animations.fori {
+            it.pause()
+        }
+    }
+
+    override fun play() {
+        super.play()
+        animations.fori {
+            it.paused = false
+        }
+    }
+
+    override fun goTo(time: Double) {
+        this.time = time
+        animations.fori {
+            it.goTo(time)
+        }
+    }
+
+    override fun update(delta: Double) {
+        if (!paused) {
+            animations.fori {
+                it.goTo(time)
+                it.update(delta)
+            }
+            time += delta
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/animation/FrameAnimation.kt b/mechanica/src/main/kotlin/com/mechanica/engine/animation/FrameAnimation.kt
index cfff200b..97d43daf 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/animation/FrameAnimation.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/animation/FrameAnimation.kt
@@ -2,45 +2,77 @@ package com.mechanica.engine.animation
 
 import com.mechanica.engine.models.Image
 import com.mechanica.engine.resources.ResourceDirectory
+import com.mechanica.engine.util.extensions.constrain
+import com.mechanica.engine.util.extensions.constrainLooped
 import com.mechanica.engine.utils.loadImage
-import kotlin.math.abs
 import kotlin.math.floor
+import kotlin.math.sign
 
-class FrameAnimation(private val frames: List<Image>, frameRate : Double) {
-    val duration = frames.size.toDouble()/frameRate
-    private var progress = 0.0
-        set(value) { field = value%duration }
+class FrameAnimation(private val frames: List<Image>, frameRate : Double,
+                     override var startTime: Double = 0.0,
+                     override var endTime: Double = frames.size.toDouble()/frameRate): AnimationController {
+    val duration: Double
+        get() = endTime - startTime
+    private val direction = sign(duration)
+    private val originalDuration = duration
 
-    var fraction: Double
-        get() = progress/duration
-        set(value) {
-            progress = value*duration
+    override var paused = false
+
+    override var time: Double = startTime
+        private set(value) {
+            field = if (looped) {
+                value.constrainLooped(startTime, endTime)
+            } else {
+                value.constrain(startTime, endTime)
+            }
         }
+    private val relativeTime: Double
+        get() = time - startTime
 
-    var currentFrame: Image
+    private val fraction: Double
+        get() = relativeTime/duration
+
+    val currentFrame: Image
         get() {
-            val index = floor(fraction*frames.size).toInt()
+            val index = floor(fraction*(frames.size-1)).toInt()
             return frames[index]
         }
-        set(value) {
-            fraction = value.id.toDouble()/frames.size.toDouble()
-        }
 
-    var scale: Double = 1.0
+    var scale: Double
+        get() = duration/originalDuration
         set(value) {
-            field = abs(value)
+            val scaleValue = direction/value
+            endTime = startTime + scaleValue*originalDuration
+            time = startTime + scaleValue*fraction*originalDuration
         }
 
-    fun play(delta: Double, reversed: Boolean = false) {
-        if (!reversed) {
-            progress += scale*delta
-        } else {
-            progress -= scale*delta
+    override var looped: Boolean = true
+
+    override fun goTo(time: Double) {
+        this.time = time
+    }
+
+    override fun restart() {
+        time = startTime
+    }
+
+    override fun pause() {
+        paused = true
+    }
+
+    override fun play() {
+        paused = false
+        if (time == endTime) {
+            time = startTime
         }
     }
 
+    override fun update(delta: Double) {
+        time += direction*delta
+    }
+
     companion object {
         fun loadAnimation(directory: ResourceDirectory, frameRate: Double = 24.0)
-                = FrameAnimation(directory.map { loadImage(it) }, frameRate)
+                = FrameAnimation(directory.resources.map { loadImage(it) }, frameRate)
     }
 }
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/debug/GameDebugConfiguration.kt b/mechanica/src/main/kotlin/com/mechanica/engine/debug/GameDebugConfiguration.kt
index fed749ab..10b4faa7 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/debug/GameDebugConfiguration.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/debug/GameDebugConfiguration.kt
@@ -1,9 +1,19 @@
 package com.mechanica.engine.debug
 
+import com.mechanica.engine.game.Game
+
 class GameDebugConfiguration : DebugConfiguration {
     override var failEarly = false
     override var screenLog = false
     override var constructionDraws = false
     override var printWarnings = false
     override var lwjglDebug = false
+
+    override fun pauseUpdates(pause: Boolean) {
+        Game.sceneManager.pauseExecution(pause)
+    }
+
+    override fun frameAdvance() {
+        Game.sceneManager.frameAdvance()
+    }
 }
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/debug/ScreenLog.kt b/mechanica/src/main/kotlin/com/mechanica/engine/debug/ScreenLog.kt
index 178297c8..95b5d053 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/debug/ScreenLog.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/debug/ScreenLog.kt
@@ -8,8 +8,10 @@ object ScreenLog {
     internal fun render(draw: Drawer) {
         val v = Game.ui
         val fontSize = v.height*0.02
-        draw.ui.layout.origin(0, 1).green.alpha(0.5).text(sb.toString(), fontSize, v.left, v.top)
-        sb.clear()
+        if (sb.isNotEmpty()) {
+            draw.ui.origin.relative(0, 1).green.alpha(0.5).text(sb.toString(), fontSize, v.left, v.top)
+            sb.clear()
+        }
     }
 
     fun addLine(text: String) {
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/DrawData.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/DrawData.kt
index f7135226..4dae1bb3 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/DrawData.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/DrawData.kt
@@ -1,6 +1,7 @@
 package com.mechanica.engine.drawer
 
 import com.mechanica.engine.color.DynamicColor
+import com.mechanica.engine.drawer.shader.AbstractDrawerShader
 import com.mechanica.engine.drawer.shader.DrawerRenderer
 import com.mechanica.engine.game.Game
 import com.mechanica.engine.models.Model
@@ -10,6 +11,7 @@ import com.mechanica.engine.unit.vector.LightweightVector
 import com.mechanica.engine.unit.vector.Vector
 import org.joml.Matrix4f
 import org.joml.Vector3f
+import kotlin.math.tan
 
 class DrawData {
 
@@ -20,20 +22,24 @@ class DrawData {
             viewMatrixWasSet = true
             field = value
         }
-    var projectionMatrix: Matrix4f = Game.matrices.projection
+    private var projectionMatrix: Matrix4f = Game.matrices.projection
 
     private val renderer = DrawerRenderer()
-    private val transformation = Matrix4f().identity()
+    private val defaultTransformation = Matrix4f().identity()
+    private val spareTransformation = Matrix4f().identity()
+    var transformation: Matrix4f? = null
 
     private val translation: Vector3f = Vector3f()
     private val pivot: Vector3f = Vector3f()
-    private val unpivot: Vector3f = Vector3f()
     private val scale: Vector3f = Vector3f(1f, 1f, 1f)
     private val zAxis = Vector3f(0f, 0f, 1f)
     private var rx = 0f
     private var ry = 0f
     private var rz = 0f
 
+    private var skewX = 0f
+    private var skewY = 0f
+
     val scaleX get() = scale.x
     val scaleY get() = scale.y
 
@@ -47,9 +53,19 @@ class DrawData {
             renderer.strokeWidth = value
         }
 
+    var strokeColorWasSet = false
     val strokeColor = DynamicColor(0.0, 0.0, 0.0, 1.0)
+        get() {
+            strokeColorWasSet = true
+            return field
+        }
 
+    var fillColorWasSet = false
     val fillColor = DynamicColor(0.0, 0.0, 0.0, 1.0)
+        get() {
+            fillColorWasSet = true
+            return field
+        }
 
     val modelOrigin = OriginVector()
 
@@ -72,27 +88,28 @@ class DrawData {
     val cornerSize: DynamicVector
         get() = renderer.size
 
-//    private val fontMap = HashMap<Font, TextModel>()
-//
-//    private var font: Font = Font.create(Res.font["Roboto-Regular.ttf"]).also { fontMap[it] = TextModel("", it) }
-
-    val textModel: TextModel = TextModel("Test")
-        //get() = fontMap[font] ?: TextModel("", font).also { fontMap[font] = it }
+    val stringHolderModel: TextModel = TextModel("")
+    val textHolderModel: TextModel = TextModel("")
 
     fun setTranslate(x: Float, y: Float) {
-        translation.set(x, y, translateZ)
+        translation.set(translation.x + x, translation.y + y, translateZ)
     }
 
     fun setRotate(angle: Float) {
-        rz = angle
+        rz += angle
     }
 
     fun setScale(x: Float, y: Float) {
-        scale.set(x, y, 0f)
+        scale.set(scale.x*x, scale.y*y, 0f)
+    }
+
+    fun setSkew(x: Float, y: Float) {
+        skewX = x
+        skewY = y
     }
 
     fun setDepth(z: Float) {
-        translation.set(translateX, translateY, -z)
+        translation.set(translateX, translateY, translation.z-z)
     }
 
     fun getTransformationMatrix(matrix: Matrix4f): Matrix4f {
@@ -101,38 +118,52 @@ class DrawData {
         if (rz != 0f)
             matrix.rotate(rz, zAxis)
 
-        if (modelOrigin.x != 0.0 || modelOrigin.y != 0.0) {
-            val pivotX = modelOrigin.x.toFloat()*scale.x
-            val pivotY = modelOrigin.y.toFloat()*scale.y
-            matrix.translate(-pivotX, -pivotY, 0f)
-        }
+        addSkewToMatrix(matrix)
+        addModelOriginToMatrix(matrix)
 
         matrix.scale(scale)
         pivot.set(0f, 0f, 0f)
-        unpivot.set(0f, 0f, 0f)
-        rx = 0f
-        ry = 0f
-        rz = 0f
         return matrix
     }
 
-    fun draw(model: Model) {
+    fun draw(model: Model, shader: AbstractDrawerShader = renderer.shader) {
         renderer.color = fillColor
         renderer.radius = radius
 
-        getTransformationMatrix(transformation)
-        renderer.render(model, transformation, viewMatrix, projectionMatrix)
+        getTransformationMatrix(defaultTransformation)
+        transformation?.let { defaultTransformation.mul(it) }
+
+        shader.render(model, defaultTransformation, projectionMatrix, viewMatrix)
 
         if (!noReset) {
             rewind()
         }
     }
 
+    private fun addModelOriginToMatrix(matrix: Matrix4f) {
+        if (modelOrigin.x != 0.0 || modelOrigin.y != 0.0) {
+            val pivotX = modelOrigin.x.toFloat()*scale.x
+            val pivotY = modelOrigin.y.toFloat()*scale.y
+            matrix.translate(-pivotX, -pivotY, 0f)
+        }
+    }
+
+    private fun addSkewToMatrix(matrix: Matrix4f) {
+        if (skewX != 0f || skewY != 0f) {
+            spareTransformation.m10(tan(-skewX))
+            spareTransformation.m01(tan(skewY))
+
+            matrix.mul(spareTransformation)
+        }
+    }
+
     fun rewind() {
-        setRotate(0f)
-        setTranslate(0f, 0f)
-        setDepth(0f)
-        setScale(1f, 1f)
+        rz = 0f
+        fillColor.a = 1.0
+        translation.set(0f, 0f, 0f)
+        scale.set(1f, 1f, 1f)
+        skewX = 0f
+        skewY = 0f
 
         radius = 0f
         noReset = false
@@ -141,7 +172,11 @@ class DrawData {
         viewMatrixWasSet = false
         projectionMatrix = Game.matrices.projection
 
-        transformation.identity()
+        strokeColorWasSet = false
+        fillColorWasSet = false
+
+        defaultTransformation.identity()
+        transformation = null
         renderer.rewind()
         modelOrigin.reset()
     }
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/Drawer.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/Drawer.kt
index 9378cbad..962a0241 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/Drawer.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/Drawer.kt
@@ -1,9 +1,10 @@
 package com.mechanica.engine.drawer
 
 import com.mechanica.engine.color.hex
+import com.mechanica.engine.drawer.shader.AbstractDrawerShader
 import com.mechanica.engine.drawer.subclasses.color.ColorDrawer
+import com.mechanica.engine.drawer.subclasses.layout.OriginDrawer
 import com.mechanica.engine.drawer.subclasses.rotation.RotatedDrawer
-import com.mechanica.engine.drawer.subclasses.layout.LayoutDrawer
 import com.mechanica.engine.drawer.subclasses.stroke.StrokeDrawer
 import com.mechanica.engine.drawer.subclasses.transformation.TransformationDrawer
 import com.mechanica.engine.drawer.superclass.circle.CircleDrawer
@@ -15,9 +16,9 @@ import com.mechanica.engine.models.Model
 import com.mechanica.engine.models.PolygonModel
 
 interface Drawer : RectangleDrawer, CircleDrawer, ImageDrawer, TextDrawer, PathDrawer {
-    val layout: LayoutDrawer
+    val origin: OriginDrawer
     val centered: Drawer
-        get() = layout.origin(0.5, 0.5)
+        get() = origin.relative(0.5, 0.5)
 
     val color: ColorDrawer
 
@@ -90,7 +91,9 @@ interface Drawer : RectangleDrawer, CircleDrawer, ImageDrawer, TextDrawer, PathD
 
     fun polygon(polygon: PolygonModel)
 
-    fun model(model: Model)
+    fun model(model: Model, blend: Float = 0f, alphaBlend: Float = 0f, colorPassthrough: Boolean = true)
+
+    fun shader(shader: AbstractDrawerShader, model: Model? = null)
 
     fun radius(r: Number): Drawer
 
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/DrawerImpl.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/DrawerImpl.kt
index 1ca5f397..3b4cf602 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/DrawerImpl.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/DrawerImpl.kt
@@ -1,11 +1,13 @@
 package com.mechanica.engine.drawer
 
+import com.mechanica.engine.context.loader.GLLoader
+import com.mechanica.engine.drawer.shader.AbstractDrawerShader
 import com.mechanica.engine.drawer.subclasses.color.ColorDrawer
 import com.mechanica.engine.drawer.subclasses.color.ColorDrawerImpl
+import com.mechanica.engine.drawer.subclasses.layout.OriginDrawer
+import com.mechanica.engine.drawer.subclasses.layout.OriginDrawerImpl
 import com.mechanica.engine.drawer.subclasses.rotation.RotatedDrawer
 import com.mechanica.engine.drawer.subclasses.rotation.RotatedDrawerImpl
-import com.mechanica.engine.drawer.subclasses.layout.LayoutDrawer
-import com.mechanica.engine.drawer.subclasses.layout.LayoutDrawerImpl
 import com.mechanica.engine.drawer.subclasses.stroke.StrokeDrawer
 import com.mechanica.engine.drawer.subclasses.stroke.StrokeDrawerImpl
 import com.mechanica.engine.drawer.subclasses.transformation.TransformationDrawer
@@ -23,6 +25,7 @@ import com.mechanica.engine.drawer.superclass.text.TextDrawerImpl
 import com.mechanica.engine.game.Game
 import com.mechanica.engine.models.Model
 import com.mechanica.engine.models.PolygonModel
+import com.mechanica.engine.shader.qualifiers.Attribute
 import org.lwjgl.opengl.GL11
 
 class DrawerImpl(private val data: DrawData) :
@@ -34,6 +37,15 @@ class DrawerImpl(private val data: DrawData) :
         Drawer
 {
 
+    private val model: Model
+
+    init {
+        val position = Attribute.location(0).vec3().createUnitQuad()
+        val texCoords = Attribute.location(1).vec2().createInvertedUnitQuad()
+
+        model = Model(position, texCoords, draw = GLLoader.graphicsLoader::drawArrays)
+    }
+
     private val colorDrawer = ColorDrawerImpl(this, data)
     override val color: ColorDrawer
         get() = colorDrawer
@@ -46,8 +58,8 @@ class DrawerImpl(private val data: DrawData) :
     override val rotated: RotatedDrawer
         get() = rotatedDrawer
 
-    private val layoutDrawer = LayoutDrawerImpl(this, data)
-    override val layout: LayoutDrawer
+    private val layoutDrawer = OriginDrawerImpl(this, data)
+    override val origin: OriginDrawer
         get() = layoutDrawer
 
     private val transformationDrawer = TransformationDrawerImpl(this, data)
@@ -87,8 +99,14 @@ class DrawerImpl(private val data: DrawData) :
         data.draw(polygon)
     }
 
-    override fun model(model: Model) {
-        data.colorPassthrough = true
+    override fun model(model: Model, blend: Float, alphaBlend: Float, colorPassthrough: Boolean) {
+        data.blend = blend
+        data.alphaBlend = alphaBlend
+        data.colorPassthrough = colorPassthrough
         data.draw(model)
     }
+
+    override fun shader(shader: AbstractDrawerShader, model: Model?) {
+        data.draw(model ?: this.model, shader)
+    }
 }
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/shader/AbstractDrawerShader.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/shader/AbstractDrawerShader.kt
new file mode 100644
index 00000000..600a605f
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/shader/AbstractDrawerShader.kt
@@ -0,0 +1,113 @@
+package com.mechanica.engine.drawer.shader
+
+import com.mechanica.engine.game.Game
+import com.mechanica.engine.game.view.GameMatrices
+import com.mechanica.engine.matrix.Matrices
+import com.mechanica.engine.models.Model
+import com.mechanica.engine.shader.script.Shader
+import com.mechanica.engine.shader.script.ShaderLoader
+import com.mechanica.engine.shader.script.ShaderScript
+import org.joml.Matrix4f
+import org.lwjgl.opengl.GL20
+
+abstract class AbstractDrawerShader : Shader() {
+
+    abstract override val vertex: DrawerScript
+    abstract override val fragment: DrawerScript
+    override val tessellation: DrawerScript? = null
+    override val geometry: DrawerScript? = null
+
+    private val matrixLoaders by lazy {
+        val loaders = ArrayList<MatrixLoader>()
+        loaders.add(MatrixLoader(vertex))
+
+        val geometry = this.geometry
+        if (geometry != null) {
+            loaders.add(MatrixLoader(geometry))
+        }
+
+        loaders
+    }
+
+    private val pixelSize by lazy { fragment.uniform.float("pixelSize") }
+
+    private val loader: ShaderLoader by lazy { ShaderLoader(vertex, fragment, tessellation, geometry) }
+
+    override val id: Int
+        get() = loader.id
+
+    fun render(model: Model, transformation: Matrix4f, projection: Matrix4f? = null, view: Matrix4f? = null) {
+
+        loadMatrixUniforms(transformation,
+                projection ?: Game.matrices.projection,
+                view ?: Game.matrices.view
+        )
+
+        render(model)
+    }
+
+    private fun loadMatrixUniforms(transformation: Matrix4f, projection: Matrix4f, view: Matrix4f) {
+        setGameMatrices(projection, view)
+
+        for (loader in matrixLoaders) {
+            loader.transformation.set(transformation)
+            loader.projection.set(projection)
+            loader.view.set(view)
+        }
+    }
+
+    private fun setGameMatrices(projection: Matrix4f, view: Matrix4f) {
+
+        for (loader in matrixLoaders) {
+            loader.matrixType.value = 1f
+            if (projection === Game.matrices.projection) {
+                if (view === Game.matrices.view) {
+                    loader.matrixType.value = 0f
+                    loader.pvMatrix.set((Game.matrices as GameMatrices).pvMatrix)
+                    this.pixelSize.value = (Game.matrices as GameMatrices).pixelScale
+                } else if (view === Game.matrices.uiView) {
+                    loader.matrixType.value = 0f
+                    loader.pvMatrix.set((Game.matrices as GameMatrices).pvUiMatrix)
+                    this.pixelSize.value = (Game.matrices as GameMatrices).pixelUIScale
+                }
+            }
+            if (loader.matrixType.value == 1f) {
+                this.pixelSize.value = Matrices.calculatePixelSize(projection, view, Game.window.height)
+            }
+        }
+    }
+
+    override fun loadProgram(id: Int) {
+        GL20.glUseProgram(id)
+    }
+
+    override fun loadUniformLocation(name: String) = GL20.glGetUniformLocation(id, name)
+
+    private class MatrixLoader(script: DrawerScript) {
+        val matrixType = script.uniform.float("matrixType")
+
+        val projection = script.uniform.mat4("projection")
+        val transformation = script.uniform.mat4("transformation")
+        val view = script.uniform.mat4("view")
+
+        val pvMatrix = script.uniform.mat4("pvMatrix")
+
+        init {
+            loadMatrixMethod(script)
+        }
+
+        fun loadMatrixMethod(script: ShaderScript) {
+            if (!script.script.contains("vec4 matrices(vec4 position)")) {
+                //language=GLSL
+                script.addOther("""
+                    vec4 matrices(vec4 position) {
+                        if(matrixType == 0.0) {
+                            return pvMatrix*transformation*position;
+                        }
+                        return projection*view*transformation*position;
+                    }
+                """)
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/shader/DrawerRenderer.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/shader/DrawerRenderer.kt
index 009c90a4..17384a35 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/shader/DrawerRenderer.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/shader/DrawerRenderer.kt
@@ -41,12 +41,12 @@ class DrawerRenderer {
                     vec4 inColor;
                     if ($blend > 0.0 || $alphaBlend > 0.0) {
                         vec4 texColor = texture(samp, tc);
-                        inColor = vec4(mix($color.rgb, texColor.rgb, $blend), mix($color.a, texColor.a, $alphaBlend));
+                        inColor = vec4(mix($color.rgb, texColor.rgb, $blend), $color.a*texColor.a);
                     } else {
                         inColor = $color;
                     }
                     
-                    if ($colorPassthrough == 0f) {
+                    if ($colorPassthrough == 0.0) {
                         vec2 st = pos - vec2(0.5);
                         
                         float height = abs($size.y);
@@ -74,7 +74,7 @@ class DrawerRenderer {
 
     }
 
-    private val shader: DrawerShader by lazy { DrawerShader(vertex, fragment) }
+    val shader: DrawerShader by lazy { DrawerShader(vertex, fragment) }
 
     var color: Color
         get() = fragment.color.value.toColor()
@@ -115,7 +115,7 @@ class DrawerRenderer {
 
     var strokeWidth = 0.0
 
-    fun render(model: Model, transformation: Matrix4f, view: Matrix4f, projection: Matrix4f) {
+    fun render(model: Model, transformation: Matrix4f, projection: Matrix4f, view: Matrix4f) {
         shader.render(model, transformation, projection, view)
     }
 
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/shader/DrawerShader.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/shader/DrawerShader.kt
index 92d193b3..26a72591 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/shader/DrawerShader.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/shader/DrawerShader.kt
@@ -1,104 +1,7 @@
 package com.mechanica.engine.drawer.shader
 
-import com.mechanica.engine.game.Game
-import com.mechanica.engine.game.view.GameMatrices
-import com.mechanica.engine.shader.script.ShaderScript
-import com.mechanica.engine.shader.script.Shader
-import com.mechanica.engine.shader.script.ShaderLoader
-import com.mechanica.engine.matrix.Matrices
-import com.mechanica.engine.models.Model
-import org.joml.Matrix4f
-
-class DrawerShader(
+open class DrawerShader(
         override val vertex: DrawerScript,
         override val fragment: DrawerScript,
         override val tessellation: DrawerScript? = null,
-        override val geometry: DrawerScript? = null): Shader() {
-
-    private val matrixLoaders = ArrayList<MatrixLoader>()
-
-    private val pixelSize = fragment.uniform.float("pixelSize")
-
-    private val loader: ShaderLoader by lazy { ShaderLoader(vertex, fragment, tessellation, geometry) }
-
-    override val id: Int
-        get() = loader.id
-
-    init {
-        matrixLoaders.add(MatrixLoader(vertex))
-        if (geometry != null) {
-            matrixLoaders.add(MatrixLoader(geometry))
-        }
-    }
-
-    fun render(model: Model, transformation: Matrix4f, projection: Matrix4f? = null, view: Matrix4f? = null) {
-
-        loadMatrixUniforms(transformation,
-                projection ?: Game.matrices.projection,
-                view ?: Game.matrices.view
-        )
-        load()
-
-        model.bind()
-        model.draw()
-    }
-
-    private fun loadMatrixUniforms(transformation: Matrix4f, projection: Matrix4f, view: Matrix4f) {
-        setGameMatrices(projection, view)
-
-        for (loader in matrixLoaders) {
-            loader.transformation.set(transformation)
-            loader.projection.set(projection)
-            loader.view.set(view)
-        }
-    }
-
-    private fun setGameMatrices(projection: Matrix4f, view: Matrix4f) {
-
-        for (loader in matrixLoaders) {
-            loader.matrixType.value = 1f
-            if (projection === Game.matrices.projection) {
-                if (view === Game.matrices.view) {
-                    loader.matrixType.value = 0f
-                    loader.pvMatrix.set((Game.matrices as GameMatrices).pvMatrix)
-                    this.pixelSize.value = (Game.matrices as GameMatrices).pixelScale
-                } else if (view === Game.matrices.uiView) {
-                    loader.matrixType.value = 0f
-                    loader.pvMatrix.set((Game.matrices as GameMatrices).pvUiMatrix)
-                    this.pixelSize.value = (Game.matrices as GameMatrices).pixelUIScale
-                }
-            }
-            if (loader.matrixType.value == 1f) {
-                this.pixelSize.value = Matrices.calculatePixelSize(projection, view, Game.window.height)
-            }
-        }
-    }
-
-    private class MatrixLoader(script: DrawerScript) {
-        val matrixType = script.uniform.float("matrixType")
-
-        val projection = script.uniform.mat4("projection")
-        val transformation = script.uniform.mat4("transformation")
-        val view = script.uniform.mat4("view")
-
-        val pvMatrix = script.uniform.mat4("pvMatrix")
-
-        init {
-            loadMatrixMethod(script)
-        }
-
-        fun loadMatrixMethod(script: ShaderScript) {
-            if (!script.script.contains("vec4 matrices(vec4 position)")) {
-                //language=GLSL
-                script.addOther("""
-                    vec4 matrices(vec4 position) {
-                        if(matrixType == 0f) {
-                            return pvMatrix*transformation*position;
-                        }
-                        return projection*view*transformation*position;
-                    }
-                """)
-            }
-        }
-    }
-}
\ No newline at end of file
+        override val geometry: DrawerScript? = null): AbstractDrawerShader()
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/shader/PathRenderer.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/shader/PathRenderer.kt
index c01a2a11..9f4af48c 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/shader/PathRenderer.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/shader/PathRenderer.kt
@@ -15,7 +15,7 @@ import org.joml.Matrix4f
 import org.lwjgl.opengl.GL11.*
 import org.lwjgl.opengl.GL20
 
-class PathRenderer(positionBufferMaker: FloatBufferMaker = Attribute(0).vec3()) {
+class PathRenderer(positionBufferMaker: FloatBufferMaker = Attribute.location(0).vec3()) {
 
     private val vertex = object : DrawerScript() {
 
@@ -37,7 +37,12 @@ class PathRenderer(positionBufferMaker: FloatBufferMaker = Attribute(0).vec3())
         override val main: String = """
             layout (lines) in;
             layout (triangle_strip, max_vertices = 4) out;
-                        
+                       
+            out GS_OUT
+            {
+                vec2 v_TexCoord;
+            } gs_out;
+             
             void main() {
                 vec2 p1 = gl_in[0].gl_Position.xy;
                 vec2 p2 = gl_in[1].gl_Position.xy;
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/color/ColorDrawer.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/color/ColorDrawer.kt
index cdfd387c..94dc1643 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/color/ColorDrawer.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/color/ColorDrawer.kt
@@ -2,10 +2,10 @@ package com.mechanica.engine.drawer.subclasses.color
 
 import com.mechanica.engine.color.Color
 import com.mechanica.engine.color.LightweightColor
-import com.mechanica.engine.color.hsl
 import com.mechanica.engine.color.hex
+import com.mechanica.engine.color.hsl
 import com.mechanica.engine.drawer.Drawer
-import com.mechanica.engine.unit.angle.Angle
+import com.mechanica.engine.unit.angle.Degree
 
 interface ColorDrawer : Drawer, Color {
     fun get(): Color
@@ -16,27 +16,27 @@ interface ColorDrawer : Drawer, Color {
 
     operator fun invoke(hex: Long): ColorDrawer = invoke(hex(hex))
 
-    fun alpha(alpha: Double): Drawer {
+    fun alpha(alpha: Double): ColorDrawer {
         this.invoke(com.mechanica.engine.color.rgba(r, g, b, alpha))
         return this
     }
 
-    fun rgba(r: Double = this.r, g: Double = this.g, b: Double = this.b, a: Double = this.a): Drawer {
+    fun rgba(r: Double = this.r, g: Double = this.g, b: Double = this.b, a: Double = this.a): ColorDrawer {
         this.invoke(com.mechanica.engine.color.rgba(r, g, b, a))
         return this
     }
 
-    fun hue(hue: Angle): Drawer {
+    fun hue(hue: Degree): ColorDrawer {
         this.invoke(hsl(hue, saturation, lightness))
         return this
     }
 
-    fun lightness(lightness: Double): Drawer {
+    fun lightness(lightness: Double): ColorDrawer {
         this.invoke(hsl(hue, saturation, lightness))
         return this
     }
 
-    fun saturation(saturation: Double): Drawer {
+    fun saturation(saturation: Double): ColorDrawer {
         this.invoke(hsl(hue, saturation, lightness))
         return this
     }
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/layout/LayoutDrawer.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/layout/LayoutDrawer.kt
deleted file mode 100644
index 34f888b5..00000000
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/layout/LayoutDrawer.kt
+++ /dev/null
@@ -1,12 +0,0 @@
-package com.mechanica.engine.drawer.subclasses.layout
-
-import com.mechanica.engine.drawer.Drawer
-import com.mechanica.engine.unit.vector.LightweightVector
-import com.mechanica.engine.unit.vector.Vector
-
-interface LayoutDrawer {
-    fun origin(): Drawer
-    fun origin(x: Number, y: Number): Drawer
-    fun origin(point: Vector) = origin(point.x, point.y)
-    fun origin(point: LightweightVector) = origin(point.x, point.y)
-}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/layout/OriginDrawer.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/layout/OriginDrawer.kt
new file mode 100644
index 00000000..cee352b7
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/layout/OriginDrawer.kt
@@ -0,0 +1,12 @@
+package com.mechanica.engine.drawer.subclasses.layout
+
+import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.unit.vector.LightweightVector
+import com.mechanica.engine.unit.vector.Vector
+
+interface OriginDrawer {
+    fun relative(): Drawer
+    fun relative(x: Number, y: Number): Drawer
+    fun relative(point: Vector) = relative(point.x, point.y)
+    fun relative(point: LightweightVector) = relative(point.x, point.y)
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/layout/LayoutDrawerImpl.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/layout/OriginDrawerImpl.kt
similarity index 59%
rename from mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/layout/LayoutDrawerImpl.kt
rename to mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/layout/OriginDrawerImpl.kt
index df9e499c..84b9d2ce 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/layout/LayoutDrawerImpl.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/layout/OriginDrawerImpl.kt
@@ -3,14 +3,14 @@ package com.mechanica.engine.drawer.subclasses.layout
 import com.mechanica.engine.drawer.DrawData
 import com.mechanica.engine.drawer.Drawer
 
-class LayoutDrawerImpl(drawer: Drawer, private val data: DrawData) : LayoutDrawer, Drawer by drawer {
+class OriginDrawerImpl(drawer: Drawer, private val data: DrawData) : OriginDrawer, Drawer by drawer {
 
-    override fun origin(): Drawer {
+    override fun relative(): Drawer {
         data.modelOrigin.set(0.0, 0.0)
         return this
     }
 
-    override fun origin(x: Number, y: Number): Drawer {
+    override fun relative(x: Number, y: Number): Drawer {
         data.modelOrigin.set(x.toDouble(), y.toDouble())
         return this
     }
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/rotation/RotatedDrawerImpl.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/rotation/RotatedDrawerImpl.kt
index 0e9446ae..ea0c0732 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/rotation/RotatedDrawerImpl.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/rotation/RotatedDrawerImpl.kt
@@ -9,9 +9,9 @@ import com.mechanica.engine.unit.vector.Vector
 
 internal class RotatedDrawerImpl(drawer: Drawer, private val data: DrawData): RotatedDrawer, Drawer by drawer {
 
-    override fun invoke(angle: Degree) = rotate(angle.toRadians().asDouble())
+    override fun invoke(angle: Degree) = rotate(angle.toRadians().toDouble())
 
-    override fun invoke(angle: Radian) = rotate(angle.asDouble())
+    override fun invoke(angle: Radian) = rotate(angle.toDouble())
 
     override fun about(pivotX: Number, pivotY: Number): Drawer {
         data.modelOrigin.set(pivotX.toDouble(), pivotY.toDouble())
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/transformation/TransformationDrawer.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/transformation/TransformationDrawer.kt
index 136f06c6..d722d191 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/transformation/TransformationDrawer.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/transformation/TransformationDrawer.kt
@@ -1,8 +1,13 @@
 package com.mechanica.engine.drawer.subclasses.transformation
 
 import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.unit.angle.Degree
+import com.mechanica.engine.unit.angle.Radian
+import com.mechanica.engine.unit.angle.degrees
+import com.mechanica.engine.unit.angle.radians
 import com.mechanica.engine.unit.vector.LightweightVector
 import com.mechanica.engine.unit.vector.Vector
+import org.joml.Matrix4f
 
 interface TransformationDrawer : Drawer {
     fun translate(x: Number, y: Number): TransformationDrawer
@@ -15,4 +20,13 @@ interface TransformationDrawer : Drawer {
     fun scale(scale: LightweightVector) = scale(scale.x, scale.y)
     fun scale(scale: Vector) = scale(scale.x, scale.y)
     fun scale(scale: Double) = scale(scale, scale)
+
+    fun skew(horizontal: Degree = 0.degrees, vertical: Degree = 0.degrees): TransformationDrawer = skew(horizontal.toRadians(), vertical.toRadians())
+    fun skew(horizontal: Radian = 0.radians, vertical: Radian = 0.radians): TransformationDrawer
+
+    fun matrix(matrix: Matrix4f): TransformationDrawer
+
+    operator fun invoke(x: Number = 0.0, y: Number = 0.0, scaleX: Number = 1.0, scaleY: Number = 1.0): TransformationDrawer
+
+    operator fun invoke(matrix: Matrix4f) = matrix(matrix)
 }
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/transformation/TransformationDrawerImpl.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/transformation/TransformationDrawerImpl.kt
index 2ecc97d7..18f1fc1b 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/transformation/TransformationDrawerImpl.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/subclasses/transformation/TransformationDrawerImpl.kt
@@ -2,6 +2,8 @@ package com.mechanica.engine.drawer.subclasses.transformation
 
 import com.mechanica.engine.drawer.DrawData
 import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.unit.angle.Radian
+import org.joml.Matrix4f
 
 class TransformationDrawerImpl(drawer: Drawer, private val data: DrawData): TransformationDrawer, Drawer by drawer {
     override fun translate(x: Number, y: Number): TransformationDrawer {
@@ -14,4 +16,19 @@ class TransformationDrawerImpl(drawer: Drawer, private val data: DrawData): Tran
         return this
     }
 
+    override fun skew(horizontal: Radian, vertical: Radian): TransformationDrawer {
+        data.setSkew(horizontal.toDouble().toFloat(), vertical.toDouble().toFloat())
+        return this
+    }
+
+    override fun matrix(matrix: Matrix4f): TransformationDrawer {
+        data.transformation = matrix
+        return this
+    }
+
+    override fun invoke(x: Number, y: Number, scaleX: Number, scaleY: Number): TransformationDrawer {
+        translate(x, y)
+        scale(scaleX, scaleY)
+        return this
+    }
 }
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/circle/CircleDrawer.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/circle/CircleDrawer.kt
index 717482f5..ce9b9f09 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/circle/CircleDrawer.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/circle/CircleDrawer.kt
@@ -4,17 +4,11 @@ import com.mechanica.engine.unit.vector.LightweightVector
 import com.mechanica.engine.unit.vector.Vector
 
 interface CircleDrawer {
-    fun circle()
+    fun circle(x: Number = 0, y: Number = 0, radius: Number = 0.5f)
 
-    fun circle(x: Number, y: Number)
-    fun circle(x: Number, y: Number, radius: Number)
+    fun circle(position: Vector, radius: Number = 0.5f) = circle(position.x, position.y, radius)
+    fun circle(position: LightweightVector, radius: Number = 0.5f) = circle(position.x, position.y, radius)
 
-    fun circle(position: Vector) = circle(position.x, position.y)
-    fun circle(position: LightweightVector) = circle(position.x, position.y)
-
-    fun circle(position: Vector, radius: Number) = circle(position.x, position.y, radius)
-    fun circle(position: LightweightVector, radius: Number) = circle(position.x, position.y, radius)
-
-    fun ellipse(x: Number, y: Number, width: Number, height: Number)
+    fun ellipse(x: Number = 0, y: Number = 0, width: Number = 1, height: Number = 1)
     fun ellipse(xy: LightweightVector, wh: LightweightVector) = ellipse(xy.x, xy.y, wh.x, wh.y)
 }
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/circle/CircleDrawerImpl.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/circle/CircleDrawerImpl.kt
index 86054ef7..c77aef52 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/circle/CircleDrawerImpl.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/circle/CircleDrawerImpl.kt
@@ -14,7 +14,7 @@ class CircleDrawerImpl(
     private val model: Model
 
     init {
-        val position = Attribute(0).vec3().createUnitQuad()
+        val position = Attribute.location(0).vec3().createUnitQuad()
 
         val disableTexCoords = object : Bindable {
             override fun bind() {
@@ -24,7 +24,7 @@ class CircleDrawerImpl(
         model = Model(position, disableTexCoords, draw = GLLoader.graphicsLoader::drawArrays)
     }
 
-    override fun circle() {
+    private fun drawCircle() {
         val radius = if (data.radius > 0.0) data.radius
         else {
             data.radius = 0.5f
@@ -44,14 +44,10 @@ class CircleDrawerImpl(
         data.draw(model)
     }
 
-    override fun circle(x: Number, y: Number) {
-        data.setTranslate(x.toFloat(), y.toFloat())
-        circle()
-    }
-
     override fun circle(x: Number, y: Number, radius: Number) {
         data.radius = radius.toFloat()
-        circle(x, y)
+        data.setTranslate(x.toFloat(), y.toFloat())
+        drawCircle()
     }
 
     override fun ellipse(x: Number, y: Number, width: Number, height: Number) {
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/image/ImageDrawer.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/image/ImageDrawer.kt
index 7be9f498..1b8610c1 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/image/ImageDrawer.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/image/ImageDrawer.kt
@@ -4,10 +4,7 @@ import com.mechanica.engine.models.Image
 import com.mechanica.engine.unit.vector.LightweightVector
 
 interface ImageDrawer {
-    fun image(image: Image)
-
-    fun image(image: Image, x: Number, y: Number)
-    fun image(image: Image, x: Number, y: Number, width: Number, height: Number)
+    fun image(image: Image, x: Number = 0, y: Number = 0, width: Number = 1, height: Number = 1)
     fun image(image: Image, xy: LightweightVector, wh: LightweightVector) = image(image, xy.x, xy.y, wh.x, wh.y)
 
 }
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/image/ImageDrawerImpl.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/image/ImageDrawerImpl.kt
index ad4e201f..0d34c8dc 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/image/ImageDrawerImpl.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/image/ImageDrawerImpl.kt
@@ -11,13 +11,23 @@ class ImageDrawerImpl(
     private val model: ImageModel
 
     init {
-        val position = Attribute(0).vec3().createUnitQuad()
-        val textureCoords = Attribute(1).vec2().createInvertedUnitQuad()
+        val position = Attribute.location(0).vec3().createUnitQuad()
+        val textureCoords = Attribute.location(1).vec2().createInvertedUnitQuad()
 
         model = ImageModel(Image(0), position, textureCoords)
     }
 
-    override fun image(image: Image) {
+    override fun image(image: Image, x: Number, y: Number, width: Number, height: Number) {
+        data.setTranslate(x.toFloat(), y.toFloat())
+        data.setScale(width.toFloat(), height.toFloat())
+
+        data.cornerSize.x = width.toDouble()
+        data.cornerSize.y = height.toDouble()
+
+        drawImage(image)
+    }
+
+    private fun drawImage(image: Image) {
         model.image = image
 
         data.cornerSize.x = data.scaleX.toDouble()
@@ -30,19 +40,4 @@ class ImageDrawerImpl(
         data.alphaBlend = 0f
     }
 
-    override fun image(image: Image, x: Number, y: Number) {
-        data.setTranslate(x.toFloat(), y.toFloat())
-        image(image)
-    }
-
-    override fun image(image: Image, x: Number, y: Number, width: Number, height: Number) {
-        data.setTranslate(x.toFloat(), y.toFloat())
-        data.setScale(width.toFloat(), height.toFloat())
-
-        data.cornerSize.x = width.toDouble()
-        data.cornerSize.y = height.toDouble()
-
-        image(image)
-    }
-
 }
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/path/PathDrawerImpl.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/path/PathDrawerImpl.kt
index effb0a54..e98b9ac7 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/path/PathDrawerImpl.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/path/PathDrawerImpl.kt
@@ -1,9 +1,9 @@
 package com.mechanica.engine.drawer.superclass.path
 
 import com.mechanica.engine.drawer.DrawData
+import com.mechanica.engine.drawer.shader.PathRenderer
 import com.mechanica.engine.unit.vector.DynamicVector
 import com.mechanica.engine.unit.vector.Vector
-import com.mechanica.engine.drawer.shader.PathRenderer
 import com.mechanica.engine.unit.vector.VectorArray
 import org.joml.Matrix4f
 
@@ -45,7 +45,7 @@ class PathDrawerImpl(private val data: DrawData): PathDrawer {
 
     private fun draw() {
         data.getTransformationMatrix(transformation)
-        renderer.color = data.strokeColor
+        renderer.color = data.fillColor
         renderer.stroke = data.strokeWidth.toFloat()
         renderer.render(transformation)
     }
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/rectangle/RectangleDrawer.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/rectangle/RectangleDrawer.kt
index 4f9f9668..b26f811d 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/rectangle/RectangleDrawer.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/rectangle/RectangleDrawer.kt
@@ -3,8 +3,6 @@ package com.mechanica.engine.drawer.superclass.rectangle
 import com.mechanica.engine.unit.vector.LightweightVector
 
 interface RectangleDrawer {
-    fun rectangle()
-    fun rectangle(x: Number, y: Number)
-    fun rectangle(x: Number, y: Number, width: Number, height: Number)
+    fun rectangle(x: Number = 0, y: Number = 0, width: Number = 1, height: Number = 1)
     fun rectangle(xy: LightweightVector, wh: LightweightVector) = rectangle(xy.x, xy.y, wh.x, wh.y)
 }
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/rectangle/RectangleDrawerImpl.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/rectangle/RectangleDrawerImpl.kt
index 94877519..77915d34 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/rectangle/RectangleDrawerImpl.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/rectangle/RectangleDrawerImpl.kt
@@ -13,7 +13,7 @@ internal class RectangleDrawerImpl(
     private val model: Model
 
     init {
-        val position = Attribute(0).vec3().createUnitQuad()
+        val position = Attribute.location(0).vec3().createUnitQuad()
 
         val disableTexCoords = object : Bindable {
             override fun bind() {
@@ -24,21 +24,16 @@ internal class RectangleDrawerImpl(
 
     }
 
-    override fun rectangle() {
-        data.cornerSize.x = data.scaleX.toDouble()
-        data.cornerSize.y = data.scaleY.toDouble()
-        data.draw(model)
-    }
-
-    override fun rectangle(x: Number, y: Number) {
-        data.setTranslate(x.toFloat(), y.toFloat())
-        rectangle()
-    }
-
     override fun rectangle(x: Number, y: Number, width: Number, height: Number) {
         data.setTranslate(x.toFloat(), y.toFloat())
         data.setScale(width.toFloat(), height.toFloat())
-        rectangle()
+        drawRectangle()
+    }
+
+    private fun drawRectangle() {
+        data.cornerSize.x = data.scaleX.toDouble()
+        data.cornerSize.y = data.scaleY.toDouble()
+        data.draw(model)
     }
 
 }
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/text/TextDrawer.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/text/TextDrawer.kt
index 19e855dc..8bcc42fe 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/text/TextDrawer.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/text/TextDrawer.kt
@@ -7,13 +7,13 @@ import com.mechanica.engine.unit.vector.Vector
 interface TextDrawer {
     fun text(text: String)
 
-    fun text(text: String, size: Number, x: Number, y: Number)
+    fun text(text: String, size: Number = 1.0, x: Number = 0.0, y: Number = 0.0)
     fun text(text: String, size: Number, position: Vector) = text(text, size, position.x, position.y)
     fun text(text: String, size: Number, position: LightweightVector) = text(text, size, position.x, position.y)
 
     fun text(text: Text)
 
-    fun text(text: Text, size: Number, x: Number, y: Number)
+    fun text(text: Text, size: Number = 1.0, x: Number = 0.0, y: Number = 0.0)
     fun text(text: Text, size: Number, position: Vector) = text(text, size, position.x, position.y)
     fun text(text: Text, size: Number, position: LightweightVector) = text(text, size, position.x, position.y)
 }
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/text/TextDrawerImpl.kt b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/text/TextDrawerImpl.kt
index 9a92eae4..c7229faf 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/text/TextDrawerImpl.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/drawer/superclass/text/TextDrawerImpl.kt
@@ -2,8 +2,8 @@ package com.mechanica.engine.drawer.superclass.text
 
 import com.mechanica.engine.drawer.DrawData
 import com.mechanica.engine.game.Game
-import com.mechanica.engine.text.Text
 import com.mechanica.engine.models.TextModel
+import com.mechanica.engine.text.Text
 import com.mechanica.engine.unit.vector.LightweightVector
 import com.mechanica.engine.unit.vector.vec
 
@@ -11,14 +11,14 @@ class TextDrawerImpl(
         private val data: DrawData) : TextDrawer {
 
     override fun text(text: String) {
-        val model = data.textModel
-        model.text = text
+        val model = data.stringHolderModel
+        model.string = text
         drawText(model)
     }
 
     override fun text(text: Text) {
-        val model = data.textModel
-        data.textModel.setText(text)
+        val model = data.textHolderModel
+        model.setText(text)
         drawText(model)
     }
 
@@ -41,7 +41,6 @@ class TextDrawerImpl(
 
         origin.set(oX*width, oY*height - bottomRight.y)
         data.draw(model)
-        origin.set(oX, oY)
     }
 
 
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/game/Game.kt b/mechanica/src/main/kotlin/com/mechanica/engine/game/Game.kt
index 6fd8ed55..3e4bfa0f 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/game/Game.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/game/Game.kt
@@ -1,50 +1,60 @@
 package com.mechanica.engine.game
 
 import com.mechanica.engine.config.BackendDebugConfiguration
-import com.mechanica.engine.context.GLFWContext
-import com.mechanica.engine.display.Monitor
+import com.mechanica.engine.configuration.Configurable
+import com.mechanica.engine.context.Application
 import com.mechanica.engine.display.Window
-import com.mechanica.engine.context.GLContext
-import com.mechanica.engine.persistence.loadData
-import com.mechanica.engine.persistence.saveData
 import com.mechanica.engine.game.configuration.GameConfiguration
 import com.mechanica.engine.game.configuration.GameConfigurationImpl
-import com.mechanica.engine.game.configuration.GameSetup
 import com.mechanica.engine.game.view.GameMatrices
-import com.mechanica.engine.game.view.GameView
-import com.mechanica.engine.game.view.View
-import com.mechanica.engine.context.GLInitializer
-import com.mechanica.engine.context.loader.LwjglLoader
+import com.mechanica.engine.game.view.UIView
+import com.mechanica.engine.game.view.WorldView
 import com.mechanica.engine.matrix.Matrices
-import com.mechanica.engine.state.State
-import com.mechanica.engine.state.StateManager
-import com.mechanica.engine.unit.vector.Vector
-import com.mechanica.engine.unit.vector.vec
+import com.mechanica.engine.persistence.populateData
+import com.mechanica.engine.persistence.storeData
+import com.mechanica.engine.scenes.SceneManager
+import com.mechanica.engine.scenes.processes.Process
+import com.mechanica.engine.scenes.scenes.MainScene
+import com.mechanica.engine.scenes.scenes.Scene
 import com.mechanica.engine.util.Timer
-import org.lwjgl.glfw.GLFW
 
-object Game {
+object Game : Configurable<GameConfiguration> {
+    private var _application: Application? = null
+    val application: Application
+        get() = _application ?: throw IllegalStateException("Cannot access this application object because the game context has not been initialized.\nCall Game.configureAs() before using this object")
+
     private val configuration = GameConfigurationImpl()
+
     private val data by lazy { configuration.data }
 
-    val view: GameView by lazy { GameView(data) }
-    val ui: View by lazy { UIView() }
+    val view: WorldView by lazy { WorldView(data) }
+    val ui: UIView by lazy { UIView() }
     val window: Window by lazy { data.window }
 
-    internal val controls by lazy { data.controlsMap }
-
     val debug by lazy { data.debugConfig }
 
     val matrices: Matrices by lazy { GameMatrices(data, view) }
     private val gameMatrices: GameMatrices
         get() = matrices as GameMatrices
 
-    private val stateManager = StateManager()
+    internal val sceneManager = SceneManager()
+    val scene: Scene
+        get() = sceneManager.currentScene ?: throw UninitializedPropertyAccessException("The top level scene has not yet been initialized")
 
     private var hasStarted = false
     private var hasFinished = false
 
-    fun configure(setup: GameConfiguration.() -> Unit) {
+    fun addProcess(process: Process) {
+        sceneManager.addProcess(process)
+    }
+
+    fun addScene(scene: Scene) {
+        sceneManager.addScene(scene)
+    }
+
+    override fun configureAs(application: Application, setup: GameConfiguration.() -> Unit) {
+        this._application = application
+        loadPersistenceData()
         setup(configuration)
         if (configuration.initalize) start()
         BackendDebugConfiguration.set(debug)
@@ -53,13 +63,12 @@ object Game {
     fun start(block: () -> Unit = {}) {
         try {
             if (!hasStarted) {
-                GLContext.initialize(window)
-                GLInitializer.initialize(LwjglLoader())
+                application.initialize(window)
+
                 window.addRefreshCallback { refreshView(it) }
 
                 Timer
-                loadPersistenceData()
-                setStartingState(data)
+                sceneManager.setStartingScene(data)
 
                 hasStarted = true
             }
@@ -71,17 +80,25 @@ object Game {
         }
     }
 
-    fun run(update: () -> Unit = { }) {
+    fun run() {
+        start()
+        loop()
+    }
+
+    fun run(update: (Double) -> Unit) {
         start()
+        sceneManager.updateVar = update
+        loop()
+    }
+
+    private fun loop() {
         try {
             while (!hasFinished) {
-                GLContext.startFrame()
+                application.startFrame()
 
                 gameMatrices.updateMatrices()
 
-                stateManager.updateState()
-
-                update()
+                sceneManager.updateScenes()
 
                 if (!window.update()) {
                     return
@@ -102,29 +119,11 @@ object Game {
     fun terminate() {
         savePersistenceData()
         hasFinished = true
-        GLContext.free()
-        GLFWContext.terminate()
-    }
-
-    fun setCurrentState(setter: () -> State?) {
-        stateManager.setCurrentState(setter)
+        application.terminate()
     }
 
-    private fun setStartingState(data: GameSetup) {
-        val state = data.startingState
-        val loadState = data.loadState?.invoke()
-
-        if (loadState != null) {
-            loadState.onFinish = {
-                setCurrentState { state?.invoke() }
-            }
-            setCurrentState {
-                loadState.preLoad()
-                loadState
-            }
-        } else {
-            setCurrentState { state?.invoke() }
-        }
+    fun setMainScene(setter: () -> MainScene?) {
+        sceneManager.setMainScene(setter)
     }
 
     private fun refreshView(window: Window) {
@@ -142,32 +141,11 @@ object Game {
     }
 
     private fun loadPersistenceData() {
-        for (saveData in data.saveData) {
-            loadData(saveData)
-        }
+        populateData()
     }
 
     private fun savePersistenceData() {
-        for (saveData in data.saveData) {
-            saveData(saveData)
-        }
+        storeData()
     }
 
-    private class UIView : View {
-        private val scale: Vector
-        override val width: Double
-        override val height: Double
-        override val x: Double = 0.0
-        override val y: Double = 0.0
-        override val center: Vector = vec(0.0, 0.0)
-        override val ratio: Double
-            get() = view.ratio*(scale.y/scale.x)
-
-        init {
-            val contentScale = Monitor.getPrimaryMonitor().contentScale
-            scale = vec(contentScale.xScale, contentScale.yScale)
-            width = view.width/scale.x
-            height = view.height/scale.y
-        }
-    }
 }
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/ConfigurationData.kt b/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/ConfigurationData.kt
index 9d0b6bc7..62584ad2 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/ConfigurationData.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/ConfigurationData.kt
@@ -1,14 +1,11 @@
 package com.mechanica.engine.game.configuration
 
+import com.mechanica.engine.debug.GameDebugConfiguration
 import com.mechanica.engine.display.Monitor
 import com.mechanica.engine.display.Window
-import com.mechanica.engine.debug.GameDebugConfiguration
-import com.mechanica.engine.drawer.Drawer
 import com.mechanica.engine.game.view.View
-import com.mechanica.engine.input.ControlsMap
+import com.mechanica.engine.scenes.scenes.MainScene
 import org.joml.Matrix4f
-import com.mechanica.engine.state.LoadState
-import com.mechanica.engine.state.State
 
 interface ConfigurationData {
     val monitor: Monitor?
@@ -19,29 +16,10 @@ interface ConfigurationData {
     val viewHeight: Double?
     val viewX: Double?
     val viewY: Double?
-    val saveData: Array<Any>?
-    val controlsMap: ControlsMap?
     val fullscreen: Boolean?
-    val startingState: (() -> State)?
-    val loadState: (() -> LoadState)?
+    val startingScene: (() -> MainScene)?
     val windowConfiguration: (Window.() -> Unit)?
     val debugConfiguration: (GameDebugConfiguration.() -> Unit)?
     val projectionMatrixConfiguration: (Matrix4f.(View) -> Unit)?
 
-    companion object {
-        fun emptyState(): State {
-            return object : State(){
-                override fun update(delta: Double) {}
-                override fun render(draw: Drawer) {}
-            }
-        }
-
-        fun emptyLoadeState(): LoadState {
-            return object : LoadState(){
-                override fun preLoad() {}
-                override fun renderLoadScreen(draw: Drawer) {}
-                override fun load() { }
-            }
-        }
-    }
 }
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/GameConfiguration.kt b/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/GameConfiguration.kt
index 749c11bd..751a69f0 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/GameConfiguration.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/GameConfiguration.kt
@@ -1,12 +1,10 @@
 package com.mechanica.engine.game.configuration
 
-import com.mechanica.engine.display.Window
 import com.mechanica.engine.debug.GameDebugConfiguration
+import com.mechanica.engine.display.Window
 import com.mechanica.engine.game.view.View
-import com.mechanica.engine.input.ControlsMap
+import com.mechanica.engine.scenes.scenes.MainScene
 import org.joml.Matrix4f
-import com.mechanica.engine.state.LoadState
-import com.mechanica.engine.state.State
 
 interface GameConfiguration {
     var initalize: Boolean
@@ -15,11 +13,7 @@ interface GameConfiguration {
     fun setViewport(width: Double = 0.0, height: Double = 0.0)
     fun setViewLocation(x: Double, y: Double)
 
-    fun setStartingState(state: () -> State)
-    fun setLoader(loader: () -> LoadState)
-
-    fun setControlMapping(controlsMap: ControlsMap)
-    fun setSaveData(vararg savedata: Any)
+    fun setStartingScene(scene: () -> MainScene)
 
     fun setMultisampling(samples: Int)
 
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/GameConfigurationImpl.kt b/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/GameConfigurationImpl.kt
index c5336ee9..f3ce09b3 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/GameConfigurationImpl.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/GameConfigurationImpl.kt
@@ -1,14 +1,11 @@
 package com.mechanica.engine.game.configuration
 
 import com.mechanica.engine.context.GLFWContext
-import com.mechanica.engine.display.Window
 import com.mechanica.engine.debug.GameDebugConfiguration
-import com.mechanica.engine.game.Game
+import com.mechanica.engine.display.Window
 import com.mechanica.engine.game.view.View
-import com.mechanica.engine.input.ControlsMap
+import com.mechanica.engine.scenes.scenes.MainScene
 import org.joml.Matrix4f
-import com.mechanica.engine.state.LoadState
-import com.mechanica.engine.state.State
 
 internal class GameConfigurationImpl : GameConfiguration {
     private val _data = NullableConfigurationData()
@@ -40,20 +37,8 @@ internal class GameConfigurationImpl : GameConfiguration {
         _data.viewY = y
     }
 
-    override fun setStartingState(state: () -> State) {
-        _data.startingState = state
-    }
-
-    override fun setLoader(loader: () -> LoadState) {
-        _data.loadState = loader
-    }
-
-    override fun setControlMapping(controlsMap: ControlsMap) {
-        _data.controlsMap = controlsMap
-    }
-
-    override fun setSaveData(vararg savedata: Any) {
-        _data.saveData = arrayOf(*savedata)
+    override fun setStartingScene(scene: () -> MainScene) {
+        _data.startingScene = scene
     }
 
     override fun configureWindow(configuration: Window.() -> Unit) {
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/GameSetup.kt b/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/GameSetup.kt
index c05d77a2..ca5dabef 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/GameSetup.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/GameSetup.kt
@@ -1,21 +1,18 @@
 package com.mechanica.engine.game.configuration
 
+import com.mechanica.engine.context.GLInitializer
+import com.mechanica.engine.context.loader.LwjglDisplayLoader
+import com.mechanica.engine.debug.GameDebugConfiguration
 import com.mechanica.engine.display.Monitor
 import com.mechanica.engine.display.Window
-import com.mechanica.engine.debug.GameDebugConfiguration
 import com.mechanica.engine.game.view.GameMatrices
 import com.mechanica.engine.game.view.ResolutionConverter
 import com.mechanica.engine.game.view.View
-import com.mechanica.engine.input.ControlsMap
-import com.mechanica.engine.input.KeyboardHandler
-import com.mechanica.engine.input.MouseHandler
+import com.mechanica.engine.scenes.scenes.MainScene
 import org.joml.Matrix4f
-import org.lwjgl.glfw.GLFW
-import com.mechanica.engine.state.LoadState
-import com.mechanica.engine.state.State
 
 class GameSetup(data: NullableConfigurationData) : ConfigurationData {
-    override val monitor = Monitor.getPrimaryMonitor()
+    override val monitor by lazy { Monitor.getPrimaryMonitor() }
     
     override val title: String = data.title ?: "Mechanica"
     override val resolutionWidth: Int
@@ -24,11 +21,8 @@ class GameSetup(data: NullableConfigurationData) : ConfigurationData {
     override val viewHeight: Double
     override val viewX: Double = data.viewX ?: 0.0
     override val viewY: Double = data.viewX ?: 0.0
-    override val saveData: Array<Any> = data.saveData ?: emptyArray()
-    override val controlsMap: ControlsMap = data.controlsMap ?: object : ControlsMap() { }
     override val fullscreen: Boolean = data.fullscreen ?: false
-    override val startingState: (() -> State)? = data.startingState
-    override val loadState: (() -> LoadState)? = data.loadState
+    override val startingScene: (() -> MainScene)? = data.startingScene
     override val windowConfiguration: (Window.() -> Unit) = data.windowConfiguration ?: { }
     override val debugConfiguration: (GameDebugConfiguration.() -> Unit) = data.debugConfiguration ?: { }
     override val projectionMatrixConfiguration: (Matrix4f.(View) -> Unit)
@@ -42,6 +36,7 @@ class GameSetup(data: NullableConfigurationData) : ConfigurationData {
     val resolutionConverter: ResolutionConverter
 
     init {
+        GLInitializer.initializeDisplay(LwjglDisplayLoader())
 
         val resolutionWasSet = data.resolutionWidth != null && data.resolutionHeight != null
 
@@ -52,7 +47,6 @@ class GameSetup(data: NullableConfigurationData) : ConfigurationData {
         ratio = resolutionHeight.toDouble()/resolutionWidth.toDouble()
 
         window = setWindow(resolutionWasSet)
-        setCallbacks(window)
 
         resolutionConverter = ResolutionConverter(resolutionWidth, resolutionHeight, data.viewWidth, data.viewHeight)
 
@@ -75,25 +69,14 @@ class GameSetup(data: NullableConfigurationData) : ConfigurationData {
 
     private fun centerWindow(window: Window) {
         val monitor = Monitor.getPrimaryMonitor()
-        val screenWidth = monitor.currentVideoMode.width()
-        val screenHeight = monitor.currentVideoMode.height()
+        val screenWidth = monitor.width
+        val screenHeight = monitor.height
         window.position.set((screenWidth - window.width)/2, (screenHeight - window.height)/2)
     }
 
-    private fun setCallbacks(window: Window) {
-        // Setup a key callback. It will be called every time a key is pressed, repeated or released.
-        GLFW.glfwSetKeyCallback(window.id, KeyboardHandler.KeyHandler())
-        GLFW.glfwSetCharCallback(window.id, KeyboardHandler.TextHandler())
-
-        GLFW.glfwSetMouseButtonCallback(window.id, MouseHandler.ButtonHandler())
-        GLFW.glfwSetCursorPosCallback(window.id, MouseHandler.CursorHandler())
-        GLFW.glfwSetScrollCallback(window.id, MouseHandler.ScrollHandler())
-
-    }
-
     private fun setResolution(resolutionWasSet: Boolean, data: NullableConfigurationData): Pair<Int, Int> {
-        val defaultResolutionWidth = (monitor.currentVideoMode.width()*0.75).toInt()
-        val defaultResolutionHeight = (monitor.currentVideoMode.height()*0.75).toInt()
+        val defaultResolutionWidth = (monitor.width*0.75).toInt()
+        val defaultResolutionHeight = (monitor.height*0.75).toInt()
 
         return Pair(
                 if (resolutionWasSet) data.resolutionWidth ?: defaultResolutionWidth
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/NullableConfigurationData.kt b/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/NullableConfigurationData.kt
index cf476cb2..433d10bf 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/NullableConfigurationData.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/game/configuration/NullableConfigurationData.kt
@@ -1,13 +1,11 @@
 package com.mechanica.engine.game.configuration
 
+import com.mechanica.engine.debug.GameDebugConfiguration
 import com.mechanica.engine.display.Monitor
 import com.mechanica.engine.display.Window
-import com.mechanica.engine.debug.GameDebugConfiguration
 import com.mechanica.engine.game.view.View
-import com.mechanica.engine.input.ControlsMap
+import com.mechanica.engine.scenes.scenes.MainScene
 import org.joml.Matrix4f
-import com.mechanica.engine.state.LoadState
-import com.mechanica.engine.state.State
 
 class NullableConfigurationData : ConfigurationData {
     override val monitor: Monitor? = null
@@ -22,14 +20,10 @@ class NullableConfigurationData : ConfigurationData {
     
     override var viewX: Double? = null
     override var viewY: Double? = null
-    
-    override var saveData: Array<Any>? = null
-    override var controlsMap: ControlsMap? = null
-    
+
     override var fullscreen: Boolean? = null
 
-    override var startingState: (() -> State)? = null
-    override var loadState: (() -> LoadState)? = null
+    override var startingScene: (() -> MainScene)? = null
 
     override var windowConfiguration: (Window.() -> Unit)? = null
     override var debugConfiguration: (GameDebugConfiguration.() -> Unit)? = null
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/game/view/DefaultDynamicView.kt b/mechanica/src/main/kotlin/com/mechanica/engine/game/view/DefaultDynamicView.kt
new file mode 100644
index 00000000..685e2794
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/game/view/DefaultDynamicView.kt
@@ -0,0 +1,55 @@
+package com.mechanica.engine.game.view
+
+import com.mechanica.engine.unit.vector.DynamicVector
+
+class DefaultDynamicView(
+        override var x: Double = 0.0,
+        override var y: Double = 0.0,
+        override var width: Double = 1.0,
+        override var height: Double = 1.0) : DynamicView {
+
+    @Suppress("SetterBackingFieldAssignment")
+    override var xy: DynamicVector = object : DynamicVector {
+        override var x: Double
+            get() = this@DefaultDynamicView.x
+            set(value) {this@DefaultDynamicView.x = value}
+        override var y: Double
+            get() = this@DefaultDynamicView.y
+            set(value) { this@DefaultDynamicView.y = value}
+    }
+        set(value) {
+            x = value.x
+            y = value.y
+        }
+
+    @Suppress("SetterBackingFieldAssignment")
+    override var wh: DynamicVector = object : DynamicVector {
+        override var x: Double
+            get() = this@DefaultDynamicView.width
+            set(value) {this@DefaultDynamicView.width = value }
+        override var y: Double
+            get() = this@DefaultDynamicView.height
+            set(value) { this@DefaultDynamicView.height = value}
+    }
+        set(value) {
+            x = value.x
+            y = value.y
+        }
+
+    @Suppress("SetterBackingFieldAssignment")
+    override var center: DynamicVector = object : DynamicVector {
+        override var x: Double
+            get() = this@DefaultDynamicView.x
+            set(value) {this@DefaultDynamicView.x = value }
+        override var y: Double
+            get() = this@DefaultDynamicView.y + height/2.0
+            set(value) { this@DefaultDynamicView.y = value }
+    }
+        set(value) {
+            x = value.x
+            y = value.y
+        }
+
+    override val ratio: Double
+        get() = height/width
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/game/view/DynamicView.kt b/mechanica/src/main/kotlin/com/mechanica/engine/game/view/DynamicView.kt
new file mode 100644
index 00000000..363e5db7
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/game/view/DynamicView.kt
@@ -0,0 +1,21 @@
+package com.mechanica.engine.game.view
+
+import com.mechanica.engine.unit.vector.DynamicVector
+
+interface DynamicView : View {
+    override var x: Double
+    override var y: Double
+    override var width: Double
+    override var height: Double
+
+    override var xy: DynamicVector
+    override var wh: DynamicVector
+    override var center: DynamicVector
+
+    companion object {
+        fun create(x: Double = 0.0,
+                   y: Double = 0.0,
+                   width: Double = 1.0,
+                   height: Double = 1.0): DynamicView = DefaultDynamicView(x, y, width, height)
+    }
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/game/view/GameMatrices.kt b/mechanica/src/main/kotlin/com/mechanica/engine/game/view/GameMatrices.kt
index 3b6918e6..c1ae4dbb 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/game/view/GameMatrices.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/game/view/GameMatrices.kt
@@ -3,7 +3,6 @@ package com.mechanica.engine.game.view
 import com.mechanica.engine.display.Monitor
 import com.mechanica.engine.game.Game
 import com.mechanica.engine.game.configuration.GameSetup
-import com.mechanica.engine.input.Mouse
 import com.mechanica.engine.matrix.Matrices
 import com.mechanica.engine.matrix.Matrices.Companion.calculatePixelSize
 import com.mechanica.engine.matrix.Matrices.Companion.getYScale
@@ -29,10 +28,8 @@ internal class GameMatrices(data: GameSetup, viewPort: View) : Matrices {
         pixelUIScale = calculatePixelSize(projection, uiView, Game.window.height)
     }
 
-    fun updateView(viewData: GameView) {
+    fun updateView(viewData: WorldView) {
         updateView(viewData.x, viewData.y, viewData.height)
-
-        Mouse.refreshCursor()
     }
 
     private fun updateView(x: Double, y: Double, height: Double) {
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/game/view/GameView.kt b/mechanica/src/main/kotlin/com/mechanica/engine/game/view/GameView.kt
deleted file mode 100644
index c303a29a..00000000
--- a/mechanica/src/main/kotlin/com/mechanica/engine/game/view/GameView.kt
+++ /dev/null
@@ -1,79 +0,0 @@
-package com.mechanica.engine.game.view
-
-import com.mechanica.engine.game.Game
-import com.mechanica.engine.unit.vector.DynamicVector
-import com.mechanica.engine.game.configuration.GameSetup
-import com.mechanica.engine.unit.vector.Vector
-import com.mechanica.engine.unit.vector.vec
-
-class GameView(data: GameSetup): View {
-    private var _width: Double = data.viewWidth
-    override var width: Double
-        get() = _width
-        set(value) {
-            _width = value
-            if (lockRatio) {
-                _height = value/ratio
-            } else {
-                ratio = value/_height
-            }
-            gameMatrices.updateView(this)
-        }
-
-    private var _height: Double = data.viewHeight
-    override var height: Double
-        get() = _height
-        set(value) {
-            _height = value
-            if (lockRatio) {
-                _width = value*ratio
-            } else {
-                ratio = _width/value
-            }
-            gameMatrices.updateView(this)
-        }
-
-    override var x: Double = data.viewX
-        set(value) {
-            field = value
-            gameMatrices.updateView(this)
-        }
-    override var y: Double = data.viewY
-        set(value) {
-            field = value
-            gameMatrices.updateView(this)
-        }
-
-    var xy: Vector = DynamicVector.create()
-        set(value) {
-            (field as DynamicVector).set(value)
-            x = value.x
-            y = value.y
-        }
-
-    var wh: Vector = DynamicVector.create()
-        set(value) {
-            (field as DynamicVector).set(value)
-            width = value.x
-            height = value.y
-        }
-
-    override var ratio: Double = height/width
-        private set
-        get() {
-            return if (lockRatio) {
-                Game.window.aspectRatio
-            } else field
-        }
-    var lockRatio = true
-
-    override val center: DynamicVector = DynamicVector.create(x + width/2.0, y + height/2.0)
-        get() {
-            field.x = x + width/2.0
-            field.y = y + height/2.0
-            return field
-        }
-
-    private val gameMatrices: GameMatrices
-        get() = Game.matrices as GameMatrices
-}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/game/view/GameViews.kt b/mechanica/src/main/kotlin/com/mechanica/engine/game/view/GameViews.kt
new file mode 100644
index 00000000..450985c2
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/game/view/GameViews.kt
@@ -0,0 +1,125 @@
+package com.mechanica.engine.game.view
+
+import com.mechanica.engine.display.Monitor
+import com.mechanica.engine.game.Game
+import com.mechanica.engine.game.configuration.GameSetup
+import com.mechanica.engine.unit.vector.DynamicVector
+import com.mechanica.engine.unit.vector.Vector
+import com.mechanica.engine.unit.vector.vec
+
+sealed class GameView : View
+
+class UIView internal constructor() : GameView() {
+    private val scale: Vector
+    override val width: Double
+    override val height: Double
+    override val x: Double = 0.0
+    override val y: Double = 0.0
+    override val xy: Vector = vec(0.0, 0.0)
+    override val wh: Vector
+    override val center: Vector
+    override val ratio: Double
+        get() = Game.view.ratio*(scale.y/scale.x)
+
+    init {
+        val contentScale = Monitor.getPrimaryMonitor().contentScale
+        scale = vec(contentScale.xScale, contentScale.yScale)
+        width = Game.view.width/scale.x
+        height = Game.view.height/scale.y
+        wh = vec(width, height)
+        center = vec(0.0, 0.0)
+    }
+}
+
+class WorldView internal constructor(data: GameSetup): GameView(), DynamicView {
+    private var _width: Double = data.viewWidth
+    override var width: Double
+        get() = _width
+        set(value) {
+            _width = value
+            if (lockRatio) {
+                _height = value/ratio
+            } else {
+                ratio = value/_height
+            }
+            gameMatrices.updateView(this)
+        }
+
+    private var _height: Double = data.viewHeight
+    override var height: Double
+        get() = _height
+        set(value) {
+            _height = value
+            if (lockRatio) {
+                _width = value*ratio
+            } else {
+                ratio = _width/value
+            }
+            gameMatrices.updateView(this)
+        }
+
+    override var x: Double = data.viewX
+        set(value) {
+            field = value
+            gameMatrices.updateView(this)
+        }
+    override var y: Double = data.viewY
+        set(value) {
+            field = value
+            gameMatrices.updateView(this)
+        }
+
+    @Suppress("SetterBackingFieldAssignment")
+    override var xy: DynamicVector = object : DynamicVector {
+        override var x: Double
+            get() = this@WorldView.x
+            set(value) {this@WorldView.x = value}
+        override var y: Double
+            get() = this@WorldView.y
+            set(value) { this@WorldView.y = value}
+    }
+        set(value) {
+            x = value.x
+            y = value.y
+        }
+
+    @Suppress("SetterBackingFieldAssignment")
+    override var center: DynamicVector = object : DynamicVector {
+        override var x: Double
+            get() = this@WorldView.x
+            set(value) {this@WorldView.x = value}
+        override var y: Double
+            get() = this@WorldView.y
+            set(value) { this@WorldView.y = value}
+    }
+        set(value) {
+            x = value.x
+            y = value.y
+        }
+
+    @Suppress("SetterBackingFieldAssignment")
+    override var wh: DynamicVector = object : DynamicVector {
+        override var x: Double
+            get() = this@WorldView.width
+            set(value) {this@WorldView.width = value }
+        override var y: Double
+            get() = this@WorldView.height
+            set(value) { this@WorldView.height = value}
+    }
+        set(value) {
+            x = value.x
+            y = value.y
+        }
+
+    override var ratio: Double = height/width
+        private set
+        get() {
+            return if (lockRatio) {
+                Game.window.aspectRatio
+            } else field
+        }
+    var lockRatio = true
+
+    private val gameMatrices: GameMatrices
+        get() = Game.matrices as GameMatrices
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/game/view/StaticView.kt b/mechanica/src/main/kotlin/com/mechanica/engine/game/view/StaticView.kt
new file mode 100644
index 00000000..27919223
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/game/view/StaticView.kt
@@ -0,0 +1,34 @@
+package com.mechanica.engine.game.view
+
+import com.mechanica.engine.unit.vector.Vector
+
+class StaticView(
+        override val x: Double = 0.0,
+        override val y: Double = 0.0,
+        override val width: Double = 1.0,
+        override val height: Double = 1.0) : View {
+
+    override val xy: Vector = object : Vector {
+        override val x: Double
+            get() = this@StaticView.x
+        override val y: Double
+            get() = this@StaticView.y
+    }
+
+    override val wh: Vector = object : Vector {
+        override val x: Double
+            get() = this@StaticView.width
+        override val y: Double
+            get() = this@StaticView.height
+    }
+
+    override val center: Vector = object : Vector {
+        override val x: Double
+            get() = this@StaticView.x
+        override val y: Double
+            get() = this@StaticView.y
+    }
+
+    override val ratio: Double
+        get() = height/width
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/game/view/View.kt b/mechanica/src/main/kotlin/com/mechanica/engine/game/view/View.kt
index 8ba8a6f0..267303f4 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/game/view/View.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/game/view/View.kt
@@ -7,6 +7,8 @@ interface View {
     val height: Double
     val x: Double
     val y: Double
+    val xy: Vector
+    val wh: Vector
 
     val bottom: Double
         get() = y - height/2.0
@@ -20,4 +22,12 @@ interface View {
     val center: Vector
 
     val ratio: Double
+        get() = width/height
+
+    companion object {
+        fun create(x: Double = 0.0,
+                   y: Double = 0.0,
+                   width: Double = 1.0,
+                   height: Double = 1.0): View = StaticView(x, y, width, height)
+    }
 }
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/game/view/WorldView.kt b/mechanica/src/main/kotlin/com/mechanica/engine/game/view/WorldView.kt
new file mode 100644
index 00000000..06b0749e
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/game/view/WorldView.kt
@@ -0,0 +1,2 @@
+package com.mechanica.engine.game.view
+
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/input/ControlsMap.kt b/mechanica/src/main/kotlin/com/mechanica/engine/input/ControlsMap.kt
deleted file mode 100644
index cd1522f1..00000000
--- a/mechanica/src/main/kotlin/com/mechanica/engine/input/ControlsMap.kt
+++ /dev/null
@@ -1,27 +0,0 @@
-package com.mechanica.engine.input
-
-abstract class ControlsMap {
-    private val map = HashMap<Int, ArrayList<Key>>()
-
-    operator fun get(keyId: Int): ArrayList<Key> {
-        val keys = map[keyId]
-        if (keys != null) {
-            return keys
-        }
-        return arrayListOf(Key(map, keyId))
-    }
-
-    protected fun mapToKeys(vararg keys: Keys): Key {
-        return Key(map, *keys)
-    }
-
-    companion object {
-        fun getKeyEnum(keyId: Int): Keys? {
-            for (value in Keys.values()) {
-                if (keyId == value.id)
-                    return value
-            }
-            return null
-        }
-    }
-}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/input/Key.kt b/mechanica/src/main/kotlin/com/mechanica/engine/input/Key.kt
index 6d724d2a..1d55b847 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/input/Key.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/input/Key.kt
@@ -1,16 +1,14 @@
 package com.mechanica.engine.input
 
-import org.lwjgl.glfw.GLFW
+open class Key (label: String, private val condition: () -> Boolean) {
+    private val label = label.toUpperCase()
 
-open class Key (map: HashMap<Int, ArrayList<Key>>, private vararg val key: Int) {
-    private val label: String
-            get() = getLabel(key)
-
-    internal var isDown: Boolean = false
-        set(value) {
-            if (value) hasBeenReleased = true
+    val isDown: Boolean
+        get() {
+            val isPressed = condition()
+            if (isPressed) hasBeenReleased = true
             else hasBeenPressed = true
-            field = value
+            return isPressed
         }
 
     private var privateHasBeenDown = false
@@ -20,6 +18,7 @@ open class Key (map: HashMap<Int, ArrayList<Key>>, private vararg val key: Int)
         }
         get() {
             if (isDown) {
+                privateHasBeenDown = true
                 return false
             }
             if (privateHasBeenDown) {
@@ -36,6 +35,7 @@ open class Key (map: HashMap<Int, ArrayList<Key>>, private vararg val key: Int)
         }
         get() {
             if (!isDown) {
+                privateHasBeenUp = true
                 return false
             }
             if (privateHasBeenUp) {
@@ -45,33 +45,29 @@ open class Key (map: HashMap<Int, ArrayList<Key>>, private vararg val key: Int)
             return privateHasBeenUp
         }
 
-
     operator fun invoke(): Boolean {
         return isDown
     }
 
-    init {
-        key.forEach {
-            if (map.containsKey(it)) {
-                map[it]?.add(this)
-            } else {
-                map[it] = arrayListOf(this)
-            }
-        }
-    }
-
-    constructor(map: HashMap<Int, ArrayList<Key>>, vararg keys: Keys) : this(
-            map,
-            *(keys.map { it.id }).toIntArray()
+    constructor(vararg keys: KeyID) : this(
+            keys[0].label,
+            keysToBoolean(*keys)
     )
 
-    private fun getLabel(keys: IntArray): String {
-        return if (keys.isNotEmpty()) {
-            GLFW.glfwGetKeyName(keys[0], 0) ?: "N/A"
-        } else "N/A"
+    override fun toString(): String {
+        return label
     }
 
-    override fun toString(): String {
-        return label.toUpperCase()
+    companion object {
+
+        fun keysToBoolean(vararg key: KeyID): () -> Boolean {
+            return {
+                var isPressed = false
+                for (i in key.indices) {
+                    isPressed = KeyInput.isPressed(key[i].id) || isPressed
+                }
+                isPressed
+            }
+        }
     }
 }
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/input/Keyboard.kt b/mechanica/src/main/kotlin/com/mechanica/engine/input/Keyboard.kt
deleted file mode 100644
index 70c3aac2..00000000
--- a/mechanica/src/main/kotlin/com/mechanica/engine/input/Keyboard.kt
+++ /dev/null
@@ -1,172 +0,0 @@
-@file:Suppress("unused") // There will be many variables here that go unused most of the time
-package com.mechanica.engine.input
-
-import com.mechanica.engine.util.codepointToString
-import java.util.*
-import kotlin.collections.HashMap
-
-
-object Keyboard {
-    private val map = HashMap<Int, ArrayList<Key>>()
-
-    val pressed: Iterable<Key> = PressedKeys(map)
-
-    val textInput = TextInput()
-
-    val any = KeyboardKey()
-
-    val A = KeyboardKey(Keys.A)
-    val B = KeyboardKey(Keys.B)
-    val C = KeyboardKey(Keys.C)
-    val D = KeyboardKey(Keys.D)
-    val E = KeyboardKey(Keys.E)
-    val F = KeyboardKey(Keys.F)
-    val G = KeyboardKey(Keys.G)
-    val H = KeyboardKey(Keys.H)
-    val I = KeyboardKey(Keys.I)
-    val J = KeyboardKey(Keys.J)
-    val K = KeyboardKey(Keys.K)
-    val L = KeyboardKey(Keys.L)
-    val M = KeyboardKey(Keys.M)
-    val N = KeyboardKey(Keys.N)
-    val O = KeyboardKey(Keys.O)
-    val P = KeyboardKey(Keys.P)
-    val Q = KeyboardKey(Keys.Q)
-    val R = KeyboardKey(Keys.R)
-    val S = KeyboardKey(Keys.S)
-    val T = KeyboardKey(Keys.T)
-    val U = KeyboardKey(Keys.U)
-    val V = KeyboardKey(Keys.V)
-    val W = KeyboardKey(Keys.W)
-    val X = KeyboardKey(Keys.X)
-    val Y = KeyboardKey(Keys.Y)
-    val Z = KeyboardKey(Keys.Z)
-
-    val space = KeyboardKey(Keys.SPACE)
-    val shift = KeyboardKey(Keys.LSHIFT)
-    val tab = KeyboardKey(Keys.TAB)
-    val lAlt = KeyboardKey(Keys.LALT)
-    val esc = KeyboardKey(Keys.ESC)
-    val comma = KeyboardKey(Keys.COMMA)
-    val period = KeyboardKey(Keys.PERIOD)
-
-    val apostrophe = KeyboardKey(Keys.APOSTROPHE)
-    val minus = KeyboardKey(Keys.MINUS)
-    val slash = KeyboardKey(Keys.SLASH)
-    val N0 = KeyboardKey(Keys.N0)
-    val N1 = KeyboardKey(Keys.N1)
-    val N2 = KeyboardKey(Keys.N2)
-    val N3 = KeyboardKey(Keys.N3)
-    val N4 = KeyboardKey(Keys.N4)
-    val N5 = KeyboardKey(Keys.N5)
-    val N6 = KeyboardKey(Keys.N6)
-    val N7 = KeyboardKey(Keys.N7)
-    val N8 = KeyboardKey(Keys.N8)
-    val N9 = KeyboardKey(Keys.N9)
-    val semicolon = KeyboardKey(Keys.SEMICOLON)
-    val equal = KeyboardKey(Keys.EQUAL)
-
-    val leftBracket = KeyboardKey(Keys.LEFT_BRACKET)
-    val backslash = KeyboardKey(Keys.BACKSLASH)
-    val rightBracket = KeyboardKey(Keys.RIGHT_BRACKET)
-    val graveAccent = KeyboardKey(Keys.GRAVE_ACCENT)
-    val world1 = KeyboardKey(Keys.WORLD_1)
-    val world2 = KeyboardKey(Keys.WORLD_2)
-    val enter = KeyboardKey(Keys.ENTER)
-    val backspace = KeyboardKey(Keys.BACKSPACE)
-    val insert = KeyboardKey(Keys.INSERT)
-    val delete = KeyboardKey(Keys.DELETE)
-    val right = KeyboardKey(Keys.RIGHT)
-    val left = KeyboardKey(Keys.LEFT)
-    val down = KeyboardKey(Keys.DOWN)
-    val up = KeyboardKey(Keys.UP)
-    val pageUp = KeyboardKey(Keys.PAGE_UP)
-    val pageDown = KeyboardKey(Keys.PAGE_DOWN)
-    val home = KeyboardKey(Keys.HOME)
-    val end = KeyboardKey(Keys.END)
-    val capsLock = KeyboardKey(Keys.CAPS_LOCK)
-    val scrollLock = KeyboardKey(Keys.SCROLL_LOCK)
-    val numLock = KeyboardKey(Keys.NUM_LOCK)
-    val printScreen = KeyboardKey(Keys.PRINT_SCREEN)
-    val pause = KeyboardKey(Keys.PAUSE)
-
-    val F1 = KeyboardKey(Keys.F1)
-    val F2 = KeyboardKey(Keys.F2)
-    val F3 = KeyboardKey(Keys.F3)
-    val F4 = KeyboardKey(Keys.F4)
-    val F5 = KeyboardKey(Keys.F5)
-    val F6 = KeyboardKey(Keys.F6)
-    val F7 = KeyboardKey(Keys.F7)
-    val F8 = KeyboardKey(Keys.F8)
-    val F9 = KeyboardKey(Keys.F9)
-    val F10 = KeyboardKey(Keys.F10)
-    val F11 = KeyboardKey(Keys.F11)
-    val F12 = KeyboardKey(Keys.F12)
-
-    val lShift = KeyboardKey(Keys.LSHIFT)
-    val lCtrl = KeyboardKey(Keys.LCTRL)
-    val ctrl = KeyboardKey(Keys.LCTRL, Keys.RCTRL)
-    val leftSuper = KeyboardKey(Keys.LEFT_SUPER)
-    val rShift = KeyboardKey(Keys.RSHIFT)
-    val rCtrl = KeyboardKey(Keys.RCTRL)
-    val rAlt = KeyboardKey(Keys.RALT)
-    val rightSuper = KeyboardKey(Keys.RIGHT_SUPER)
-    val menu = KeyboardKey(Keys.MENU)
-
-    operator fun get(keyId: Int): ArrayList<Key> {
-        val keys = map[keyId]
-        if (keys != null) {
-            return keys
-        }
-        return arrayListOf(Key(map, keyId))
-    }
-
-    internal fun addPressed(key: Int) {
-        val pressed = (pressed as PressedKeys)
-        val pressedCount = pressed.size
-        get(key).forEach { it.isDown = true }
-        pressed.add(key)
-        any.isDown = pressed.size > pressedCount
-    }
-
-    internal fun removePressed(key: Int) {
-        val pressed = (pressed as PressedKeys)
-        val pressedCount = pressed.size
-        get(key).forEach { it.isDown = false }
-        pressed.remove(key)
-        any.isDown = pressed.size >= pressedCount
-    }
-
-    class KeyboardKey(vararg keys: Keys): Key(map, *keys)
-
-    class TextInput {
-
-        private val emptyString = ""
-
-        var hasBeenInput: String = emptyString
-            get() {
-                val value = field
-                field = emptyString
-                return value
-            }
-            private set
-
-
-        private val inputCharacterHistory = Array(1024) { emptyString }
-
-        var inputText = emptyString
-            private set(value) {
-                field = value
-                hasBeenInput = value
-            }
-
-        internal fun setInputTextChar(codepoint: Int) {
-            var characters = inputCharacterHistory[codepoint]
-            if (characters == emptyString) {
-                characters = codepointToString(codepoint)
-                inputCharacterHistory[codepoint] = characters
-            }
-            inputText = characters
-        }
-    }
-}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/input/KeyboardHandler.kt b/mechanica/src/main/kotlin/com/mechanica/engine/input/KeyboardHandler.kt
deleted file mode 100644
index cb18f2cb..00000000
--- a/mechanica/src/main/kotlin/com/mechanica/engine/input/KeyboardHandler.kt
+++ /dev/null
@@ -1,32 +0,0 @@
-package com.mechanica.engine.input
-
-import com.mechanica.engine.game.Game
-import org.lwjgl.glfw.GLFW.GLFW_PRESS
-import org.lwjgl.glfw.GLFW.GLFW_RELEASE
-import org.lwjgl.glfw.GLFWCharCallback
-import org.lwjgl.glfw.GLFWKeyCallback
-
-/**
- * Created by domin on 29/10/2017.
- */
-class KeyboardHandler {
-    class KeyHandler : GLFWKeyCallback() {
-        override fun invoke(window: Long, key: Int, scancode: Int, action: Int, mods: Int) {
-            if (action == GLFW_PRESS) {
-                Keyboard.addPressed(key)
-                Game.controls[key].forEach { it.isDown = true }
-            } else if (action == GLFW_RELEASE) {
-                Keyboard.removePressed(key)
-                Game.controls[key].forEach { it.isDown = false }
-            }
-        }
-
-    }
-
-    class TextHandler : GLFWCharCallback() {
-        override fun invoke(window: Long, codepoint: Int) {
-            Keyboard.textInput.setInputTextChar(codepoint)
-        }
-
-    }
-}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/input/Keys.kt b/mechanica/src/main/kotlin/com/mechanica/engine/input/Keys.kt
index 1b4ac69e..0a51df43 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/input/Keys.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/input/Keys.kt
@@ -3,7 +3,7 @@ package com.mechanica.engine.input
 
 import org.lwjgl.glfw.GLFW.*
 
-enum class Keys(val id: Int) {
+enum class Keys(var id: Int) {
     UNKNOWN(GLFW_KEY_UNKNOWN),
     M1(GLFW_MOUSE_BUTTON_1),
     M2(GLFW_MOUSE_BUTTON_2),
@@ -135,8 +135,10 @@ enum class Keys(val id: Int) {
     MENU(GLFW_KEY_MENU),
 
     SCROLL_UP(1000),
-    SCROLL_DOWN(1000);
+    SCROLL_DOWN(1001),
+    SCROLL(1002);
 
+    val label: String get() = glfwGetKeyName(id, 0) ?: "?"
     companion object {
         fun uniqueId(): Int {
             val keys = values().map { it.id }.toTypedArray()
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/input/Mouse.kt b/mechanica/src/main/kotlin/com/mechanica/engine/input/Mouse.kt
deleted file mode 100644
index 43e3652b..00000000
--- a/mechanica/src/main/kotlin/com/mechanica/engine/input/Mouse.kt
+++ /dev/null
@@ -1,95 +0,0 @@
-package com.mechanica.engine.input
-
-import com.mechanica.engine.unit.vector.DynamicVector
-import com.mechanica.engine.unit.vector.Vector
-import com.mechanica.engine.game.Game
-
-object Mouse {
-    private val map = HashMap<Int, ArrayList<Key>>()
-
-    val MB1 = MouseButton(Keys.M1)
-    val MB2 = MouseButton(Keys.M2)
-    val MMB = MouseButton(Keys.M3)
-    val M4 = MouseButton(Keys.M4)
-    val M5 = MouseButton(Keys.M5)
-    val M6 = MouseButton(Keys.M6)
-    val M7 = MouseButton(Keys.M7)
-    val M8 = MouseButton(Keys.M8)
-
-    val scrollUp = ScrollWheel(Keys.SCROLL_UP)
-    val scrollDown = ScrollWheel(Keys.SCROLL_DOWN)
-
-    operator fun get(keyId: Int): ArrayList<Key> {
-        val keys = map[keyId]
-        if (keys != null) {
-            return keys
-        }
-        return arrayListOf(Key(map, keyId))
-    }
-
-    private val worldRatio: Vector = object : Vector {
-        override val x: Double
-            get() = Game.window.width/ Game.view.width
-        override val y: Double
-            get() = Game.window.height/ Game.view.height
-    }
-
-    private val uiRatio: Vector = object : Vector {
-        override val x: Double
-            get() = Game.window.width/ Game.ui.width
-        override val y: Double
-            get() = Game.window.height/ Game.ui.height
-
-    }
-
-    val pixel: Vector = object : DynamicVector {
-        override var x: Double = 0.0
-            set(value) {
-                field = value
-                setX(value)
-            }
-        override var y: Double = 0.0
-            set(value) {
-                field = value
-                setY(value)
-            }
-    }
-
-    val world: Vector = DynamicVector.create()
-    val ui: Vector = DynamicVector.create()
-
-    fun refreshCursor() {
-        setX(pixel.x)
-        setY(pixel.y)
-    }
-
-    private fun setX(value: Double) {
-        val uiX = value/ uiRatio.x - Game.ui.width/2.0
-        val worldX = value/ worldRatio.x - Game.view.width/2.0 + Game.view.x
-
-        setUi(x = uiX)
-        setWorld(x = worldX)
-    }
-
-    private fun setY(value: Double) {
-        val uiY = Game.ui.height/2.0 - value/ uiRatio.y
-        val worldY = Game.view.height/2.0 - value/ worldRatio.y + Game.view.y
-
-        setUi(y = uiY)
-        setWorld(y = worldY)
-    }
-
-    private fun setWorld(x: Double = world.x, y: Double = world.y) {
-        (world as DynamicVector).set(x, y)
-    }
-
-    private fun setUi(x: Double = ui.x, y: Double = ui.y) {
-        (ui as DynamicVector).set(x, y)
-    }
-
-    class MouseButton(vararg keys: Keys): Key(map, *keys)
-    class ScrollWheel(vararg keys: Keys): Key(map, *keys) {
-        var distance = 0.0
-            internal set
-    }
-}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/input/MouseHandler.kt b/mechanica/src/main/kotlin/com/mechanica/engine/input/MouseHandler.kt
deleted file mode 100644
index a415aeba..00000000
--- a/mechanica/src/main/kotlin/com/mechanica/engine/input/MouseHandler.kt
+++ /dev/null
@@ -1,49 +0,0 @@
-package com.mechanica.engine.input
-
-import com.mechanica.engine.unit.vector.DynamicVector
-import com.mechanica.engine.game.Game
-import org.lwjgl.glfw.GLFW
-import org.lwjgl.glfw.GLFWCursorPosCallback
-import org.lwjgl.glfw.GLFWMouseButtonCallback
-import org.lwjgl.glfw.GLFWScrollCallback
-
-class MouseHandler {
-    class ButtonHandler : GLFWMouseButtonCallback() {
-        override fun invoke(window: Long, button: Int, action: Int, mods: Int) {
-            if (action == GLFW.GLFW_RELEASE) {
-                Keyboard[button].forEach { it.isDown = false }
-                Mouse[button].forEach { it.isDown = false }
-                Game.controls[button].forEach { it.isDown = false }
-            } else if (action == GLFW.GLFW_PRESS) {
-                Keyboard[button].forEach { it.isDown = true }
-                Mouse[button].forEach { it.isDown = true }
-                Game.controls[button].forEach { it.isDown = true }
-            }
-        }
-
-    }
-
-    class CursorHandler : GLFWCursorPosCallback() {
-        override fun invoke(window: Long, x: Double, y: Double) {
-            (Mouse.pixel as DynamicVector).set(x, y)
-        }
-
-    }
-
-    class ScrollHandler: GLFWScrollCallback() {
-        override fun invoke(window: Long, xoffset: Double, yoffset: Double) {
-
-            if (yoffset > 0.0) {
-                Mouse.scrollUp.isDown = false
-                Mouse.scrollUp.isDown = true
-                Mouse.scrollUp.distance = yoffset
-            } else if (yoffset < 0.0) {
-                Mouse.scrollDown.isDown = false
-                Mouse.scrollDown.isDown = true
-                Mouse.scrollDown.distance = -yoffset
-            }
-        }
-
-    }
-
-}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/input/PressedKeys.kt b/mechanica/src/main/kotlin/com/mechanica/engine/input/PressedKeys.kt
deleted file mode 100644
index 200cfa35..00000000
--- a/mechanica/src/main/kotlin/com/mechanica/engine/input/PressedKeys.kt
+++ /dev/null
@@ -1,68 +0,0 @@
-package com.mechanica.engine.input
-
-internal class PressedKeys(private val map: HashMap<Int, ArrayList<Key>>) : Iterable<Key>, Iterator<Key> {
-    private val emptyElement = -10
-    private var pressedKeys = IntArray(100) { emptyElement }
-    private var current = 0
-    private var currentIndex = -1
-    var size = 0; private set
-
-    override fun hasNext(): Boolean {
-        val hasNext = current < size
-        if (!hasNext) {
-            current = 0
-            currentIndex = -1
-        }
-        return hasNext
-    }
-
-    override fun next(): Key {
-        current++
-        var nextIndex = currentIndex + 1
-        while (pressedKeys[nextIndex] == -10) {
-            nextIndex++
-        }
-        currentIndex = nextIndex
-
-        val keyId = pressedKeys[currentIndex]
-        val keys = map[keyId]
-        if (keys != null && keys.size > 0) {
-            return keys.first()
-        }
-        return Key(map, keyId)
-    }
-
-    override fun iterator() = this
-
-    fun add(key: Int) {
-        if (!pressedKeys.contains(key)) {
-            var firstAvailable = 0
-            while (pressedKeys[firstAvailable] != -10) {
-                firstAvailable++
-            }
-            sizeCheck()
-            pressedKeys[firstAvailable] = key
-            size++
-        }
-    }
-
-    fun remove(key: Int) {
-        val index = pressedKeys.indexOf(key)
-        if (index != -1) {
-            pressedKeys[index] = emptyElement
-            if (size > 0) {
-                size--
-            }
-        }
-    }
-
-    private fun sizeCheck() {
-        if (size + 1 >= pressedKeys.size) {
-            pressedKeys = IntArray(pressedKeys.size*2) {
-                if (pressedKeys.size < it) {
-                    pressedKeys[it]
-                } else emptyElement
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/input/keyboard/Keyboard.kt b/mechanica/src/main/kotlin/com/mechanica/engine/input/keyboard/Keyboard.kt
new file mode 100644
index 00000000..640a2ab2
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/input/keyboard/Keyboard.kt
@@ -0,0 +1,106 @@
+@file:Suppress("unused") // There will be many variables here that go unused most of the time
+package com.mechanica.engine.input.keyboard
+
+import com.mechanica.engine.input.Key
+import java.util.ArrayList
+
+
+interface Keyboard {
+    val any: Key
+    val A: Key
+    val B: Key
+    val C: Key
+    val D: Key
+    val E: Key
+    val F: Key
+    val G: Key
+    val H: Key
+    val I: Key
+    val J: Key
+    val K: Key
+    val L: Key
+    val M: Key
+    val N: Key
+    val O: Key
+    val P: Key
+    val Q: Key
+    val R: Key
+    val S: Key
+    val T: Key
+    val U: Key
+    val V: Key
+    val W: Key
+    val X: Key
+    val Y: Key
+    val Z: Key
+    val space: Key
+    val shift: Key
+    val tab: Key
+    val lAlt: Key
+    val esc: Key
+    val comma: Key
+    val period: Key
+    val apostrophe: Key
+    val minus: Key
+    val slash: Key
+    val N0: Key
+    val N1: Key
+    val N2: Key
+    val N3: Key
+    val N4: Key
+    val N5: Key
+    val N6: Key
+    val N7: Key
+    val N8: Key
+    val N9: Key
+    val semicolon: Key
+    val equal: Key
+    val leftBracket: Key
+    val backslash: Key
+    val rightBracket: Key
+    val graveAccent: Key
+    val world1: Key
+    val world2: Key
+    val enter: Key
+    val backspace: Key
+    val insert: Key
+    val delete: Key
+    val right: Key
+    val left: Key
+    val down: Key
+    val up: Key
+    val pageUp: Key
+    val pageDown: Key
+    val home: Key
+    val end: Key
+    val capsLock: Key
+    val scrollLock: Key
+    val numLock: Key
+    val printScreen: Key
+    val pause: Key
+    val F1: Key
+    val F2: Key
+    val F3: Key
+    val F4: Key
+    val F5: Key
+    val F6: Key
+    val F7: Key
+    val F8: Key
+    val F9: Key
+    val F10: Key
+    val F11: Key
+    val F12: Key
+    val lShift: Key
+    val lCtrl: Key
+    val ctrl: Key
+    val leftSuper: Key
+    val rShift: Key
+    val rCtrl: Key
+    val rAlt: Key
+    val rightSuper: Key
+    val menu: Key
+
+    companion object : Keyboard by KeyboardImpl() {
+        fun create(): Keyboard = KeyboardImpl()
+    }
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/input/keyboard/KeyboardImpl.kt b/mechanica/src/main/kotlin/com/mechanica/engine/input/keyboard/KeyboardImpl.kt
new file mode 100644
index 00000000..129ccad2
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/input/keyboard/KeyboardImpl.kt
@@ -0,0 +1,106 @@
+package com.mechanica.engine.input.keyboard
+
+import com.mechanica.engine.input.Key
+import com.mechanica.engine.input.KeyInput
+import com.mechanica.engine.input.KeyIDs
+
+internal class KeyboardImpl : Keyboard {
+    override val any: Key by lazy { Key("any") { KeyInput.any } }
+    override val A: Key by lazy { Key(KeyIDs.A) }
+    override val B: Key by lazy { Key(KeyIDs.B) }
+    override val C: Key by lazy { Key(KeyIDs.C) }
+    override val D: Key by lazy { Key(KeyIDs.D) }
+    override val E: Key by lazy { Key(KeyIDs.E) }
+    override val F: Key by lazy { Key(KeyIDs.F) }
+    override val G: Key by lazy { Key(KeyIDs.G) }
+    override val H: Key by lazy { Key(KeyIDs.H) }
+    override val I: Key by lazy { Key(KeyIDs.I) }
+    override val J: Key by lazy { Key(KeyIDs.J) }
+    override val K: Key by lazy { Key(KeyIDs.K) }
+    override val L: Key by lazy { Key(KeyIDs.L) }
+    override val M: Key by lazy { Key(KeyIDs.M) }
+    override val N: Key by lazy { Key(KeyIDs.N) }
+    override val O: Key by lazy { Key(KeyIDs.O) }
+    override val P: Key by lazy { Key(KeyIDs.P) }
+    override val Q: Key by lazy { Key(KeyIDs.Q) }
+    override val R: Key by lazy { Key(KeyIDs.R) }
+    override val S: Key by lazy { Key(KeyIDs.S) }
+    override val T: Key by lazy { Key(KeyIDs.T) }
+    override val U: Key by lazy { Key(KeyIDs.U) }
+    override val V: Key by lazy { Key(KeyIDs.V) }
+    override val W: Key by lazy { Key(KeyIDs.W) }
+    override val X: Key by lazy { Key(KeyIDs.X) }
+    override val Y: Key by lazy { Key(KeyIDs.Y) }
+    override val Z: Key by lazy { Key(KeyIDs.Z) }
+
+    override val space: Key by lazy { Key(KeyIDs.SPACE) }
+    override val shift: Key by lazy { Key(KeyIDs.LSHIFT) }
+    override val tab: Key by lazy { Key(KeyIDs.TAB) }
+    override val lAlt: Key by lazy { Key(KeyIDs.LALT) }
+    override val esc: Key by lazy { Key(KeyIDs.ESC) }
+    override val comma: Key by lazy { Key(KeyIDs.COMMA) }
+    override val period: Key by lazy { Key(KeyIDs.PERIOD) }
+    override val apostrophe: Key by lazy { Key(KeyIDs.APOSTROPHE) }
+    override val minus: Key by lazy { Key(KeyIDs.MINUS) }
+    override val slash: Key by lazy { Key(KeyIDs.SLASH) }
+
+    override val N0: Key by lazy { Key(KeyIDs.N0) }
+    override val N1: Key by lazy { Key(KeyIDs.N1) }
+    override val N2: Key by lazy { Key(KeyIDs.N2) }
+    override val N3: Key by lazy { Key(KeyIDs.N3) }
+    override val N4: Key by lazy { Key(KeyIDs.N4) }
+    override val N5: Key by lazy { Key(KeyIDs.N5) }
+    override val N6: Key by lazy { Key(KeyIDs.N6) }
+    override val N7: Key by lazy { Key(KeyIDs.N7) }
+    override val N8: Key by lazy { Key(KeyIDs.N8) }
+    override val N9: Key by lazy { Key(KeyIDs.N9) }
+
+    override val semicolon: Key by lazy { Key(KeyIDs.SEMICOLON) }
+    override val equal: Key by lazy { Key(KeyIDs.EQUAL) }
+    override val leftBracket: Key by lazy { Key(KeyIDs.LEFT_BRACKET) }
+    override val backslash: Key by lazy { Key(KeyIDs.BACKSLASH) }
+    override val rightBracket: Key by lazy { Key(KeyIDs.RIGHT_BRACKET) }
+    override val graveAccent: Key by lazy { Key(KeyIDs.GRAVE_ACCENT) }
+    override val world1: Key by lazy { Key(KeyIDs.WORLD_1) }
+    override val world2: Key by lazy { Key(KeyIDs.WORLD_2) }
+    override val enter: Key by lazy { Key(KeyIDs.ENTER) }
+    override val backspace: Key by lazy { Key(KeyIDs.BACKSPACE) }
+    override val insert: Key by lazy { Key(KeyIDs.INSERT) }
+    override val delete: Key by lazy { Key(KeyIDs.DELETE) }
+    override val right: Key by lazy { Key(KeyIDs.RIGHT) }
+    override val left: Key by lazy { Key(KeyIDs.LEFT) }
+    override val down: Key by lazy { Key(KeyIDs.DOWN) }
+    override val up: Key by lazy { Key(KeyIDs.UP) }
+    override val pageUp: Key by lazy { Key(KeyIDs.PAGE_UP) }
+    override val pageDown: Key by lazy { Key(KeyIDs.PAGE_DOWN) }
+    override val home: Key by lazy { Key(KeyIDs.HOME) }
+    override val end: Key by lazy { Key(KeyIDs.END) }
+    override val capsLock: Key by lazy { Key(KeyIDs.CAPS_LOCK) }
+    override val scrollLock: Key by lazy { Key(KeyIDs.SCROLL_LOCK) }
+    override val numLock: Key by lazy { Key(KeyIDs.NUM_LOCK) }
+    override val printScreen: Key by lazy { Key(KeyIDs.PRINT_SCREEN) }
+    override val pause: Key by lazy { Key(KeyIDs.PAUSE) }
+
+    override val F1: Key by lazy { Key(KeyIDs.F1) }
+    override val F2: Key by lazy { Key(KeyIDs.F2) }
+    override val F3: Key by lazy { Key(KeyIDs.F3) }
+    override val F4: Key by lazy { Key(KeyIDs.F4) }
+    override val F5: Key by lazy { Key(KeyIDs.F5) }
+    override val F6: Key by lazy { Key(KeyIDs.F6) }
+    override val F7: Key by lazy { Key(KeyIDs.F7) }
+    override val F8: Key by lazy { Key(KeyIDs.F8) }
+    override val F9: Key by lazy { Key(KeyIDs.F9) }
+    override val F10: Key by lazy { Key(KeyIDs.F10) }
+    override val F11: Key by lazy { Key(KeyIDs.F11) }
+    override val F12: Key by lazy { Key(KeyIDs.F12) }
+
+    override val lShift: Key by lazy { Key(KeyIDs.LSHIFT) }
+    override val lCtrl: Key by lazy { Key(KeyIDs.LCTRL) }
+    override val ctrl: Key by lazy { Key(KeyIDs.LCTRL, KeyIDs.RCTRL) }
+    override val leftSuper: Key by lazy { Key(KeyIDs.LEFT_SUPER) }
+    override val rShift: Key by lazy { Key(KeyIDs.RSHIFT) }
+    override val rCtrl: Key by lazy { Key(KeyIDs.RCTRL) }
+    override val rAlt: Key by lazy { Key(KeyIDs.RALT) }
+    override val rightSuper: Key by lazy { Key(KeyIDs.RIGHT_SUPER) }
+    override val menu: Key by lazy { Key(KeyIDs.MENU) }
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/input/mouse/Mouse.kt b/mechanica/src/main/kotlin/com/mechanica/engine/input/mouse/Mouse.kt
new file mode 100644
index 00000000..3f18ab89
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/input/mouse/Mouse.kt
@@ -0,0 +1,34 @@
+package com.mechanica.engine.input.mouse
+
+import com.mechanica.engine.context.callbacks.MouseHandler
+import com.mechanica.engine.input.Key
+import com.mechanica.engine.input.KeyID
+import com.mechanica.engine.unit.vector.Vector
+
+
+interface Mouse {
+    val MB1: Key
+    val MB2: Key
+    val MMB: Key
+    val M4: Key
+    val M5: Key
+    val M6: Key
+    val M7: Key
+    val M8: Key
+    val scroll: ScrollWheel
+    val scrollDown: ScrollWheel
+    val scrollUp: ScrollWheel
+    val pixel: Vector
+    val world: Vector
+    val ui: Vector
+    val normalized: Vector
+
+    class ScrollWheel(vararg keys: KeyID): Key(*keys) {
+        val distance: Double
+            get() = MouseHandler.scrollY
+    }
+
+    companion object : Mouse by MouseImpl() {
+        fun create(): Mouse = MouseImpl()
+    }
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/input/mouse/MouseImpl.kt b/mechanica/src/main/kotlin/com/mechanica/engine/input/mouse/MouseImpl.kt
new file mode 100644
index 00000000..45fa1b3e
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/input/mouse/MouseImpl.kt
@@ -0,0 +1,68 @@
+package com.mechanica.engine.input.mouse
+
+import com.mechanica.engine.context.callbacks.MouseHandler
+import com.mechanica.engine.game.Game
+import com.mechanica.engine.input.Key
+import com.mechanica.engine.input.KeyIDs
+import com.mechanica.engine.unit.vector.Vector
+
+internal class MouseImpl : Mouse {
+    override val MB1 = Key(KeyIDs.M1)
+    override val MB2 = Key(KeyIDs.M2)
+    override val MMB = Key(KeyIDs.M3)
+    override val M4 = Key(KeyIDs.M4)
+    override val M5 = Key(KeyIDs.M5)
+    override val M6 = Key(KeyIDs.M6)
+    override val M7 = Key(KeyIDs.M7)
+    override val M8 = Key(KeyIDs.M8)
+
+    override val scroll = Mouse.ScrollWheel(KeyIDs.SCROLL)
+    override val scrollDown = Mouse.ScrollWheel(KeyIDs.SCROLL_DOWN)
+    override val scrollUp = Mouse.ScrollWheel(KeyIDs.SCROLL_UP)
+
+    private val worldRatio: Vector = object : Vector {
+        override val x: Double
+            get() = Game.window.width/ Game.view.width
+        override val y: Double
+            get() = Game.window.height/ Game.view.height
+    }
+
+    private val uiRatio: Vector = object : Vector {
+        override val x: Double
+            get() = Game.window.width/ Game.ui.width
+        override val y: Double
+            get() = Game.window.height/ Game.ui.height
+
+    }
+
+    override val pixel: Vector = object : Vector {
+        override val x: Double
+            get() = MouseHandler.cursorX
+        override val y: Double
+            get() = MouseHandler.cursorY
+
+    }
+
+    override val world: Vector = object : Vector {
+        override val x: Double
+            get() = pixel.x/ worldRatio.x - Game.view.width/2.0 + Game.view.x
+        override val y: Double
+            get() = Game.view.height/2.0 - pixel.y/ worldRatio.y + Game.view.y
+    }
+
+    override val ui: Vector = object : Vector {
+        override val x: Double
+            get() = pixel.x/ uiRatio.x - Game.ui.width/2.0
+        override val y: Double
+            get() = Game.ui.height/2.0 - pixel.y/ uiRatio.y
+
+    }
+
+    override val normalized: Vector = object : Vector {
+        override val x: Double
+            get() = pixel.x/ Game.window.width
+        override val y: Double
+            get() = 1.0 - pixel.y/ Game.window.height
+
+    }
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/resources/Res.kt b/mechanica/src/main/kotlin/com/mechanica/engine/resources/Res.kt
index d07acebf..99981d73 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/resources/Res.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/resources/Res.kt
@@ -1,18 +1,12 @@
 package com.mechanica.engine.resources
 
 object Res {
-    class SpecificResource(private val prefix: String, private val extension: String) {
-        operator fun get(file: String): Resource {
-            val fileFixed = fixExtension(file)
-            return Resource("$prefix$fileFixed")
-        }
+    class SpecificResource(prefix: String, extension: String): SpecificGenericResource<Resource>(prefix, extension) {
+        override fun returnResource(fixedFile: String) = Resource(fixedFile)
+    }
 
-        private fun fixExtension(file: String): String {
-            val lastSlash = file.lastIndexOf("/")
-            val dotIndex = file.lastIndexOf(".")
-            val hasExtension = (dotIndex > lastSlash) || (lastSlash == -1 && dotIndex != -1)
-            return if (hasExtension) file else "$file.$extension"
-        }
+    class SpecificAudioResource(prefix: String,  extension: String) : SpecificGenericResource<AudioResource>(prefix, extension) {
+        override fun returnResource(fixedFile: String) = AudioResource(fixedFile)
     }
 
     class SpecificResourceDirectory(private val prefix: String) {
@@ -23,7 +17,8 @@ object Res {
 
     val svg = SpecificResource("res/svg/", "svg")
     val image = SpecificResource("res/images/", "png")
-    val font = SpecificResource("res/fonts/", "png")
+    val font = SpecificResource("res/fonts/", "ttf")
+    val audio = SpecificAudioResource("res/audio/", "ogg")
     val animations = SpecificResourceDirectory("/res/animations/")
 
     fun external(path: String, createIfAbsent: Boolean = false): ExternalResource {
@@ -32,6 +27,10 @@ object Res {
     }
 
     operator fun get(file: String): Resource {
+        return invoke(file)
+    }
+
+    operator fun invoke(file: String): Resource {
         return Resource("res/$file")
     }
 }
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/resources/SpecificGenericResource.kt b/mechanica/src/main/kotlin/com/mechanica/engine/resources/SpecificGenericResource.kt
new file mode 100644
index 00000000..742e5274
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/resources/SpecificGenericResource.kt
@@ -0,0 +1,18 @@
+package com.mechanica.engine.resources
+
+abstract class SpecificGenericResource<R: GenericResource>(private val prefix: String, private val extension: String) {
+    operator fun get(file: String): R = invoke(file)
+    operator fun invoke(file: String): R {
+        val fileFixed = fixExtension(file)
+        return returnResource("$prefix$fileFixed")
+    }
+
+    protected abstract fun returnResource(fixedFile: String): R
+
+    private fun fixExtension(file: String): String {
+        val lastSlash = file.lastIndexOf("/")
+        val dotIndex = file.lastIndexOf(".")
+        val hasExtension = (dotIndex > lastSlash) || (lastSlash == -1 && dotIndex != -1)
+        return if (hasExtension) file else "$file.$extension"
+    }
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/scenes/SceneManager.kt b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/SceneManager.kt
new file mode 100644
index 00000000..14051792
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/SceneManager.kt
@@ -0,0 +1,143 @@
+package com.mechanica.engine.scenes
+
+import com.mechanica.engine.debug.DebugDrawer
+import com.mechanica.engine.debug.ScreenLog
+import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.game.Game
+import com.mechanica.engine.game.configuration.GameSetup
+import com.mechanica.engine.game.view.View
+import com.mechanica.engine.scenes.scenes.MainScene
+import com.mechanica.engine.scenes.scenes.Scene
+import com.mechanica.engine.util.Timer
+
+internal class SceneManager : Scene() {
+    override val view: View
+        get() = Game.view
+
+    var updateVar: ((Double) -> Unit)? = null
+
+    private var sceneSetter: () -> MainScene? = { null }
+    var currentScene: MainScene? = null
+        private set(value) {
+            val scene = currentScene
+
+            if (value == null) {
+                if (scene != null) removeScene(scene)
+                field = null
+                return
+            }
+
+            if (scene == null) {
+                addScene(value)
+                field = value
+                return
+            }
+
+            val new = replaceScene(scene, value)
+            if (new === scene) {
+                addScene(value)
+            }
+
+            field = new
+        }
+
+    private var scheduleSceneChange = true
+
+    private var drawer: Drawer? = null
+
+    private var startOfLoop = Timer.now
+    private var updateDuration = 0.1
+
+    private var pause = false
+    private var hasPaused = false
+    private var pausedUpdate = 0.17
+
+    private var frameAdvance = false
+
+    fun pauseExecution(pause: Boolean) {
+        this.pause = pause
+        hasPaused = false
+
+        if (!pause) {
+            updateDuration = 0.017
+            startOfLoop = Timer.now
+        }
+    }
+
+    fun frameAdvance() {
+        frameAdvance = true
+    }
+
+    fun setStartingScene(data: GameSetup) {
+        val state = data.startingScene
+
+        setMainScene { state?.invoke() }
+    }
+
+    fun setMainScene(setter: () -> MainScene?) {
+        sceneSetter = setter
+        scheduleSceneChange = true
+    }
+
+    fun updateScenes(): Double {
+        if (!pause || frameAdvance) {
+            updateScene()
+            frameAdvance = false
+        } else {
+            updatePaused()
+        }
+
+        render()
+        checkStateChange()
+
+        return updateDuration
+    }
+
+    private fun updateScene() {
+        updateDuration = Timer.now - startOfLoop
+        startOfLoop = Timer.now
+
+        updateNodes(updateDuration)
+    }
+
+    override fun update(delta: Double) {
+        updateVar?.invoke(delta)
+    }
+
+    private fun render() {
+        if (currentScene != null || childScenes.isNotEmpty()) {
+            renderNodes(getDrawer())
+        }
+
+        if (Game.debug.screenLog)
+            ScreenLog.render(getDrawer())
+        if (Game.debug.constructionDraws)
+            DebugDrawer.render(getDrawer())
+    }
+
+    override fun render(draw: Drawer) { }
+
+    private fun checkStateChange() {
+        if (scheduleSceneChange) {
+            currentScene = sceneSetter()
+            scheduleSceneChange = false
+        }
+    }
+
+    private fun getDrawer(): Drawer {
+        val drawer = this.drawer ?: Drawer.create()
+        this.drawer = drawer
+        return drawer
+    }
+
+
+    private fun updatePaused() {
+        if (!hasPaused) {
+            hasPaused = true
+            updateDuration = Timer.now - startOfLoop
+        }
+        startOfLoop = Timer.now
+    }
+
+
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/scenes/SceneUtil.kt b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/SceneUtil.kt
new file mode 100644
index 00000000..8ca32c2a
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/SceneUtil.kt
@@ -0,0 +1,67 @@
+package com.mechanica.engine.scenes
+
+import com.mechanica.engine.animation.AnimationController
+import com.mechanica.engine.animation.AnimationFormula
+import com.mechanica.engine.animation.AnimationFormulas
+import com.mechanica.engine.animation.AnimationSequence
+import com.mechanica.engine.scenes.exclusiveScenes.ExclusiveActivationMap
+import com.mechanica.engine.scenes.processes.Process
+import com.mechanica.engine.scenes.processes.ProcessNode
+import com.mechanica.engine.scenes.scenes.Scene
+import com.mechanica.engine.scenes.scenes.SceneNode
+
+
+fun ProcessNode.addAnimation(start: Double, end: Double, formula: AnimationFormulas.(Double) -> Double): AnimationFormula {
+    return addProcess(AnimationFormula(start, end, formula))
+}
+
+fun ProcessNode.addAnimation(length: Double, formula: AnimationFormulas.(Double) -> Double): AnimationFormula {
+    return addProcess(AnimationFormula(length, formula))
+}
+
+fun ProcessNode.addAnimationSequence(vararg animations: AnimationController): AnimationSequence {
+    return addProcess(AnimationSequence(*animations))
+}
+
+
+/**
+ * Sets the [processes] in which only one process can be active at once. This exclusivity is automatically enforced
+ *
+ * Usage:
+ * ```
+ * val currentlyActiveProcess by exclusivelyActiveProcesses(Process1(), Process2(), Process3())
+ * ```
+ *
+ * @param processes the set of processes that will be added as children to this process and only one can be
+ *                  set to active at a time
+ * @return An ExclusiveProcessMap which can have more processes added at a later stage
+ */
+fun <P: Process> ProcessNode.exclusivelyActiveProcesses(vararg processes: P): ExclusiveActivationMap<P> {
+    val parent = this
+    return object : ExclusiveActivationMap<P>(*processes) {
+        override fun <R : P> addProcess(process: R): R {
+            parent.addProcess(process)
+            return super.addProcess(process)
+        }
+    }
+}
+
+/**
+ * This does the same as [exclusivelyActiveProcesses][com.mechanica.engine.scenes.exclusivelyActiveProcesses] but it adds
+ * scenes to the parent instead of processes
+ *
+ * @param scenes the set of scenes that will be added as children to this scene and only one can be
+ *                  set to active at a time
+ * @return An ExclusiveProcessMap which can have more processes added at a later stage
+ */
+fun <P: Scene> SceneNode.exclusivelyActiveScenes(vararg scenes: P): ExclusiveActivationMap<P> {
+    val parent = this
+    return object : ExclusiveActivationMap<P>(*scenes) {
+        override fun <R : P> addProcess(process: R): R {
+            parent.addScene(process)
+            return super.addProcess(process)
+        }
+    }
+}
+
+
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/scenes/exclusiveScenes/ExclusiveActivationMap.kt b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/exclusiveScenes/ExclusiveActivationMap.kt
new file mode 100644
index 00000000..7a0433d5
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/exclusiveScenes/ExclusiveActivationMap.kt
@@ -0,0 +1,48 @@
+package com.mechanica.engine.scenes.exclusiveScenes
+
+import com.mechanica.engine.scenes.processes.ProcessNode
+import com.mechanica.engine.scenes.processes.Process
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
+
+open class ExclusiveActivationMap<P : Process>(vararg processes: P) : ReadOnlyProperty<ProcessNode, P?> {
+    private val processes: ArrayList<P> = ArrayList()
+    private var activeIndex = -1
+    val active: P?
+        get() = if (activeIndex != -1) processes[activeIndex] else null
+
+    init {
+        for (i in processes.indices) {
+            add(processes[i])
+        }
+    }
+
+    override operator fun getValue(thisRef: ProcessNode, property: KProperty<*>): P? = active
+
+    fun add(process: P) = addProcess(process)
+
+    open fun <R : P> addProcess(process: R): R {
+        processes.add(process)
+        process.addActivationCallback()
+        return process
+    }
+
+    private fun P.addActivationCallback() {
+        addActivationChangedListener(0) {
+            if (it) {
+                setExclusiveActivation(this)
+            } else if (this@ExclusiveActivationMap.active === this) {
+                activeIndex = -1
+            }
+        }
+    }
+
+    private fun setExclusiveActivation(process: P) {
+        activeIndex = processes.indexOf(process)
+        for (i in processes.indices) {
+            if (processes[i] != process) {
+                processes[i].active = false
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/scenes/processes/InputProcess.kt b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/processes/InputProcess.kt
new file mode 100644
index 00000000..8587834b
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/processes/InputProcess.kt
@@ -0,0 +1,9 @@
+package com.mechanica.engine.scenes.processes
+
+import com.mechanica.engine.input.keyboard.Keyboard
+import com.mechanica.engine.input.mouse.Mouse
+
+abstract class InputProcess(order: Int = -1) :  Process(order) {
+    val keyboard = Keyboard.create()
+    val mouse = Mouse.create()
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/scenes/processes/Process.kt b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/processes/Process.kt
new file mode 100644
index 00000000..3f058570
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/processes/Process.kt
@@ -0,0 +1,184 @@
+package com.mechanica.engine.scenes.processes
+
+import com.mechanica.engine.util.extensions.fori
+
+abstract class Process(override val order: Int = 0) : ProcessNode {
+
+    private val activationListeners = ArrayList<ActivationChangedEvents>()
+    private var _active = true
+    final override var active: Boolean
+        get() = _active
+        set(value) {
+            val hasChanged = _active != value
+            if (hasChanged) {
+                runActivationCallbacks(value)
+            }
+        }
+
+    private val childProcesses: List<ProcessNode> = ArrayList()
+    private val leafProcesses: List<Updateable> = ArrayList()
+
+    private var callbacksInitialized = false
+
+    init {
+        addActivationChangedListener(0) { _active = it }
+    }
+
+    /**
+     * Adds a callback for when the value of [active] is changed. The [priority] value dictates the order in which
+     * the callbacks are executed, the higher the priority value, the earlier the callback will execute.
+     * The value can be negative, in which case the callback will be called after the value for [active]
+     * has been set
+     *
+     * @param priority an integer value which represents the order that the callbacks are executed, the higher
+     * the value, the earlier the execution, the value for [active] is changed at a priority of zero
+     *
+     * @param listener the callback which will execute when the value of [active] has been changed, the lambda takes
+     * a boolean expression which is the new value for [active]
+     */
+    fun addActivationChangedListener(priority: Int = 0, listener: (Boolean) -> Unit) {
+        activationListeners.add(ActivationChangedEvents(priority, listener))
+        activationListeners.sortByDescending { it.priority }
+    }
+
+    private fun runActivationCallbacks(activate: Boolean) {
+        callbacksInitialized = true
+        for (i in activationListeners.indices) {
+            activationListeners[i].listener.invoke(activate)
+        }
+    }
+
+    final override fun <P:Updateable> addProcess(process: P): P {
+        if (process is ProcessNode) {
+            addProcessNode(process)
+        } else {
+            addUpdateable(process)
+        }
+        return process
+    }
+
+    private fun addProcessNode(process: ProcessNode) {
+        val processes = (childProcesses as ArrayList)
+
+        if (!processes.contains(process)) {
+            processes.add(process)
+            processes.sortBy { it.order }
+        }
+    }
+
+    private fun addUpdateable(updateable: Updateable) {
+        val processes = (leafProcesses as ArrayList)
+
+        if (!processes.contains(updateable)) {
+            processes.add(updateable)
+        }
+    }
+
+    final override fun removeProcess(process: Updateable): Boolean {
+        return if (process is ProcessNode) {
+            removeProcessNode(process)
+        } else {
+            removeUpdateable(process)
+        }
+    }
+
+    private fun removeProcessNode(process: ProcessNode): Boolean {
+        process.destructNodes()
+        return (childProcesses as ArrayList).remove(process)
+    }
+
+    private fun removeUpdateable(updateable: Updateable): Boolean {
+        return (leafProcesses as ArrayList).remove(updateable)
+    }
+
+    final override fun <P:Updateable> replaceProcess(old: P, new: P): P {
+        val success = if (old is ProcessNode && new is ProcessNode) {
+            replaceProcessNode(old, new)
+        } else {
+            replaceUpdateable(old, new)
+        }
+
+        return if (success) new else old
+    }
+
+    private fun replaceProcessNode(old: ProcessNode, new: ProcessNode): Boolean {
+        val processes = (childProcesses as ArrayList)
+        val index = processes.indexOf(old)
+        if (index != -1) {
+            removeProcess(processes[index])
+            processes.add(index, new)
+            processes.sortBy { it.order }
+            return true
+        }
+        return false
+    }
+
+    private fun replaceUpdateable(old: Updateable, new: Updateable): Boolean {
+        val processes = (leafProcesses as ArrayList)
+        val index = processes.indexOf(old)
+        if (index != -1) {
+            removeProcess(processes[index])
+            processes.add(index, new)
+            return true
+        }
+        return false
+    }
+
+    inline fun forEachProcess(operation: (ProcessNode)-> Unit) {
+        for (i in `access$childProcesses`.indices) {
+            operation(`access$childProcesses`[i])
+        }
+    }
+
+    override fun updateNodes(delta: Double) {
+        if (!callbacksInitialized) runActivationCallbacks(active)
+
+        val index = updateNodesFor(delta) { it.order < 0 }
+        updateLeaves(delta)
+        this.update(delta)
+        updateNodesFor(delta, index) { it.order >= 0 }
+    }
+
+    /**
+     * A function to be overridden which will run while [active] is set to false
+     */
+    open fun whileInactive(delta: Double) { }
+
+    private inline fun updateNodesFor(delta: Double, from: Int = 0, condition: (ProcessNode) -> Boolean): Int {
+        var inverseI = childProcesses.lastIndex - from
+        do {
+            val process = childProcesses.getOrNull(childProcesses.lastIndex - (inverseI--)) ?: break
+            if (process.active) {
+                process.updateNodes(delta)
+            } else if (process is Process) {
+                process.whileInactive(delta)
+            }
+        } while (condition(process))
+        return childProcesses.lastIndex - inverseI
+    }
+
+    private fun updateLeaves(delta: Double) {
+        leafProcesses.fori {
+            it.update(delta)
+        }
+    }
+
+    override fun destructNodes() {
+        for (i in childProcesses.indices) {
+            childProcesses[i].destructNodes()
+        }
+        destructor()
+    }
+
+
+    override fun destructor() { }
+
+    protected fun finalize() { destructor() }
+
+    @Suppress("PropertyName")
+    @PublishedApi
+    internal val `access$childProcesses`: List<ProcessNode>
+        get() = childProcesses
+
+    private class ActivationChangedEvents(val priority: Int, val listener: (Boolean) -> Unit)
+}
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/scenes/processes/ProcessNode.kt b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/processes/ProcessNode.kt
new file mode 100644
index 00000000..3edef02a
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/processes/ProcessNode.kt
@@ -0,0 +1,20 @@
+package com.mechanica.engine.scenes.processes
+
+interface ProcessNode : Updateable {
+    /**
+     * The [order] value dictates the order in which the processes are updated and/or rendered,
+     * the lower the order value, the earlier the process will update.
+     * The value can be negative, in which case the process will be updated before the parent process
+     * has been updated. If it is positive, it will happen after.
+     */
+    val order: Int
+        get() = 0
+    val active: Boolean
+        get() = true
+    fun <P:Updateable> addProcess(process: P): P
+    fun removeProcess(process: Updateable): Boolean
+    fun <P:Updateable> replaceProcess(old: P, new: P): P
+    fun updateNodes(delta: Double)
+    fun destructor()
+    fun destructNodes()
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/scenes/processes/Updateable.kt b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/processes/Updateable.kt
new file mode 100644
index 00000000..9d12dd6d
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/processes/Updateable.kt
@@ -0,0 +1,5 @@
+package com.mechanica.engine.scenes.processes
+
+interface Updateable {
+    fun update(delta: Double)
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/Drawable.kt b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/Drawable.kt
new file mode 100644
index 00000000..ebb9a066
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/Drawable.kt
@@ -0,0 +1,7 @@
+package com.mechanica.engine.scenes.scenes
+
+import com.mechanica.engine.drawer.Drawer
+
+interface Drawable {
+    fun render(draw: Drawer)
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/DynamicScene.kt b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/DynamicScene.kt
new file mode 100644
index 00000000..1959fc83
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/DynamicScene.kt
@@ -0,0 +1,75 @@
+package com.mechanica.engine.scenes.scenes
+
+import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.game.view.DynamicView
+import com.mechanica.engine.game.view.View
+import com.mechanica.engine.unit.vector.DynamicVector
+
+abstract class DynamicScene(
+        x: Double = 0.0,
+        y: Double = 0.0,
+        width: Double = 1.0,
+        height: Double = 1.0,
+        order: Int = 0) : Scene(order) {
+
+    constructor(
+            view: View,
+            priority: Int = 0) : this(view.x, view.y, view.width, view.height, priority)
+
+    open val position = DynamicVector.create(x + width/2.0, y + height/2.0)
+
+    override val view: DynamicView by lazy { DynamicSceneView(width, height) }
+
+    override fun drawInScene(draw: Drawer, view: View): Drawer {
+        return draw.centered.transformed.translate(position).scale(view.wh)
+    }
+
+    inner class DynamicSceneView(
+            override var width: Double,
+            override var height: Double) : DynamicView {
+
+        override var x: Double
+            get() {
+                return center.x
+            }
+            set(value) { center.x = value}
+        override var y: Double
+            get() = center.y
+            set(value) {center.y = value}
+
+        @Suppress("SetterBackingFieldAssignment")
+        override var center: DynamicVector = object : DynamicVector by position {}
+            set(value) {
+                position.x = value.x
+                position.y = value.y
+            }
+
+        @Suppress("SetterBackingFieldAssignment")
+        override var xy: DynamicVector = object : DynamicVector {
+            override var x: Double
+                get() = this@DynamicSceneView.width
+                set(value) {this@DynamicSceneView.width = value }
+            override var y: Double
+                get() = this@DynamicSceneView.height
+                set(value) { this@DynamicSceneView.height = value}
+        }
+            set(value) {
+                x = value.x
+                y = value.y
+            }
+
+        @Suppress("SetterBackingFieldAssignment")
+        override var wh: DynamicVector = object : DynamicVector {
+            override var x: Double
+                get() = this@DynamicSceneView.width
+                set(value) {this@DynamicSceneView.width = value }
+            override var y: Double
+                get() = this@DynamicSceneView.height
+                set(value) { this@DynamicSceneView.height = value}
+        }
+            set(value) {
+                width = value.x
+                height = value.y
+            }
+    }
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/state/LoadState.kt b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/LoadScene.kt
similarity index 75%
rename from mechanica/src/main/kotlin/com/mechanica/engine/state/LoadState.kt
rename to mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/LoadScene.kt
index 0c8c7ce8..422a78fa 100644
--- a/mechanica/src/main/kotlin/com/mechanica/engine/state/LoadState.kt
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/LoadScene.kt
@@ -1,11 +1,8 @@
-package com.mechanica.engine.state
+package com.mechanica.engine.scenes.scenes
 
 import com.mechanica.engine.drawer.Drawer
 
-/**
- * Created by domin on 4 Aug 2017.
- */
-abstract class LoadState : State() {
+abstract class LoadScene : WorldScene() {
     private val waitTime = 0.2f
     private val minLoops = 2
 
@@ -14,10 +11,17 @@ abstract class LoadState : State() {
     private var startLoading = false
     private var finishedLoading = false
 
+    private var hasPreLoaded = false
+
     override fun update(delta: Double) {
+        if (!hasPreLoaded) {
+            hasPreLoaded = true
+            preLoad()
+        }
         currentWait += delta
         currentLoops++
         startLoading = currentWait > waitTime && currentLoops > minLoops
+
         if (finishedLoading) onFinish()
 
     }
@@ -36,5 +40,5 @@ abstract class LoadState : State() {
 
     abstract fun load()
 
-    internal var onFinish: () -> Unit = { }
-}
+    abstract fun onFinish()
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/MainScene.kt b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/MainScene.kt
new file mode 100644
index 00000000..f2402b47
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/MainScene.kt
@@ -0,0 +1,10 @@
+package com.mechanica.engine.scenes.scenes
+
+import com.mechanica.engine.game.Game
+import com.mechanica.engine.game.view.GameView
+
+abstract class MainScene(order: Int = 0) : Scene(order) {
+    abstract override val view: GameView
+
+    fun setNewMainScene(setter: () -> MainScene?) = Game.setMainScene(setter)
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/MainUIScene.kt b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/MainUIScene.kt
new file mode 100644
index 00000000..3778d4a1
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/MainUIScene.kt
@@ -0,0 +1,15 @@
+package com.mechanica.engine.scenes.scenes
+
+import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.game.Game
+import com.mechanica.engine.game.view.UIView
+import com.mechanica.engine.game.view.View
+
+abstract class MainUIScene(order: Int = 1) : MainScene(order) {
+    override val view: UIView
+        get() = Game.ui
+
+    override fun drawInScene(draw: Drawer, view: View): Drawer {
+        return super.drawInScene(draw, view).ui
+    }
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/Scene.kt b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/Scene.kt
new file mode 100644
index 00000000..cb815848
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/Scene.kt
@@ -0,0 +1,85 @@
+package com.mechanica.engine.scenes.scenes
+
+import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.game.view.View
+import com.mechanica.engine.scenes.processes.Process
+
+abstract class Scene(order: Int = 0) : Process(order), SceneNode {
+
+    protected val childScenes: List<SceneNode> = ArrayList()
+
+    protected val Drawer.inScene: Drawer
+        get() = drawInScene(this, view)
+
+    protected open fun drawInScene(draw: Drawer, view: View): Drawer = draw.transformed.translate(view.x, view.y)
+
+    final override fun <S:SceneNode> addScene(scene: S): S {
+        addProcess(scene)
+        val scenes = (childScenes as ArrayList)
+
+        if (!scenes.contains(scene)) {
+            scenes.add(scene)
+            scenes.sortBy { it.order }
+        }
+        return scene
+    }
+
+    final override fun removeScene(scene: SceneNode): Boolean {
+        removeProcess(scene)
+        return (childScenes as ArrayList).remove(scene)
+    }
+
+    final override fun <S : SceneNode> replaceScene(old: S, new: S): S {
+        replaceProcess(old, new)
+
+        val scenes = (childScenes as ArrayList)
+        val index = scenes.indexOf(old)
+        if (index != -1) {
+            scenes.removeAt(index)
+            scenes.add(index, new)
+            scenes.sortBy { it.order }
+            return new
+        }
+        return old
+    }
+
+    inline fun forEachScene(operation: (SceneNode)-> Unit) {
+        for (i in `access$childScenes`.indices) {
+            operation(`access$childScenes`[i])
+        }
+    }
+
+    override fun renderNodes(draw: Drawer) {
+        val index = renderNodesFor(draw) { it.order < 0}
+        this.render(draw)
+        renderNodesFor(draw, index) { it.order >= 0 }
+    }
+
+    private inline fun renderNodesFor(draw: Drawer, from: Int = 0, condition: (SceneNode) -> Boolean): Int {
+        var i = from
+        do {
+            val scene = childScenes.getOrNull(i++) ?: break
+            if (scene.active) {
+                scene.renderNodes(draw)
+            }
+        } while (condition(scene))
+        return i
+    }
+
+    override fun update(delta: Double) { }
+
+    override fun destructNodes() {
+        for (i in childScenes.indices) {
+            childScenes[i].destructNodes()
+        }
+        super.destructNodes()
+    }
+
+    override fun render(draw: Drawer) { }
+
+    @Suppress("PropertyName")
+    @PublishedApi
+    internal val `access$childScenes`: List<SceneNode>
+        get() = childScenes
+
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/SceneNode.kt b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/SceneNode.kt
new file mode 100644
index 00000000..2a58a3e3
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/SceneNode.kt
@@ -0,0 +1,13 @@
+package com.mechanica.engine.scenes.scenes
+
+import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.game.view.View
+import com.mechanica.engine.scenes.processes.ProcessNode
+
+interface SceneNode : ProcessNode, Drawable {
+    val view: View
+    fun <S:SceneNode> addScene(scene: S): S
+    fun removeScene(scene: SceneNode): Boolean
+    fun <S:SceneNode> replaceScene(old: S, new: S): S
+    fun renderNodes(draw: Drawer)
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/StaticScene.kt b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/StaticScene.kt
new file mode 100644
index 00000000..cc4447d4
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/StaticScene.kt
@@ -0,0 +1,21 @@
+package com.mechanica.engine.scenes.scenes
+
+import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.game.view.View
+import com.mechanica.engine.unit.vector.Vector
+import com.mechanica.engine.unit.vector.vec
+
+abstract class StaticScene(final override val view: View, order: Int = 0) : Scene(order) {
+    constructor(
+            x: Double = 0.0,
+            y: Double = 0.0,
+            width: Double = 1.0,
+            height: Double = 1.0,
+            priority: Int = 0) : this(View.create(x, y, width, height), priority)
+
+    val position: Vector by lazy { vec(view.xy) }
+
+    override fun drawInScene(draw: Drawer, view: View): Drawer {
+        return draw.centered.transformed.translate(position).scale(view.wh)
+    }
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/WorldScene.kt b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/WorldScene.kt
new file mode 100644
index 00000000..21588a25
--- /dev/null
+++ b/mechanica/src/main/kotlin/com/mechanica/engine/scenes/scenes/WorldScene.kt
@@ -0,0 +1,9 @@
+package com.mechanica.engine.scenes.scenes
+
+import com.mechanica.engine.game.Game
+import com.mechanica.engine.game.view.WorldView
+
+abstract class WorldScene(order: Int = 0) : MainScene(order) {
+    override val view: WorldView
+        get() = Game.view
+}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/state/EmptyLoadState.kt b/mechanica/src/main/kotlin/com/mechanica/engine/state/EmptyLoadState.kt
deleted file mode 100644
index 9631e757..00000000
--- a/mechanica/src/main/kotlin/com/mechanica/engine/state/EmptyLoadState.kt
+++ /dev/null
@@ -1,9 +0,0 @@
-package com.mechanica.engine.state
-
-import com.mechanica.engine.drawer.Drawer
-
-object EmptyLoadState : LoadState() {
-    override fun preLoad() {}
-    override fun renderLoadScreen(draw: Drawer) {}
-    override fun load() {}
-}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/state/EmptyState.kt b/mechanica/src/main/kotlin/com/mechanica/engine/state/EmptyState.kt
deleted file mode 100644
index 8eacf1fe..00000000
--- a/mechanica/src/main/kotlin/com/mechanica/engine/state/EmptyState.kt
+++ /dev/null
@@ -1,8 +0,0 @@
-package com.mechanica.engine.state
-
-import com.mechanica.engine.drawer.Drawer
-
-object EmptyState : State(){
-    override fun update(delta: Double) { }
-    override fun render(draw: Drawer) { }
-}
\ No newline at end of file
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/state/State.kt b/mechanica/src/main/kotlin/com/mechanica/engine/state/State.kt
deleted file mode 100644
index c077b685..00000000
--- a/mechanica/src/main/kotlin/com/mechanica/engine/state/State.kt
+++ /dev/null
@@ -1,13 +0,0 @@
-package com.mechanica.engine.state
-
-import com.mechanica.engine.drawer.Drawer
-
-/**
- * Created by domin on 22 Mar 2017.
- */
-
-abstract class State {
-    abstract fun update(delta: Double)
-
-    abstract fun render(draw: Drawer)
-}
diff --git a/mechanica/src/main/kotlin/com/mechanica/engine/state/StateManager.kt b/mechanica/src/main/kotlin/com/mechanica/engine/state/StateManager.kt
deleted file mode 100644
index 372139c9..00000000
--- a/mechanica/src/main/kotlin/com/mechanica/engine/state/StateManager.kt
+++ /dev/null
@@ -1,43 +0,0 @@
-package com.mechanica.engine.state
-
-import com.mechanica.engine.debug.DebugDrawer
-import com.mechanica.engine.debug.ScreenLog
-import com.mechanica.engine.drawer.Drawer
-import com.mechanica.engine.game.Game
-import com.mechanica.engine.util.Timer
-
-internal class StateManager {
-
-    private var stateSetter: () -> State? = { null }
-    private var currentState: State? = null
-    private var scheduleStateChange = true
-
-    private val drawer: Drawer by lazy { Drawer.create() }
-
-    private var startOfLoop = Timer.now
-    private var updateDuration = 0.1
-
-    fun updateState() {
-        updateDuration = Timer.now - startOfLoop
-        startOfLoop = Timer.now
-
-        if (scheduleStateChange) {
-            currentState = stateSetter()
-            scheduleStateChange = false
-        }
-
-        currentState?.update(updateDuration)
-        currentState?.render(drawer)
-
-        if (Game.debug.screenLog)
-            ScreenLog.render(drawer)
-        if (Game.debug.constructionDraws)
-            DebugDrawer.render(drawer)
-    }
-
-    fun setCurrentState(setter: () -> State?) {
-        stateSetter = setter
-        scheduleStateChange = true
-    }
-
-}
\ No newline at end of file
diff --git a/samples/build.gradle.kts b/samples/build.gradle.kts
index dd548318..4464ecf0 100644
--- a/samples/build.gradle.kts
+++ b/samples/build.gradle.kts
@@ -1,6 +1,7 @@
 
 plugins {
     kotlin("jvm")
+    kotlin("plugin.serialization")
     application
 }
 
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/audio/AudioTest.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/audio/AudioTest.kt
new file mode 100644
index 00000000..e44b5f58
--- /dev/null
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/audio/AudioTest.kt
@@ -0,0 +1,36 @@
+package com.mechanica.engine.samples.audio
+
+import com.mechanica.engine.audio.Listener
+import com.mechanica.engine.config.configure
+import com.mechanica.engine.game.Game
+import com.mechanica.engine.input.keyboard.Keyboard
+import com.mechanica.engine.input.mouse.Mouse
+import com.mechanica.engine.resources.Res
+
+fun main() {
+    Game.configure {
+        setViewport(height = 10.0)
+    }
+
+    val source = Res.audio("radar3").createSource()
+
+    Game.run {
+        if (Keyboard.space.hasBeenPressed) {
+            source.play()
+        }
+        if (Keyboard.esc.hasBeenPressed) {
+            source.stop()
+        }
+        if (Keyboard.P.hasBeenPressed) {
+            source.pause()
+        }
+        if (Keyboard.up.hasBeenPressed) {
+            source.pitch += 0.1f
+        }
+        if (Keyboard.down.hasBeenPressed) {
+            source.pitch -= 0.1f
+        }
+
+        Listener.position.set(Mouse.world.x.toFloat()/5f, 0f, Mouse.world.y.toFloat()/2f)
+    }
+}
\ No newline at end of file
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/basic/BasicDemo.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/basic/BasicDemo.kt
new file mode 100644
index 00000000..b4186775
--- /dev/null
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/basic/BasicDemo.kt
@@ -0,0 +1,17 @@
+package com.mechanica.engine.samples.basic
+
+import com.mechanica.engine.config.configure
+import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.game.Game
+
+fun main() {
+    Game.configure {
+        setViewport(height = 10.0)
+    }
+
+    val draw = Drawer.create()
+
+    Game.run {
+        draw.centered.grey.text("Hello, Mechanica")
+    }
+}
\ No newline at end of file
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/color/Main.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/color/Main.kt
index e8e8936d..7fba31b5 100644
--- a/samples/src/main/kotlin/com/mechanica/engine/samples/color/Main.kt
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/color/Main.kt
@@ -1,22 +1,23 @@
 package com.mechanica.engine.samples.color
 
+import com.mechanica.engine.config.configure
 import com.mechanica.engine.drawer.Drawer
 import com.mechanica.engine.game.Game
-import com.mechanica.engine.input.Mouse
-import com.mechanica.engine.state.State
+import com.mechanica.engine.input.mouse.Mouse
+import com.mechanica.engine.scenes.scenes.WorldScene
 
 fun main() {
     Game.configure {
         setViewport(height = 10.0)
         setResolution(2000, 2000)
-        setStartingState { StartMain() }
+        setStartingScene { StartMain() }
     }
 
     Game.run()
 }
 
 
-private class StartMain : State() {
+private class StartMain : WorldScene() {
     override fun update(delta: Double) {
 
     }
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/data/SaveDataExample.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/data/SaveDataExample.kt
new file mode 100644
index 00000000..03342102
--- /dev/null
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/data/SaveDataExample.kt
@@ -0,0 +1,40 @@
+package com.mechanica.engine.samples.data
+
+import com.mechanica.engine.config.configure
+import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.game.Game
+import com.mechanica.engine.input.Key
+import com.mechanica.engine.input.KeyIDs
+import com.mechanica.engine.persistence.persistent
+import com.mechanica.engine.scenes.scenes.WorldScene
+import com.mechanica.engine.text.Text
+
+fun main() {
+    Game.configure {
+        setViewport(height = 10.0)
+        setStartingScene { SaveDataExample() }
+    }
+
+    Game.run()
+}
+
+class SaveDataExample : WorldScene() {
+    private var count by persistent(0)
+
+    private val upKey = Key(KeyIDs.W, KeyIDs.UP, KeyIDs.SCROLL_UP)
+    private val downKey = Key(KeyIDs.S, KeyIDs.DOWN, KeyIDs.SCROLL_DOWN)
+
+    private val info by lazy { Text("Press $upKey or $downKey to change count\nThe value persists after re-running") }
+
+    override fun render(draw: Drawer) {
+        if (upKey.hasBeenPressed) {
+            count++
+        }
+        if (downKey.hasBeenPressed) {
+            count--
+        }
+
+        draw.centered.darkGrey.text("count: $count", y = 1.0)
+        draw.centered.darkGrey.text(info, 0.4, 0.0, -1.0)
+    }
+}
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/display/DisplayDemo.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/display/DisplayDemo.kt
index 7e47092f..1c822633 100644
--- a/samples/src/main/kotlin/com/mechanica/engine/samples/display/DisplayDemo.kt
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/display/DisplayDemo.kt
@@ -1,19 +1,20 @@
 package com.mechanica.engine.samples.display
 
+import com.mechanica.engine.config.configure
 import com.mechanica.engine.drawer.Drawer
 import com.mechanica.engine.game.Game
-import com.mechanica.engine.state.State
+import com.mechanica.engine.scenes.scenes.WorldScene
 
 fun main() {
     Game.configure {
         setViewport(height = 10.0)
-        setStartingState { DisplayTestState() }
+        setStartingScene { DisplayTestState() }
     }
 
     Game.run()
 }
 
-class DisplayTestState : State() {
+class DisplayTestState : WorldScene() {
     override fun update(delta: Double) { }
 
     override fun render(draw: Drawer) {
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/drawer/DrawerDemo.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/drawer/DrawerDemo.kt
index 89cf0e24..fa9c01bd 100644
--- a/samples/src/main/kotlin/com/mechanica/engine/samples/drawer/DrawerDemo.kt
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/drawer/DrawerDemo.kt
@@ -1,16 +1,17 @@
 package com.mechanica.engine.samples.drawer
 
 import com.mechanica.engine.color.hex
+import com.mechanica.engine.config.configure
+import com.mechanica.engine.debug.ScreenLog
 import com.mechanica.engine.drawer.Drawer
 import com.mechanica.engine.game.Game
-import com.mechanica.engine.utils.loadImage
-import com.mechanica.engine.input.Mouse
+import com.mechanica.engine.input.mouse.Mouse
 import com.mechanica.engine.models.PolygonModel
 import com.mechanica.engine.resources.Res
 import com.mechanica.engine.unit.angle.degrees
 import com.mechanica.engine.unit.vector.LightweightVector
 import com.mechanica.engine.unit.vector.vec
-import com.mechanica.engine.debug.ScreenLog
+import com.mechanica.engine.utils.loadImage
 
 fun main() {
     Game.configure {
@@ -20,7 +21,6 @@ fun main() {
 
     val draw = Drawer.create()
     val image = loadImage(Res.image["testImage"])
-    val stand = loadImage(Res.image["stand"])
 
     val points = arrayOf(
             vec(0, 0),
@@ -49,11 +49,10 @@ fun main() {
         draw.radius(0.2).blue.rectangle(0, -1, 2.0, 1.0)
         draw.depth(radius*2).radius(0.2).image(image, 3, 3)
         draw.radius(0.2).image(image, 3, 3)
-        draw.layout.origin(0.5, 0.5).green.text("Hello,\nworld\nHi", radius, 1, 1)
+        draw.origin.relative(0.5, 0.5).green.text("Hello,\nworld\nHi", radius, 1, 1)
         draw.transformed.scale(3, 3).translate(4, -2).cyan.polygon(polygonModel)
         draw.color.strokeColor(hex(0xD0F045FF), strokeWidth = 0.05).path(points)
         draw.cyan.ellipse(-3, -3, 2, 1)
-        draw.image(stand)
     }
 }
 
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/geometry/BezierCurve.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/geometry/BezierCurve.kt
index 93008c9d..dda0c577 100644
--- a/samples/src/main/kotlin/com/mechanica/engine/samples/geometry/BezierCurve.kt
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/geometry/BezierCurve.kt
@@ -1,23 +1,24 @@
 package com.mechanica.engine.samples.geometry
 
 import com.mechanica.engine.color.rgba
+import com.mechanica.engine.config.configure
 import com.mechanica.engine.drawer.Drawer
 import com.mechanica.engine.game.Game
-import com.mechanica.engine.input.Keyboard
-import com.mechanica.engine.input.Mouse
-import com.mechanica.engine.state.State
+import com.mechanica.engine.input.keyboard.Keyboard
+import com.mechanica.engine.input.mouse.Mouse
+import com.mechanica.engine.scenes.scenes.WorldScene
 import com.mechanica.engine.unit.vector.*
 
 fun main() {
     Game.configure {
         setViewport(height = 10.0)
-        setStartingState { BezierCurve() }
+        setStartingScene { BezierCurve() }
     }
 
     Game.run()
 }
 
-class BezierCurve : State() {
+class BezierCurve : WorldScene() {
 
     private val maxVertices = 1000
     private val minLineLength = 0.1
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/geometry/DrawingExample.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/geometry/DrawingExample.kt
index 851bfeb0..242b71ed 100644
--- a/samples/src/main/kotlin/com/mechanica/engine/samples/geometry/DrawingExample.kt
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/geometry/DrawingExample.kt
@@ -1,12 +1,13 @@
 package com.mechanica.engine.samples.geometry
 
 import com.mechanica.engine.color.rgba
+import com.mechanica.engine.config.configure
 import com.mechanica.engine.drawer.Drawer
 import com.mechanica.engine.drawer.shader.PathRenderer
 import com.mechanica.engine.game.Game
-import com.mechanica.engine.input.Keyboard
-import com.mechanica.engine.input.Mouse
-import com.mechanica.engine.state.State
+import com.mechanica.engine.input.keyboard.Keyboard
+import com.mechanica.engine.input.mouse.Mouse
+import com.mechanica.engine.scenes.scenes.WorldScene
 import com.mechanica.engine.unit.vector.Vector
 import com.mechanica.engine.unit.vector.distanceTo
 import com.mechanica.engine.unit.vector.vec
@@ -15,13 +16,13 @@ import org.joml.Matrix4f
 fun main() {
     Game.configure {
         setViewport(height = 10.0)
-        setStartingState { DrawingExample() }
+        setStartingScene { DrawingExample() }
     }
 
     Game.run()
 }
 
-class DrawingExample : State() {
+class DrawingExample : WorldScene() {
     private val renderer = PathRenderer()
 
     private val transformation = Matrix4f()
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/geometry/LinesExample.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/geometry/LinesExample.kt
index 87272d70..6d6e3a2c 100644
--- a/samples/src/main/kotlin/com/mechanica/engine/samples/geometry/LinesExample.kt
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/geometry/LinesExample.kt
@@ -2,28 +2,29 @@ package com.mechanica.engine.samples.geometry
 
 import com.mechanica.engine.color.Color
 import com.mechanica.engine.color.hex
+import com.mechanica.engine.config.configure
+import com.mechanica.engine.debug.ScreenLog
 import com.mechanica.engine.drawer.Drawer
 import com.mechanica.engine.drawer.shader.PathRenderer
 import com.mechanica.engine.game.Game
 import com.mechanica.engine.geometry.lines.LineSegment
 import com.mechanica.engine.geometry.lines.LineSegmentImpl
-import com.mechanica.engine.input.Keyboard
-import com.mechanica.engine.input.Mouse
-import com.mechanica.engine.state.State
+import com.mechanica.engine.input.keyboard.Keyboard
+import com.mechanica.engine.input.mouse.Mouse
+import com.mechanica.engine.scenes.scenes.WorldScene
 import com.mechanica.engine.unit.vector.Vector
 import com.mechanica.engine.unit.vector.vec
-import com.mechanica.engine.debug.ScreenLog
 
 fun main() {
     Game.configure {
         setViewport(height = 10.0)
-        setStartingState { LinesDemo() }
+        setStartingScene { LinesDemo() }
     }
 
     Game.run()
 }
 
-class LinesDemo : State() {
+class LinesDemo : WorldScene() {
     private val stroke = 0.05f
 
     private val renderer = PathRenderer()
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/polygon/Main.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/polygon/Main.kt
index af8937f4..01d03493 100644
--- a/samples/src/main/kotlin/com/mechanica/engine/samples/polygon/Main.kt
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/polygon/Main.kt
@@ -1,21 +1,22 @@
 package com.mechanica.engine.samples.polygon
 
 import com.mechanica.engine.color.hex
+import com.mechanica.engine.config.configure
 import com.mechanica.engine.drawer.Drawer
 import com.mechanica.engine.drawer.shader.PathRenderer
 import com.mechanica.engine.game.Game
 import com.mechanica.engine.geometry.lines.LineSegment
 import com.mechanica.engine.geometry.lines.LineSegmentImpl
-import com.mechanica.engine.input.Keyboard
-import com.mechanica.engine.input.Mouse
+import com.mechanica.engine.input.keyboard.Keyboard
+import com.mechanica.engine.input.mouse.Mouse
 import com.mechanica.engine.models.PolygonModel
-import com.mechanica.engine.state.State
+import com.mechanica.engine.scenes.scenes.WorldScene
 import com.mechanica.engine.unit.vector.vec
 
 fun main() {
     Game.configure {
         setViewport(height = 1.5)
-        setStartingState { StartMain() }
+        setStartingScene { StartMain() }
         setResolution(1500, 1500)
         configureDebugMode {
             printWarnings = true
@@ -34,7 +35,7 @@ fun main() {
     }
 }
 
-private class StartMain : State() {
+private class StartMain : WorldScene() {
     val pathRenderer = PathRenderer()
 
     val points = arrayOf(
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/polygon/PolygonRenderer.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/polygon/PolygonRenderer.kt
index 2d0ba1af..b48956e9 100644
--- a/samples/src/main/kotlin/com/mechanica/engine/samples/polygon/PolygonRenderer.kt
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/polygon/PolygonRenderer.kt
@@ -5,7 +5,7 @@ import com.mechanica.engine.color.hex
 import com.mechanica.engine.color.toColor
 import com.mechanica.engine.drawer.shader.DrawerScript
 import com.mechanica.engine.drawer.shader.DrawerShader
-import com.mechanica.engine.input.Mouse
+import com.mechanica.engine.input.mouse.Mouse
 import com.mechanica.engine.models.Model
 import org.joml.Matrix4f
 
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/renderer/Main.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/renderer/Main.kt
index a8bce753..37d50531 100644
--- a/samples/src/main/kotlin/com/mechanica/engine/samples/renderer/Main.kt
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/renderer/Main.kt
@@ -1,16 +1,17 @@
 package com.mechanica.engine.samples.renderer
 
+import com.mechanica.engine.config.configure
 import com.mechanica.engine.drawer.Drawer
 import com.mechanica.engine.game.Game
+import com.mechanica.engine.input.keyboard.Keyboard
+import com.mechanica.engine.input.mouse.Mouse
 import com.mechanica.engine.models.Image
-import com.mechanica.engine.utils.loadImage
-import com.mechanica.engine.input.Keyboard
-import com.mechanica.engine.input.Mouse
 import com.mechanica.engine.models.PolygonModel
 import com.mechanica.engine.resources.Res
-import com.mechanica.engine.state.State
+import com.mechanica.engine.scenes.scenes.WorldScene
 import com.mechanica.engine.unit.angle.degrees
 import com.mechanica.engine.unit.vector.vec
+import com.mechanica.engine.utils.loadImage
 import org.joml.Matrix4f
 import org.lwjgl.opengl.GL11.GL_STENCIL_TEST
 import org.lwjgl.opengl.GL11.glEnable
@@ -19,12 +20,12 @@ import org.lwjgl.opengl.GL11.glEnable
 fun main() {
     Game.configure {
         setViewport(height = 10.0)
-        setStartingState { StartMain() }
+        setStartingScene { StartMain() }
     }
     Game.run()
 }
 
-private class StartMain : State() {
+private class StartMain : WorldScene() {
     private val transformation = Matrix4f()
 
     val image: Image
@@ -34,6 +35,15 @@ private class StartMain : State() {
 
     init {
         transformation.scale(1f, 1f,1f)
+        println(transformation)
+        println()
+
+        transformation.rotationZ((-Math.PI/6f).toFloat())
+        transformation.m01(transformation.m10() + transformation.m01())
+
+//        transformation.rotationZ((-Math.PI/6f).toFloat())
+//        transformation.m10(transformation.m10() + transformation.m01())
+
 
         image = loadImage(Res.image["testImage"])
 
@@ -80,7 +90,8 @@ private class StartMain : State() {
 
         draw.stroke(0.1).transformed.scale(cursorFraction*3.0).blue.polygon(polygon)
         draw.centered.rotated(blend).about(0, 1).image(image, 0, 0, 1, 1)
-        draw.image(image, -0.5, -0.5, 1, 1)
+        draw.transformed(transformation).image(image, -0.5, -0.5, 1, 1)
+        draw.rotated(30.degrees).image(image, 0.5, -0.5, 1, 1)
         draw.stroke(0.1).red.circle(0, 3, 1.0)
         draw.stroke(0.1).green.line(vec(4, 3), Mouse.world)
     }
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/shaders/FragmentRenderer.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/shaders/FragmentRenderer.kt
index 4b2fdea4..82ba16ce 100644
--- a/samples/src/main/kotlin/com/mechanica/engine/samples/shaders/FragmentRenderer.kt
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/shaders/FragmentRenderer.kt
@@ -4,13 +4,13 @@ import com.mechanica.engine.drawer.shader.DrawerScript
 import com.mechanica.engine.drawer.shader.DrawerShader
 import com.mechanica.engine.game.Game
 import com.mechanica.engine.shader.qualifiers.Attribute
-import com.mechanica.engine.input.Mouse
+import com.mechanica.engine.input.mouse.Mouse
 import com.mechanica.engine.models.Model
 import org.joml.Matrix4f
 
 class FragmentRenderer {
 
-    private val vbo = Attribute(0).vec3().createUnitQuad()
+    private val vbo = Attribute.location(0).vec3().createUnitQuad()
     private val model = Model(vbo)
 
     private val vertex = object : DrawerScript() {
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/shaders/FragmentShaderDemo.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/shaders/FragmentShaderDemo.kt
index 04a551cf..ee26435e 100644
--- a/samples/src/main/kotlin/com/mechanica/engine/samples/shaders/FragmentShaderDemo.kt
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/shaders/FragmentShaderDemo.kt
@@ -1,7 +1,8 @@
 package com.mechanica.engine.samples.shaders
 
+import com.mechanica.engine.config.configure
 import com.mechanica.engine.game.Game
-import com.mechanica.engine.input.Keyboard
+import com.mechanica.engine.input.keyboard.Keyboard
 
 fun main() {
     Game.configure {
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/temp/ColorHSL.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/temp/ColorHSL.kt
new file mode 100644
index 00000000..97cbc3d6
--- /dev/null
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/temp/ColorHSL.kt
@@ -0,0 +1,20 @@
+package com.mechanica.engine.samples.temp
+
+import com.mechanica.engine.color.rgba
+import com.mechanica.engine.config.configure
+import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.game.Game
+import com.mechanica.engine.input.mouse.Mouse
+
+fun main() {
+    Game.configure {
+        setViewport(height = 10.0)
+    }
+    val draw = Drawer.create()
+
+    Game.run {
+        val color = rgba(0.5, 0.5, 0.5, 1.0)
+        draw.centered.cyan.rectangle(x = 2.5, width = 5.0, height = 5.0)
+        draw.centered.color(color).lightness(Mouse.normalized.x).saturation(Mouse.normalized.y).rectangle(width = 5.0, height = 5.0)
+    }
+}
\ No newline at end of file
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/temp/LwjglDebug.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/temp/LwjglDebug.kt
index f0e6ee77..2891eb86 100644
--- a/samples/src/main/kotlin/com/mechanica/engine/samples/temp/LwjglDebug.kt
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/temp/LwjglDebug.kt
@@ -1,18 +1,18 @@
 package com.mechanica.engine.samples.temp
 
-import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.config.configure
 import com.mechanica.engine.game.Game
-import com.mechanica.engine.shader.script.ShaderScript
-import com.mechanica.engine.shader.script.Shader
-import com.mechanica.engine.utils.loadImage
-import com.mechanica.engine.models.TextModel
 import com.mechanica.engine.resources.Res
+import com.mechanica.engine.shader.script.Shader
+import com.mechanica.engine.shader.script.ShaderScript
 import com.mechanica.engine.unit.vector.Vector
 import com.mechanica.engine.unit.vector.vec
+import com.mechanica.engine.utils.loadImage
 import com.mechanica.engine.vertices.IndexArray
 import org.intellij.lang.annotations.Language
 import org.joml.Matrix4f
-import org.lwjgl.opengl.GL11.*
+import org.lwjgl.opengl.GL11.GL_TRIANGLES
+import org.lwjgl.opengl.GL11.GL_UNSIGNED_SHORT
 import org.lwjgl.opengl.GL32.glDrawElementsBaseVertex
 
 fun main() {
@@ -65,10 +65,6 @@ fun main() {
 
     val inputs = arrayOf(pos, tc, image, indices)
 
-    val model = TextModel("")
-
-    val draw = Drawer.create()
-
     Game.run {
         shader.render(inputs) {
             glDrawElementsBaseVertex(GL_TRIANGLES, 12, GL_UNSIGNED_SHORT, 0, 0)
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/temp/PolygonTest.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/temp/PolygonTest.kt
index e07a806f..43a2115f 100644
--- a/samples/src/main/kotlin/com/mechanica/engine/samples/temp/PolygonTest.kt
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/temp/PolygonTest.kt
@@ -1,9 +1,10 @@
 package com.mechanica.engine.samples.temp
 
+import com.mechanica.engine.config.configure
 import com.mechanica.engine.game.Game
-import com.mechanica.engine.shader.script.ShaderScript
-import com.mechanica.engine.shader.script.Shader
 import com.mechanica.engine.models.PolygonModel
+import com.mechanica.engine.shader.script.Shader
+import com.mechanica.engine.shader.script.ShaderScript
 import com.mechanica.engine.unit.vector.vec
 import org.intellij.lang.annotations.Language
 
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/temp/SkewTest.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/temp/SkewTest.kt
new file mode 100644
index 00000000..0f926b8c
--- /dev/null
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/temp/SkewTest.kt
@@ -0,0 +1,30 @@
+package com.mechanica.engine.samples.temp
+
+import com.mechanica.engine.config.configure
+import com.mechanica.engine.drawer.Drawer
+import com.mechanica.engine.game.Game
+import com.mechanica.engine.input.mouse.Mouse
+import com.mechanica.engine.unit.angle.degrees
+import com.mechanica.engine.unit.angle.radians
+
+fun main() {
+    Game.configure {
+        setViewport(height = 10.0)
+    }
+
+    val draw = Drawer.create()
+
+    var skewY = Mouse.ui.theta
+    var skewX = 0.radians
+
+    Game.run {
+        if (Mouse.MB1()) {
+            skewX = Mouse.ui.theta
+        } else {
+            skewY = Mouse.ui.theta
+        }
+        draw.lightGrey.centered.rotated(10.degrees).rectangle(2, 2, width = 2.0, height = 2.0)
+        draw.darkGrey.transformed.skew(skewX, skewY).rotated(10.degrees).rectangle(2,2, 1, 1)
+
+    }
+}
\ No newline at end of file
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/temp/Test.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/temp/Test.kt
index 9bb5ddb6..d9c44e86 100644
--- a/samples/src/main/kotlin/com/mechanica/engine/samples/temp/Test.kt
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/temp/Test.kt
@@ -1,21 +1,22 @@
 package com.mechanica.engine.samples.temp
 
 import com.mechanica.engine.color.hex
+import com.mechanica.engine.config.configure
 import com.mechanica.engine.drawer.Drawer
-import com.mechanica.engine.text.Text
 import com.mechanica.engine.game.Game
+import com.mechanica.engine.input.keyboard.Keyboard
+import com.mechanica.engine.input.mouse.Mouse
 import com.mechanica.engine.models.Bindable
-import com.mechanica.engine.shader.qualifiers.Attribute
-import com.mechanica.engine.shader.script.ShaderScript
-import com.mechanica.engine.shader.script.Shader
-import com.mechanica.engine.utils.loadImage
-import com.mechanica.engine.input.Keyboard
-import com.mechanica.engine.input.Mouse
 import com.mechanica.engine.models.TextModel
 import com.mechanica.engine.resources.Res
+import com.mechanica.engine.shader.qualifiers.Attribute
+import com.mechanica.engine.shader.script.Shader
+import com.mechanica.engine.shader.script.ShaderScript
+import com.mechanica.engine.text.Text
 import com.mechanica.engine.unit.angle.degrees
 import com.mechanica.engine.unit.vector.Vector
 import com.mechanica.engine.unit.vector.vec
+import com.mechanica.engine.utils.loadImage
 import com.mechanica.engine.vertices.IndexArray
 import org.intellij.lang.annotations.Language
 import org.joml.Matrix4f
@@ -27,7 +28,7 @@ fun main() {
         setMultisampling(0)
     }
 
-    Attribute(0).vec3().createBuffer(emptyArray<Vector>())
+    Attribute.location(0).vec3().createBuffer(emptyArray<Vector>())
     val vertex = object : ShaderScript() {
 
         val position = attribute(0).vec4()
@@ -77,7 +78,7 @@ fun main() {
             vec(0.85, 0.95)
     )
 
-    val square = Attribute(0).vec2().createBuffer(squareArray)
+    val square = Attribute.location(0).vec2().createBuffer(squareArray)
 
     val colorArray = arrayOf(
             hex(0xFF00FFFF),
@@ -115,7 +116,7 @@ fun main() {
         draw.image(image, -1, 0)
         shader.render(textModel)
         if (Keyboard.enter.hasBeenPressed) {
-            textModel.text = "Enter Pressed"
+            textModel.string = "Enter Pressed"
         }
         draw.text(text)
     }
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/temp/TextTest.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/temp/TextTest.kt
index 656cd1cc..a6a554c7 100644
--- a/samples/src/main/kotlin/com/mechanica/engine/samples/temp/TextTest.kt
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/temp/TextTest.kt
@@ -1,9 +1,10 @@
 package com.mechanica.engine.samples.temp
 
+import com.mechanica.engine.config.configure
 import com.mechanica.engine.game.Game
 import com.mechanica.engine.models.TextModel
-import com.mechanica.engine.shader.script.ShaderScript
 import com.mechanica.engine.shader.script.Shader
+import com.mechanica.engine.shader.script.ShaderScript
 import org.intellij.lang.annotations.Language
 
 fun main() {
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/text/FontRenderer.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/text/FontRenderer.kt
index f1582b98..77f0571e 100644
--- a/samples/src/main/kotlin/com/mechanica/engine/samples/text/FontRenderer.kt
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/text/FontRenderer.kt
@@ -13,6 +13,7 @@ import com.mechanica.engine.unit.vector.Vector
 import com.mechanica.engine.unit.vector.vec
 import com.mechanica.engine.util.extensions.constrain
 import com.mechanica.engine.debug.ScreenLog
+import com.mechanica.engine.input.mouse.Mouse
 import org.joml.Matrix4f
 import kotlin.math.ceil
 import kotlin.math.max
@@ -41,6 +42,7 @@ class FontRenderer {
 
     private val fragment = object : DrawerScript() {
 
+        val mouse = uniform.float()
         //language=GLSL
         override val main: String = """
                 sample in vec2 tc;
@@ -49,7 +51,23 @@ class FontRenderer {
                                 
                 void main(void) {
                     vec4 texColor = texture(samp, tc);
-                    out_Color = vec4($color.rgb, texColor.a*$color.a);
+                    float alpha = texColor.a;
+                    float thickness = 0.52;
+                    vec3 neon = vec3(1.0, 0.43, 0.78);
+                    
+                    vec4 inside = vec4(mix(neon, vec3(1.0), 0.95), 1.0);
+                    vec4 outside = vec4(mix(vec3(1.0, 0.43, 0.78), vec3(1.0), alpha*thickness), texColor.a/0.55 - 0.5);
+                    float border = 0.03;
+                    if (alpha < 1.0 && alpha > thickness) {
+                        out_Color = inside;
+                    } else if (alpha < thickness && alpha > thickness-border) {
+                        float blend = (alpha - thickness + border)/border;
+                        out_Color = mix(outside, inside, blend);
+                    } else {
+                        float blend = texColor.a*thickness;
+                        out_Color = outside;
+                    }
+//                    out_Color = vec4($color.rgb, alpha*$color.a);
                 }
             """
 
@@ -59,20 +77,19 @@ class FontRenderer {
 
     var text: String = ""
         set(value) {
-            model.text = value
+            model.string = value
             field = value
         }
 
-    private val fontMap = HashMap<Font, TextModel>()
-
-    var font: Font = Font.create(Res.font["Roboto-Regular.ttf"]).also { fontMap[it] = TextModel(text, it) }
-        set(value) {
-            fontMap[value] = TextModel(text, value)
-            field = value
+    private val font: Font = Font.create(Res.font["Roboto-Regular.ttf"]) {
+        characterSize = 100f
+        configureSDF {
+            start = -20.0
+            end = 20.0
         }
+    }
 
-    val model: TextModel
-        get() = fontMap[font] ?: TextModel(text, font).also { fontMap[font] = it }
+    val model: TextModel = TextModel(text, font)
 
     private val characterOutput = CharacterOutputImpl()
 
@@ -90,6 +107,7 @@ class FontRenderer {
         }
 
     fun render(transformation: Matrix4f ) {
+        fragment.mouse.value = (Mouse.world.x/Game.view.width).toFloat() + 0.5f
         if (transformation == this.transformation) {
             transformation.translate(position.x.toFloat(), position.y.toFloat(), 0f)
             transformation.scale(fontSize.toFloat(), fontSize.toFloat(), 1f)
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/text/SDFTest.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/text/SDFTest.kt
new file mode 100644
index 00000000..b8c8f827
--- /dev/null
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/text/SDFTest.kt
@@ -0,0 +1,7 @@
+package com.mechanica.engine.samples.text
+
+import com.mechanica.engine.text.LwjglStandardFont
+
+fun main() {
+
+}
\ No newline at end of file
diff --git a/samples/src/main/kotlin/com/mechanica/engine/samples/text/TextEditor.kt b/samples/src/main/kotlin/com/mechanica/engine/samples/text/TextEditor.kt
index 033afe05..724145be 100644
--- a/samples/src/main/kotlin/com/mechanica/engine/samples/text/TextEditor.kt
+++ b/samples/src/main/kotlin/com/mechanica/engine/samples/text/TextEditor.kt
@@ -1,14 +1,13 @@
 package com.mechanica.engine.samples.text
 
-import com.mechanica.engine.color.hex
+import com.mechanica.engine.config.configure
 import com.mechanica.engine.drawer.Drawer
 import com.mechanica.engine.game.Game
-import com.mechanica.engine.input.Keyboard
-import com.mechanica.engine.input.Mouse
-import com.mechanica.engine.models.Model
-import com.mechanica.engine.state.State
+import com.mechanica.engine.input.TextInput
+import com.mechanica.engine.input.keyboard.Keyboard
+import com.mechanica.engine.input.mouse.Mouse
+import com.mechanica.engine.scenes.scenes.WorldScene
 import com.mechanica.engine.unit.vector.vec
-import com.mechanica.engine.util.extensions.constrain
 import org.joml.Matrix4f
 import kotlin.math.max
 import kotlin.math.min
@@ -16,26 +15,28 @@ import kotlin.math.min
 fun main() {
     Game.configure {
         setViewport(height = 10.0)
-        setStartingState { StartText() }
+        setStartingScene { StartText() }
         configureDebugMode {
             constructionDraws = true
         }
     }
+//    val font = LwjglSDFFont(Res.font["freebooterscript.ttf"])
 
     Game.run()
 }
 
 
-private class StartText : State() {
+private class StartText : WorldScene() {
     val renderer = FontRenderer()
 
-    val model = Model()
     val transformation = Matrix4f()
 
     val startPosition = vec(-Game.view.width.toFloat()/2f, Game.view.height.toFloat()/2f - renderer.fontSize)
 
     var cursor = 0
 
+    private val sb = StringBuilder()
+
     init {
         renderer.text = ""
 
@@ -45,20 +46,17 @@ private class StartText : State() {
 
     override fun update(delta: Double) {
         fun setViewPosition() {
-            Game.view.x = startPosition.x + Game.view.width/2.0
-            Game.view.y = startPosition.y + 1.0 - Game.view.height/2.0
-        }
-        if (Mouse.scrollDown.hasBeenPressed) {
-            Game.view.height *= 1.0 + Mouse.scrollDown.distance/10.0
-            setViewPosition()
+            view.x = startPosition.x + Game.view.width/2.0
+            view.y = startPosition.y + 1.0 - Game.view.height/2.0
         }
-        if (Mouse.scrollUp.hasBeenPressed) {
-            Game.view.height /= 1.0 + Mouse.scrollUp.distance/10.0
+
+        if (Mouse.scroll.hasBeenPressed) {
+            view.height /= 1.0 + Mouse.scroll.distance/10.0
             setViewPosition()
         }
 
-        if (Keyboard.textInput.hasBeenInput.isNotEmpty()) {
-            addLetter(cursor, Keyboard.textInput.inputText)
+        if (TextInput.hasTextInput) {
+            addLetterFromKeyboard()
         }
 
         if (Keyboard.backspace.hasBeenPressed) {
@@ -67,11 +65,13 @@ private class StartText : State() {
                 cursor--
             }
         }
+
         if (Keyboard.delete.hasBeenPressed) {
-            removeLetter(cursor+1)
+            removeLetter(cursor + 1)
         }
         if (Keyboard.enter.hasBeenPressed) {
-            addLetter(cursor, "\n")
+            addLetter('\n', cursor)
+            cursor++
         }
 
         if (Keyboard.left.hasBeenPressed) {
@@ -96,40 +96,31 @@ private class StartText : State() {
     }
 
     override fun render(draw: Drawer) {
-        draw.color(hex(0xC0C0C0FF)).background()
+        draw.black.background()
 
         val pos = renderer.from(cursor).getPosition()
         draw.blue.rectangle(pos.x, pos.y - 0.1*renderer.fontSize, 0.05, 0.75*renderer.fontSize)
         renderer.render(transformation)
     }
 
-    fun addLetter(index: Int, str: String) {
-        val fullText = renderer.text
-        val safeIndex = index.constrain(0, fullText.length)
-
-        val before = if (index <= 0) ""
-            else fullText.substring(0 until safeIndex)
-
-        val after = if (index >= fullText.length) ""
-                    else fullText.substring(safeIndex until fullText.length)
+    fun updateText() {
+        renderer.text = sb.toString()
+    }
 
-        renderer.text = before + str + after
-        cursor++
+    fun addLetterFromKeyboard() {
+        val changed = TextInput.getCodepoints(sb, cursor)
+        cursor += changed
+        updateText()
+    }
 
+    fun addLetter(char: Char, index: Int) {
+        sb.insert(index, char)
+        updateText()
     }
 
     fun removeLetter(index: Int) {
-        val fullText = renderer.text
-        val safeIndex = index.constrain(0, fullText.length)
-
-        val before = if (index <= 0) ""
-        else fullText.substring(0 until max(0,safeIndex-1))
-
-        val after = if (index >= fullText.length) ""
-        else fullText.substring(safeIndex until fullText.length)
-
-        renderer.text = before + after
+        sb.delete(index-1, index)
+        updateText()
     }
-
 }
 
diff --git a/samples/src/main/resources/res/audio/radar3.ogg b/samples/src/main/resources/res/audio/radar3.ogg
new file mode 100644
index 00000000..6d2766c3
Binary files /dev/null and b/samples/src/main/resources/res/audio/radar3.ogg differ
diff --git a/samples/src/main/resources/res/audio/switch3.ogg b/samples/src/main/resources/res/audio/switch3.ogg
new file mode 100644
index 00000000..6effb43a
Binary files /dev/null and b/samples/src/main/resources/res/audio/switch3.ogg differ
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 240d1bff..253cb405 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -9,4 +9,6 @@
 
 rootProject.name = "Mechanica"
 
-include("common", "desktop-application", "application-interface", "mechanica", "samples")
+includeBuild("E:/Src/General/DukeUI")
+
+include("common", "desktop-application", "application-interface", "mechanica", "samples", "mechanica-ui")