diff --git a/build.gradle.kts b/build.gradle.kts
index 1920f5a6..d6b422a0 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -25,6 +25,10 @@ val shadowImpl: Configuration by configurations.creating {
   configurations.implementation.get().extendsFrom(this)
 }
 
+loom {
+  accessWidenerPath = rootProject.file("src/main/resources/cobalt.accesswidener")
+}
+
 dependencies {
   minecraft(libs.minecraft)
   implementation(libs.bundles.fabric)
diff --git a/config/detekt/detekt.yml b/config/detekt/detekt.yml
index 6e566264..bea0121d 100644
--- a/config/detekt/detekt.yml
+++ b/config/detekt/detekt.yml
@@ -57,7 +57,7 @@ complexity:
 
   CyclomaticComplexMethod:
     active: true
-    allowedComplexity: 6
+    allowedComplexity: 10
 
   NestedBlockDepth:
     active: true
diff --git a/src/main/java/org/cobalt/mixin/client/AbstractClientPlayerAccessor.java b/src/main/java/org/cobalt/mixin/client/AbstractClientPlayerAccessor.java
deleted file mode 100644
index bcafb250..00000000
--- a/src/main/java/org/cobalt/mixin/client/AbstractClientPlayerAccessor.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package org.cobalt.mixin.client;
-
-import net.minecraft.client.multiplayer.PlayerInfo;
-import net.minecraft.client.player.AbstractClientPlayer;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Accessor;
-
-@Mixin(AbstractClientPlayer.class)
-public interface AbstractClientPlayerAccessor {
-
-  @Accessor("playerInfo")
-  PlayerInfo getClientPlayerInfo();
-
-}
diff --git a/src/main/java/org/cobalt/mixin/client/MinecraftAccessor.java b/src/main/java/org/cobalt/mixin/client/MinecraftAccessor.java
deleted file mode 100644
index 65b3600b..00000000
--- a/src/main/java/org/cobalt/mixin/client/MinecraftAccessor.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package org.cobalt.mixin.client;
-
-import net.minecraft.client.Minecraft;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Invoker;
-
-@Mixin(Minecraft.class)
-public interface MinecraftAccessor {
-
-  @Invoker("startAttack")
-  boolean leftClick();
-
-  @Invoker("startUseItem")
-  void rightClick();
-
-}
diff --git a/src/main/java/org/cobalt/mixin/client/MouseHandlerMixin.java b/src/main/java/org/cobalt/mixin/client/MouseHandlerMixin.java
index b7109a0a..25309c64 100644
--- a/src/main/java/org/cobalt/mixin/client/MouseHandlerMixin.java
+++ b/src/main/java/org/cobalt/mixin/client/MouseHandlerMixin.java
@@ -4,6 +4,7 @@
 import net.minecraft.client.input.MouseButtonInfo;
 import org.cobalt.event.EventBus;
 import org.cobalt.event.impl.MouseEvent;
+import org.cobalt.util.MouseMode;
 import org.cobalt.util.MouseUtils;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -65,14 +66,14 @@ private void onMouseButton(long handle, MouseButtonInfo rawButtonInfo, int actio
 
   @Inject(method = "turnPlayer", at = @At("HEAD"), cancellable = true)
   private void onUpdateMouse(CallbackInfo callbackInfo) {
-    if (MouseUtils.shouldBlockRotation()) {
+    if (MouseUtils.getMouseMode() == MouseMode.LOCK_MOUSE) {
       callbackInfo.cancel();
     }
   }
 
   @Inject(method = "isMouseGrabbed", at = @At("HEAD"), cancellable = true)
   private void onIsCursorLocked(CallbackInfoReturnable<Boolean> callbackInfoReturnable) {
-    if (MouseUtils.isForceUngrabbed()) {
+    if (MouseUtils.getMouseMode() == MouseMode.UNGRAB_MOUSE) {
       if (this.mouseGrabbed) {
         this.releaseMouse();
       }
@@ -83,7 +84,7 @@ private void onIsCursorLocked(CallbackInfoReturnable<Boolean> callbackInfoReturn
 
   @Inject(method = "grabMouse", at = @At("HEAD"), cancellable = true)
   private void onLockCursor(CallbackInfo callbackInfo) {
-    if (MouseUtils.isForceUngrabbed()) {
+    if (MouseUtils.getMouseMode() == MouseMode.UNGRAB_MOUSE) {
       callbackInfo.cancel();
     }
   }
diff --git a/src/main/java/org/cobalt/mixin/gui/SplashManagerMixin.java b/src/main/java/org/cobalt/mixin/gui/SplashManagerMixin.java
new file mode 100644
index 00000000..bf064586
--- /dev/null
+++ b/src/main/java/org/cobalt/mixin/gui/SplashManagerMixin.java
@@ -0,0 +1,41 @@
+package org.cobalt.mixin.gui;
+
+import net.minecraft.client.gui.components.SplashRenderer;
+import net.minecraft.client.resources.SplashManager;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.Style;
+import net.minecraft.network.chat.TextColor;
+import org.cobalt.Cobalt;
+import org.cobalt.ui.theme.ThemeManager;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.ModifyArgs;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import org.spongepowered.asm.mixin.injection.invoke.arg.Args;
+
+@Mixin(SplashManager.class)
+public class SplashManagerMixin {
+
+  @Inject(
+    method = "getSplash",
+    at = @At("HEAD"),
+    cancellable = true
+  )
+  private void modifySplash(CallbackInfoReturnable<SplashRenderer> cir) {
+    Component splash = cobalt$createSplash();
+    SplashRenderer splashRenderer = new SplashRenderer(splash);
+
+    cir.setReturnValue(splashRenderer);
+  }
+
+  @Unique
+  private Component cobalt$createSplash() {
+    int color = ThemeManager.getActiveTheme().getAccentPrimary();
+
+    return Component.literal(Cobalt.MOD_NAME + " on top!")
+      .setStyle(Style.EMPTY.withColor(TextColor.fromRgb(color)));
+  }
+
+}
diff --git a/src/main/java/org/cobalt/mixin/gui/SplashRendererMixin.java b/src/main/java/org/cobalt/mixin/gui/SplashRendererMixin.java
deleted file mode 100644
index 210ffec8..00000000
--- a/src/main/java/org/cobalt/mixin/gui/SplashRendererMixin.java
+++ /dev/null
@@ -1,34 +0,0 @@
-package org.cobalt.mixin.gui;
-
-import net.minecraft.client.gui.components.SplashRenderer;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.Style;
-import net.minecraft.network.chat.TextColor;
-import org.cobalt.Cobalt;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Unique;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.ModifyArgs;
-import org.spongepowered.asm.mixin.injection.invoke.arg.Args;
-
-@Mixin(SplashRenderer.class)
-public class SplashRendererMixin {
-
-  @Final
-  @Unique
-  public Component cobalt$splash = Component.literal(Cobalt.MOD_NAME + " on top!")
-    .setStyle(Style.EMPTY.withColor(TextColor.fromRgb(0x4F8CFF)));
-
-  @ModifyArgs(
-    method = "extractRenderState",
-    at = @At(
-      value = "INVOKE",
-      target = "Lnet/minecraft/client/gui/ActiveTextCollector;accept(Lnet/minecraft/client/gui/TextAlignment;IILnet/minecraft/client/gui/ActiveTextCollector$Parameters;Lnet/minecraft/network/chat/Component;)V"
-    )
-  )
-  private void modifySplash(Args args) {
-    args.set(4, cobalt$splash);
-  }
-
-}
diff --git a/src/main/java/org/cobalt/mixin/render/FrustumInvoker.java b/src/main/java/org/cobalt/mixin/render/FrustumInvoker.java
deleted file mode 100644
index 1b74d5d2..00000000
--- a/src/main/java/org/cobalt/mixin/render/FrustumInvoker.java
+++ /dev/null
@@ -1,13 +0,0 @@
-package org.cobalt.mixin.render;
-
-import net.minecraft.client.renderer.culling.Frustum;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Invoker;
-
-@Mixin(Frustum.class)
-public interface FrustumInvoker {
-
-  @Invoker
-  int invokeCubeInFrustum(double minX, double minY, double minZ, double maxX, double maxY, double maxZ);
-
-}
diff --git a/src/main/kotlin/org/cobalt/Cobalt.kt b/src/main/kotlin/org/cobalt/Cobalt.kt
index 62ac8e66..951554f3 100644
--- a/src/main/kotlin/org/cobalt/Cobalt.kt
+++ b/src/main/kotlin/org/cobalt/Cobalt.kt
@@ -11,6 +11,7 @@ import org.cobalt.command.impl.MainCommand
 import org.cobalt.event.EventBus
 import org.cobalt.event.impl.WorldRenderEvent
 import org.cobalt.module.ModuleManager
+import org.cobalt.script.ScriptManager
 import org.slf4j.LoggerFactory
 
 object Cobalt : ClientModInitializer {
@@ -33,6 +34,7 @@ object Cobalt : ClientModInitializer {
   override fun onInitializeClient() {
     logger.info("Initializing $MOD_NAME ${SharedConstants.getCurrentVersion().name()} (v$MOD_VERSION)")
 
+    ScriptManager.registerScripts()
     ModuleManager.registerModules()
     CommandManager.register(MainCommand)
 
diff --git a/src/main/kotlin/org/cobalt/command/CommandManager.kt b/src/main/kotlin/org/cobalt/command/CommandManager.kt
index bd4bffa7..3f3f0e9a 100644
--- a/src/main/kotlin/org/cobalt/command/CommandManager.kt
+++ b/src/main/kotlin/org/cobalt/command/CommandManager.kt
@@ -43,6 +43,7 @@ object CommandManager {
 
     try {
       dispatcher.execute(commandLine, player.connection.suggestionsProvider)
+      minecraft.commandHistory().addCommand(content)
     } catch (exception: CommandSyntaxException) {
       ChatUtils.sendSystemMessage("${ChatFormatting.RED}${exception.message}")
     }
diff --git a/src/main/kotlin/org/cobalt/command/impl/MainCommand.kt b/src/main/kotlin/org/cobalt/command/impl/MainCommand.kt
index a9f91c3c..9be876ff 100644
--- a/src/main/kotlin/org/cobalt/command/impl/MainCommand.kt
+++ b/src/main/kotlin/org/cobalt/command/impl/MainCommand.kt
@@ -1,11 +1,14 @@
 package org.cobalt.command.impl
 
+import kotlin.time.Duration.Companion.seconds
 import org.cobalt.Cobalt.minecraft
 import org.cobalt.command.Command
 import org.cobalt.command.annotation.DefaultHandler
 import org.cobalt.command.annotation.SubCommand
+import org.cobalt.ui.notification.NotificationManager
 import org.cobalt.ui.screen.ConfigScreen
 import org.cobalt.ui.screen.HudEditorScreen
+import org.cobalt.util.MouseUtils
 import org.cobalt.util.helper.TickScheduler
 
 internal object MainCommand : Command(name = "cobalt", aliases = listOf("cb")) {
@@ -26,4 +29,9 @@ internal object MainCommand : Command(name = "cobalt", aliases = listOf("cb")) {
     }
   }
 
+  @SubCommand
+  fun notification(title: String, description: String, duration: Int) {
+    NotificationManager.queue(title, description, duration.seconds)
+  }
+
 }
diff --git a/src/main/kotlin/org/cobalt/dsl/Utils.kt b/src/main/kotlin/org/cobalt/dsl/Utils.kt
index e2d5555e..89f92a6e 100644
--- a/src/main/kotlin/org/cobalt/dsl/Utils.kt
+++ b/src/main/kotlin/org/cobalt/dsl/Utils.kt
@@ -1,7 +1,5 @@
 package org.cobalt.dsl
 
-import org.cobalt.Cobalt.minecraft
-
 inline val Int.red
   get() = this shr 16 and 0xFF
 
@@ -13,9 +11,3 @@ inline val Int.blue
 
 inline val Int.alpha
   get() = this shr 24 and 0xFF
-
-inline val mouseX: Float
-  get() = minecraft.mouseHandler.xpos().toFloat()
-
-inline val mouseY: Float
-  get() = minecraft.mouseHandler.ypos().toFloat()
diff --git a/src/main/kotlin/org/cobalt/event/impl/SkiaDrawEvent.kt b/src/main/kotlin/org/cobalt/event/impl/SkiaDrawEvent.kt
index 02c6e4e2..6fd1af0d 100644
--- a/src/main/kotlin/org/cobalt/event/impl/SkiaDrawEvent.kt
+++ b/src/main/kotlin/org/cobalt/event/impl/SkiaDrawEvent.kt
@@ -1,12 +1,12 @@
 package org.cobalt.event.impl
 
+import io.github.humbleui.skija.BackendRenderTarget
 import io.github.humbleui.skija.Canvas
 import io.github.humbleui.skija.DirectContext
 import org.cobalt.event.Event
-import org.cobalt.util.skia.WrappedBackendRenderTarget
 
 class SkiaDrawEvent(
   val context: DirectContext,
-  val renderTarget: WrappedBackendRenderTarget,
+  val renderTarget: BackendRenderTarget,
   val canvas: Canvas,
 ) : Event()
diff --git a/src/main/kotlin/org/cobalt/module/Module.kt b/src/main/kotlin/org/cobalt/module/Module.kt
index 1036c52c..f9f90703 100644
--- a/src/main/kotlin/org/cobalt/module/Module.kt
+++ b/src/main/kotlin/org/cobalt/module/Module.kt
@@ -1,86 +1,96 @@
 package org.cobalt.module
 
-import net.minecraft.ChatFormatting
-import org.cobalt.util.ChatUtils
+import org.cobalt.ui.theme.Theme
+import org.cobalt.ui.theme.ThemeManager
+import org.cobalt.util.Dimensions
+import org.cobalt.util.Vec2f
+import org.cobalt.util.WindowUtils.windowHeight
+import org.cobalt.util.WindowUtils.windowWidth
 
 abstract class Module(
   val name: String,
   val category: ModuleCategory,
 ) {
 
-  private var enabled: Boolean = false
+  var enabled: Boolean = false
 
   open fun onRegistration() {}
 
-  fun setEnabled(enabled: Boolean) {
-    this.enabled = enabled
-  }
-
-  fun isEnabled(): Boolean = enabled
-
 }
 
-abstract class Script(
+abstract class RenderableModule(
   name: String,
   category: ModuleCategory,
+  var anchor: Anchor = Anchor.TOP_LEFT,
+  var offsetX: Float = 5.0f,
+  var offsetY: Float = 5.0f,
+  var scale: Float = 1.0f,
 ) : Module(name, category) {
 
-  private var running: Boolean = false
-
-  abstract fun onEnable()
-  abstract fun onDisable()
-
-  fun startScript() {
-    onEnable()
-    ChatUtils.sendSystemMessage("$name ${ChatFormatting.GREEN}Started")
-    running = true
-  }
-
-  fun stopScript() {
-    onDisable()
-    ChatUtils.sendSystemMessage("$name ${ChatFormatting.RED}Stopped")
-    running = false
-  }
-
-  fun toggleScript() {
-    if (running) {
-      stopScript()
-    } else {
-      startScript()
+  val theme: Theme
+    get() = ThemeManager.getActiveTheme()
+
+  val screenPosition: Vec2f
+    get() = anchor.computePosition(
+      offsetX,
+      offsetY,
+      getWidth() * scale,
+      getHeight() * scale,
+      windowWidth,
+      windowHeight
+    )
+
+  val dimensions: Dimensions
+    get() = Dimensions(getWidth(), getHeight())
+
+  val xPos: Float
+    get() = screenPosition.x
+
+  val yPos: Float
+    get() = screenPosition.y
+
+  abstract fun getWidth(): Float
+  abstract fun getHeight(): Float
+  abstract fun renderComponent()
+
+  enum class Anchor {
+
+    TOP_LEFT,
+    TOP_CENTER,
+    TOP_RIGHT,
+    CENTER_LEFT,
+    CENTER,
+    CENTER_RIGHT,
+    BOTTOM_LEFT,
+    BOTTOM_CENTER,
+    BOTTOM_RIGHT;
+
+    fun computePosition(
+      offsetX: Float,
+      offsetY: Float,
+      moduleWidth: Float,
+      moduleHeight: Float,
+      screenWidth: Float,
+      screenHeight: Float,
+    ): Vec2f {
+      val x = when (this) {
+        TOP_LEFT, CENTER_LEFT, BOTTOM_LEFT -> offsetX
+        TOP_CENTER, CENTER, BOTTOM_CENTER -> screenWidth / 2f - moduleWidth / 2f + offsetX
+        TOP_RIGHT, CENTER_RIGHT, BOTTOM_RIGHT -> screenWidth - moduleWidth - offsetX
+      }
+
+      val y = when (this) {
+        TOP_LEFT, TOP_CENTER, TOP_RIGHT -> offsetY
+        CENTER_LEFT, CENTER, CENTER_RIGHT -> screenHeight / 2f - moduleHeight / 2f + offsetY
+        BOTTOM_LEFT, BOTTOM_CENTER, BOTTOM_RIGHT -> screenHeight - moduleHeight - offsetY
+      }
+
+      return Vec2f(
+        x.coerceIn(0f, (screenWidth - moduleWidth).coerceAtLeast(0f)),
+        y.coerceIn(0f, (screenHeight - moduleHeight).coerceAtLeast(0f))
+      )
     }
-  }
-
-  fun isRunning(): Boolean = running
 
-}
-
-interface Renderable {
-
-  val renderProps: RenderProperties
-
-  var xPos: Float
-    get() = renderProps.xPos;
-    set(value) { renderProps.xPos = value }
-
-  var yPos: Float
-    get() = renderProps.yPos;
-    set(value) { renderProps.yPos = value }
-
-  var scale: Float
-    get() = renderProps.scale;
-    set(value) { renderProps.scale = value }
-
-  fun getWidth(): Float
-  fun getHeight(): Float
-  fun renderComponent()
+  }
 
 }
-
-private const val DEFAULT_OFFSET = 5.0f
-private const val DEFAULT_SCALE = 1.0f
-
-data class RenderProperties(
-  var xPos: Float = DEFAULT_OFFSET,
-  var yPos: Float = DEFAULT_OFFSET,
-  var scale: Float = DEFAULT_SCALE,
-)
diff --git a/src/main/kotlin/org/cobalt/module/ModuleManager.kt b/src/main/kotlin/org/cobalt/module/ModuleManager.kt
index 9ad2536d..31f38b9f 100644
--- a/src/main/kotlin/org/cobalt/module/ModuleManager.kt
+++ b/src/main/kotlin/org/cobalt/module/ModuleManager.kt
@@ -5,13 +5,13 @@ import org.cobalt.event.EventBus
 import org.cobalt.event.annotation.SubscribeEvent
 import org.cobalt.event.impl.SkiaDrawEvent
 import org.cobalt.module.impl.render.PerformanceHUD
+import org.cobalt.ui.screen.HudEditorScreen
 import org.cobalt.util.Vec2f
-import org.cobalt.util.WindowUtils
 import org.cobalt.util.skia.SkiaTransforms
 
 object ModuleManager {
 
-  private val modules = mutableSetOf<Module>()
+  val modules = mutableSetOf<Module>()
 
   init {
     EventBus.register(this)
@@ -45,39 +45,33 @@ object ModuleManager {
     }
   }
 
-  fun getModules(): Set<Module> {
-    return modules
-  }
-
   @SubscribeEvent
   fun drawRenderableModules(@Suppress("UnusedParameter") event: SkiaDrawEvent) {
-    if (
-      minecraft.level == null ||
-      minecraft.player == null ||
-      minecraft.options.hideGui ||
-      minecraft.debugOverlay.showDebugScreen()
-    ) {
+    if (minecraft.level == null || minecraft.player == null) {
+      return
+    }
+
+    if (minecraft.options.hideGui || minecraft.debugOverlay.showDebugScreen()) {
       return
     }
 
-    val windowScale = WindowUtils.getWindowScale()
+    if (minecraft.screen is HudEditorScreen) {
+      return
+    }
 
-    modules
-      .filter { module -> module.isEnabled() && module is Renderable }
+    modules.filterIsInstance<RenderableModule>()
+      .filter { module -> module.enabled }
       .forEach { module ->
-        val renderable = module as Renderable
-
         SkiaTransforms.save()
 
-        val originX = renderable.xPos
-        val originY = renderable.yPos
-        val moduleScale = renderable.scale * windowScale
+        val (x, y) = module.screenPosition
+        val scale = module.scale
 
-        SkiaTransforms.translate(Vec2f(originX, originY))
-        SkiaTransforms.scale(Vec2f(moduleScale, moduleScale))
-        SkiaTransforms.translate(Vec2f(-originX, -originY))
+        SkiaTransforms.translate(Vec2f(x, y))
+        SkiaTransforms.scale(Vec2f(scale, scale))
+        SkiaTransforms.translate(Vec2f(-x, -y))
 
-        renderable.renderComponent()
+        module.renderComponent()
 
         SkiaTransforms.restore()
       }
diff --git a/src/main/kotlin/org/cobalt/module/impl/render/PerformanceHUD.kt b/src/main/kotlin/org/cobalt/module/impl/render/PerformanceHUD.kt
index 744888b4..d05e6b17 100644
--- a/src/main/kotlin/org/cobalt/module/impl/render/PerformanceHUD.kt
+++ b/src/main/kotlin/org/cobalt/module/impl/render/PerformanceHUD.kt
@@ -2,11 +2,8 @@ package org.cobalt.module.impl.render
 
 import kotlin.math.roundToInt
 import org.cobalt.Cobalt.minecraft
-import org.cobalt.module.Module
 import org.cobalt.module.ModuleCategory
-import org.cobalt.module.RenderProperties
-import org.cobalt.module.Renderable
-import org.cobalt.ui.ColorPalette
+import org.cobalt.module.RenderableModule
 import org.cobalt.util.Dimensions
 import org.cobalt.util.ServerUtils
 import org.cobalt.util.Vec2f
@@ -14,22 +11,10 @@ import org.cobalt.util.skia.SkiaShapes
 import org.cobalt.util.skia.SkiaText
 import org.cobalt.util.skia.TextStyle
 
-internal object PerformanceHUD : Module(
+internal object PerformanceHUD : RenderableModule(
   name = "Performance HUD",
   category = ModuleCategory.RENDER,
-), Renderable {
-
-  override var renderProps = RenderProperties()
-
-  private const val PADDING = 25f
-  private const val CORNER_RADIUS = 5f
-  private const val OUTLINE_THICKNESS = 2f
-  private const val FONT_SIZE = 16f
-  private const val TEXT_SPACING = 5f
-  private const val DIVIDER_HALF_HEIGHT = 10f
-  private const val PANEL_HEIGHT = 50f
-  private const val MID_FACTOR = 0.5f
-  private const val DIVIDER_GAP = PADDING / 2 + TEXT_SPACING
+) {
 
   override fun getWidth(): Float {
     var width = PADDING * 2
@@ -59,13 +44,11 @@ internal object PerformanceHUD : Module(
   }
 
   private fun drawBackground(width: Float, height: Float) {
-    SkiaShapes.drawRoundedRect(Vec2f(xPos, yPos), Dimensions(width, height), CORNER_RADIUS, ColorPalette.PANEL)
-    SkiaShapes.drawRoundedOutline(
+    SkiaShapes.drawRoundedRect(
       Vec2f(xPos, yPos),
       Dimensions(width, height),
       CORNER_RADIUS,
-      ColorPalette.BORDER,
-      OUTLINE_THICKNESS
+      theme.backgroundPrimary
     )
   }
 
@@ -86,16 +69,17 @@ internal object PerformanceHUD : Module(
 
   private fun drawDivider(startX: Float, height: Float): Float {
     var x = startX + DIVIDER_GAP
-
     val midY = yPos + height * MID_FACTOR
+
     SkiaShapes.drawLine(
       Vec2f(x, midY - DIVIDER_HALF_HEIGHT),
       Vec2f(x, midY + DIVIDER_HALF_HEIGHT),
-      ColorPalette.BORDER,
+      theme.border,
       OUTLINE_THICKNESS
     )
 
     x += DIVIDER_GAP
+
     return x
   }
 
@@ -106,7 +90,7 @@ internal object PerformanceHUD : Module(
       SkiaText.primaryFont,
       stat.value,
       Vec2f(x, textY),
-      TextStyle(FONT_SIZE, ColorPalette.TEXT_PRIMARY)
+      TextStyle(FONT_SIZE, theme.textPrimary)
     )
 
     x += SkiaText.getTextWidth(SkiaText.primaryFont, stat.value, FONT_SIZE) + TEXT_SPACING
@@ -115,7 +99,7 @@ internal object PerformanceHUD : Module(
       SkiaText.primaryFont,
       stat.unit,
       Vec2f(x, textY),
-      TextStyle(FONT_SIZE, ColorPalette.TEXT_DISABLED)
+      TextStyle(FONT_SIZE, theme.textDisabled)
     )
 
     x += SkiaText.getTextWidth(SkiaText.primaryFont, stat.unit, FONT_SIZE)
@@ -133,6 +117,16 @@ internal object PerformanceHUD : Module(
   private fun getTPS(): String = ServerUtils.averageTps.roundToInt().toString()
   private fun getPing(): String = ServerUtils.currentPing.toString()
 
+  private const val PADDING = 25f
+  private const val CORNER_RADIUS = 5f
+  private const val OUTLINE_THICKNESS = 2f
+  private const val FONT_SIZE = 16f
+  private const val TEXT_SPACING = 5f
+  private const val DIVIDER_HALF_HEIGHT = 10f
+  private const val PANEL_HEIGHT = 50f
+  private const val MID_FACTOR = 0.5f
+  private const val DIVIDER_GAP = PADDING / 2 + TEXT_SPACING
+
   private data class Stat(val value: String, val unit: String)
 
 }
diff --git a/src/main/kotlin/org/cobalt/script/Script.kt b/src/main/kotlin/org/cobalt/script/Script.kt
new file mode 100644
index 00000000..74bb8750
--- /dev/null
+++ b/src/main/kotlin/org/cobalt/script/Script.kt
@@ -0,0 +1,37 @@
+package org.cobalt.script
+
+import net.minecraft.ChatFormatting
+import org.cobalt.util.ChatUtils
+
+abstract class Script(
+  val name: String,
+  val category: ScriptCategory,
+) {
+
+  var running: Boolean = false
+    private set
+
+  abstract fun onEnable()
+  abstract fun onDisable()
+
+  fun startScript() {
+    onEnable()
+    ChatUtils.sendSystemMessage("$name ${ChatFormatting.GREEN}Started")
+    running = true
+  }
+
+  fun stopScript() {
+    onDisable()
+    ChatUtils.sendSystemMessage("$name ${ChatFormatting.RED}Stopped")
+    running = false
+  }
+
+  fun toggleScript() {
+    if (running) {
+      stopScript()
+    } else {
+      startScript()
+    }
+  }
+
+}
diff --git a/src/main/kotlin/org/cobalt/script/ScriptCategory.kt b/src/main/kotlin/org/cobalt/script/ScriptCategory.kt
new file mode 100644
index 00000000..1e66ba04
--- /dev/null
+++ b/src/main/kotlin/org/cobalt/script/ScriptCategory.kt
@@ -0,0 +1,26 @@
+package org.cobalt.script
+
+class ScriptCategory private constructor(
+  val displayName: String,
+) {
+
+  companion object {
+
+    private val entries = mutableMapOf<String, ScriptCategory>()
+
+    @JvmField
+    val SKILLS = register(displayName = "Skills")
+
+    fun register(displayName: String): ScriptCategory {
+      return entries.getOrPut(displayName.lowercase()) {
+        ScriptCategory(displayName)
+      }
+    }
+
+    fun getCategories(): Collection<ScriptCategory> {
+      return entries.values
+    }
+
+  }
+
+}
diff --git a/src/main/kotlin/org/cobalt/script/ScriptManager.kt b/src/main/kotlin/org/cobalt/script/ScriptManager.kt
new file mode 100644
index 00000000..5f91784c
--- /dev/null
+++ b/src/main/kotlin/org/cobalt/script/ScriptManager.kt
@@ -0,0 +1,40 @@
+package org.cobalt.script
+
+import org.cobalt.event.EventBus
+import org.cobalt.module.impl.render.PerformanceHUD
+
+object ScriptManager {
+
+  val scripts = mutableSetOf<Script>()
+
+  init {
+    EventBus.register(this)
+  }
+
+  internal fun registerScripts() {
+    val builtIn = arrayOf<Script>()
+
+    builtIn.forEach { script ->
+      addScript(script)
+    }
+  }
+
+  fun addScript(script: Script) {
+    if (!scripts.add(script)) {
+      error("'${script.name}' is already registered")
+    }
+  }
+
+  fun removeScript(script: Script): Boolean {
+    return scripts.remove(script)
+  }
+
+  fun getScript(scriptName: String): Script? {
+    return scripts.find { script ->
+      script.name.equals(scriptName, true)
+    }
+  }
+
+}
+
+
diff --git a/src/main/kotlin/org/cobalt/ui/ColorPalette.kt b/src/main/kotlin/org/cobalt/ui/ColorPalette.kt
deleted file mode 100644
index 2681d19f..00000000
--- a/src/main/kotlin/org/cobalt/ui/ColorPalette.kt
+++ /dev/null
@@ -1,29 +0,0 @@
-package org.cobalt.ui
-
-import java.awt.Color
-
-// TODO: Bring to a theme manager
-object ColorPalette {
-
-  val BACKGROUND_PRIMARY = Color(18, 18, 18).rgb
-  val BACKGROUND_SECONDARY = Color(24, 24, 24).rgb
-  val PANEL = Color(30, 30, 30).rgb
-  val HOVER = Color(37, 37, 37).rgb
-  val BORDER = Color(42, 42, 42).rgb
-
-  val ACCENT_PRIMARY = Color(79, 140, 255).rgb
-  val ACCENT_HOVER = Color(106, 162, 255).rgb
-  val ACCENT_ACTIVE = Color(58, 116, 230).rgb
-  val ACCENT_GLOW = Color(47, 95, 191, 64).rgb
-
-  val TEXT_PRIMARY = Color(230, 230, 230).rgb
-  val TEXT_SECONDARY = Color(179, 179, 179).rgb
-  val TEXT_MUTED = Color(122, 122, 122).rgb
-  val TEXT_DISABLED = Color(95, 95, 95).rgb
-
-  val SUCCESS = Color(63, 191, 127).rgb
-  val WARNING = Color(230, 181, 102).rgb
-  val ERROR = Color(224, 90, 90).rgb
-  val INFO = Color(93, 169, 233).rgb
-
-}
diff --git a/src/main/kotlin/org/cobalt/ui/UIComponent.kt b/src/main/kotlin/org/cobalt/ui/UIComponent.kt
index 65f8155f..001664cb 100644
--- a/src/main/kotlin/org/cobalt/ui/UIComponent.kt
+++ b/src/main/kotlin/org/cobalt/ui/UIComponent.kt
@@ -1,14 +1,61 @@
 package org.cobalt.ui
 
+import net.minecraft.client.input.CharacterEvent
+import net.minecraft.client.input.KeyEvent
+import org.cobalt.ui.theme.Theme
+import org.cobalt.ui.theme.ThemeManager
+
 abstract class UIComponent(
-  var xPos: Float,
-  var yPos: Float,
+  var xPos: Float = 0f,
+  var yPos: Float = 0f,
   open val width: Float = 0.0f,
   open val height: Float = 0.0f,
 ) {
 
+  protected val theme: Theme
+    get() = ThemeManager.getActiveTheme()
+
+  private val children =
+    mutableListOf<UIComponent>()
+
   abstract fun renderComponent()
 
+  fun addChild(component: UIComponent) {
+    if (children.contains(component) || component == this) {
+      throw IllegalArgumentException("Cannot add component as a child: ${component::class.simpleName}")
+    }
+
+    children.add(component)
+  }
+
+  open fun mouseClicked(button: Int): Boolean {
+    return children.any { it.mouseClicked(button) }
+  }
+
+  open fun mouseReleased(button: Int): Boolean {
+    return children.any { it.mouseReleased(button) }
+  }
+
+  open fun mouseDragged(button: Int, offsetX: Double, offsetY: Double): Boolean {
+    return children.any { it.mouseDragged(button, offsetX, offsetY) }
+  }
+
+  open fun mouseScrolled(horizontalAmount: Double, verticalAmount: Double): Boolean {
+    return children.any { it.mouseScrolled(horizontalAmount, verticalAmount) }
+  }
+
+  open fun charTyped(input: CharacterEvent): Boolean {
+    return children.any { it.charTyped(input) }
+  }
+
+  open fun keyPressed(input: KeyEvent): Boolean {
+    return children.any { it.keyPressed(input) }
+  }
+
+  open fun keyReleased(input: KeyEvent): Boolean {
+    return children.any { it.keyReleased(input) }
+  }
+
   fun updateBounds(xPos: Float, yPos: Float): UIComponent {
     this.xPos = xPos
     this.yPos = yPos
diff --git a/src/main/kotlin/org/cobalt/ui/animation/Animation.kt b/src/main/kotlin/org/cobalt/ui/animation/Animation.kt
index 91a0df7c..475c52fb 100644
--- a/src/main/kotlin/org/cobalt/ui/animation/Animation.kt
+++ b/src/main/kotlin/org/cobalt/ui/animation/Animation.kt
@@ -5,7 +5,7 @@
 
 package org.cobalt.ui.animation
 
-abstract class Animation<T>(private val duration: Long) {
+abstract class Animation<T>(val duration: Long) {
 
   companion object {
     private const val PERCENT_MAX: Float = 100f
diff --git a/src/main/kotlin/org/cobalt/ui/animation/ColorAnimation.kt b/src/main/kotlin/org/cobalt/ui/animation/ColorAnimation.kt
new file mode 100644
index 00000000..c2ffbc85
--- /dev/null
+++ b/src/main/kotlin/org/cobalt/ui/animation/ColorAnimation.kt
@@ -0,0 +1,51 @@
+package org.cobalt.ui.animation
+
+import java.awt.Color
+import kotlin.math.roundToInt
+
+internal class ColorAnimation(duration: Long) {
+
+  private val animation = EaseOutAnimation(duration)
+
+  fun start() =
+    animation.start()
+
+  fun get(start: Color, end: Color, reverse: Boolean): Color {
+    return Color(
+      interpolateColor(start.red, end.red, reverse),
+      interpolateColor(start.green, end.green, reverse),
+      interpolateColor(start.blue, end.blue, reverse),
+      interpolateColor(start.alpha, end.alpha, reverse),
+    )
+  }
+
+  fun get(start: Int, end: Int, reverse: Boolean): Int {
+    val startColor = Color(start, true)
+    val endColor = Color(end, true)
+
+    val red = interpolate(startColor.red, endColor.red, reverse)
+    val green = interpolate(startColor.green, endColor.green, reverse)
+    val blue = interpolate(startColor.blue, endColor.blue, reverse)
+    val alpha = interpolate(startColor.alpha, endColor.alpha, reverse)
+
+    return (alpha shl 24) or (red shl 16) or (green shl 8) or blue
+  }
+
+  private fun interpolate(start: Int, end: Int, reverse: Boolean): Int {
+    return animation
+      .get(start.toFloat(), end.toFloat(), reverse)
+      .roundToInt()
+      .coerceIn(MIN_VALUE, MAX_VALUE)
+  }
+
+  private fun interpolateColor(start: Int, end: Int, reverse: Boolean): Float {
+    return interpolate(start, end, reverse) / MAX_VALUE_FLOAT
+  }
+
+  companion object {
+    private const val MIN_VALUE = 0
+    private const val MAX_VALUE = 255
+    private const val MAX_VALUE_FLOAT = 255f
+  }
+
+}
diff --git a/src/main/kotlin/org/cobalt/ui/component/SidebarComponent.kt b/src/main/kotlin/org/cobalt/ui/component/SidebarComponent.kt
new file mode 100644
index 00000000..1946fece
--- /dev/null
+++ b/src/main/kotlin/org/cobalt/ui/component/SidebarComponent.kt
@@ -0,0 +1,28 @@
+package org.cobalt.ui.component
+
+import org.cobalt.ui.UIComponent
+import org.cobalt.util.Dimensions
+import org.cobalt.util.Vec2f
+import org.cobalt.util.skia.SkiaShapes
+import org.cobalt.util.skia.SkiaSide
+
+class SidebarComponent : UIComponent(
+  width = 250f,
+  height = 600f
+) {
+
+  override fun renderComponent() {
+    SkiaShapes.drawHalfRoundedRect(
+      Vec2f(xPos, yPos),
+      Dimensions(width, height),
+      radius = CORNER_RADIUS,
+      color = theme.backgroundSecondary,
+      side = SkiaSide.LEFT
+    )
+  }
+
+  companion object {
+    private const val CORNER_RADIUS: Float = 10f
+  }
+
+}
diff --git a/src/main/kotlin/org/cobalt/ui/helper/SnapHelper.kt b/src/main/kotlin/org/cobalt/ui/helper/SnapHelper.kt
new file mode 100644
index 00000000..a19e58f4
--- /dev/null
+++ b/src/main/kotlin/org/cobalt/ui/helper/SnapHelper.kt
@@ -0,0 +1,74 @@
+package org.cobalt.ui.helper
+
+import kotlin.math.abs
+import kotlin.math.round
+import org.cobalt.util.Vec2f
+
+internal class SnapHelper(
+  private val gridSize: Float = 10f,
+  private val snapThreshold: Float = 5f,
+) {
+
+  var activeGuides: List<GuideLine> = emptyList()
+    private set
+
+  fun clearGuides() {
+    activeGuides = emptyList()
+  }
+
+  fun findAlignmentGuides(
+    moduleX: Float,
+    moduleY: Float,
+    moduleW: Float,
+    moduleH: Float,
+    screenWidth: Float,
+    screenHeight: Float,
+    otherModuleBounds: List<ModuleBounds>,
+  ): Vec2f {
+    val xTargets = buildXTargets(screenWidth, otherModuleBounds)
+    val yTargets = buildYTargets(screenHeight, otherModuleBounds)
+
+    val (snappedX, xGuide) = snapAxis(moduleX, moduleW, xTargets, isVertical = true)
+    val (snappedY, yGuide) = snapAxis(moduleY, moduleH, yTargets, isVertical = false)
+
+    activeGuides = listOfNotNull(xGuide, yGuide)
+
+    return Vec2f(snappedX, snappedY)
+  }
+
+  private fun buildXTargets(screenWidth: Float, bounds: List<ModuleBounds>): List<Float> =
+    mutableListOf(0f, screenWidth / 2f, screenWidth).apply {
+      bounds.forEach { add(it.x); add(it.x + it.width); add(it.x + it.width / 2f) }
+    }
+
+  private fun buildYTargets(screenHeight: Float, bounds: List<ModuleBounds>): List<Float> =
+    mutableListOf(0f, screenHeight / 2f, screenHeight).apply {
+      bounds.forEach { add(it.y); add(it.y + it.height); add(it.y + it.height / 2f) }
+    }
+
+  private fun snapAxis(pos: Float, size: Float, targets: List<Float>, isVertical: Boolean): Pair<Float, GuideLine?> {
+    val center = pos + size / 2f
+    val far = pos + size
+    var best = pos
+    var bestDiff = snapThreshold + 1f
+    var guide: GuideLine? = null
+
+    targets.forEach { target ->
+      val candidates = listOf(pos to target, center to target - size / 2f, far to target - size)
+      candidates.forEach { (edge, newPos) ->
+        val diff = abs(edge - target)
+        if (diff <= snapThreshold && diff < bestDiff) {
+          bestDiff = diff
+          best = newPos
+          guide = GuideLine(isVertical, target)
+        }
+      }
+    }
+
+    return best to guide
+  }
+
+  data class GuideLine(val isVertical: Boolean, val position: Float)
+  data class ModuleBounds(val x: Float, val y: Float, val width: Float, val height: Float)
+
+}
diff --git a/src/main/kotlin/org/cobalt/ui/notification/Notification.kt b/src/main/kotlin/org/cobalt/ui/notification/Notification.kt
index f6c86a08..e78a8428 100644
--- a/src/main/kotlin/org/cobalt/ui/notification/Notification.kt
+++ b/src/main/kotlin/org/cobalt/ui/notification/Notification.kt
@@ -1,13 +1,12 @@
 package org.cobalt.ui.notification
 
 import kotlin.time.Duration
-import org.cobalt.ui.ColorPalette
 import org.cobalt.ui.UIComponent
 import org.cobalt.ui.animation.BounceAnimation
 import org.cobalt.ui.animation.EaseOutAnimation
 import org.cobalt.util.Dimensions
 import org.cobalt.util.Vec2f
-import org.cobalt.util.WindowUtils
+import org.cobalt.util.WindowUtils.windowWidth
 import org.cobalt.util.skia.SkiaShapes
 import org.cobalt.util.skia.SkiaSide
 import org.cobalt.util.skia.SkiaText
@@ -18,15 +17,13 @@ internal class Notification(
   private val description: String,
   private val duration: Duration,
 ) : UIComponent(
-  xPos = DEFAULT_X,
-  yPos = DEFAULT_Y,
   width = DEFAULT_WIDTH,
   height = calculateHeight(title, description)
 ) {
 
-  private val slideInAnim = BounceAnimation(SLIDE_IN_DURATION_MS)
-  private val slideDownAnim = EaseOutAnimation(SLIDE_DOWN_DURATION_MS)
-  private val slideOutAnim = EaseOutAnimation(SLIDE_OUT_DURATION_MS)
+  private val slideInAnim = BounceAnimation(duration = 300L)
+  private val slideDownAnim = EaseOutAnimation(duration = 200L)
+  private val slideOutAnim = EaseOutAnimation(duration = 400L)
 
   private var isExpired: Boolean = false
   private var startTime: Long = 0L
@@ -38,7 +35,7 @@ internal class Notification(
   fun start(currentTime: Long) {
     slideInAnim.start()
     startTime = System.currentTimeMillis()
-    expiryTime = currentTime + SLIDE_IN_DURATION_MS + duration.inWholeMilliseconds
+    expiryTime = currentTime + slideInAnim.duration + duration.inWholeMilliseconds
     isExpired = false
   }
 
@@ -58,13 +55,10 @@ internal class Notification(
   }
 
   override fun renderComponent() {
-    val windowScale = WindowUtils.getWindowScale()
-    val screenWidth = WindowUtils.getWidth() / windowScale
-
     val resolvedX = if (isExpired) {
-      slideOutAnim.get(screenWidth - width - SCREEN_MARGIN - CONTENT_PADDING, screenWidth, false)
+      slideOutAnim.get(windowWidth - width - SCREEN_MARGIN - CONTENT_PADDING, windowWidth, false)
     } else {
-      slideInAnim.get(screenWidth, screenWidth - width - SCREEN_MARGIN - CONTENT_PADDING, false)
+      slideInAnim.get(windowWidth, windowWidth - width - SCREEN_MARGIN - CONTENT_PADDING, false)
     }
 
     val resolvedY = targetY + slideDownAnim.get(previousY - targetY, 0f, false)
@@ -74,7 +68,7 @@ internal class Notification(
       Vec2f(xPos, yPos),
       Dimensions(width, height),
       CORNER_RADIUS,
-      ColorPalette.BACKGROUND_PRIMARY
+      theme.backgroundPrimary
     )
 
     drawText()
@@ -89,7 +83,7 @@ internal class Notification(
       title,
       Vec2f(xPos + CONTENT_PADDING, yPos + CONTENT_PADDING),
       contentWidth,
-      TextStyle(TITLE_FONT_SIZE, ColorPalette.TEXT_PRIMARY)
+      TextStyle(TITLE_FONT_SIZE, theme.textPrimary)
     )
 
     val titleHeight = SkiaText.getWrappedTextHeight(
@@ -101,7 +95,7 @@ internal class Notification(
       description,
       Vec2f(xPos + CONTENT_PADDING, yPos + CONTENT_PADDING + titleHeight + TITLE_DESCRIPTION_GAP),
       contentWidth,
-      TextStyle(DESCRIPTION_FONT_SIZE, ColorPalette.TEXT_SECONDARY)
+      TextStyle(DESCRIPTION_FONT_SIZE, theme.textSecondary)
     )
   }
 
@@ -113,7 +107,7 @@ internal class Notification(
       Vec2f(xPos, yPos + height - PROGRESS_BAR_HEIGHT),
       Dimensions(width, PROGRESS_BAR_HEIGHT),
       CORNER_RADIUS,
-      ColorPalette.PANEL,
+      theme.backgroundSecondary,
       SkiaSide.BOTTOM
     )
 
@@ -122,7 +116,7 @@ internal class Notification(
         Vec2f(xPos, yPos + height - PROGRESS_BAR_HEIGHT),
         Dimensions(fillWidth, PROGRESS_BAR_HEIGHT),
         CORNER_RADIUS,
-        ColorPalette.ACCENT_PRIMARY,
+        theme.accentPrimary,
         SkiaSide.BOTTOM
       )
     }
@@ -131,7 +125,7 @@ internal class Notification(
   private fun calculateProgress(currentTime: Long): Float {
     if (isExpired) return 0f
     val totalDuration = duration.inWholeMilliseconds.toFloat()
-    val elapsed = (currentTime - startTime - SLIDE_IN_DURATION_MS).toFloat()
+    val elapsed = (currentTime - startTime - slideInAnim.duration).toFloat()
     return (1f - (elapsed / totalDuration)).coerceIn(0f, 1f)
   }
 
@@ -140,8 +134,6 @@ internal class Notification(
   }
 
   companion object {
-    private const val DEFAULT_X: Float = 0f
-    private const val DEFAULT_Y: Float = 0f
     private const val DEFAULT_WIDTH: Float = 350f
     private const val MIN_HEIGHT: Float = 100f
 
@@ -153,10 +145,6 @@ internal class Notification(
     private const val TITLE_FONT_SIZE: Float = 16f
     private const val DESCRIPTION_FONT_SIZE: Float = 14f
 
-    private const val SLIDE_IN_DURATION_MS: Long = 300L
-    private const val SLIDE_DOWN_DURATION_MS: Long = 200L
-    private const val SLIDE_OUT_DURATION_MS: Long = 400L
-
     private const val PROGRESS_BAR_HEIGHT: Float = 5f
 
     private fun calculateHeight(title: String, description: String): Float {
diff --git a/src/main/kotlin/org/cobalt/ui/notification/NotificationManager.kt b/src/main/kotlin/org/cobalt/ui/notification/NotificationManager.kt
index 5e850127..08f8f064 100644
--- a/src/main/kotlin/org/cobalt/ui/notification/NotificationManager.kt
+++ b/src/main/kotlin/org/cobalt/ui/notification/NotificationManager.kt
@@ -4,9 +4,7 @@ import kotlin.time.Duration
 import org.cobalt.event.EventBus
 import org.cobalt.event.annotation.SubscribeEvent
 import org.cobalt.event.impl.SkiaDrawEvent
-import org.cobalt.util.Vec2f
-import org.cobalt.util.WindowUtils
-import org.cobalt.util.skia.SkiaTransforms
+import org.cobalt.util.WindowUtils.windowHeight
 
 object NotificationManager {
 
@@ -34,20 +32,14 @@ object NotificationManager {
 
   @SubscribeEvent
   fun onSkiaDraw(@Suppress("UnusedParameter") event: SkiaDrawEvent) {
-    val windowScale = WindowUtils.getWindowScale()
-
-    updateNotifications(windowScale)
+    updateNotifications()
 
     activeNotifications.forEach { notification ->
-      SkiaTransforms.save()
-      SkiaTransforms.scale(Vec2f(windowScale, windowScale))
       notification.renderComponent()
-      SkiaTransforms.restore()
     }
   }
 
-  private fun updateNotifications(windowScale: Float) {
-    val screenHeight = WindowUtils.getHeight() / windowScale
+  private fun updateNotifications() {
     val currentTime = System.currentTimeMillis()
 
     activeNotifications.forEach { it.checkExpiry(currentTime) }
@@ -55,7 +47,7 @@ object NotificationManager {
 
     while (activeNotifications.size < MAX_ACTIVE_NOTIFICATIONS && notifQueue.isNotEmpty()) {
       val notif = notifQueue.removeAt(0)
-      val targetY = computeTargetY(screenHeight, activeNotifications.size, notif.height)
+      val targetY = computeTargetY(windowHeight, activeNotifications.size, notif.height)
 
       notif.targetY = targetY
       notif.previousY = targetY
@@ -65,7 +57,7 @@ object NotificationManager {
     }
 
     activeNotifications.forEachIndexed { index, notif ->
-      notif.moveTo(computeTargetY(screenHeight, index, notif.height))
+      notif.moveTo(computeTargetY(windowHeight, index, notif.height))
     }
   }
 
diff --git a/src/main/kotlin/org/cobalt/ui/page/ModulesPage.kt b/src/main/kotlin/org/cobalt/ui/page/ModulesPage.kt
new file mode 100644
index 00000000..00e91431
--- /dev/null
+++ b/src/main/kotlin/org/cobalt/ui/page/ModulesPage.kt
@@ -0,0 +1,62 @@
+package org.cobalt.ui.page
+
+import org.cobalt.ui.UIComponent
+import org.cobalt.ui.component.SidebarComponent
+import org.cobalt.util.Dimensions
+import org.cobalt.util.Vec2f
+import org.cobalt.util.skia.SkiaShapes
+import org.cobalt.util.skia.SkiaSide
+
+internal object ModulesPage : UIComponent(
+  height = 600f
+) {
+
+  private val sidebar = SidebarComponent()
+
+  override val width: Float
+    get() = BODY_WIDTH + sidebar.width
+
+  init {
+    addChild(sidebar)
+  }
+
+  override fun renderComponent() {
+    SkiaShapes.drawHalfRoundedRect(
+      Vec2f(xPos + sidebar.width, yPos),
+      Dimensions(BODY_WIDTH, height),
+      radius = CORNER_RADIUS,
+      color = theme.backgroundPrimary,
+      side = SkiaSide.RIGHT
+    )
+
+    drawSidebar()
+    drawBorders()
+  }
+
+  private fun drawSidebar() {
+    sidebar
+      .updateBounds(xPos, yPos)
+      .renderComponent()
+  }
+
+  private fun drawBorders() {
+    SkiaShapes.drawRoundedOutline(
+      Vec2f(xPos, yPos),
+      Dimensions(width, height),
+      radius = CORNER_RADIUS,
+      color = theme.border,
+      thickness = 2f
+    )
+
+    SkiaShapes.drawLine(
+      Vec2f(xPos + sidebar.width, yPos),
+      Vec2f(xPos + sidebar.width, yPos + height),
+      color = theme.border,
+      thickness = 2f
+    )
+  }
+
+  private const val BODY_WIDTH = 700f
+  private const val CORNER_RADIUS: Float = 10f
+
+}
diff --git a/src/main/kotlin/org/cobalt/ui/screen/ConfigScreen.kt b/src/main/kotlin/org/cobalt/ui/screen/ConfigScreen.kt
index 388b194f..dc00824b 100644
--- a/src/main/kotlin/org/cobalt/ui/screen/ConfigScreen.kt
+++ b/src/main/kotlin/org/cobalt/ui/screen/ConfigScreen.kt
@@ -2,17 +2,26 @@ package org.cobalt.ui.screen
 
 import net.minecraft.client.gui.GuiGraphicsExtractor
 import net.minecraft.client.gui.screens.Screen
+import net.minecraft.client.input.MouseButtonEvent
 import net.minecraft.network.chat.Component
 import org.cobalt.event.EventBus
 import org.cobalt.event.annotation.SubscribeEvent
 import org.cobalt.event.impl.SkiaDrawEvent
-import org.cobalt.util.Vec2f
+import org.cobalt.ui.UIComponent
 import org.cobalt.ui.animation.BounceAnimation
+import org.cobalt.ui.component.SidebarComponent
+import org.cobalt.ui.page.ModulesPage
+import org.cobalt.util.Vec2f
+import org.cobalt.util.WindowUtils.windowHeight
+import org.cobalt.util.WindowUtils.windowWidth
 import org.cobalt.util.skia.SkiaTransforms
 
 internal object ConfigScreen : Screen(Component.empty()) {
 
-  private val openAnim = BounceAnimation(400L)
+  private val openAnim = BounceAnimation(duration = 400L)
+  private var currentPage: UIComponent = ModulesPage
+
+  private val sidebar = SidebarComponent()
 
   init {
     EventBus.register(this)
@@ -20,43 +29,41 @@ internal object ConfigScreen : Screen(Component.empty()) {
 
   @SubscribeEvent
   fun onSkiaDraw(@Suppress("UnusedParameter") event: SkiaDrawEvent) {
-    if (minecraft.screen != this) {
-      return
-    }
+    if (minecraft.screen != this) return
+
+    val centerX = windowWidth / 2f
+    val centerY = windowHeight / 2f
 
-    val window = minecraft.window
-    val width = window.screenWidth
-    val height = window.screenHeight
+    SkiaTransforms.save()
 
     if (openAnim.isAnimating()) {
       val scale = openAnim.get(0f, 1f)
-      val cx = width / 2f
-      val cy = height / 2f
 
-      SkiaTransforms.save()
-      SkiaTransforms.translate(Vec2f(cx, cy))
+      SkiaTransforms.translate(Vec2f(centerX, centerY))
       SkiaTransforms.scale(Vec2f(scale, scale))
-      SkiaTransforms.translate(Vec2f(-cx, -cy))
+      SkiaTransforms.translate(Vec2f(-centerX, -centerY))
     }
 
-    // TODO: draw the actual UI here..
+    val pageX = centerX - (currentPage.width / 2f)
+    val pageY = centerY - (currentPage.height / 2f)
 
-    if (openAnim.isAnimating()) {
-      SkiaTransforms.restore()
-    }
+    currentPage
+      .updateBounds(pageX, pageY)
+      .renderComponent()
+
+    SkiaTransforms.restore()
   }
 
   override fun added() {
     openAnim.start()
   }
 
-  override fun extractBlurredBackground(graphics: GuiGraphicsExtractor) {
-    return
+  override fun mouseReleased(event: MouseButtonEvent): Boolean {
+    return currentPage.mouseReleased(event.button()) ||  super.mouseReleased(event)
   }
 
-  override fun extractMenuBackground(graphics: GuiGraphicsExtractor) {
-    return
-  }
+  override fun extractBlurredBackground(graphics: GuiGraphicsExtractor) = Unit
+  override fun extractMenuBackground(graphics: GuiGraphicsExtractor) = Unit
 
 }
 
diff --git a/src/main/kotlin/org/cobalt/ui/screen/HudEditorScreen.kt b/src/main/kotlin/org/cobalt/ui/screen/HudEditorScreen.kt
index cf84e7a7..ec7fe692 100644
--- a/src/main/kotlin/org/cobalt/ui/screen/HudEditorScreen.kt
+++ b/src/main/kotlin/org/cobalt/ui/screen/HudEditorScreen.kt
@@ -1,13 +1,47 @@
 package org.cobalt.ui.screen
 
 import net.minecraft.client.gui.screens.Screen
+import net.minecraft.client.input.MouseButtonEvent
 import net.minecraft.network.chat.Component
 import org.cobalt.event.EventBus
 import org.cobalt.event.annotation.SubscribeEvent
 import org.cobalt.event.impl.SkiaDrawEvent
+import org.cobalt.module.ModuleManager
+import org.cobalt.module.RenderableModule
+import org.cobalt.ui.helper.SnapHelper
+import org.cobalt.ui.theme.Theme
+import org.cobalt.ui.theme.ThemeManager
+import org.cobalt.util.Dimensions
+import org.cobalt.util.MouseUtils
+import org.cobalt.util.MouseUtils.mouseX
+import org.cobalt.util.MouseUtils.mouseY
+import org.cobalt.util.Vec2f
+import org.cobalt.util.WindowUtils.windowHeight
+import org.cobalt.util.WindowUtils.windowWidth
+import org.cobalt.util.skia.SkiaShapes
+import org.cobalt.util.skia.SkiaTransforms
 
 internal object HudEditorScreen : Screen(Component.empty()) {
 
+  private val modules: List<RenderableModule>
+    get() = ModuleManager.modules
+      .filterIsInstance<RenderableModule>()
+      .filter { it.enabled }
+
+  private var selectedModule: RenderableModule? = null
+  private val snapHelper = SnapHelper()
+
+  private val theme: Theme
+    get() = ThemeManager.getActiveTheme()
+
+  private var isDraggingMove = false
+  private var dragOffsetX: Float = 0.0f
+  private var dragOffsetY: Float = 0.0f
+
+  private var isDraggingResize = false
+  private var initialMouseX = 0f
+  private var initialWidth = 0f
+
   init {
     EventBus.register(this)
   }
@@ -18,7 +52,220 @@ internal object HudEditorScreen : Screen(Component.empty()) {
       return
     }
 
-    // TODO: draw the actual HUD editor UI here..
+    modules.forEach { module ->
+      val (x, y) = module.screenPosition
+      val scale = module.scale
+
+      SkiaTransforms.save()
+
+      SkiaTransforms.translate(Vec2f(x, y))
+      SkiaTransforms.scale(Vec2f(scale, scale))
+      SkiaTransforms.translate(Vec2f(-x, -y))
+
+      drawRenderableModule(module)
+
+      SkiaTransforms.restore()
+    }
+
+    drawSnapGuides()
+  }
+
+  private fun drawSnapGuides() {
+    if (!isDraggingMove) return
+
+    snapHelper.activeGuides.forEach { guide ->
+      if (guide.isVertical) {
+        SkiaShapes.drawLine(
+          Vec2f(guide.position, 0f),
+          Vec2f(guide.position, windowHeight),
+          theme.accentPrimary,
+          thickness = 1f
+        )
+      } else {
+        SkiaShapes.drawLine(
+          Vec2f(0f, guide.position),
+          Vec2f(windowWidth, guide.position),
+          theme.accentPrimary,
+          thickness = 1f
+        )
+      }
+    }
+  }
+
+  private fun drawRenderableModule(module: RenderableModule) {
+    val (x, y) = module.screenPosition
+    val (width, height) = module.dimensions
+
+    val isSelected = module == selectedModule
+
+    module.renderComponent()
+
+    SkiaShapes.drawOutline(
+      module.screenPosition,
+      module.dimensions,
+      if (isSelected) theme.accentPrimary else theme.border,
+      thickness = 2f
+    )
+
+    if (isSelected) {
+      val squareOffset = SQUARE_SIZE / 2.0f
+      val squareX = x + width - squareOffset
+      val squareY = y + height - squareOffset
+
+      SkiaShapes.drawRect(
+        Vec2f(squareX, squareY),
+        Dimensions(SQUARE_SIZE, SQUARE_SIZE),
+        theme.accentPrimary
+      )
+    }
+  }
+
+  override fun mouseClicked(event: MouseButtonEvent, doubleClick: Boolean): Boolean {
+    if (event.button() != 0) {
+      return super.mouseClicked(event, doubleClick)
+    }
+
+    val clickedModule = modules.firstOrNull { module ->
+      val (x, y) = module.screenPosition
+      val scaledWidth = module.dimensions.width * module.scale
+      val scaledHeight = module.dimensions.height * module.scale
+
+      if (module == selectedModule && tryStartResize(module)) {
+        return@firstOrNull true
+      }
+
+      if (MouseUtils.isHoveringOver(x, y, scaledWidth, scaledHeight)) {
+        isDraggingMove = true
+        return@firstOrNull true
+      }
+
+      return@firstOrNull false
+    }
+
+    selectedModule = clickedModule
+
+    if (selectedModule != null && isDraggingMove) {
+      dragOffsetX = mouseX - selectedModule!!.xPos
+      dragOffsetY = mouseY - selectedModule!!.yPos
+    }
+
+    return clickedModule != null || super.mouseClicked(event, doubleClick)
   }
 
+  private fun tryStartResize(module: RenderableModule): Boolean {
+    val (x, y) = module.screenPosition
+    val scaledWidth = module.dimensions.width * module.scale
+    val scaledHeight = module.dimensions.height * module.scale
+    val squareSizeScaled = SQUARE_SIZE * module.scale
+    val squareOffset = squareSizeScaled / 2f
+    val squareX = x + scaledWidth - squareOffset
+    val squareY = y + scaledHeight - squareOffset
+
+    if (!MouseUtils.isHoveringOver(squareX, squareY, squareSizeScaled, squareSizeScaled)) {
+      return false
+    }
+
+    initialMouseX = mouseX
+    initialWidth = scaledWidth
+    isDraggingResize = true
+    return true
+  }
+
+  override fun mouseDragged(event: MouseButtonEvent, dx: Double, dy: Double): Boolean {
+    val module = selectedModule ?: return super.mouseDragged(event, dx, dy)
+
+    val handled = when {
+      isDraggingResize -> handleResize(module)
+      isDraggingMove -> handleMove(module)
+      else -> false
+    }
+
+    return if (handled) true else super.mouseDragged(event, dx, dy)
+  }
+
+  private fun handleResize(module: RenderableModule): Boolean {
+    val baseWidth = module.getWidth()
+    if (baseWidth <= 0f) return false
+
+    val newWidth = initialWidth + (mouseX - initialMouseX)
+    module.scale = (newWidth / baseWidth).coerceIn(MIN_SCALE, MAX_SCALE)
+    return true
+  }
+
+  private fun handleMove(module: RenderableModule): Boolean {
+    val rawX = mouseX - dragOffsetX
+    val rawY = mouseY - dragOffsetY
+
+    val width = module.getWidth() * module.scale
+    val height = module.getHeight() * module.scale
+
+    val clampedX = rawX.coerceIn(0f, windowWidth - width)
+    val clampedY = rawY.coerceIn(0f, windowHeight - height)
+
+    val otherBounds = modules
+      .filter { it != module }
+      .map { other ->
+        val (ox, oy) = other.screenPosition
+        SnapHelper.ModuleBounds(ox, oy, other.dimensions.width * other.scale, other.dimensions.height * other.scale)
+      }
+
+    val (snappedX, snappedY) = snapHelper.findAlignmentGuides(
+      clampedX, clampedY,
+      width, height,
+      windowWidth, windowHeight,
+      otherBounds
+    )
+
+    val (offsetX, offsetY) =
+      computeOffsets(module.anchor, snappedX, snappedY, width, height, windowWidth, windowHeight)
+
+    module.offsetX = offsetX
+    module.offsetY = offsetY
+
+    return true
+  }
+
+  private fun computeOffsets(
+    anchor: RenderableModule.Anchor,
+    x: Float,
+    y: Float,
+    width: Float,
+    height: Float,
+    screenWidth: Float,
+    screenHeight: Float,
+  ): Vec2f {
+    val centerX = screenWidth / 2f - width / 2f
+    val centerY = screenHeight / 2f - height / 2f
+    val rightX = screenWidth - width - x
+    val bottomY = screenHeight - height - y
+
+    return when (anchor) {
+      RenderableModule.Anchor.TOP_LEFT -> Vec2f(x, y)
+      RenderableModule.Anchor.TOP_CENTER -> Vec2f(x - centerX, y)
+      RenderableModule.Anchor.TOP_RIGHT -> Vec2f(rightX, y)
+      RenderableModule.Anchor.CENTER_LEFT -> Vec2f(x, y - centerY)
+      RenderableModule.Anchor.CENTER -> Vec2f(x - centerX, y - centerY)
+      RenderableModule.Anchor.CENTER_RIGHT -> Vec2f(rightX, y - centerY)
+      RenderableModule.Anchor.BOTTOM_LEFT -> Vec2f(x, bottomY)
+      RenderableModule.Anchor.BOTTOM_CENTER -> Vec2f(x - centerX, bottomY)
+      RenderableModule.Anchor.BOTTOM_RIGHT -> Vec2f(rightX, bottomY)
+    }
+  }
+
+  override fun mouseReleased(event: MouseButtonEvent): Boolean {
+    isDraggingResize = false
+    isDraggingMove = false
+    dragOffsetX = 0.0f
+    dragOffsetY = 0.0f
+
+    snapHelper.clearGuides()
+
+    return super.mouseReleased(event)
+  }
+
+  private const val SQUARE_SIZE = 10.0f
+  private const val GRID_SIZE = 20.0f
+  private const val MIN_SCALE = 0.75f
+  private const val MAX_SCALE = 2.0f
+
 }
diff --git a/src/main/kotlin/org/cobalt/ui/theme/Theme.kt b/src/main/kotlin/org/cobalt/ui/theme/Theme.kt
new file mode 100644
index 00000000..702c0791
--- /dev/null
+++ b/src/main/kotlin/org/cobalt/ui/theme/Theme.kt
@@ -0,0 +1,25 @@
+package org.cobalt.ui.theme
+
+import java.awt.Color
+
+// TODO: load in values
+class Theme(val name: String) {
+
+  val backgroundPrimary = Color(10, 10, 11).rgb
+  val backgroundSecondary = Color(15, 15, 16).rgb
+  val border = Color(34, 34, 35).rgb
+
+  val accentPrimary = Color(40, 90, 210).rgb
+  val accentSecondary = Color(70, 130, 255).rgb
+
+  val textPrimary = Color(230, 230, 230).rgb
+  val textSecondary = Color(179, 179, 179).rgb
+  val textMuted = Color(122, 122, 122).rgb
+  val textDisabled = Color(95, 95, 95).rgb
+
+  val success = Color(63, 191, 127).rgb
+  val warning = Color(230, 181, 102).rgb
+  val error = Color(224, 90, 90).rgb
+  val info = Color(93, 169, 233).rgb
+
+}
diff --git a/src/main/kotlin/org/cobalt/ui/theme/ThemeManager.kt b/src/main/kotlin/org/cobalt/ui/theme/ThemeManager.kt
new file mode 100644
index 00000000..ae62d5e6
--- /dev/null
+++ b/src/main/kotlin/org/cobalt/ui/theme/ThemeManager.kt
@@ -0,0 +1,12 @@
+package org.cobalt.ui.theme
+
+object ThemeManager {
+
+  private var activeTheme: Theme = Theme("default")
+
+  @JvmStatic
+  fun getActiveTheme(): Theme {
+    return activeTheme
+  }
+
+}
diff --git a/src/main/kotlin/org/cobalt/util/FrustumUtils.kt b/src/main/kotlin/org/cobalt/util/FrustumUtils.kt
index 4afafaa7..e2dd466d 100644
--- a/src/main/kotlin/org/cobalt/util/FrustumUtils.kt
+++ b/src/main/kotlin/org/cobalt/util/FrustumUtils.kt
@@ -2,7 +2,6 @@ package org.cobalt.util
 
 import net.minecraft.client.renderer.culling.Frustum
 import net.minecraft.world.phys.AABB
-import org.cobalt.mixin.render.FrustumInvoker
 import org.joml.FrustumIntersection
 
 object FrustumUtils {
@@ -22,7 +21,7 @@ object FrustumUtils {
     maxY: Double,
     maxZ: Double,
   ): Boolean {
-    val result = (frustum as FrustumInvoker).invokeCubeInFrustum(minX, minY, minZ, maxX, maxY, maxZ)
+    val result = frustum.cubeInFrustum(minX, minY, minZ, maxX, maxY, maxZ)
     return result == FrustumIntersection.INSIDE || result == FrustumIntersection.INTERSECT
   }
 
diff --git a/src/main/kotlin/org/cobalt/util/MouseUtils.kt b/src/main/kotlin/org/cobalt/util/MouseUtils.kt
index 2cc9f4db..72f22f70 100644
--- a/src/main/kotlin/org/cobalt/util/MouseUtils.kt
+++ b/src/main/kotlin/org/cobalt/util/MouseUtils.kt
@@ -1,46 +1,42 @@
 package org.cobalt.util
 
 import org.cobalt.Cobalt.minecraft
-import org.cobalt.mixin.client.MinecraftAccessor
 
 object MouseUtils {
 
-  private var mode: MouseMode = MouseMode.NORMAL
-
   @JvmStatic
-  fun getMouseMode(): MouseMode {
-    return mode
-  }
+  var mouseMode: MouseMode = MouseMode.DEFAULT
 
   @JvmStatic
-  fun setMouseMode(mode: MouseMode) {
-    this.mode = mode
-  }
+  val mouseX: Float
+    get() = minecraft.mouseHandler.xpos().toFloat()
 
   @JvmStatic
-  fun leftClick() {
-    (minecraft as MinecraftAccessor).leftClick()
-  }
+  val mouseY: Float
+    get() = minecraft.mouseHandler.ypos().toFloat()
 
   @JvmStatic
-  fun rightClick() {
-    (minecraft as MinecraftAccessor).rightClick()
+  fun isHoveringOver(x: Float, y: Float, width: Float, height: Float): Boolean {
+    return mouseX >= x &&
+      mouseX <= x + width &&
+      mouseY >= y &&
+      mouseY <= y + height
   }
 
   @JvmStatic
-  fun isForceUngrabbed(): Boolean {
-    return mode == MouseMode.FORCE_UNGRAB
+  fun leftClick() {
+    minecraft.startAttack()
   }
 
   @JvmStatic
-  fun shouldBlockRotation(): Boolean {
-    return mode == MouseMode.LOCKED
+  fun rightClick() {
+    minecraft.startUseItem()
   }
 
 }
 
 enum class MouseMode {
-  NORMAL,
-  FORCE_UNGRAB,
-  LOCKED
+  DEFAULT,
+  UNGRAB_MOUSE,
+  LOCK_MOUSE
 }
diff --git a/src/main/kotlin/org/cobalt/util/ServerUtils.kt b/src/main/kotlin/org/cobalt/util/ServerUtils.kt
index 296a8173..2ebfbcc7 100644
--- a/src/main/kotlin/org/cobalt/util/ServerUtils.kt
+++ b/src/main/kotlin/org/cobalt/util/ServerUtils.kt
@@ -5,7 +5,6 @@ import org.cobalt.Cobalt.minecraft
 import org.cobalt.event.EventBus
 import org.cobalt.event.annotation.SubscribeEvent
 import org.cobalt.event.impl.PacketEvent
-import org.cobalt.mixin.client.AbstractClientPlayerAccessor
 
 private const val DEFAULT_TPS = 20f
 private const val TICKS_PER_SECOND = 20.0
@@ -22,8 +21,7 @@ object ServerUtils {
 
   @JvmStatic
   val currentPing
-    get() = (minecraft.player as AbstractClientPlayerAccessor)
-      .clientPlayerInfo?.latency ?: 0
+    get() = minecraft.player?.playerInfo?.latency ?: 0
 
   init {
     EventBus.register(this)
diff --git a/src/main/kotlin/org/cobalt/util/WindowUtils.kt b/src/main/kotlin/org/cobalt/util/WindowUtils.kt
index c7b10a4d..5f11e424 100644
--- a/src/main/kotlin/org/cobalt/util/WindowUtils.kt
+++ b/src/main/kotlin/org/cobalt/util/WindowUtils.kt
@@ -1,37 +1,13 @@
 package org.cobalt.util
 
-import kotlin.math.min
 import org.cobalt.Cobalt.minecraft
-import org.cobalt.dsl.mouseX
-import org.cobalt.dsl.mouseY
 
 object WindowUtils {
 
-  private const val BASE_WIDTH = 1920f
-  private const val BASE_HEIGHT = 1080f
+  val windowWidth: Float
+    get() = minecraft.window.width.toFloat()
 
-  @JvmStatic
-  fun getWindowScale(): Float {
-    val windowWidth = getWidth()
-    val windowHeight = getHeight()
-
-    return min(windowWidth / BASE_WIDTH, windowHeight / BASE_HEIGHT)
-  }
-
-  @JvmStatic
-  fun getWidth(): Float {
-    return minecraft.window.width.toFloat()
-  }
-
-  @JvmStatic
-  fun getHeight(): Float {
-    return minecraft.window.height.toFloat()
-  }
-
-  @JvmStatic
-  fun getMouseX(): Float = mouseX
-
-  @JvmStatic
-  fun getMouseY(): Float = mouseY
+  val windowHeight: Float
+    get() = minecraft.window.height.toFloat()
 
 }
diff --git a/src/main/kotlin/org/cobalt/util/skia/SkiaContext.kt b/src/main/kotlin/org/cobalt/util/skia/SkiaContext.kt
index dddb0656..1141731f 100644
--- a/src/main/kotlin/org/cobalt/util/skia/SkiaContext.kt
+++ b/src/main/kotlin/org/cobalt/util/skia/SkiaContext.kt
@@ -18,13 +18,7 @@
 
 package org.cobalt.util.skia
 
-import io.github.humbleui.skija.Canvas
-import io.github.humbleui.skija.ColorSpace
-import io.github.humbleui.skija.ColorType
-import io.github.humbleui.skija.DirectContext
-import io.github.humbleui.skija.FramebufferFormat
-import io.github.humbleui.skija.Surface
-import io.github.humbleui.skija.SurfaceOrigin
+import io.github.humbleui.skija.*
 import org.cobalt.event.EventBus
 import org.cobalt.event.impl.SkiaDrawEvent
 import org.cobalt.util.skia.gl.States
@@ -32,7 +26,7 @@ import org.lwjgl.opengl.GL11
 
 private const val DEFAULT_SAMPLES = 0
 private const val DEFAULT_STENCIL_BITS = 8
-private const val DEFAULT_PREFER_SAMPLES = 0
+private const val FRAMEBUFFER_ID = 0
 private const val CLEAR_R = 0f
 private const val CLEAR_G = 0f
 private const val CLEAR_B = 0f
@@ -41,37 +35,31 @@ private const val CLEAR_A_TRANSPARENT = 0f
 internal object SkiaContext {
 
   private var context: DirectContext? = null
-  private var renderTarget: WrappedBackendRenderTarget? = null
-  private var surface: Surface? = null
+  private var renderTarget: BackendRenderTarget? = null
 
-  var canvas: Canvas? = null
-    private set
+  var surface: Surface? = null
+
+  val canvas: Canvas?
+    get() = surface?.canvas
 
   init {
     EventBus.register(this)
   }
 
   internal fun initSkia(width: Int, height: Int) {
-    ensureContext()
-    recreateRenderTarget(width, height)
-
-    canvas = surface?.canvas
-  }
-
-  private fun ensureContext() {
-    if (context == null) context = DirectContext.makeGL()
-  }
+    if (context == null) {
+      context = DirectContext.makeGL()
+    }
 
-  private fun recreateRenderTarget(width: Int, height: Int) {
     surface?.close()
     renderTarget?.close()
 
-    renderTarget = WrappedBackendRenderTarget.makeGL(
+    renderTarget = BackendRenderTarget.makeGL(
       width,
       height,
       DEFAULT_SAMPLES,
       DEFAULT_STENCIL_BITS,
-      DEFAULT_PREFER_SAMPLES,
+      FRAMEBUFFER_ID,
       FramebufferFormat.GR_GL_RGBA8
     )
 
@@ -80,27 +68,29 @@ internal object SkiaContext {
       requireNotNull(renderTarget),
       SurfaceOrigin.BOTTOM_LEFT,
       ColorType.RGBA_8888,
-      ColorSpace.getSRGB()
+      ColorSpace.getSRGB(),
+      null
     )
   }
 
   internal fun draw() {
-    val ctx = context ?: return
-    val srf = surface ?: return
+    val context = context ?: return
+    val surface = surface ?: return
 
     States.push()
     GL11.glDisable(GL11.GL_CULL_FACE)
     GL11.glClearColor(CLEAR_R, CLEAR_G, CLEAR_B, CLEAR_A_TRANSPARENT)
 
-    ctx.resetGLAll()
+    context.resetGLAll()
+
+    val canvas = canvas
+    val renderTarget = renderTarget
 
-    val cvs = canvas
-    val rt = renderTarget
-    if (cvs != null && rt != null) {
-      EventBus.post(SkiaDrawEvent(ctx, rt, cvs))
+    if (canvas != null && renderTarget != null) {
+      EventBus.post(SkiaDrawEvent(context, renderTarget, canvas))
     }
 
-    ctx.flushAndSubmit(srf)
+    context.flushAndSubmit(surface)
 
     States.pop()
   }
diff --git a/src/main/kotlin/org/cobalt/util/skia/SkiaImage.kt b/src/main/kotlin/org/cobalt/util/skia/SkiaImage.kt
index 33b9cb1a..3c851e2a 100644
--- a/src/main/kotlin/org/cobalt/util/skia/SkiaImage.kt
+++ b/src/main/kotlin/org/cobalt/util/skia/SkiaImage.kt
@@ -11,7 +11,11 @@ import java.nio.file.Files
 import kotlinx.coroutines.runBlocking
 import org.cobalt.util.WebUtils
 
-class SkiaImage(identifier: String, val radius: Float? = null, val colorMask: Int? = null) {
+class SkiaImage(
+  identifier: String,
+  var radius: Float? = null,
+  var colorMask: Int? = null
+) {
 
   val isSvg = identifier.endsWith(".svg", ignoreCase = true)
   val image: Image?
diff --git a/src/main/kotlin/org/cobalt/util/skia/SkiaImages.kt b/src/main/kotlin/org/cobalt/util/skia/SkiaImages.kt
index bc8f4e6e..39145df3 100644
--- a/src/main/kotlin/org/cobalt/util/skia/SkiaImages.kt
+++ b/src/main/kotlin/org/cobalt/util/skia/SkiaImages.kt
@@ -62,8 +62,9 @@ object SkiaImages {
     sourceImage: Image,
     paint: Paint,
   ) {
-    val roundedRect = if (image.radius != null && image.radius > 0f) {
-      RRect.makeXYWH(pos.x, pos.y, dim.width, dim.height, image.radius)
+    val radius = image.radius
+    val roundedRect = if (radius != null && radius > 0f) {
+      RRect.makeXYWH(pos.x, pos.y, dim.width, dim.height, radius)
     } else null
 
     withOptionalClip(canvas, roundedRect) {
diff --git a/src/main/kotlin/org/cobalt/util/skia/SkiaShaders.kt b/src/main/kotlin/org/cobalt/util/skia/SkiaShaders.kt
index 866e68e0..bdb7efcb 100644
--- a/src/main/kotlin/org/cobalt/util/skia/SkiaShaders.kt
+++ b/src/main/kotlin/org/cobalt/util/skia/SkiaShaders.kt
@@ -3,54 +3,55 @@ package org.cobalt.util.skia
 import io.github.humbleui.skija.Data
 import io.github.humbleui.skija.Paint
 import io.github.humbleui.skija.RuntimeEffect
+import io.github.humbleui.skija.RuntimeEffectChild
 import io.github.humbleui.types.Rect
+import java.io.IOException
 import java.nio.ByteBuffer
 import java.nio.ByteOrder
+import java.nio.charset.StandardCharsets
 import org.cobalt.util.Dimensions
 import org.cobalt.util.Vec2f
 import org.cobalt.util.skia.SkiaContext.canvas
 
 object SkiaShaders {
 
-  private const val UNIFORM_BUFFER_SIZE = 20
-  private const val NANOSECONDS_PER_SECOND = 1_000_000_000f
+  private val START_TIME: Long = System.currentTimeMillis()
 
-  @JvmStatic
-  fun renderShader(
-    pos: Vec2f,
-    dim: Dimensions,
-    shaderCode: String,
-  ) {
-    val canvas = canvas ?: return
-
-    if (!isValid(dim)) {
-      return
-    }
+  fun loadShader(resourcePath: String): RuntimeEffect {
+    try {
+      SkiaShaders.javaClass.getResourceAsStream(resourcePath).use { inputStream ->
+        checkNotNull(inputStream) { "Missing shader resource" }
 
-    RuntimeEffect.makeForShader(shaderCode).use { effect ->
-      val shader = effect.makeShader(buildUniformData(dim), emptyArray())
+        val sksl = String(inputStream.readAllBytes(), StandardCharsets.UTF_8)
+        val shaderEffect = RuntimeEffect.makeForShader(sksl)
 
-      Paint().apply {
-        this.shader = shader
-        isAntiAlias = true
-      }.use { paint ->
-        canvas.drawRect(Rect.makeXYWH(pos.x, pos.y, dim.width, dim.height), paint)
+        return shaderEffect
       }
+    } catch (exception: IOException) {
+      throw IllegalStateException("Failed to read shader resource", exception)
     }
   }
 
-  private fun buildUniformData(dim: Dimensions): Data {
-    val buffer = ByteBuffer.allocateDirect(UNIFORM_BUFFER_SIZE)
-      .order(ByteOrder.nativeOrder())
-
-    buffer.putFloat(dim.width)
-    buffer.putFloat(dim.height)
-    buffer.putFloat(System.nanoTime() / NANOSECONDS_PER_SECOND)
-    buffer.flip()
+  fun renderShader(pos: Vec2f, dim: Dimensions, runtimeEffect: RuntimeEffect) {
+    val canvas = canvas ?: return
 
-    return Data.makeFromBytes(ByteArray(buffer.remaining()).also { buffer.get(it) })
+    val elapsedSeconds = (System.currentTimeMillis() - START_TIME) / 1000f
+    val uniformBytes = ByteBuffer.allocate(12)
+      .order(ByteOrder.LITTLE_ENDIAN)
+      .putFloat(elapsedSeconds)
+      .putFloat(dim.width)
+      .putFloat(dim.height)
+      .array()
+
+    Data.makeFromBytes(uniformBytes).use { data ->
+      runtimeEffect.makeShader<RuntimeEffectChild>(data, null, null).use { shader ->
+        Paint().setShader(shader).use { paint ->
+          canvas.drawRect(
+            Rect.makeXYWH(pos.x, pos.y, dim.width, dim.height), paint
+          )
+        }
+      }
+    }
   }
 
-  private fun isValid(dim: Dimensions) = dim.width > 0f && dim.height > 0f
-
 }
diff --git a/src/main/kotlin/org/cobalt/util/skia/SkiaShapes.kt b/src/main/kotlin/org/cobalt/util/skia/SkiaShapes.kt
index 4a9cd27f..6639a37c 100644
--- a/src/main/kotlin/org/cobalt/util/skia/SkiaShapes.kt
+++ b/src/main/kotlin/org/cobalt/util/skia/SkiaShapes.kt
@@ -168,6 +168,32 @@ object SkiaShapes {
     }
   }
 
+  @JvmStatic
+  fun drawCircle(centerPos: Vec2f, radius: Float, color: Int) {
+    val canvas = canvas ?: return
+
+    Paint().setColor(color).use { paint ->
+      paint.isAntiAlias = true
+      canvas.drawCircle(centerPos.x, centerPos.y, radius.coerceAtLeast(0f), paint)
+    }
+  }
+
+  @JvmStatic
+  fun drawCircleOutline(centerPos: Vec2f, radius: Float, color: Int, thickness: Float = 1f) {
+    val canvas = canvas ?: return
+
+    val thickness = thickness.coerceAtLeast(0f)
+
+    Paint().apply {
+      setColor(color)
+      mode = PaintMode.STROKE
+      strokeWidth = thickness
+      isAntiAlias = true
+    }.use { paint ->
+      canvas.drawCircle(centerPos.x, centerPos.y, radius.coerceAtLeast(0f), paint)
+    }
+  }
+
   private fun createLinearGradientShader(
     pos: Vec2f,
     dim: Dimensions,
diff --git a/src/main/kotlin/org/cobalt/util/skia/WrappedBackendRenderTarget.kt b/src/main/kotlin/org/cobalt/util/skia/WrappedBackendRenderTarget.kt
deleted file mode 100644
index 231e1bea..00000000
--- a/src/main/kotlin/org/cobalt/util/skia/WrappedBackendRenderTarget.kt
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * This file is part of https://github.com/Lyzev/Skija.
- *
- * Copyright (c) 2025. Lyzev
- *
- * Skija is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, version 3 of the License, or
- * (at your option) any later version.
- *
- * Skija is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along with Skija. If not, see <https://www.gnu.org/licenses/>.
- */
-
-package org.cobalt.util.skia
-
-import io.github.humbleui.skija.BackendRenderTarget
-import io.github.humbleui.skija.BackendRenderTarget._nMakeGL
-import io.github.humbleui.skija.impl.Stats
-import org.jetbrains.annotations.Contract
-
-class WrappedBackendRenderTarget(
-  val width: Int,
-  val height: Int,
-  val sampleCnt: Int,
-  val stencilBits: Int,
-  val fbId: Int,
-  val fbFormat: Int,
-  ptr: Long,
-) : BackendRenderTarget(ptr) {
-
-  companion object {
-
-    @Contract("_, _, _, _, _, _ -> new")
-    internal fun makeGL(
-      width: Int, height: Int, sampleCnt: Int, stencilBits: Int, fbId: Int, fbFormat: Int,
-    ): WrappedBackendRenderTarget {
-      Stats.onNativeCall()
-      return WrappedBackendRenderTarget(
-        width,
-        height,
-        sampleCnt,
-        stencilBits,
-        fbId,
-        fbFormat,
-        _nMakeGL(width, height, sampleCnt, stencilBits, fbId, fbFormat)
-      )
-    }
-
-  }
-
-}
diff --git a/src/main/kotlin/org/cobalt/util/skia/gl/State.kt b/src/main/kotlin/org/cobalt/util/skia/gl/State.kt
index 87af1488..f8dbee2b 100644
--- a/src/main/kotlin/org/cobalt/util/skia/gl/State.kt
+++ b/src/main/kotlin/org/cobalt/util/skia/gl/State.kt
@@ -1,4 +1,4 @@
-@file:Suppress("WildcardImport") // Imports 60+ items, so a wildcard import is fine here.
+@file:Suppress("WildcardImport")
 
 /*
  * This file is part of https://github.com/Lyzev/Skija.
diff --git a/src/main/resources/assets/cobalt/panorama/panorama_0.png b/src/main/resources/assets/cobalt/panorama/panorama_0.png
index 82199baa..7ab4326c 100644
Binary files a/src/main/resources/assets/cobalt/panorama/panorama_0.png and b/src/main/resources/assets/cobalt/panorama/panorama_0.png differ
diff --git a/src/main/resources/assets/cobalt/panorama/panorama_1.png b/src/main/resources/assets/cobalt/panorama/panorama_1.png
index d8698239..15bebc49 100644
Binary files a/src/main/resources/assets/cobalt/panorama/panorama_1.png and b/src/main/resources/assets/cobalt/panorama/panorama_1.png differ
diff --git a/src/main/resources/assets/cobalt/panorama/panorama_2.png b/src/main/resources/assets/cobalt/panorama/panorama_2.png
index 73172c96..ad72cedb 100644
Binary files a/src/main/resources/assets/cobalt/panorama/panorama_2.png and b/src/main/resources/assets/cobalt/panorama/panorama_2.png differ
diff --git a/src/main/resources/assets/cobalt/panorama/panorama_3.png b/src/main/resources/assets/cobalt/panorama/panorama_3.png
index 561f905c..35812292 100644
Binary files a/src/main/resources/assets/cobalt/panorama/panorama_3.png and b/src/main/resources/assets/cobalt/panorama/panorama_3.png differ
diff --git a/src/main/resources/assets/cobalt/panorama/panorama_4.png b/src/main/resources/assets/cobalt/panorama/panorama_4.png
index 36f1d802..33916c34 100644
Binary files a/src/main/resources/assets/cobalt/panorama/panorama_4.png and b/src/main/resources/assets/cobalt/panorama/panorama_4.png differ
diff --git a/src/main/resources/assets/cobalt/panorama/panorama_5.png b/src/main/resources/assets/cobalt/panorama/panorama_5.png
index 8e722a0a..3ef51b07 100644
Binary files a/src/main/resources/assets/cobalt/panorama/panorama_5.png and b/src/main/resources/assets/cobalt/panorama/panorama_5.png differ
diff --git a/src/main/resources/assets/cobalt/shader/background.sksl b/src/main/resources/assets/cobalt/shader/background.sksl
new file mode 100644
index 00000000..b01b7b73
--- /dev/null
+++ b/src/main/resources/assets/cobalt/shader/background.sksl
@@ -0,0 +1,174 @@
+uniform float iTime;
+uniform float2 iResolution;
+
+float hash(float2 p) {
+    p = fract(p * float2(123.34, 456.21));
+    p += dot(p, p + 45.32);
+    return fract(p.x * p.y);
+}
+
+float noise(float2 p) {
+    float2 i = floor(p);
+    float2 f = fract(p);
+
+    float a = hash(i);
+    float b = hash(i + float2(1.0, 0.0));
+    float c = hash(i + float2(0.0, 1.0));
+    float d = hash(i + float2(1.0, 1.0));
+
+    float2 u = f * f * (3.0 - 2.0 * f);
+    return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
+}
+
+float fbm(float2 p) {
+    float v = 0.0;
+    float a = 0.5;
+    for (int i = 0; i < 6; i++) {
+        v += noise(p) * a;
+        p = p * 2.02 + float2(31.7, 19.3);
+        a *= 0.52;
+    }
+    return v;
+}
+
+float ridge(float n) {
+    n = abs(n * 2.0 - 1.0);
+    return 1.0 - n;
+}
+
+float ridgedFbm(float2 p) {
+    float v = 0.0;
+    float a = 0.55;
+    float prev = 1.0;
+    for (int i = 0; i < 5; i++) {
+        float n = ridge(noise(p));
+        n *= n;
+        v += n * a * prev;
+        prev = clamp(n * 1.8, 0.0, 1.0);
+        p = p * 2.05 + float2(17.2, 9.1);
+        a *= 0.55;
+    }
+    return v;
+}
+
+float2 warp(float2 p, float t) {
+    float2 q = float2(
+        fbm(p * 0.95 + float2(0.0,  t * 0.22)),
+        fbm(p * 0.95 + float2(5.2, -t * 0.18))
+    );
+
+    float2 r = float2(
+        fbm(p * 1.80 + q * 2.3 + float2( 1.7, -0.8) + t * 0.11),
+        fbm(p * 1.80 + q * 2.3 + float2(-3.4,  2.1) - t * 0.09)
+    );
+
+    return p + (q - 0.5) * 0.55 + (r - 0.5) * 0.28;
+}
+
+half4 main(float2 fragCoord) {
+    float2 uv = fragCoord / iResolution;
+    float aspect = iResolution.x / iResolution.y;
+    float px = 1.0 / min(iResolution.x, iResolution.y);
+
+    float2 p = float2((uv.x - 0.5) * aspect, uv.y - 0.5);
+
+    float t = iTime * 0.18;
+
+    float2 cam = p;
+    cam += float2(sin(t * 0.60), cos(t * 0.43)) * 0.015;
+
+    float2 w0 = warp(cam * 0.95, t * 0.8);
+    float2 w1 = warp(cam * 1.50 + float2(2.0, -1.4), -t * 0.9);
+    float2 w2 = warp(cam * 2.35 + float2(-3.4, 2.7), t * 1.1);
+
+    float f0 = ridgedFbm(w0 * 1.2 + float2(t * 0.18, -t * 0.10));
+    float f1 = ridgedFbm(w1 * 1.4 + float2(-t * 0.26, t * 0.16));
+    float f2 = fbm(w2 * 2.2 + float2(t * 0.35, t * 0.24));
+
+    float3 colBgPrimary   = float3(0.0706, 0.0706, 0.0706);
+    float3 colBgSecondary = float3(0.0941, 0.0941, 0.0941);
+    float3 colPanel       = float3(0.1176, 0.1176, 0.1176);
+    float3 colHover       = float3(0.1451, 0.1451, 0.1451);
+    float3 colBorder      = float3(0.1647, 0.1647, 0.1647);
+
+    float vgrad = smoothstep(-0.65, 0.75, p.y);
+    float3 color = mix(colBgPrimary, colBgSecondary, vgrad);
+    color = mix(color, colPanel, smoothstep(0.15, 0.95, vgrad));
+
+    float mass0 = smoothstep(0.22, 0.82, f0 + p.y * 0.18 + 0.08);
+    float mass1 = smoothstep(0.28, 0.84, f1 - p.y * 0.10);
+    float mass2 = smoothstep(0.40, 0.86, f2 + f1 * 0.18);
+
+    color += colPanel  * mass0 * 0.18;
+    color += colHover  * mass1 * 0.12;
+    color += colBorder * mass2 * 0.05;
+
+    float lv0 = f0 + p.y * 0.23 + f2 * 0.08;
+    float lv1 = f1 - p.y * 0.10 + f0 * 0.12;
+    float lv2 = f2 + f1 * 0.20;
+
+    float seamFreq0 = 4.5;
+    float seamFreq1 = 6.0;
+    float seamFreq2 = 8.5;
+
+    float c0 = abs(fract(lv0 * seamFreq0) - 0.5);
+    float c1 = abs(fract(lv1 * seamFreq1) - 0.5);
+    float c2 = abs(fract(lv2 * seamFreq2) - 0.5);
+
+    float a0 = px * seamFreq0 * 0.9;
+    float a1 = px * seamFreq1 * 0.9;
+    float a2 = px * seamFreq2 * 0.9;
+
+    float line0 = (1.0 - smoothstep(a0 * 0.55, a0 * 1.25, c0)) * mass0;
+    float line1 = (1.0 - smoothstep(a1 * 0.55, a1 * 1.25, c1)) * mass1;
+    float line2 = (1.0 - smoothstep(a2 * 0.55, a2 * 1.25, c2)) * mass2;
+
+    float glow0 = (1.0 - smoothstep(a0 * 1.8, a0 * 4.5, c0)) * mass0;
+    float glow1 = (1.0 - smoothstep(a1 * 1.8, a1 * 4.5, c1)) * mass1;
+    float glow2 = (1.0 - smoothstep(a2 * 1.8, a2 * 4.5, c2)) * mass2;
+
+    color += colPanel  * glow0 * 0.04;
+    color += colHover  * glow1 * 0.035;
+    color += colBorder * glow2 * 0.02;
+
+    color += colHover                        * line0 * 0.04;
+    color += colBorder                       * line1 * 0.03;
+    color += (colBorder + float3(0.02))      * line2 * 0.01;
+
+    float edge0 = smoothstep(0.10, 0.55, abs(f0 - f1));
+    float edge1 = smoothstep(0.08, 0.42, abs(f1 - f2));
+    color += colPanel  * edge0 * 0.16;
+    color += colHover  * edge1 * 0.12;
+
+    float sweep = sin((p.x * 1.7 - p.y * 0.8) * 4.0 + t * 1.8 + f0 * 2.0);
+    sweep = smoothstep(0.55, 0.95, sweep);
+    color += colPanel * sweep * (0.08 + 0.10 * mass1);
+
+    float2 sparkSpace = w1 * 3.2 + float2(t * 0.22, -t * 0.08);
+    float2 sparkCell  = floor(sparkSpace * 6.0);
+    float2 sparkLocal = fract(sparkSpace * 6.0) - 0.5;
+    float  sparkRnd   = hash(sparkCell);
+
+    float spark = 0.0;
+    if (sparkRnd > 0.972) {
+        float d = length(sparkLocal);
+        spark = 1.0 - smoothstep(0.05, 0.14, d);
+        spark *= 0.55 + 0.45 * sin(iTime * 2.0 + sparkRnd * 40.0);
+    }
+
+    float streak = 1.0 - smoothstep(0.03, 0.16, length(float2(sparkLocal.x * 0.55, sparkLocal.y)));
+    spark = max(spark, streak * step(0.986, sparkRnd) * 0.55);
+
+    color += colBorder * spark * (0.18 + 0.22 * mass1);
+
+    color = pow(max(color, 0.0), float3(0.95));
+
+    float grain = hash(fragCoord + iTime * 13.7) - 0.5;
+    color += grain * 0.010;
+
+    float vignette = smoothstep(1.18, 0.24, length(float2(p.x * 0.95, p.y * 1.08)));
+    color *= vignette;
+    color *= 0.96;
+
+    return half4(half3(color), 1.0);
+}
diff --git a/src/main/resources/assets/cobalt/steve.png b/src/main/resources/assets/cobalt/steve.png
new file mode 100644
index 00000000..0042fb9a
Binary files /dev/null and b/src/main/resources/assets/cobalt/steve.png differ
diff --git a/src/main/resources/assets/cobalt/theme/default.json b/src/main/resources/assets/cobalt/theme/default.json
new file mode 100644
index 00000000..0967ef42
--- /dev/null
+++ b/src/main/resources/assets/cobalt/theme/default.json
@@ -0,0 +1 @@
+{}
diff --git a/src/main/resources/assets/cobalt/ui/box.svg b/src/main/resources/assets/cobalt/ui/box.svg
new file mode 100644
index 00000000..c60c63c7
--- /dev/null
+++ b/src/main/resources/assets/cobalt/ui/box.svg
@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 24 24" fill="#FFFFFF">
+    <g fill="none" stroke="#FFFFFF" stroke-linecap="round" stroke-linejoin="round" stroke-width="2">
+        <path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"/>
+        <path d="M3.29 7L12 12l8.71-5M12 22V12"/>
+    </g>
+</svg>
diff --git a/src/main/resources/assets/cobalt/ui/hud.svg b/src/main/resources/assets/cobalt/ui/hud.svg
new file mode 100644
index 00000000..ebbfe6f3
--- /dev/null
+++ b/src/main/resources/assets/cobalt/ui/hud.svg
@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 24 24" fill="#FFFFFF">
+    <g fill="none" stroke="#FFFFFF" stroke-linecap="round" stroke-linejoin="round" stroke-width="2">
+        <rect x="3" y="3" width="18" height="18" rx="2" ry="2"/>
+        <line x1="12" y1="3" x2="12" y2="21"/>
+        <line x1="12" y1="12" x2="21" y2="12"/>
+    </g>
+</svg>
diff --git a/src/main/resources/cobalt.accesswidener b/src/main/resources/cobalt.accesswidener
new file mode 100644
index 00000000..c1830158
--- /dev/null
+++ b/src/main/resources/cobalt.accesswidener
@@ -0,0 +1,8 @@
+accessWidener v1 official
+
+accessible field net/minecraft/client/player/AbstractClientPlayer playerInfo Lnet/minecraft/client/multiplayer/PlayerInfo;
+
+accessible method net/minecraft/client/Minecraft startAttack ()Z
+accessible method net/minecraft/client/Minecraft startUseItem ()V
+
+accessible method net/minecraft/client/renderer/culling/Frustum cubeInFrustum (DDDDDD)I
diff --git a/src/main/resources/cobalt.mixins.json b/src/main/resources/cobalt.mixins.json
index bed7d454..1bf09b22 100644
--- a/src/main/resources/cobalt.mixins.json
+++ b/src/main/resources/cobalt.mixins.json
@@ -4,16 +4,13 @@
   "package": "org.cobalt.mixin",
   "compatibilityLevel": "JAVA_21",
   "client": [
-    "client.AbstractClientPlayerAccessor",
-    "client.MinecraftAccessor",
     "client.MinecraftMixin",
     "client.MouseHandlerMixin",
     "gui.ClientPacketListenerMixin",
     "gui.CommandSuggestionsMixin",
     "gui.GuiRendererMixin",
-    "gui.SplashRendererMixin",
-    "platform.WindowMixin",
-    "render.FrustumInvoker"
+    "gui.SplashManagerMixin",
+    "platform.WindowMixin"
   ],
   "mixins": [
     "mojang.YggdrasilServicesKeyInfoMixin",
diff --git a/src/main/resources/fabric.mod.json b/src/main/resources/fabric.mod.json
index 37d059ae..d2d460e3 100644
--- a/src/main/resources/fabric.mod.json
+++ b/src/main/resources/fabric.mod.json
@@ -20,9 +20,8 @@
       }
     ]
   },
-  "mixins": [
-    "cobalt.mixins.json"
-  ],
+  "mixins": ["cobalt.mixins.json"],
+  "accessWidener": "cobalt.accesswidener",
   "depends": {
     "java": ">=25",
     "fabric-api": "*",