diff --git a/README.md b/README.md
index 357f9f7..8e88f21 100644
--- a/README.md
+++ b/README.md
@@ -138,6 +138,12 @@ If you'd like to see the options for the benchmarking tool, just run `lein bench
 
 See the `doc/` folder for technical details of the hitchhiker tree and Redis garbage collection system.
 
+### Async support
+
+We have preliminary async support that has to be selected before macro expansion
+time by setting `hitchhiker.tree.async/*async-backend*` either to `none` or
+`core.async`.
+
 ## Gratitude
 
 Thanks to the early reviewers, Kovas Boguta & Leif Walsh.
diff --git a/project.clj b/project.clj
index 3203edc..5307388 100644
--- a/project.clj
+++ b/project.clj
@@ -1,17 +1,17 @@
-(defproject hitchhiker-tree "0.1.0-SNAPSHOT"
+(defproject io.replikativ/hitchhiker-tree "0.1.2"
   :description "A Hitchhiker Tree Library"
   :url "https://github.com/dgrnbrg/hitchhiker-tree"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
-  :dependencies [[org.clojure/clojure "1.8.0"]
+  :dependencies [[org.clojure/clojure "1.9.0"]
                  [org.clojure/clojurescript "1.8.51" :scope "provided"]
                  [org.clojure/core.memoize "0.5.8"]
                  [com.taoensso/carmine "2.12.2"]
                  [org.clojure/core.rrb-vector "0.0.11"]
                  [org.clojure/core.cache "0.6.5"]
 
-                 [io.replikativ/incognito "0.2.2-SNAPSHOT"]
-                 [io.replikativ/konserve "0.4.9"]]
+                 [io.replikativ/konserve "0.5.0-beta3"]
+                 ]
   :aliases {"bench" ["with-profile" "profiling" "run" "-m" "hitchhiker.bench"]}
   :jvm-opts ["-server" "-Xmx3700m" "-Xms3700m"]
   :profiles {:test
@@ -23,15 +23,18 @@
                              [org.clojure/tools.cli "0.3.3"]
                              [org.clojure/test.check "0.9.0"]
                              [com.infolace/excel-templates "0.3.3"]]}
-             :dev {:dependencies [[binaryage/devtools "0.8.2"]
-                                  [figwheel-sidecar "0.5.8"]
-                                  [com.cemerick/piggieback "0.2.1"]
-                                  [org.clojure/test.check "0.9.0"]]
+             :dev {:dependencies [#_[binaryage/devtools "0.8.2"]
+                                  #_[figwheel-sidecar "0.5.8"]
+                                  #_[com.cemerick/piggieback "0.2.1"]
+                                  [org.clojure/test.check "0.9.0"]
+                                  ;; plotting
+                                  [aysylu/loom "1.0.1"]
+                                  [cheshire "5.8.0"]]
                    :source-paths ["src" "dev"]
-                   :plugins [[lein-figwheel "0.5.8"]]
+                   ;:plugins [[lein-figwheel "0.5.8"]]
                    :repl-options {; for nREPL dev you really need to limit output
                                   :init (set! *print-length* 50)
-                                  :nrepl-middleware [cemerick.piggieback/wrap-cljs-repl]}}}
+                                  #_:nrepl-middleware #_[cemerick.piggieback/wrap-cljs-repl]}}}
   :clean-targets ^{:protect false} ["resources/public/js/compiled" "target"]
 
 
diff --git a/src/hitchhiker/konserve.cljc b/src/hitchhiker/konserve.cljc
index eeed82e..2a05638 100644
--- a/src/hitchhiker/konserve.cljc
+++ b/src/hitchhiker/konserve.cljc
@@ -3,13 +3,16 @@
   (:require [clojure.core.rrb-vector :refer [catvec subvec]]
             #?(:clj [clojure.core.async :refer [chan promise-chan put!] :as async]
                :cljs [cljs.core.async :refer [chan promise-chan put!] :as async])
-            [konserve.core :as k]
+            [konserve.cache :as k]
+            #?(:clj [clojure.core.cache :as cache]
+               :cljs [cljs.cache :as cache])
             [konserve.memory :refer [new-mem-store]]
             [hasch.core :refer [uuid]]
             [clojure.set :as set]
-            #?(:clj [hitchhiker.tree.core :refer [go-try <?] :as core]
+            #?(:clj [hitchhiker.tree.core :refer [go-try <? <??] :as core]
                :cljs [hitchhiker.tree.core :as core])
-            [hitchhiker.tree.messaging :as msg])
+            [hitchhiker.tree.messaging :as msg]
+            [hitchhiker.tree.async :refer [*async-backend*]])
   #?(:cljs (:require-macros [hitchhiker.tree.core :refer [go-try <?]])))
 
 
