Rete Algorithm

• clara-rules

  3 1,185 5.4 Clojure

  Forward-chaining rules in Clojure(Script)

  

I'm another early/core contributor to the clara-rules project. It does utilize a DSL that is implemented and allows for some Clojure - so it does have some coupling on that front. The https://www.clara-rules.org webpage shows it has a Java based API that works as far as integrating with the rest of a system (eg. when you aren't using Clojure).

The rule structures themself have a data structure representation that is independent of the DSL. You can have other DSL's implemented that target this structure. Again though, it certainly is easiest to do with Clojure. This was touched on in this post https://www.toomuchcode.org/blog/2015/11/14/insta-declarativ...

• Scout Monitoring

  www.scoutapm.com featured

  Free Django app performance insights with Scout Monitoring. Get Scout setup in minutes, and let us sweat the small stuff. A couple lines in settings.py is all you need to start monitoring your apps. Sign up for our free tier today.

  

• Intellect

  1 422 - Python

  DSL and Rules Engine For Python

Here a small collection:

- https://github.com/nemonik/Intellect (Dead - 2017)

• rules

  3 1,121 0.0 JavaScript

  Durable Rules Engine (by jruizgit)

• py_rete

  1 52 0.0 Python

  Python RETE algorithm

• experta

  1 139 0.0 Python

  Expert Systems for Python

• naive-rete

  1 62 - Python

  Python RETE algorithm

  

- https://github.com/GNaive/naive-rete (dead)

(All of them are rule engine - I guess they implement the Rete algo or some variant but no time to check ATM).

Also: "production" is probably false since all of them are dead (or were, last time I checked - I'd be happy to be proven wrong).

• rete

  1 12 - C++

  An implementation of the rete algorithm from 'Production Matching for Large Learning Systems' (by bollu)

I have a very well documented implementation of rete, that also produces nice looking SVGs of the state of the rete algorithm here: https://github.com/bollu/rete

It's a really interesting algorithm, and allows one to get O(1) incremental pattern matching (ie, when one adds a pattern, one is told of a matching pattern in O(1) time) at the cost of O(npattern * nitems) memory usage. I was trying to use it in the context of pattern matching within a compiler, but I never went anywhere since I had COVID, then a PhD to get to :)

• InfluxDB

  www.influxdata.com featured

  Power Real-Time Data Analytics at Scale. Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.

  

• clara-rules

  1 1,182 - Clojure

  Discontinued Forward-chaining rules in Clojure(Script) [Moved to: https://github.com/oracle-samples/clara-rules] (by cerner)

  

Interestingly https://github.com/cerner/clara-rules redirects to https://github.com/oracle-samples/clara-rules so I'd guess Cerner was acquired by Oracle, although the repo is Apache 2 and doesn't seem to have any weird stuff in their contributing.md

For me, the "It's just Clojure" part is a drawback, not only for me personally but when I think about the kind of audiences that I have traditionally wanted to author rules, between a real, lisp-y, dynamically-typed, programming language and asking folks to write in the Drools DSLs, I'll take my chances with the DSLs

• rs-rhizome

  1 102 4.8 Rust
  

My research went in similar directions although I was looking at RETE for rule evaluation as part of a general purpose workflow engine with rules as just one part.

Incremental view maintenance is different enough from rule composition and evaluation that the model diverges to be more optimal. Collections of tuples and instead of DAGs lots of cyclical loops to continue computation of the diffs.

There are deep and intrinsic space or time trade offs so many of the modern approaches moved toward natural dataflow concurrency, and streaming semantics where space or time trade offs can be chosen at runtime through batching and data context opposed to early RETE variations which were very OOP and eagerly evaluated instead of lazy (all in memory in the same place instantiated and mutated).

It'll be interesting to see where these differential dataflow approaches go as we head into local-first constraints where central authority on data isn't possible and long divergence of synchronization occurs. Lots of CRDTs in this future for sure. E.g. https://github.com/RhizomeDB/rs-rhizome / https://fission.codes/blog/fission-reactor-dialog-first-look...

Suggest a related project