diff --git a/src/frontend/il/app.cljs b/src/frontend/il/app.cljs
index 2c17c2b..52494b9 100644
--- a/src/frontend/il/app.cljs
+++ b/src/frontend/il/app.cljs
@@ -49,22 +49,29 @@
         entity-relative-mouse-pos (.toLocal ^js entity-layer global-mouse-pos)
         send-interval 25 ; Send every 25ms (10 tps)
         elapsed (.-elapsedMS t)
-        {:keys [player entities]} (-> (update @state :elapsed + elapsed)
-                                      (update/update-state :entities dt layers)
-                                      (update/update-state :players dt layers)
-                                      (update/update-player dt send-interval layers entity-relative-mouse-pos sb)
-                                      (update/update-from-server rx-chan)
-                                      (drain-outbox! tx-chan)
-                                      (->> (swap! state merge)))
+        {player :player} @state
+        {:keys [player entities players]} (-> (update @state :elapsed + elapsed)
+                                              (update/update-state :entities dt layers)
+                                              (update/update-state :players dt layers)
+                                              (update/update-player dt send-interval layers entity-relative-mouse-pos sb)
+                                              (update/update-from-server rx-chan)
+                                              (drain-outbox! tx-chan)
+                                              (->> (swap! state merge)))
         sx (- (/ (.. app -screen -width) 2) (player :x))
         sy (- (/ (.. app -screen -height) 2) (player :y))
         entity-renderables (->> (vals entities)
                                 (remove #(nil? (% :renderable)))
                                 (vec))
+        other-players-renderables (->> (vals players)
+                                       (remove #(nil? (% :renderable)))
+                                       (vec))
         world-renderables (vector {:renderable world-layer :x sx :y sy})
         player-renderables (vector player
                                    (assoc player :renderable (:shootbox player)))
-        things-to-update (concat player-renderables entity-renderables world-renderables)]
+        things-to-update (concat player-renderables
+                                 other-players-renderables
+                                 entity-renderables
+                                 world-renderables)]
     (doseq [thing things-to-update]
       (let [{renderable :renderable
              x :x
diff --git a/src/frontend/il/update.cljs b/src/frontend/il/update.cljs
index da2b49c..d936c9a 100644
--- a/src/frontend/il/update.cljs
+++ b/src/frontend/il/update.cljs
@@ -17,7 +17,6 @@
   (if (and (nil? (e :renderable)) (e :sprite))
     (let [{entity-layer :entity-layer} layers
           renderable (entity/render entity-layer e)]
-      (js/console.log (clj->js e))
       (assoc e :renderable renderable))
     e))
 
@@ -56,16 +55,17 @@
           (update :outbox conj {:type "position" :x x :y y}))
       state)))
 