@@ -24,9 +27,20 @@
   (dirty? [_] false)
   (last-key [_] last-key)
   (resolve [_]
-    (go-try
-      (-> (<? (k/get-in store [konserve-key]))
-          (assoc :storage-addr (synthesize-storage-addr konserve-key))))))
+    ;; inline konserve cache resolution
+    (let [cache (:cache store)]
+      (if-let [v (cache/lookup @cache konserve-key)]
+        (go-try
+            #_(prn "hitting cache" konserve-key)
+          (swap! cache cache/hit konserve-key)
+          (assoc v :storage-addr (synthesize-storage-addr konserve-key)))
+        (go-try
+            #_(prn "missing cache")
+            (let [ch (k/get-in store [konserve-key])]
+              (-> (case *async-backend*
+                    :none (async/<!! ch)
+                    :core.async (<? ch))
+                  (assoc :storage-addr (synthesize-storage-addr konserve-key)))))))))
 
 
 (defrecord KonserveBackend [store]
@@ -43,42 +57,51 @@
                         (update :children (fn [cs] (mapv #(assoc % :store nil
                                                                  :storage-addr nil) cs))))
                     (assoc node :storage-addr nil))]
-        (let [id (uuid pnode)]
-          (<? (k/assoc-in store [id] node))
+        (let [id (uuid pnode)
+              ch (k/assoc-in store [id] node)]
+          (case *async-backend*
+            :none (async/<!! ch)
+            :core.async (<? ch))
           (->KonserveAddr store (core/last-key node) id (synthesize-storage-addr id))))))
   (delete-addr [_ addr session]
-    (swap! session update-in :deletes inc)))
+    (swap! session update :deletes inc)))
 
 (defn get-root-key
   [tree]
-  (-> tree :storage-addr (async/poll!)))
-
-(defn create-tree-from-root-key
-  [store root-key]
-  (go-try
-    (let [val (<? (k/get-in store [root-key]))
-          last-key (core/last-key (assoc val :storage-addr (synthesize-storage-addr root-key)))] ; need last key to bootstrap
-      (<? (core/resolve
-           (->KonserveAddr store last-key root-key (synthesize-storage-addr root-key)))))))
+  ;; TODO find out why this is inconsistent
+  (or
+    (-> tree :storage-addr (async/poll!) :konserve-key)
+    (-> tree :storage-addr (async/poll!))))
 
