odoyle-rules

There's another Clojure rules library worth considering. It has a section in the README about why you might prefer it to Clara. https://github.com/oakes/odoyle-rules

I'd also look at https://github.com/oakes/odoyle-rules/ I think the userbase is slowly shrinking, but I'd personally use Clojure even if all Clojure developers disappeared tomorrow. It's not built on shifting sand as the JVM is stable. If you need really niche/cutting edge stuff you're probably going to need to dip into Java or JS interop anyway

Reactive updates is the big one, in my opinion. DataScript is a triumph and arguably is the reason why so many note-taking tools (Roam, Athens, Logseq, etc) are written in Clojure. But there are so many cases where it would be nice to react when some set of entities is changed. I think what we need is to figure out how to combine DataScript with a rules engine. I wrote a rules engine and made a writeup that compares the two together: "Using O'Doyle Rules as a poor man's DataScript" https://github.com/oakes/odoyle-rules/blob/master/bench-src/... Subscribing to individual entities is nice but with a rules engine you have so much more fine-grained control over your reactions. And with the RETE algorithm this can be done efficiently. Most libraries in this space just ignore it and make their own ad-hoc solution -- an informally-specified, bug

There's also this in the Clojure ecosystem: https://github.com/oakes/odoyle-rules

I'm hedging my bets by using Datalog and the Datomic protocol wherever I can: https://tonsky.me/blog/datomic-as-protocol/ And keeping a close eye on Differential Dataflow: https://github.com/TimelyDataflow/differential-dataflow/ DD is commercialized in Materialize: https://materialize.io/ The solution is likely to arrive in the Clojure/ClojureScript ecosystem before it arrives anywhere else because tools like Datascript lend itself to this type of thinking, e.g. 3DF: https://github.com/sixthnormal/clj-3df/ The closest thing we have to streaming updates right now is FactUI, which uses the Clara rules engine, but it's IMO hampered by limitations of Clara and Cljs namespacing: https://github.com/arachne-framework/factui The RETE algorithm is a less general solution to incremental updates. Zach Oakes is doing some interesting work with O'Doyl