diff --git a/.luacheckrc b/.luacheckrc
index 084ab76..6c0381d 100644
--- a/.luacheckrc
+++ b/.luacheckrc
@@ -460,7 +460,7 @@ do -- Factorio STDs--
             -- @global@: The global dictionary, useful for storing data persistent across a save-load cycle.
             -- Writing access is given to the mod-id field (for mod-wise saved data).
             -- (http://lua-api.factorio.com/latest/Global.html)
-            "global",
+            "storage",
 
             -- @MOD@: Keep it organized, use this variable for anything that "NEEDS" to be global for some reason.
             "MOD"
diff --git a/module/control.lua b/module/control.lua
index 947434b..96a2fac 100644
--- a/module/control.lua
+++ b/module/control.lua
@@ -26,20 +26,20 @@ local universal_edges = {
 
 local function setupGlobalData()
 	local GLOBAL_VERSION = 3
-	if global.universal_edges == nil
-		or global.universal_edges.GLOBAL_VERSION == nil
-		or global.universal_edges.GLOBAL_VERSION < GLOBAL_VERSION
+	if storage.universal_edges == nil
+		or storage.universal_edges.GLOBAL_VERSION == nil
+		or storage.universal_edges.GLOBAL_VERSION < GLOBAL_VERSION
 	then
 		-- Cleanup old global before resetting
-		if global.universal_edges and global.universal_edges.debug_shapes then
-			local debug_shapes = global.universal_edges.debug_shapes
+		if storage.universal_edges and storage.universal_edges.debug_shapes then
+			local debug_shapes = storage.universal_edges.debug_shapes
 			for index, id in ipairs(debug_shapes) do
 				if id.valid then id.destroy() end
 				debug_shapes[index] = nil
 			end
 		end
 
-		global.universal_edges = {
+		storage.universal_edges = {
 			edges = {},
 			debug_shapes = {},
 			config = {},
@@ -47,31 +47,31 @@ local function setupGlobalData()
 			GLOBAL_VERSION = GLOBAL_VERSION,
 		}
 	end
-	if not global.universal_edges.carriage_drivers then
-		global.universal_edges.carriage_drivers = {}
+	if not storage.universal_edges.carriage_drivers then
+		storage.universal_edges.carriage_drivers = {}
 	end
-	if not global.universal_edges.players_waiting_to_leave then
-		global.universal_edges.players_waiting_to_leave = {}
+	if not storage.universal_edges.players_waiting_to_leave then
+		storage.universal_edges.players_waiting_to_leave = {}
 	end
-	if not global.universal_edges.players_waiting_to_join then
-		global.universal_edges.players_waiting_to_join = {}
+	if not storage.universal_edges.players_waiting_to_join then
+		storage.universal_edges.players_waiting_to_join = {}
 	end
-	global.universal_edges = global.universal_edges
+	storage.universal_edges = storage.universal_edges
 end
 
 
 local function debug_draw()
-	local debug_shapes = global.universal_edges.debug_shapes
+	local debug_shapes = storage.universal_edges.debug_shapes
     for index, id in ipairs(debug_shapes) do
 		if id.valid then id.destroy() end
         debug_shapes[index] = nil
 	end
 
-	for id, edge in pairs(global.universal_edges.edges) do
+	for id, edge in pairs(storage.universal_edges.edges) do
 		local edge_target
-		if global.universal_edges.config.instance_id == edge.source.instanceId then
+		if storage.universal_edges.config.instance_id == edge.source.instanceId then
 			edge_target = edge.source
-		elseif global.universal_edges.config.instance_id == edge.target.instanceId then
+		elseif storage.universal_edges.config.instance_id == edge.target.instanceId then
 			edge_target = edge.target
 		else
 			log("Edge with id " .. id .. " has invalid source/target")
@@ -108,17 +108,17 @@ local function debug_draw()
 end
 
 function universal_edges.set_config(config)
-	if global.universal_edges.config == nil then global.universal_edges.config = {} end
-	global.universal_edges.config.instance_id = config.instance_id
+	if storage.universal_edges.config == nil then storage.universal_edges.config = {} end
+	storage.universal_edges.config.instance_id = config.instance_id
 end
 
 local function cleanup()
 	-- Filter out edges that do not have source or target on this instance
-	for id, edge in pairs(global.universal_edges.edges) do
-		if tostring(global.universal_edges.config.instance_id) ~= tostring(edge.source.instanceId)
-			and tostring(global.universal_edges.config.instance_id) ~= tostring(edge.target.instanceId)
+	for id, edge in pairs(storage.universal_edges.edges) do
+		if tostring(storage.universal_edges.config.instance_id) ~= tostring(edge.source.instanceId)
+			and tostring(storage.universal_edges.config.instance_id) ~= tostring(edge.target.instanceId)
 		then
-			global.universal_edges.edges[id] = nil
+			storage.universal_edges.edges[id] = nil
 		end
 	end
 end
@@ -133,17 +133,17 @@ function universal_edges.edge_update(edge_id, edge_json)
 	if edge.isDeleted then
 		game.print("Deleting edge " .. edge_id)
 		-- Perform cleanup, remove edge
-		global.universal_edges.edges[edge_id] = nil
+		storage.universal_edges.edges[edge_id] = nil
 		debug_draw()
 		return
 	end
-	if global.universal_edges.edges[edge_id] == nil then
+	if storage.universal_edges.edges[edge_id] == nil then
 		game.print("Adding new edge " .. edge_id)
-		global.universal_edges.edges[edge_id] = edge
+		storage.universal_edges.edges[edge_id] = edge
 		active_status_has_changed = true
 	else
 		-- Do a partial update
-		local old_edge = global.universal_edges.edges[edge_id]
+		local old_edge = storage.universal_edges.edges[edge_id]
 		old_edge.updatedAtMs = edge.updatedAtMs
 		old_edge.source = edge.source
 		old_edge.target = edge.target
@@ -207,7 +207,7 @@ function universal_edges.edge_link_update(json)
 	if update == nil then return end
 
 	local data = update.data
-	local edge = global.universal_edges.edges[update.edge_id]
+	local edge = storage.universal_edges.edges[update.edge_id]
 	if not edge then
 		log("Got update for unknown edge " .. serpent.line(update))
 		return
@@ -245,7 +245,7 @@ function universal_edges.transfer(json)
 	local data = game.json_to_table(json)
 	if data == nil then return end
 
-	local edge = global.universal_edges.edges[data.edge_id]
+	local edge = storage.universal_edges.edges[data.edge_id]
 	if not edge then
 		rcon.print("invalid edge")
 		return
@@ -304,11 +304,11 @@ universal_edges.events = {
 		log("Universal edges startup")
 		setupGlobalData()
 		pathfinder_events.on_server_startup()
-		if not global.universal_edges.config.ticks_per_edge then
-			global.universal_edges.config.ticks_per_edge = 15
+		if not storage.universal_edges.config.ticks_per_edge then
+			storage.universal_edges.config.ticks_per_edge = 15
 		end
 		-- Refresh belt edge flow status in cases where the belt is not packed
-		for _, edge in pairs(global.universal_edges.edges) do
+		for _, edge in pairs(storage.universal_edges.edges) do
 			-- Active status is remembered from last shutdown, if its wrong this gets overwritten later
 			if edge.active and edge.linked_belts then
 				for _offset, link in pairs(edge.linked_belts) do
@@ -323,20 +323,20 @@ universal_edges.events = {
 	[defines.events.on_tick] = function(event)
 		universal_serializer.events.on_tick(event)
 		pathfinder_events.on_tick()
-		local ticks_left = -game.tick % global.universal_edges.config.ticks_per_edge
-		local id = global.universal_edges.current_edge_id
+		local ticks_left = -game.tick % storage.universal_edges.config.ticks_per_edge
+		local id = storage.universal_edges.current_edge_id
 		if id == nil then
-			id = next(global.universal_edges.edges)
+			id = next(storage.universal_edges.edges)
 			if id == nil then
 				return -- no edges
 			end
-			global.universal_edges.current_edge_id = id
+			storage.universal_edges.current_edge_id = id
 		end
-		local edge = global.universal_edges.edges[id]
+		local edge = storage.universal_edges.edges[id]
 
 		-- edge may have been removed while iterating over it
 		if edge == nil then
-			global.universal_edges.current_edge_id = nil
+			storage.universal_edges.current_edge_id = nil
 			return
 		end
 
@@ -351,7 +351,7 @@ universal_edges.events = {
 		end
 
 		if ticks_left == 0 then
-			global.universal_edges.current_edge_id = next(global.universal_edges.edges, id)
+			storage.universal_edges.current_edge_id = next(storage.universal_edges.edges, id)
 		end
 	end,
 
@@ -366,18 +366,18 @@ universal_edges.events = {
 	[defines.events.script_raised_destroy] = function(event) on_removed(event.entity) end,
 
     [defines.events.on_player_joined_game] = function(event)
-		if global.universal_edges == nil then
+		if storage.universal_edges == nil then
 			setupGlobalData()
 		end
 		entity_link.on_player_joined_game(event)
 		local player = game.players[event.player_index]
 		-- Check if we have a pending request to enter a vehicle
-		if global.universal_edges.carriage_drivers[player.name] ~= nil then
-			local entity = global.universal_edges.carriage_drivers[player.name]
+		if storage.universal_edges.carriage_drivers[player.name] ~= nil then
+			local entity = storage.universal_edges.carriage_drivers[player.name]
 			if entity.valid then
 				entity.set_driver(player)
 			end
-			global.universal_edges.carriage_drivers[player.name] = nil
+			storage.universal_edges.carriage_drivers[player.name] = nil
 		end
 	end,
 	[defines.events.on_player_left_game] = entity_link.on_player_left_game,
@@ -387,11 +387,11 @@ universal_edges.events = {
 		if entity.name == "train-stop"
 			and entity.backer_name
 			and (
-				global.universal_edges.pathfinder.rescan_connector_paths_after == nil
-				or global.universal_edges.pathfinder.rescan_connector_paths_after < game.tick
+				storage.universal_edges.pathfinder.rescan_connector_paths_after == nil
+				or storage.universal_edges.pathfinder.rescan_connector_paths_after < game.tick
 			)
 		then
-			global.universal_edges.pathfinder.rescan_connector_paths_after = game.tick + 180
+			storage.universal_edges.pathfinder.rescan_connector_paths_after = game.tick + 180
 		end
 	end,
 }
diff --git a/module/edge/entity_link.lua b/module/edge/entity_link.lua
index 0af5164..4175f67 100644
--- a/module/edge/entity_link.lua
+++ b/module/edge/entity_link.lua
@@ -18,7 +18,7 @@ local function poll_links(id, edge, ticks_left)
 	end
 
 	-- Clear records from players waiting to leave that left the edge again
-	for player_name, leave in pairs(global.universal_edges.players_waiting_to_leave) do
+	for player_name, leave in pairs(storage.universal_edges.players_waiting_to_leave) do
 		if leave.edge_id == edge.id then
 			local clear = false
 			if not leave.entity.valid then
@@ -30,7 +30,7 @@ local function poll_links(id, edge, ticks_left)
 				end
 			end
 			if clear then
-				global.universal_edges.players_waiting_to_leave[player_name] = nil
+				storage.universal_edges.players_waiting_to_leave[player_name] = nil
 			end
 		end
 	end
@@ -49,10 +49,10 @@ local function poll_links(id, edge, ticks_left)
 		end
 		if entity.type == "character" then
 			if entity.player then
-				local waiting = global.universal_edges.players_waiting_to_leave[entity.player.name]
+				local waiting = storage.universal_edges.players_waiting_to_leave[entity.player.name]
 				if waiting == nil or waiting.edge_id ~= edge.id then
 					edge_pos = edge_util.world_to_edge_pos({entity.position.x, entity.position.y}, edge)
-					global.universal_edges.players_waiting_to_leave[entity.player.name] = {
+					storage.universal_edges.players_waiting_to_leave[entity.player.name] = {
 						edge_id = edge.id,
 						entity = entity,
 						edge_pos = edge_pos,
@@ -84,14 +84,14 @@ local function on_player_left_game(event)
 	if player == nil then
 		return
 	end
-	if not global.universal_edges.players_waiting_to_leave then
+	if not storage.universal_edges.players_waiting_to_leave then
 		return
 	end
-	if not global.universal_edges.players_waiting_to_leave[player.name] then
+	if not storage.universal_edges.players_waiting_to_leave[player.name] then
 		return
 	end
-	local leave = global.universal_edges.players_waiting_to_leave[player.name]
-	global.universal_edges.players_waiting_to_leave[player.name] = nil
+	local leave = storage.universal_edges.players_waiting_to_leave[player.name]
+	storage.universal_edges.players_waiting_to_leave[player.name] = nil
 	clusterio_api.send_json("universal_edges:transfer", {
 		edge_id = leave.edge_id,
 		entity_transfers = {
@@ -113,7 +113,7 @@ local function receive_transfers(edge, entity_transfers)
 	local entity_response_transfers = {}
 	for _, entity_transfer in ipairs(entity_transfers) do
 		if entity_transfer.type == "player" then
-			global.universal_edges.players_waiting_to_join[entity_transfer.player_name] = {
+			storage.universal_edges.players_waiting_to_join[entity_transfer.player_name] = {
 				edge_id = edge.id,
 				edge_pos = entity_transfer.edge_pos
 			}
@@ -127,12 +127,12 @@ local function on_player_joined_game(event)
 	if player == nil then
 		return
 	end
-	if not global.universal_edges.players_waiting_to_join[player.name] then
+	if not storage.universal_edges.players_waiting_to_join[player.name] then
 		return
 	end
-	local join = global.universal_edges.players_waiting_to_join[player.name]
-	global.universal_edges.players_waiting_to_join[player.name] = nil
-	local edge = global.universal_edges.edges[join.edge_id]
+	local join = storage.universal_edges.players_waiting_to_join[player.name]
+	storage.universal_edges.players_waiting_to_join[player.name] = nil
+	local edge = storage.universal_edges.edges[join.edge_id]
 	if not edge then
 		log("Got player joined for unknown edge " .. serpent.line(join))
 		return
diff --git a/module/edge/power_link.lua b/module/edge/power_link.lua
index 986a4bc..eccdee0 100644
--- a/module/edge/power_link.lua
+++ b/module/edge/power_link.lua
@@ -33,7 +33,7 @@ local function poll_links(id, edge, ticks_left)
 	end
 
 	-- Add power to the eei from the lua buffer to get smooth graphs
-	for _, edge in pairs(global.universal_edges.edges) do
+	for _, edge in pairs(storage.universal_edges.edges) do
 		if not edge.linked_power then
 			goto continue
 		end
@@ -46,11 +46,11 @@ local function poll_links(id, edge, ticks_left)
 				log("FATAL: received power for a link that does not have an eei " .. link.offset)
 				goto continue2
 			end
-			if global.universal_edges.linked_power_update_tick ~= nil and link.lua_buffered_energy ~= nil and link.lua_buffered_energy > 0 then
+			if storage.universal_edges.linked_power_update_tick ~= nil and link.lua_buffered_energy ~= nil and link.lua_buffered_energy > 0 then
 				local ticks_until_next_frame = 5 +
 					math.max(0,
-						global.universal_edges.linked_power_update_tick +
-						(global.universal_edges.linked_power_update_period or 60) - game.tick)
+						storage.universal_edges.linked_power_update_tick +
+						(storage.universal_edges.linked_power_update_period or 60) - game.tick)
 				link.eei.energy = link.eei.energy + link.lua_buffered_energy / ticks_until_next_frame
 				link.lua_buffered_energy = math.max(0,
 					link.lua_buffered_energy - link.lua_buffered_energy / ticks_until_next_frame)
@@ -62,7 +62,7 @@ local function poll_links(id, edge, ticks_left)
 
     -- Balance links in the same power network
     local networks = {}
-    for _, edge in pairs(global.universal_edges.edges) do
+    for _, edge in pairs(storage.universal_edges.edges) do
         if not edge.linked_power then
             goto continue
         end
@@ -100,10 +100,10 @@ local function poll_links(id, edge, ticks_left)
 end
 
 local function receive_transfers(edge, power_transfers)
-	if global.universal_edges.linked_power_update_tick then
-		global.universal_edges.linked_power_update_period = game.tick - global.universal_edges.linked_power_update_tick
+	if storage.universal_edges.linked_power_update_tick then
+		storage.universal_edges.linked_power_update_period = game.tick - storage.universal_edges.linked_power_update_tick
 	end
-	global.universal_edges.linked_power_update_tick = game.tick
+	storage.universal_edges.linked_power_update_tick = game.tick
 	if power_transfers == nil then
 		return {}
 	end
diff --git a/module/edge/train/pathfinding/events.lua b/module/edge/train/pathfinding/events.lua
index 7a9742e..ce5bb0f 100644
--- a/module/edge/train/pathfinding/events.lua
+++ b/module/edge/train/pathfinding/events.lua
@@ -12,10 +12,10 @@ local clusterio_api = require("modules/clusterio/api")
 ]]
 
 local function on_server_startup()
-	if not global.universal_edges.pathfinder then
-		global.universal_edges.pathfinder = {}
+	if not storage.universal_edges.pathfinder then
+		storage.universal_edges.pathfinder = {}
 	end
-	for _, edge in pairs(global.universal_edges.edges) do
+	for _, edge in pairs(storage.universal_edges.edges) do
 		local train_transfers = {}
 		if edge.linked_trains then
 			for offset, link in pairs(edge.linked_trains) do
@@ -59,11 +59,11 @@ local function on_built(entity)
 	-- Queue rescan
 	if types_to_cause_update[entity.type]
 		and (
-			global.universal_edges.pathfinder.rescan_connector_paths_after == nil
-			or global.universal_edges.pathfinder.rescan_connector_paths_after < game.tick
+			storage.universal_edges.pathfinder.rescan_connector_paths_after == nil
+			or storage.universal_edges.pathfinder.rescan_connector_paths_after < game.tick
 		)
 	then
-		global.universal_edges.pathfinder.rescan_connector_paths_after = game.tick + 180
+		storage.universal_edges.pathfinder.rescan_connector_paths_after = game.tick + 180
 	end
 end
 
@@ -71,20 +71,20 @@ local function on_removed(entity)
 	-- Queue rescan
 	if types_to_cause_update[entity.type]
 		and (
-			global.universal_edges.pathfinder.rescan_connector_paths_after == nil
-			or global.universal_edges.pathfinder.rescan_connector_paths_after < game.tick
+			storage.universal_edges.pathfinder.rescan_connector_paths_after == nil
+			or storage.universal_edges.pathfinder.rescan_connector_paths_after < game.tick
 		)
 	then
-		global.universal_edges.pathfinder.rescan_connector_paths_after = game.tick + 180
+		storage.universal_edges.pathfinder.rescan_connector_paths_after = game.tick + 180
 	end
 end
 
 local function on_tick()
-	if global.universal_edges.pathfinder.rescan_connector_paths_after == game.tick then
-		global.universal_edges.pathfinder.rescan_connector_paths_after = nil
+	if storage.universal_edges.pathfinder.rescan_connector_paths_after == game.tick then
+		storage.universal_edges.pathfinder.rescan_connector_paths_after = nil
 		-- Add rescan_penalties property to all links
 		log("Starting rescan")
-		for _, edge in pairs(global.universal_edges.edges) do
+		for _, edge in pairs(storage.universal_edges.edges) do
 			if edge.linked_trains then
 				for _, link in pairs(edge.linked_trains) do
 					if link.is_input == false then
diff --git a/module/edge/train/pathfinding/update.lua b/module/edge/train/pathfinding/update.lua
index 1e0a75e..dc70725 100644
--- a/module/edge/train/pathfinding/update.lua
+++ b/module/edge/train/pathfinding/update.lua
@@ -327,11 +327,11 @@ local function update_train_penalty_map(offset, edge, penalty_map)
 		paths with modificaitons.
 	]]
 	if (
-			global.universal_edges.pathfinder.rescan_connector_paths_after == nil
-			or global.universal_edges.pathfinder.rescan_connector_paths_after < game.tick
+			storage.universal_edges.pathfinder.rescan_connector_paths_after == nil
+			or storage.universal_edges.pathfinder.rescan_connector_paths_after < game.tick
 		)
 	then
-		global.universal_edges.pathfinder.rescan_connector_paths_after = game.tick + 180
+		storage.universal_edges.pathfinder.rescan_connector_paths_after = game.tick + 180
 	end
 end
 
diff --git a/module/edge/train/train_box.lua b/module/edge/train/train_box.lua
index 802f564..759f9ad 100644
--- a/module/edge/train/train_box.lua
+++ b/module/edge/train/train_box.lua
@@ -198,11 +198,11 @@ local function create_train_destination_box(offset, edge, surface, update)
 		This enables propagaiton over multiple instances in a cluster.
 	]]
 	if (
-			global.universal_edges.pathfinder.rescan_connector_paths_after == nil
-			or global.universal_edges.pathfinder.rescan_connector_paths_after < game.tick
+			storage.universal_edges.pathfinder.rescan_connector_paths_after == nil
+			or storage.universal_edges.pathfinder.rescan_connector_paths_after < game.tick
 		)
 	then
-		global.universal_edges.pathfinder.rescan_connector_paths_after = game.tick + 180
+		storage.universal_edges.pathfinder.rescan_connector_paths_after = game.tick + 180
 	end
 
 	return true
diff --git a/module/edge/train/train_link.lua b/module/edge/train/train_link.lua
index 0aa39c2..2599cbc 100644
--- a/module/edge/train/train_link.lua
+++ b/module/edge/train/train_link.lua
@@ -275,13 +275,13 @@ local function receive_transfers(edge, train_transfers)
 						if player ~= nil then
 							-- Check if both sides of the edge are on the same instanceId
 							if edge.source.instanceId == edge.target.instanceId then
-								local new_carriage = global.universal_edges.carriage_drivers[player.name]
+								local new_carriage = storage.universal_edges.carriage_drivers[player.name]
 								if new_carriage ~= nil and new_carriage.valid then
 									new_carriage.set_driver(player)
 								else
 									player.print("Carriage not found, did you miss your train?")
 								end
-								global.universal_edges.carriage_drivers[player.name] = nil
+								storage.universal_edges.carriage_drivers[player.name] = nil
 							else
 								-- Cross server train rides need talking to the controller to figure out where to go
 								clusterio_api.send_json("universal_edges:teleport_player_to_server", {
diff --git a/module/edge/util.lua b/module/edge/util.lua
index 0b5c71b..0fbb1ca 100644
--- a/module/edge/util.lua
+++ b/module/edge/util.lua
@@ -1,16 +1,16 @@
 local vectorutil = require("modules/universal_edges/vectorutil")
 
 local function edge_get_local_target(edge)
-	if global.universal_edges.config.instance_id == edge.source.instanceId then
+	if storage.universal_edges.config.instance_id == edge.source.instanceId then
 		return edge.source
-	elseif global.universal_edges.config.instance_id == edge.target.instanceId then
+	elseif storage.universal_edges.config.instance_id == edge.target.instanceId then
 		return edge.target
 	end
 end
 local function edge_get_remote_target(edge)
-	if global.universal_edges.config.instance_id == edge.source.instanceId then
+	if storage.universal_edges.config.instance_id == edge.source.instanceId then
 		return edge.target
-	elseif global.universal_edges.config.instance_id == edge.target.instanceId then
+	elseif storage.universal_edges.config.instance_id == edge.target.instanceId then
 		return edge.source
 	end
 end
diff --git a/module/events/on_built.lua b/module/events/on_built.lua
index 61f9b39..a87a0d2 100644
--- a/module/events/on_built.lua
+++ b/module/events/on_built.lua
@@ -16,7 +16,7 @@ local pathfinder_events = require("modules/universal_edges/edge/train/pathfindin
 local function on_built(entity)
 	if entity.valid and util.is_transport_belt[entity.name] then
 		local pos = { entity.position.x, entity.position.y }
-		for id, edge in pairs(global.universal_edges.edges) do
+		for id, edge in pairs(storage.universal_edges.edges) do
 			if edge.active and game.surfaces[edge_util.edge_get_local_target(edge).surface] == entity.surface then
 				local offset = belt_check(pos, entity.direction, edge)
 				if offset ~= nil then
@@ -28,7 +28,7 @@ local function on_built(entity)
 	end
 	if entity.valid and util.is_pipe[entity.name] then
 		local pos = { entity.position.x, entity.position.y }
-		for id, edge in pairs(global.universal_edges.edges) do
+		for id, edge in pairs(storage.universal_edges.edges) do
 			if edge.active and game.surfaces[edge_util.edge_get_local_target(edge).surface] == entity.surface then
 				local offset = fluid_check(pos, entity.direction, edge)
 				if offset ~= nil then
@@ -39,7 +39,7 @@ local function on_built(entity)
 	end
 	if entity.valid and entity.name == "substation" then
 		local pos = { entity.position.x, entity.position.y }
-		for id, edge in pairs(global.universal_edges.edges) do
+		for id, edge in pairs(storage.universal_edges.edges) do
 			if edge.active and game.surfaces[edge_util.edge_get_local_target(edge).surface] == entity.surface then
 				local offset = power_check(pos, edge)
 				if offset ~= nil then
@@ -50,7 +50,7 @@ local function on_built(entity)
 	end
 	if entity.valid and entity.name == "straight-rail" then
 		local pos = { entity.position.x, entity.position.y }
-		for id, edge in pairs(global.universal_edges.edges) do
+		for id, edge in pairs(storage.universal_edges.edges) do
 			if edge.active and game.surfaces[edge_util.edge_get_local_target(edge).surface] == entity.surface then
 				-- We can reuse power_check since rail is the same size as substation
 				local offset = power_check(pos, edge)
diff --git a/module/events/on_removed.lua b/module/events/on_removed.lua
index 9ed4074..2ab36f7 100644
--- a/module/events/on_removed.lua
+++ b/module/events/on_removed.lua
@@ -16,7 +16,7 @@ local pathfinder_events = require("modules/universal_edges/edge/train/pathfindin
 local function on_removed(entity)
 	if entity.valid and util.is_transport_belt[entity.name] then
 		local pos = { entity.position.x, entity.position.y }
-		for id, edge in pairs(global.universal_edges.edges) do
+		for id, edge in pairs(storage.universal_edges.edges) do
 			if edge.active and game.surfaces[edge_util.edge_get_local_target(edge).surface] == entity.surface then
 				local offset = belt_check(pos, entity.direction, edge)
 				if offset ~= nil then
@@ -28,7 +28,7 @@ local function on_removed(entity)
 	end
 	if entity.valid and util.is_pipe[entity.name] then
 		local pos = { entity.position.x, entity.position.y }
-		for id, edge in pairs(global.universal_edges.edges) do
+		for id, edge in pairs(storage.universal_edges.edges) do
 			if edge.active and game.surfaces[edge_util.edge_get_local_target(edge).surface] == entity.surface then
 				local offset = fluid_check(pos, entity.direction, edge)
 				if offset ~= nil then
@@ -40,7 +40,7 @@ local function on_removed(entity)
 	end
 	if entity.valid and entity.name == "substation" then
 		local pos = { entity.position.x, entity.position.y }
-		for id, edge in pairs(global.universal_edges.edges) do
+		for id, edge in pairs(storage.universal_edges.edges) do
 			if edge.active and game.surfaces[edge_util.edge_get_local_target(edge).surface] == entity.surface then
 				local offset = power_check(pos, edge)
 				if offset ~= nil then
@@ -51,7 +51,7 @@ local function on_removed(entity)
 	end
 	if entity.valid and entity.name == "straight-rail" then
 		local pos = { entity.position.x, entity.position.y }
-		for id, edge in pairs(global.universal_edges.edges) do
+		for id, edge in pairs(storage.universal_edges.edges) do
 			if edge.active and game.surfaces[edge_util.edge_get_local_target(edge).surface] == entity.surface then
 				-- We can reuse power_check since rail is the same size as substation
 				local offset = power_check(pos, edge)
diff --git a/module/universal_serializer/classes/LuaTrainComplete_deserialize.lua b/module/universal_serializer/classes/LuaTrainComplete_deserialize.lua
index 95b44c4..0059916 100644
--- a/module/universal_serializer/classes/LuaTrainComplete_deserialize.lua
+++ b/module/universal_serializer/classes/LuaTrainComplete_deserialize.lua
@@ -10,7 +10,7 @@ local function LuaTrainComplete_deserialize(train_data)
 		entity = LuaEntity_deserialize(carriage)
 		-- Store carriage entity under player name to be able to return player to the carriage once they arrive_signal
 		if carriage.driver_name then
-			global.universal_edges.carriage_drivers[carriage.driver_name] = entity
+			storage.universal_edges.carriage_drivers[carriage.driver_name] = entity
 		end
 		log("Deserialized carriage " .. _)
 	end
diff --git a/module/universal_serializer/events/on_tick.lua b/module/universal_serializer/events/on_tick.lua
index 1b94942..fac0c70 100644
--- a/module/universal_serializer/events/on_tick.lua
+++ b/module/universal_serializer/events/on_tick.lua
@@ -1,15 +1,15 @@
 local LuaEntity_deserialize = require("modules/universal_edges/universal_serializer/classes/LuaEntity_deserialize")
 
 local function on_tick()
-	if global.universal_edges.delayed_entities_tick ~= nil
-		and global.universal_edges.delayed_entities_tick <= game.tick
-		and #(global.universal_edges.delayed_entities or {}) > 0
+	if storage.universal_edges.delayed_entities_tick ~= nil
+		and storage.universal_edges.delayed_entities_tick <= game.tick
+		and #(storage.universal_edges.delayed_entities or {}) > 0
 	then
 		-- Attempt to deserialize delayed entities
-		for i = #global.universal_edges.delayed_entities, 1, -1 do
-			local entity = global.universal_edges.delayed_entities[i]
+		for i = #storage.universal_edges.delayed_entities, 1, -1 do
+			local entity = storage.universal_edges.delayed_entities[i]
 			LuaEntity_deserialize(entity, true)
-			table.remove(global.universal_edges.delayed_entities, i)
+			table.remove(storage.universal_edges.delayed_entities, i)
 		end
 	end
 end