-
-(defn add-hitchhiker-tree-handlers [store]
-  (swap! (:read-handlers store) merge
-         {'hitchhiker.konserve.KonserveAddr
-          #(-> % map->KonserveAddr
-               (assoc :store store
-                      :storage-addr (synthesize-storage-addr (:konserve-key %))))
-          'hitchhiker.tree.core.DataNode
-          (fn [{:keys [children cfg]}]
-            (core/->DataNode (into (sorted-map-by
-                                    compare) children)
-                             (promise-chan)
-                             cfg))
-          'hitchhiker.tree.core.IndexNode
-          (fn [{:keys [children cfg op-buf]}]
-            (core/->IndexNode (->> children
-                                   vec)
+  (defn create-tree-from-root-key
+    [store root-key]
+    (go-try
+     (let [val (let [ch (k/get-in store [root-key])]
+                 (case *async-backend*
+                   :none (async/<!! ch)
+                   :core.async (<? ch)))
+            last-key (core/last-key (assoc val :storage-addr (synthesize-storage-addr root-key)))] ; need last key to bootstrap
+        (<? (core/resolve
+            (->KonserveAddr store last-key root-key (synthesize-storage-addr root-key)))))))
+
+
+  (defn add-hitchhiker-tree-handlers [store]
+    (swap! (:read-handlers store) merge
+          {'hitchhiker.konserve.KonserveAddr
+            #(-> % map->KonserveAddr
+                (assoc :store store
+                        :storage-addr (synthesize-storage-addr (:konserve-key %))))
+            'hitchhiker.tree.core.DataNode
+            (fn [{:keys [children cfg]}]
+              (core/->DataNode (into (sorted-map-by
+                                      compare) children)
                               (promise-chan)
+                              cfg))
+            'hitchhiker.tree.core.IndexNode
+            (fn [{:keys [children cfg op-buf]}]
+              (core/->IndexNode (->> children
+                                    vec)
+                                (promise-chan)
                               (vec op-buf)
                               cfg))
           'hitchhiker.tree.messaging.InsertOp
diff --git a/src/hitchhiker/plot.clj b/src/hitchhiker/plot.clj
new file mode 100644
index 0000000..485d42d
--- /dev/null
+++ b/src/hitchhiker/plot.clj
@@ -0,0 +1,211 @@
+(ns hitchhiker.plot
+  "This namespace provides functions to help visualizing hh-trees.
+
+  It provides a visualization similar to those in https://youtu.be/jdn617M3-P4?t=1583
+  "
+  (:require [konserve.memory :refer [new-mem-store]]
+            [hitchhiker.konserve :as kons]
+            [konserve.cache :as kc]
+            [hitchhiker.tree.core :refer [<?? <? go-try] :as core]
+            [hitchhiker.tree.messaging :as msg]
+            [clojure.core.async :refer [promise-chan] :as async]
+            [clojure.string :as str]
+
+            [loom.io :refer [view] :as lio]
+            [loom.graph :refer [graph] :as lg]
+            [loom.derived :as deriv]
+            [loom.attr :as attr]
+
+            [cheshire.core :as json]))
+
+
+;; patch loom for compass rendering
+(ns loom.io)
+
+(defn dot-str
+  "Renders graph g as a DOT-format string. Calls (node-label node) and
+  (edge-label n1 n2) to determine what labels to use for nodes and edges,
+  if any. Weights become edge labels unless a label is specified.
+  Labels also include attributes when the graph satisfies AttrGraph."
+  [g & {:keys [graph-name node-label edge-label]
+        :or {graph-name "graph"} :as opts }]
+  (let [d? (directed? g)
+        w? (weighted? g)
+        a? (attr? g)
+        node-label (or node-label
+                       (if a?
+                         #(attr g % :label)
+                         (constantly nil)))
+        edge-label (or edge-label
+                       (cond
+                         a? #(if-let [a (attr g %1 %2 :label)]
+                               a
+                               (if w? (weight g %1 %2)))
+                         w? #(weight g %1 %2)
+                         :else (constantly nil)))
+        sb (doto (StringBuilder.
+                  (if d? "digraph \"" "graph \""))
+             (.append (dot-esc graph-name))
+             (.append "\" {\n"))]
+    (doseq [k [:graph :node :edge]]
+      (when (k opts)
+        (doto sb
+          (.append (str "  " (name k) " "))
+          (.append (dot-attrs (k opts))))))
+    (doseq [[n1 n2] (distinct-edges g)]
+      (let [n1l (str (or (node-label n1) n1))
+            n2l (str (or (node-label n2) n2))
+            el (edge-label n1 n2)
+            eattrs (assoc (if a?
+                            (attrs g n1 n2) {})
+                     :label el)]
+        (doto sb
+          (.append "  \"")
+          (.append (dot-esc n1l))
+          (.append
+           (if d? (str "\"" (when (:compass eattrs)
+                              (str ":" (:compass eattrs)))
+                       " -> \"")
+               "\" -- \""))
+          (.append (dot-esc n2l))
+          (.append \"))
+        (let [eattrs (dissoc eattrs :compass)]
+          (when (or (:label eattrs) (< 1 (count eattrs)))
+            (.append sb \space)
+            (.append sb (dot-attrs eattrs))))
+        (.append sb "\n")))
+    (doseq [n (nodes g)]
+      (doto sb
+        (.append "  \"")
+        (.append (dot-esc (str (or (node-label n) n))))
+        (.append \"))
+      (when-let [nattrs (when a?
+                          (dot-attrs (attrs g n)))]
+        (.append sb \space)
+        (.append sb nattrs))
+      (.append sb "\n"))
+    (str (doto sb (.append "}")))))
+
+
+(ns hitchhiker.plot)
+
+(def store (kons/add-hitchhiker-tree-handlers
+            (kc/ensure-cache (async/<!! (new-mem-store)))) )
+
+
+;; put a tree in the store including merkle hashes
+(def flushed (<?? (core/flush-tree
+                   (time (reduce (fn [t i]
+                                   (<?? (msg/insert t i i)))
+                                 (<?? (core/b-tree (core/->Config 3 3 3)))
+                                 (shuffle (range 1 25))))
+                   (kons/->KonserveBackend store))))
+
+
+(def flushed (<?? (core/flush-tree
+                   (time (reduce (fn [t i]
+                                   (<?? (msg/insert t i i)))
+                                 (:tree flushed)
+                                 (shuffle (range 25 50))))
+                   (kons/->KonserveBackend store))))
+
+
+
+(defn init-graph [store]
+  (apply lg/digraph
+         (->> @(:state store)
+            (filter (fn [[id {:keys [children]}]] children))
+            (map (fn [[id {:keys [children] :as node}]]
+                   (if (:op-buf node)
+                     {id (mapv (fn [c] (:konserve-key c)) children)}
+                     {id []}))))))
+
+
+(defn use-record-nodes [g]
+  (attr/add-attr-to-nodes g :shape "record" (lg/nodes g)))
+
+
+(defn node-layout [g [id {:keys [children] :as node}]]
+  (if (core/index-node? node)
+    (attr/add-attr
+     g id
+     :label (str
+             ;; key space separators
+             (str/join " | "
+                           (map #(str "<" % "> " ;; compass point (invisible)
+                                     "\\<" % "\\>")
+                                (map core/last-key (:children node))))
+             ;; render op-log
+             " | {"
+             (str/join " | " (map (fn [{:keys [key value]}]
+                                    key)
+                                  (:op-buf node)))
+             "}"))
+    (attr/add-attr
+     g id
+     :label (str (str/join "|" (map key (:children node)))))))
+
+
+(defn set-node-layouts [g store]
+  (->> @(:state store)
+     (filter (fn [[id {:keys [children]}]] children))
+     (reduce node-layout g)))
+
+(defn edge-hash [id]
+  (-> id str (subs 0 4)))
+
+(defn set-edge-layouts [g store]
+  (let [node-map @(:state store)
+        edges (lg/edges g)]
+    (reduce
+     (fn [g [n1 n2]]
+       (let [h (:konserve-key (clojure.core.async/<!!
+                               (:storage-addr (into {} (node-map n2)))))]
+         (-> g
+            (attr/add-attr-to-edges :compass (core/last-key (node-map n2))
+                                    [[n1 n2]])
+            (attr/add-attr-to-edges :label (edge-hash h) [[n1 n2]]))))
+     g
+     edges)))
+
+
+(defn create-graph [store]
+  (-> (init-graph store)
+     use-record-nodes
+     (set-node-layouts store)
+     (set-edge-layouts store)))
+
+
+
+(comment
+  (view (create-graph store))
+
+  (println (lio/dot-str g)))
+
+
+
+(defn remove-storage-addrs [[k v]]
+  (if (core/index-node? v)
+    [k (-> v
+          (dissoc :storage-addr :cfg)
+          (update :children (fn [cs] (mapv #(dissoc % :storage-addr :store) cs)))
+          (update :op-buf (fn [cs] (mapv #(into {} %) cs)))
+          )]
+    [k (dissoc v :storage-addr :cfg)]))
+
+
+(comment
+  (spit "/tmp/sample-tree.json"
+        (json/generate-string
+         (into {} (map remove-storage-addrs @(:state store)))))
+
+
+  (prn (map remove-storage-addrs @(:state store))))
+
+
+
+
+
+
+
+
diff --git a/src/hitchhiker/tree/async.cljc b/src/hitchhiker/tree/async.cljc
new file mode 100644
index 0000000..7f75fed
--- /dev/null
+++ b/src/hitchhiker/tree/async.cljc
@@ -0,0 +1,6 @@
+(ns hitchhiker.tree.async)
+
+;; rebind this *before* loading any other
+;; hh-tree namespace, so it has effect at
+;; macro-expansion time
+(def ^:dynamic *async-backend* :none)
diff --git a/src/hitchhiker/tree/core.cljc b/src/hitchhiker/tree/core.cljc
index da9b048..93f8b39 100644
--- a/src/hitchhiker/tree/core.cljc
+++ b/src/hitchhiker/tree/core.cljc
@@ -2,16 +2,19 @@
   (:refer-clojure :exclude [compare resolve subvec])
   (:require [clojure.core.rrb-vector :refer [catvec subvec]]
             #?(:clj [clojure.pprint :as pp])
+            #?(:clj [clojure.core.async :refer [promise-chan poll! put!]])
             #?(:clj [clojure.core.async :refer [go chan put! <! <!! promise-chan]
                      :as async]
                :cljs [cljs.core.async :refer [chan put! <! promise-chan]
                       :as async])
             #?(:cljs [goog.array])
-            #?(:clj [taoensso.nippy :as nippy]))
+            #?(:clj [taoensso.nippy :as nippy])
+            [hitchhiker.tree.async :refer [*async-backend*]])
   #?(:clj (:import java.io.Writer
                    [java.util Arrays Collections]))
   #?(:cljs (:require-macros [cljs.core.async.macros :refer [go]]
-                            [hitchhiker.tree.core :refer [go-try <? <?resolve]])))
+                            [hitchhiker.tree.core :refer [go-try <? <?resolve]]))
+  #?(:clj (:import [clojure.lang.PersistentTreeMap$BlackVal])))
 
 
 ;; cljs macro environment
@@ -37,7 +40,7 @@
   to maintain a full stack trace when jumping between multiple contexts."
   [x]
   (if (instance? #?(:clj Exception :cljs js/Error) x)
-    (throw (ex-info (or #?(:clj (.getMessage x)) (str x))
+    (throw (ex-info (or #?(:clj (.getMessage ^Exception x)) (str x))
                     (or (ex-data x) {})
                     x))
     x))
@@ -51,23 +54,34 @@
   result from the channel at some point."
      {:style/indent 1}
      [ & body]
-     `(if-cljs (cljs.core.async.macros/go
-                 (try ~@body
-                      (catch js/Error e#
-                        e#)))
+     (case *async-backend*
+       :none
+       `(if-cljs (throw (ex-info "You need an async backend for cljs." {}))
+                 (do ~@body))
+       :core.async
+       `(if-cljs (cljs.core.async.macros/go
+                   (try ~@body
+                        (catch js/Error e#
+                          e#)))
                (go
                  (try
                    ~@body
                    (catch Exception e#
-                     e#))))))
+                     e#)))))))
 
 #?(:clj
    (defmacro <?
      "Same as core.async <! but throws an exception if the channel returns a
 throwable error."
      [ch]
-     `(if-cljs (throw-if-exception (cljs.core.async/<! ~ch))
-               (throw-if-exception (<! ~ch)))))
+     (case *async-backend*
+       :none
+       `(if-cljs (throw (ex-info "You need an async backend for cljs." {}))
+                 ~ch)
+       :core.async
+       `(if-cljs (throw-if-exception (cljs.core.async/<! ~ch))
+                 (throw-if-exception (<! ~ch)))
+       )))
 
 
 #?(:clj
@@ -75,7 +89,11 @@ throwable error."
      "Same as core.async <!! but throws an exception if the channel returns a
 throwable error."
      [ch]
-     (throw-if-exception (<!! ch))))
+     (case *async-backend*
+       :none ch
+
+       :core.async
+       (throw-if-exception (<!! ch)))))
 
 (defn reduce<
   "Reduces over a sequence s with a go function go-f given the initial value
@@ -162,21 +180,75 @@ throwable error."
 ;; (based on proven data), and then send generated loads to check we stay within
 ;; our targets.
 
+;; TODO add full edn support including records
+(defn order-on-edn-types [t]
+  (cond (map? t) 0
+        (vector? t) 1
+        (set? t) 2
+        (number? t) 3
+        (string? t) 4
+        (symbol? t) 5
+        (keyword? t) 6))
+
 (extend-protocol IKeyCompare
   ;; By default, we use the default comparator
   #?@(:clj
       [Object
-       (compare [key1 key2] (clojure.core/compare key1 key2))
+       (compare [key1 key2]
+                (if (or (= (class key1) (class key2))
+                        (= (order-on-edn-types key1)
+                           (order-on-edn-types key2)))
+                  (try
+                    (clojure.core/compare key1 key2)
+                    (catch ClassCastException e
+                      (- (order-on-edn-types key2)
+                         (order-on-edn-types key1))))))
+       String
+       (compare [^String key1 key2]
+                (if (instance? String key2)
+                  (.compareTo key1 key2)
+                  (try
+                    (clojure.core/compare key1 key2)
+                    (catch ClassCastException e
+                      (- (order-on-edn-types key2)
+                         (order-on-edn-types key1))))))
        Double
        (compare [^Double key1 key2]
                 (if (instance? Double key2)
                   (.compareTo key1 key2)
-                  (clojure.core/compare key1 key2)))
+                  (try
+                    (clojure.core/compare key1 key2)
+                    (catch ClassCastException e
+                      (- (order-on-edn-types key2)
+                         (order-on-edn-types key1))))))
+       BigDecimal
+       (compare [^BigDecimal key1 key2]
+                (if (instance? BigDecimal key2)
+                  (.compareTo key1 key2)
+                  (try
+                    (clojure.core/compare key1 key2)
+                    (catch ClassCastException e
+                      (- (order-on-edn-types key2)
+                         (order-on-edn-types key1))))))
        Long
        (compare [^Long key1 key2]
                 (if (instance? Long key2)
-                  (.compareTo key1 key2))
-                (clojure.core/compare key1 key2))]
+                  (.compareTo key1 key2)
+                  (try
+                    (clojure.core/compare key1 key2)
+                    (catch ClassCastException e
+                      (- (order-on-edn-types key2)
+                         (order-on-edn-types key1))))))
+       BigInteger
+       (compare [^BigInteger key1 key2]
+                (if (instance? BigInteger key2)
+                  (.compareTo key1 key2)
+                  (try
+                    (clojure.core/compare key1 key2)
+                    (catch ClassCastException e
+                      (- (order-on-edn-types key2)
+                         (order-on-edn-types key1))))))
+       ]
      :cljs
       [number
        (compare [key1 key2] (cljs.core/compare key1 key2))
@@ -200,8 +272,8 @@ throwable error."
 (defrecord IndexNode [children storage-addr op-buf cfg]
   IResolve
   (index? [this] true)
-  (dirty? [this] (not (async/poll! storage-addr)))
-  (resolve [this] (go this))
+  (dirty? [this] (not (poll! storage-addr)))
+  (resolve [this] this #_(go this))
   (last-key [this]
     ;;TODO should optimize by caching to reduce IOps (can use monad)
     (last-key (peek children)))
@@ -215,7 +287,7 @@ throwable error."
           median (nth (index-node-keys children) (dec b))
           [left-buf right-buf] (split-with #(not (pos? (compare (:key %) median)))
                                            ;;TODO this should use msg/affects-key
-                                           (sort-by :key op-buf))]
+                                           (sort-by :key compare op-buf))]
       (->Split (->IndexNode (subvec children 0 b)
                             (promise-chan)
                             (vec left-buf)
@@ -295,7 +367,7 @@ throwable error."
      [node]
      (let [out ^Writer *out*]
        (.write out "IndexNode")
-       (.write out (node-status-bits node))
+       (.write out ^String (node-status-bits node))
        (pp/pprint-logical-block
         :prefix "{" :suffix "}"
         (pp/pprint-logical-block
@@ -319,8 +391,8 @@ throwable error."
 (defrecord DataNode [children storage-addr cfg]
   IResolve
   (index? [this] false)
-  (resolve [this] (go this)) 
-  (dirty? [this] (not (async/poll! storage-addr)))
+  (resolve [this] this #_(go this)) 
+  (dirty? [this] (not (poll! storage-addr)))
   (last-key [this]
     (when (seq children)
       (-> children
@@ -421,6 +493,7 @@ throwable error."
           (recur (pop tmp)))))))
 
 
+
 (defn right-successor
   "Given a node on a path, find's that node's right successor node"
   [path]
@@ -441,9 +514,20 @@ throwable error."
             sibling-lineage (loop [res [new-sibling]
                                     s new-sibling]
                               (let [c (-> s :children first)
-                                    c (if (tree-node? c)
+                                    ;_ (prn (type c) (= (class c) clojure.lang.PersistentTreeMap$BlackVal))
+                                    c (cond
+                                        ;; TODO cleanup path
+                                        ;; fast path
+                                        (or (index-node? c)
+                                            (data-node? c)
+                                            #?(:clj (= (class c) clojure.lang.PersistentTreeMap$Black))
+                                            #?(:clj (= (class c) clojure.lang.PersistentTreeMap$BlackVal)))
+                                        c
+
+                                        (tree-node? c)
                                         (<?resolve c)
-                                        c)]
+
+                                        :else c)]
                                 (if (or (index-node? c)
                                         (data-node? c))
                                   (recur (conj res c) c)
@@ -457,21 +541,7 @@ throwable error."
             (into path-suffix))))))
 
 
-(defn forward-iterator
-  "Takes the result of a search and puts the iterated elements onto iter-ch
-  going forward over the tree as needed. Does lg(n) backtracking sometimes."
-  [iter-ch path start-key]
-  (go-try
-      (loop [path path]
-        (if path
-          (let  [start-node (peek path)
-                 _ (assert (data-node? start-node))
-                 elements (-> start-node
-                              :children ; Get the indices of it
-                              (subseq >= start-key))]
-            (<? (async/onto-chan iter-ch elements false))
-            (recur (<? (right-successor (pop path)))))
-          (async/close! iter-ch)))))
+
 
 (defn lookup-path
   "Given a B-tree and a key, gets a path into the tree"
@@ -508,23 +578,66 @@ throwable error."
       (get key not-found)))))
 
 ;; this is only for the REPL and testing
-#?(:clj
-   (defn chan-seq [ch]
-     (when-some [v (<?? ch)]
-       (cons v (lazy-seq (chan-seq ch))))))
-
 
