Yes. I now use Rum + Datascript + core.async for event sourcing. Here is the entirety of my reactive event-loop handling, inspired by Tonsky's Cat Chat (https://tonsky.me/blog/datascript-chat/):

    ; One Macro in events.clj:

    (defmacro go-loop-sub [pub key binding & body]
      (let [[db-bind & bindings] binding]
        `(let [ch# (cljs.core.async/chan)]
           (cljs.core.async/sub ~pub ~key ch#)
           (go-loop []
             (let [event# (rest (cljs.core.async/<! ch#))
                   ~db-bind @yourproject.data.core/conn
                   ~(vec bindings) event#
                   result# (do ~@body)]
               (when result#
                 (yourproject.data.core/transact! yourproject.data.core/conn result#)))))
             (recur)))))

    ;; Usage (at top of core file)

    (defonce conn (d/create-conn schema))
    (defonce event-bus (async/chan))
    (defonce event-pub (async/pub event-bus first))

    ;; For each event you want to dispatch on:

    (go-loop-sub event-pub :todo/add-item [db {:as data :keys [text]}]
      ;; Query db here. Any tx-data you return will get transacted.
      [{:db/id -1
        :todo/text text}])

    ;; To display some reactive queries in DataScript:

    (rum/defc root-component
      < rum/reactive [conn]
      (let [db (rum/react conn)
            todos (d/q '[:find ?todo ?text
                         :where [?todo :todo/text ?text]]
                       db)]
        [:div "Todos: " (pr-str todos)]))

That's it. You don't need re-frame.

We've had a great experience building a mid-size app with re-frame. Sure, writing subscription and event handlers and wiring it all together seems like a lot of boilerplate when you could just fetch().then(), but in the long run the architecture really pays off.

It's not perfect, I do lament the boilerplateyness myself, but I have not seen anything better in my decade of web dev.

For solo projects that don’t need all the boilerplate I think Hoplon is an even better option (there’s a Luminus profile for it). It’s kinda like Svelte: it doesn’t use a vdom and makes interacting with the actual dom really simple: http://hoplon.io/

Hm, really? Maybe you're missing a layer of indirection if that's so?

Usually I end up wrapping things myself so I have one "setup-handler :name" function/macro that creates the subscription and event db handler for me. There are also existing libraries that does this for you, if writing it yourself is not wanted.

One example of such library: https://gitlab.com/nikperic/reframe-utils

`reg-basic-sub` has this outcome:

  (reg-basic-sub :common/active-page)

  ;; Equivalent to
  (reg-basic-sub :common/active-page :common/active-page)

  ;; Equivalent to
  (reg-sub
    :common/active-page
    (fn [db _]
      (:common/active-page db)))