-;; TODO: Cleanup entities somehow
 (defn update-state [state key dt layers]
   (let [{v key} state
-        new-entities (update-vals v #(-> %
-                                         (apply-server-position)
-                                         (apply-renderable layers)
-                                         (apply-velocity dt)))]
-    (assoc state key new-entities)))
+        _ (js/console.log (clj->js v))
+        new-values (update-vals v #(-> %
+                                       (apply-server-position)
+                                       (apply-renderable layers)
+                                       (apply-velocity dt)))]
+    (assoc state key new-values)))
 
 (defn update-player [state dt send-interval layers mouse-pos sb]
+  (println state)
   (let [{player :player} state
         updated-player (-> player
                            (apply-renderable layers)
diff --git a/src/il/core.clj b/src/il/core.clj
index 6600bc3..b5cf311 100644
--- a/src/il/core.clj
+++ b/src/il/core.clj
@@ -12,14 +12,20 @@
             [il.system.movement :as movement]))
 
 (defn ws-handler [state state-chan player-id]
+  (println "Starting session for " player-id)
   (go-websocket [in out err]
                 (go-loop []
                   (when-let [e (<! err)]
                     (println (.getMessage e))
                     (recur)))
                 (go-loop []
-                  (if-let [raw (<! in)]
-                    (if (contains? (@state :players) player-id)
+                  (if-not (contains? (@state :players) player-id)
+                    (do (s/change state-chan update :players assoc player-id {:out out :in in :err err
+                                                                              :x 0 :y 0
+                                                                              :initialized false
+                                                                              :data (merge p/default-player {:id player-id})})
+                        (recur))
+                    (if-let [raw (<! in)]
                       (let [msg (j/from-json raw)
                             type (get msg :type "invalid")
                             state @state]
@@ -31,12 +37,9 @@
                         (println msg)
                         (println state)
                         (recur))
-                      (do (s/change state-chan update :players assoc player-id {:out out :in in :err err :x 0 :y 0
-                                                                                :data (merge p/default-player {:id player-id})})
-                          (recur)))
-                    (do
-                      (s/change state-chan update :players dissoc player-id)
-                      (println "Closed: " player-id))))))
+                      (do
+                        (s/change state-chan update :players dissoc player-id)
+                        (println "Closed: " player-id)))))))
 
 (defn index-handler [_]
   (h/html
@@ -58,7 +61,7 @@
 (defn game-loop [state state-chan]
   (go-loop []
     (let [start-time (System/currentTimeMillis)
-          max-inputs-per-tick 15000 ; Stops the game from spinning for too long with events endlessly, dropping ticks
+          max-inputs-per-tick 15000 ; Stops the game from spinning for too long with events endlessly dropping ticks
           events-to-apply (loop [inputs []
                                  count 0]
                             (if (>= count max-inputs-per-tick)
@@ -77,16 +80,28 @@
             entities (updated-state :entities)
             players (updated-state :players)]
         (doseq [{:keys [initialized data out] :as player} (vals players)]
-          (when-not (nil? out)
-            (when (nil? initialized)
-              (>! out (j/to-json (assoc (merge data (select-keys player [:x :y])) :type "init")))
-              (s/change state-chan update-in [:players (data :id)] assoc :initialized true))
-            (>! out (j/to-json {:type "sync"
-                                :entities entities
-                                :players (update-vals players #(select-keys % [:x :y :data :sprite]))})))))
+          (let [player-id (data :id)]
+            (println player)
+            (when-not (nil? out)
+              (when-not initialized
+                (let [coords (select-keys player [:x :y])
+                      data-to-send (conj data coords)
+                      msg (assoc data-to-send :type "init")]
+                  (println "Initializing " player-id)
+                  (async/put! out (j/to-json msg))
+                  (s/change state-chan update-in [:players player-id] assoc :initialized true)))
+              (let [players (update-vals players (fn [e] (-> e
+                                                             (select-keys [:x :y :data])
+                                                             (#(merge (dissoc % :data) (get % :data))))))
+                    players-without-player-id (dissoc players player-id)] ; Strip the selected player from the update
+                (async/put! out (j/to-json {:type "sync"
+                                            :entities entities
+                                            :players players-without-player-id})))))))
+
       (let [elapsed (- (System/currentTimeMillis) start-time)
             sleep-time (max 0 (- 50 elapsed))]
         (<! (async/timeout sleep-time)))
+
       (recur))))
 
 (defn -main []
diff --git a/src/il/handler.clj b/src/il/handler.clj
index 746c848..7a95a78 100644
--- a/src/il/handler.clj
+++ b/src/il/handler.clj
@@ -3,11 +3,10 @@
             [il.common.velocity :as v]))
 
 (defn handle-position [_ state-chan player-id {x :x y :y}]
-  (println "Setting player movement: " player-id x y)
   (s/change state-chan update-in [:players player-id] assoc :x x :y y))
 
 (defn handle-request-init [_ state-chan player-id _]
-  (s/change state-chan update-in [:players player-id] dissoc :initialized))
+  (s/change state-chan update-in [:players player-id] assoc :initialized false))
 
 (defn handle-shoot [_ state-chan player-id msg]
   (let [bullet-id (random-uuid)
diff --git a/src/il/player.clj b/src/il/player.clj
index d495411..c6bdc18 100644
--- a/src/il/player.clj
+++ b/src/il/player.clj
@@ -9,5 +9,4 @@
           :race race/human
           :class class/priest}
    :sprite "https://pixijs.com/assets/bunny.png"
-   :speed 10
-   :renderable nil})
+   :speed 10})