-#?(:clj
-   (defn lookup-fwd-iter
-     "Compatibility helper to clojure sequences. Please prefer the channel
+(case *async-backend*
+  :none
+  (do
+    (defn forward-iterator
+      "Takes the result of a search and returns an iterator going
+   forward over the tree. Does lg(n) backtracking sometimes."
+      [path start-key]
+      (let [start-node (peek path)]
+        (assert (data-node? start-node))
+        (let [first-elements (-> start-node
+                                 :children ; Get the indices of it
+                                 (subseq >= start-key)) ; skip to the start-index
+              next-elements (lazy-seq
+                             (when-let [succ (right-successor (pop path))]
+                               (forward-iterator succ start-key)))]
+          (concat first-elements next-elements))))
+
+
+    (defn lookup-fwd-iter
+      [tree key]
+      (let [path (lookup-path tree key)]
+        (when path
+          (forward-iterator path key)))))
+
+  :core.async
+  (do
+    #?(:clj
+       (defn chan-seq [ch]
+         (when-some [v (<?? ch)]
+           (cons v (lazy-seq (chan-seq ch))))))
+
+
+    (defn forward-iterator
+      "Takes the result of a search and puts the iterated elements onto iter-ch
+  going forward over the tree as needed. Does lg(n) backtracking sometimes."
+      [iter-ch path start-key]
+      (go-try
+          (loop [path path]
+            (if path
+              (let  [start-node (peek path)
+                     _ (assert (data-node? start-node))
+                     elements (-> start-node
+                                  :children ; Get the indices of it
+                                  (subseq >= start-key))]
+                (<? (async/onto-chan iter-ch elements false))
+                (recur (<? (right-successor (pop path)))))
+              (async/close! iter-ch)))))
+
+    #?(:clj
+       (defn lookup-fwd-iter
+         "Compatibility helper to clojure sequences. Please prefer the channel
   interface of forward-iterator, as this function blocks your thread, which
   disturbs async contexts and might lead to poor performance. It is mainly here
   to facilitate testing."
-     [tree key]
-     (let [path (<?? (lookup-path tree key))
-           iter-ch (chan)]
-       (forward-iterator iter-ch path key)
-       (chan-seq iter-ch))))
+         [tree key]
+         (let [path (<?? (lookup-path tree key))
+               iter-ch (chan)]
+           (forward-iterator iter-ch path key)
+           (chan-seq iter-ch))))))
 
 (defn insert
   [{:keys [cfg] :as tree} key value]
@@ -628,7 +741,7 @@ throwable error."
   IResolve
   (dirty? [this] false)
   (last-key [_] last-key)
-  (resolve [_] (go node)))
+  (resolve [_] node #_(go node)))
 
 #?(:clj
    (defn print-testing-addr
@@ -702,7 +815,7 @@ throwable error."
        {:tree (<?resolve root) ; root should never be unresolved for API
         :stats session})))
   ([tree backend stats]
-   (go
+   (go-try
      (if (dirty? tree)
        (let [cleaned-children (if (data-node? tree)
                                 (:children tree)
@@ -718,6 +831,51 @@ throwable error."
          new-addr)
        tree))))
 
+
+;; TODO merge this with the code above
+
+(declare flush-tree-without-root)
+
+(defn flush-children-without-root
+  [children backend session]
+  (go-try
+   (loop [[c & r] children
+          res []]
+     (if-not c
+       res
+       (recur r (conj res (<? (flush-tree-without-root c backend session false))))))))
+
+
+(defn flush-tree-without-root
+  "Given the tree, finds all dirty nodes, delivering addrs into them.
+
+  Does not flush root node, but returns it."
+  ([tree backend]
+   (go-try
+     (let [session (new-session backend)
+           flushed (<? (flush-tree-without-root tree backend session true))
+           root (anchor-root backend flushed)]
+       {:tree (<?resolve root) ; root should never be unresolved for API
+        :stats session})))
+  ([tree backend stats root-node?]
+   (go-try
+     (if (dirty? tree)
+       (let [cleaned-children (if (data-node? tree)
+                                (:children tree)
+                                ;; TODO throw on nested errors
+                                (->> (flush-children-without-root (:children tree) backend stats)
+                                     <?
+                                     catvec))
+             cleaned-node (assoc tree :children cleaned-children)]
+         (if root-node?
+           cleaned-node
+           (let [new-addr (<? (write-node backend cleaned-node stats))]
+             (put! (:storage-addr tree) new-addr)
+             (when (not= new-addr (<? (:storage-addr tree)))
+               (delete-addr backend new-addr stats))
+             new-addr)))
+       tree))))
+
 ;; The parts of the serialization system that seem like they're need hooks are:
 ;; - Must provide a function that takes a node, serializes it, and returns an addr
 ;; - Must be able to rollback writing an addr
diff --git a/src/hitchhiker/tree/messaging.cljc b/src/hitchhiker/tree/messaging.cljc
index 58e97d4..e531782 100644
--- a/src/hitchhiker/tree/messaging.cljc
+++ b/src/hitchhiker/tree/messaging.cljc
@@ -6,7 +6,8 @@
                :cljs [cljs.core.async :as async])
             #?(:clj [clojure.pprint :as pp])
             #?(:clj [hitchhiker.tree.core :refer [go-try <? <??] :as core]
-               :cljs [hitchhiker.tree.core :as core]))
+              :cljs [hitchhiker.tree.core :as core])
+            [hitchhiker.tree.async :refer [*async-backend*]])
   #?(:clj (:import java.io.Writer))
   #?(:cljs (:require-macros [hitchhiker.tree.core :refer [go-try <? <?resolve]])))
 
