                                      world))) world-state observers) observing]
          :else :zero))
 
+(defmulti step (fn [lens world-state]
+                 (prn lens "and" world-state)
+                 (ast-type (fetch world-state lens))))
+
+(defmethod step :vector [morphs-ref world-state]
+  (reduce (fn [world-state idx]
+            (step (conj morphs-ref idx) world-state)) 
+          world-state 
+          (range (count (fetch world-state morphs-ref)))))
+
+(defmethod step :expr [expr-ref world-state]
+  (step (conj expr-ref submorphs) world-state))
+
+(defmethod step :morph [morph-ref world-state]
+  (let [morph (fetch world-state morph-ref)
+        world-state (if-let [step-fn (-> morph meta :compiled-props :step)]
+                      (if (fn? step-fn) 
+                        (do
+                          (prn step-fn)
+                          (step-fn world-state morph-ref))
+                        (do 
+                          (prn "Errornous step function: " step-fn)
+                          world-state))
+                      world-state)
+        [_ _ & submorphs] morph]
+    (if submorphs 
+      (step (conj morph-ref cljs-morphic.morph/submorphs) world-state)
+      world-state)))
+
+; (js/setInterval
+;   #(go (>! signals {:type :step}))
+;   1000)
+
+(defn stepping [world-state {evt-type :type}]
+  (match [evt-type]
+         [:step] [(step [it] world-state) stepping]
+         :else :zero))
+
 (def lively
   "A lively set of transitions. Enables, morphs to be grabbable, draggable, observable 
    and inspectable. This provides live and direct interaction with morphic objects."
   [(either grabbing dragging)
+   stepping
    inspecting
    observing
    hand])
 
 (def default-world-state
   [(rectangle {:id "world" 
-                  :extent {:x 1000 :y 1000} 
-                  :position {:x 500 :y 0} 
+                  :extent {:x 1500 :y 1000} 
+                  :position {:x 0 :y 0} 
                   :fill "darkgrey"})
-   (rectangle {:id "handMorph" :fill "red" :extent {:x 2 :y 2}})
-   (ace-editor "Welcome to cljs-morphic!" {:x 0 :y 0} {:x 500 :y 1000} "world-editor")])
+   (rectangle {:id "handMorph" :fill "red" :extent {:x 2 :y 2}})])
 
 (defn tree [stem-pos]
   (rectangle

              (add-morphs-to "world" editor)
              (focus-editor-on editor-id focused-morph-id))) 
          (partial inspection-protected focused-morph-id)]
         [:io _ _] [(do
                      (pprint (args :value))
                      world-state) 
                    (partial inspection-protected focused-morph-id)]
         ; redefine the morph the editor is editing by compiling the new description and hot swapping it
         [:mouse-down-left _ "closeButton"] [(-> world-state 

                               {id :id inspectable? :inspectable? target :target} :target-props
                               args :args}]
  (match [evt-type inspectable?]
         [:mouse-down-right true] [(morphic-read (-> world-state
                                                   (halo id))) (partial inspection-active id)]
         [:io _] [(do
                    (redefine world-state ($morph target) (fn [_ _ _]
                                                            (morphic-read (read-string (args :value))))))
                  (partial inspecting)]
         :else :zero))

