diff --git a/src/main/scala/ocelot/desktop/inventory/Items.scala b/src/main/scala/ocelot/desktop/inventory/Items.scala
index ed09fbd..3034fab 100644
--- a/src/main/scala/ocelot/desktop/inventory/Items.scala
+++ b/src/main/scala/ocelot/desktop/inventory/Items.scala
@@ -20,80 +20,7 @@ object Items extends Logging {
   // this is just to force load the class during initialization
   def init(): Unit = {}
 
-  /** Registers a recoverer for [[ItemRecoverer.sourceClass]]. */
-  def registerRecoverer(recoverer: ItemRecoverer[_, _]): Unit = {
-    if (!_recoverers.contains(recoverer.sourceClass)) {
-      _recoverers(recoverer.sourceClass) = recoverer
-      logger.info(s"Registered a recoverer for ${recoverer.sourceClass.getName}")
-    }
-  }
-
-  private def registerItemFactoryRecoverers(factory: ItemFactory): Unit = {
-    for (recoverer <- factory.recoverers) {
-      registerRecoverer(recoverer)
-    }
-  }
-
-  def registerSingleton(factory: ItemFactory): Unit = {
-    _groups += SingletonItemGroup(factory.name, factory)
-    registerItemFactoryRecoverers(factory)
-  }
-
-  def registerTiered(name: String, tiers: IterableOnce[Tier])(factory: Tier => ItemFactory): Unit = {
-    val group = TieredItemGroup(name, tiers.iterator.map(tier => (tier, factory(tier))).toSeq)
-    _groups += group
-
-    for ((_, factory) <- group.factories) {
-      registerItemFactoryRecoverers(factory)
-    }
-  }
-
-  def registerExtendedTiered(name: String, tiers: IterableOnce[ExtendedTier])(
-    factory: ExtendedTier => ItemFactory
-  ): Unit = {
-    val group = ExtendedTieredItemGroup(name, tiers.iterator.map(tier => (tier, factory(tier))).toSeq)
-    _groups += group
-
-    for ((_, factory) <- group.factories) {
-      registerItemFactoryRecoverers(factory)
-    }
-  }
-
-  def registerArbitrary(name: String, icon: IconSource, factories: IterableOnce[(String, ItemFactory)]): Unit = {
-    val group = ArbitraryItemGroup(name, icon, factories.iterator.toSeq)
-    _groups += group
-
-    for ((_, factory) <- group.factories) {
-      registerItemFactoryRecoverers(factory)
-    }
-  }
-
-  def groups: Iterable[ItemGroup] = _groups
-
-  /** Attempts to recover an [[Item]] from `source`.
-    *
-    * Checks superclasses and traits while looking for a recoverer.
-    */
-  def recover[A](source: A): Option[Item] = {
-    linearizationOrder(source.getClass.asInstanceOf[Class[_]])
-      .flatMap(_recoverers.get)
-      .map(_.asInstanceOf[ItemRecoverer[_ >: A, _ <: Item]].recover(source))
-      .nextOption()
-  }
-
-  sealed trait ItemGroup {
-    def name: String
-  }
-
-  case class SingletonItemGroup(name: String, factory: ItemFactory) extends ItemGroup
-
-  case class TieredItemGroup(name: String, factories: Seq[(Tier, ItemFactory)]) extends ItemGroup
-
-  case class ExtendedTieredItemGroup(name: String, factories: Seq[(ExtendedTier, ItemFactory)]) extends ItemGroup
-
-  case class ArbitraryItemGroup(name: String, icon: IconSource, factories: Seq[(String, ItemFactory)]) extends ItemGroup
-
-  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  logger.debug("Initialize item serialization...")
 
   registerTiered("CPU", Tier.One to Tier.Three)(new CpuItem.Factory(_))
   registerTiered("APU", Tier.Two to Tier.Creative)(tier => new ApuItem.Factory(tier.saturatingSub(1)))
@@ -166,4 +93,81 @@ object Items extends Logging {
       .map(new TapeItem.Factory(_))
       .map(factory => (f"${factory.name}%s (${Tape.lengthMinutes(factory.kind)}%.0f min)", factory)),
   )
+
+  logger.debug("Item serialization initialization finished.")
+
+  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+  /** Registers a recoverer for [[ItemRecoverer.sourceClass]]. */
+  private def registerRecoverer(recoverer: ItemRecoverer[_, _]): Unit = {
+    if (!_recoverers.contains(recoverer.sourceClass)) {
+      _recoverers(recoverer.sourceClass) = recoverer
+      logger.debug(s"Registered a recoverer for ${recoverer.sourceClass.getName}")
+    }
+  }
+
+  private def registerItemFactoryRecoverers(factory: ItemFactory): Unit = {
+    for (recoverer <- factory.recoverers) {
+      registerRecoverer(recoverer)
+    }
+  }
+
+  def registerSingleton(factory: ItemFactory): Unit = {
+    _groups += SingletonItemGroup(factory.name, factory)
+    registerItemFactoryRecoverers(factory)
+  }
+
+  def registerTiered(name: String, tiers: IterableOnce[Tier])(factory: Tier => ItemFactory): Unit = {
+    val group = TieredItemGroup(name, tiers.iterator.map(tier => (tier, factory(tier))).toSeq)
+    _groups += group
+
+    for ((_, factory) <- group.factories) {
+      registerItemFactoryRecoverers(factory)
+    }
+  }
+
+  def registerExtendedTiered(name: String, tiers: IterableOnce[ExtendedTier])(
+    factory: ExtendedTier => ItemFactory
+  ): Unit = {
+    val group = ExtendedTieredItemGroup(name, tiers.iterator.map(tier => (tier, factory(tier))).toSeq)
+    _groups += group
+
+    for ((_, factory) <- group.factories) {
+      registerItemFactoryRecoverers(factory)
+    }
+  }
+
+  def registerArbitrary(name: String, icon: IconSource, factories: IterableOnce[(String, ItemFactory)]): Unit = {
+    val group = ArbitraryItemGroup(name, icon, factories.iterator.toSeq)
+    _groups += group
+
+    for ((_, factory) <- group.factories) {
+      registerItemFactoryRecoverers(factory)
+    }
+  }
+
+  def groups: Iterable[ItemGroup] = _groups
+
+  /** Attempts to recover an [[Item]] from `source`.
+    *
+    * Checks superclasses and traits while looking for a recoverer.
+    */
+  def recover[A](source: A): Option[Item] = {
+    linearizationOrder(source.getClass.asInstanceOf[Class[_]])
+      .flatMap(_recoverers.get)
+      .map(_.asInstanceOf[ItemRecoverer[_ >: A, _ <: Item]].recover(source))
+      .nextOption()
+  }
+
+  sealed trait ItemGroup {
+    def name: String
+  }
+
+  case class SingletonItemGroup(name: String, factory: ItemFactory) extends ItemGroup
+
+  case class TieredItemGroup(name: String, factories: Seq[(Tier, ItemFactory)]) extends ItemGroup
+
+  case class ExtendedTieredItemGroup(name: String, factories: Seq[(ExtendedTier, ItemFactory)]) extends ItemGroup
+
+  case class ArbitraryItemGroup(name: String, icon: IconSource, factories: Seq[(String, ItemFactory)]) extends ItemGroup
 }
diff --git a/src/main/scala/ocelot/desktop/util/Spritesheet.scala b/src/main/scala/ocelot/desktop/util/Spritesheet.scala
index 3e4cf81..4a65d26 100644
--- a/src/main/scala/ocelot/desktop/util/Spritesheet.scala
+++ b/src/main/scala/ocelot/desktop/util/Spritesheet.scala
@@ -30,7 +30,7 @@ object Spritesheet extends Resource with Logging {
   }
 
   def load(): Unit = {
-    logger.info("Loading sprites")
+    logger.info("Loading sprites...")
 
     val imageURL = getClass.getResource("/ocelot/desktop/images/spritesheet/spritesheet.png")
     val image = ImageIO.read(imageURL)