@@ -102,6 +103,7 @@
              (loop [[child & children] (:children tree)
                     rebuilt-children []
                     msgs (vec (sort-by affects-key ;must be a stable sort
+                                       core/compare
                                        (concat (:op-buf tree) msgs)))]
                (let [took-msgs (into []
                                      (take-while #(>= 0 (core/compare
@@ -168,7 +170,7 @@
                                   (map :op-buf)))
                    (rseq) ; highest node should be last in seq
                    (apply catvec)
-                   (sort-by affects-key)) ;must be a stable sort
+                   (sort-by affects-key core/compare)) ;must be a stable sort
           this-node-index (-> path pop peek)
           parent (-> path pop pop peek)
           is-first? (zero? this-node-index)
@@ -238,29 +240,76 @@
                         :tag (uuid)
                         )]))
 
-(defn forward-iterator
-  "Takes the result of a search and puts the iterated elements onto iter-ch
+
+(case *async-backend*
+  :none
+  (do
+    (defn forward-iterator
+      "Takes the result of a search and returns an iterator going
+   forward over the tree. Does lg(n) backtracking sometimes."
+      [path]
+      (assert (core/data-node? (peek path)))
+      (let [first-elements (apply-ops-in-path path)
+            next-elements (lazy-seq
+                           (when-let [succ (core/right-successor (pop path))]
+                             (forward-iterator succ)))]
+        (concat first-elements next-elements)))
+
+
+    (defn lookup-fwd-iter
+      [tree key]
+      (let [path (core/lookup-path tree key)]
+        (when path
+          (drop-while (fn [[k v]]
+                        (neg? (core/compare k key)))
+                      (forward-iterator path))))))
+
+
+  :core.async
+  (do
+    (defn forward-iterator
+      "Takes the result of a search and puts the iterated elements onto iter-ch
   going forward over the tree as needed. Does lg(n) backtracking sometimes."
-  [iter-ch path start-key]
-  (go-try
-      (loop [path path]
-        (if path
-          (let  [_ (assert (core/data-node? (peek path)))
-                 elements (drop-while (fn [[k v]]
-                                        (neg? (core/compare k start-key)))
-                                      (apply-ops-in-path path))]
-            (<? (async/onto-chan iter-ch elements false))
-            (recur (<? (core/right-successor (pop path)))))
-          (async/close! iter-ch)))))
+      [iter-ch path start-key]
+      (go-try
+          (loop [path path]
+            (if path
+              (let  [_ (assert (core/data-node? (peek path)))
+                     elements (drop-while (fn [[k v]]
+                                            (neg? (core/compare k start-key)))
+                                          (apply-ops-in-path path))]
+                (<? (async/onto-chan iter-ch elements false))
+                (recur (<? (core/right-successor (pop path)))))
+              (async/close! iter-ch)))))
 
-#?(:clj
-   (defn lookup-fwd-iter
-     "Compatibility helper to clojure sequences. Please prefer the channel
+    #?(:clj
+       (defn lookup-fwd-iter
+         "Compatibility helper to clojure sequences. Please prefer the channel
   interface of forward-iterator, as this function blocks your thread, which
   disturbs async contexts and might lead to poor performance. It is mainly here
   to facilitate testing or for exploration on the REPL."
-     [tree key]
-     (let [path (<?? (core/lookup-path tree key))
-           iter-ch (async/chan)]
-       (forward-iterator iter-ch path key)
-       (core/chan-seq iter-ch))))
+         [tree key]
+         (let [path (<?? (core/lookup-path tree key))
+               iter-ch (async/chan)]
+           (forward-iterator iter-ch path key)
+           (core/chan-seq iter-ch)))))
+
+
+
+  )
+
+
+(defn slice [tree start-key end-key]
+  (let [res (transient [])]
+    (loop [path (<?? (core/lookup-path tree start-key))]
+      (if path
+        (let  [_ (assert (core/data-node? (peek path)))
+               elements (apply-ops-in-path path)
+               #_(drop-while (fn [[k v]]
+                               (neg? (core/compare k start-key)))
+                                    )]
+          (doseq [e elements]
+            (conj! res e))
+          #_(<? (async/onto-chan iter-ch elements false))
+          (recur (<? (core/right-successor (pop path)))))))
+    (persistent! res)))
diff --git a/test/hitchhiker/konserve_test.cljc b/test/hitchhiker/konserve_test.cljc
index 858f493..faa9d5c 100644
--- a/test/hitchhiker/konserve_test.cljc
+++ b/test/hitchhiker/konserve_test.cljc
@@ -10,9 +10,11 @@
             #?(:clj [konserve.filestore :refer [new-fs-store delete-store list-keys]])
             [konserve.memory :refer [new-mem-store]]
             [hitchhiker.konserve :as kons]
+            [konserve.cache :as kc]
             [hitchhiker.tree.core #?(:clj :refer :cljs :refer-macros)
              [<?? <? go-try] :as core]
             [hitchhiker.tree.messaging :as msg]
+            [hitchhiker.tree.async :refer [*async-backend*]]
             [hitchhiker.ops :refer [recorded-ops]]
             #?(:cljs [cljs.core.async :refer [promise-chan] :as async]
                :clj [clojure.core.async :refer [promise-chan] :as async])
@@ -25,11 +27,15 @@
 
 
 (defn iter-helper [tree key]
-  (go-try
-      (let [iter-ch (async/chan)
-            path (<? (core/lookup-path tree key))]
-        (msg/forward-iterator iter-ch path key)
-        (<? (async/into [] iter-ch)))))
+  (case *async-backend*
+    :none
+    (msg/forward-iterator (core/lookup-path tree key))
+    :core.async
+    (go-try
+     (let [iter-ch (async/chan)
+           path (<? (core/lookup-path tree key))]
+       (msg/forward-iterator iter-ch path key)
+       (<? (async/into [] iter-ch))))))
 
 
 (deftest simple-konserve-test
@@ -37,7 +43,7 @@
     #?(:cljs
        (async done
         (go-try
-         (let [store (<? (new-mem-store))
+         (let [store (kc/ensure-cache (async/<!! (new-mem-store))) ;; always use core.async here!
                backend (kons/->KonserveBackend store)
                init-tree (<? (core/reduce< (fn [t i] (msg/insert t i i))
                                            (<? (core/b-tree (core/->Config 1 3 (- 3 1))))
@@ -61,7 +67,7 @@
     #?(:clj
        (let [folder "/tmp/async-hitchhiker-tree-test"
              _ (delete-store folder)
-             store (kons/add-hitchhiker-tree-handlers (<?? (new-fs-store folder :config {:fsync false})))
+             store (kons/add-hitchhiker-tree-handlers (kc/ensure-cache (async/<!! (new-fs-store folder :config {:fsync false}))))
              backend (kons/->KonserveBackend store)
              flushed (<?? (core/flush-tree
                            (time (reduce (fn [t i]
@@ -108,9 +114,10 @@
       (let [folder "/tmp/konserve-mixed-workload"
             _ #?(:clj (delete-store folder) :cljs nil)
             store (kons/add-hitchhiker-tree-handlers
-                   (<? #?(:clj (new-fs-store folder :config {:fsync false})
-                          :cljs (new-mem-store))))
-            _ #?(:clj (assert (empty? (<? (list-keys store)))
+                   (kc/ensure-cache
+                    #?(:clj (async/<!! (new-fs-store folder :config {:fsync false}))
+                      :cljs (async/<! (new-mem-store)))))
+            _ #?(:clj (assert (empty? (async/<!! (list-keys store)))
                               "Start with no keys")
                  :cljs nil)
             ;_ (swap! recorded-ops conj ops)
@@ -161,7 +168,7 @@
 
 #?(:clj
    (defspec test-many-keys-bigger-trees
-     100
+     1000
      (mixed-op-seq 800 200 10 1000 1000)))
 
 
diff --git a/test/hitchhiker/tree/messaging_test.clj b/test/hitchhiker/tree/messaging_test.clj
index e6d65a8..7861e08 100644
--- a/test/hitchhiker/tree/messaging_test.clj
+++ b/test/hitchhiker/tree/messaging_test.clj
@@ -14,6 +14,7 @@
   [t v]
   (seq (map first (msg/lookup-fwd-iter t v))))
 
+
 (defspec b-tree-sorts-uniques-random-int-vector
   1000
   (prop/for-all [v (gen/vector gen/int)]