Open Source Rule Engines Written In Java

Share the article!

I don’t recall if someone has put together a review of open source Rule Engines that are written in Java. Here’s the list I’ve accumulated so far:

  • Drools The JBoss Rules engine uses a modified form of the Rete algorithm called the Rete-OO algorithm. Internally it operates using the same concepts and methods as Forgy’s original but adds some node types required for seemless integration with an object-oriented language.
  • OFBiz Rule Engine Backward chaining is supported. Original code base from “Building Parsers in Java” by Steven John Metsker.
  • Mandarax Based on backward reasoning. The easy integration of all kinds of data sources. E.g., database records can be easily integrated as sets of facts and reflection is used in order to integrate functionality available in the object model.
  • Algernon Efficient and concise KB traversal and retrieval. Straightforward access to ontology classes and instances. Supports both forward and backward chaining.
  • TyRuBa TyRuBa supports higher order logic programming: variables and compound terms are allowed everywhere in queries and rules, also in the position of a functor- or predicate-name. TyRuBa speeds up execution by making specialized copies of the rule-base for each query in the program. It does so incrementally while executing a logic program and builds an index for fast access to rules and facts in the rule base, tuned to the program that is running. The indexing techniques works also for higher-order logic. TyRuBa does ‘tabling’ of query results.
  • JTP Java Theorem Prover is based on a very simple and general reasoning architecture. The modular character of the architecture makes it easy to extend the system by adding new reasoning modules (reasoners), or by customizing or rearranging existing ones.
  • JEOPS JEOPS adds forward chaining, first-order production rules to Java through a set of classes designed to provide this language with some kind of declarative programming.
  • InfoSapient Semantics of business rules expressed using fuzzy logic.
  • RDFExpert RDF-driven expert system shell. The RDFExpert software uses Brian McBride’s JENA API and parser. A simple expert system shell that uses RDF for all of its input: knowledge base, inference rules and elements of the resolution strategy employed. It supports forward and backward chaining.
  • Jena 2 – Jena is a Java framework for writing Semantic Web applications. Jena2 has a reasoner subsystem which includes a generic rule based inference engine together with configured rule sets for RDFS and for the OWL/Lite subset of OWL Full. These reasoners can be used to construct inference models which show the RDF statements entailed by the data being reasoned over. The subsystem is designed to be extensible so that it should be possible to plug a range of external reasoners into Jena, though worked examples of doing so are left to a future release.

  • JLisa – JLisa is a powerful framework for building business rules accessible to Java and it is compatible with JSR-94. JLisa is more powerful than Clips because it has the expanded benefit of having all the features from common lisp available. These features are essential for multi-paradigm software development
  • Euler – Euler is a backward-chaining reasoner enhanced with Euler path detection and will tell you whether a given set of facts and rules supports a given conclusion. Things are described in N3.
  • JLog – JLog is an implementation of a Prolog interpreter, written in Java. JLog is a BSF-compatible language. It includes built-in source editor, query panels, online help, animation primitives, and a GUI debugger.
  • Pellet OWL Reasoner – Pellet is an open-source Java based OWL DL reasoner. It can be used in conjunction with either Jena or OWL API libraries. Pellet API provides functionalities to see the species validation, check consistency of ontologies, classify the taxonomy, check entailments and answer a subset of RDQL queries (known as ABox queries in DL terminology). Pellet is an OWL DL reasoner based on the tableaux algorithms developed for expressive Description Logics.
  • Prova – Prova is derived from Mandarax Java-based inference system developed by Jens Dietrich. Prova extends Mandarax by providing a proper language syntax, native syntax integration with Java, and agent messaging and reaction rules. The development of this language was supported by the grant provided within the EU project GeneStream. In the project, the language is used as a rules-based backbone for distributed web applications in biomedical data integration.
  • OpenRules – OpenRules is a powerful Business Rule Engine that has been designed to create, deploy, execute, and maintain decision services for complex real-world applications. OpenRules comes with a sophisticated user-friendly Rules Administrator that utilizes the power of MS Excel and Eclipse.
  • SweetRules – SweetRules is an integrated toolkit for semantic web rules, revolving around the RuleML. SweetRules supports the powerful Situated Courteous Logic Programs extension of RuleML, including prioritized conflict handling and procedural attachments for actions and tests. SweetRules’ capabilities include semantics-preserving translation and interoperability between a variety of rule and ontology languages (including XSB Prolog, Jess, HP Jena-2, and IBM CommonRules), highly scaleable backward and forward inferencing, and merging of rulebases/ontologies. The SweetRules project is a multi-institutional effort, originated and coordinated by the SweetRules group at MIT Sloan.
  • JShop2 – Simple Hierarchical Ordered Planner (SHOP) written in Java. JSHOP2 is a domain-independent automated-planning systems. They are based on ordered task decomposition, which is a type of Hierarchical Task Network (HTN) planning. JSHOP2 uses a new “planner compilation” technique to achieve faster execution speed.
  • OpenLexicon – Lexicon is a business rules and business process management tool that rapidly develops applications for transaction and process-based applications.There are two main components of Lexicon: the metadata repository and the business rules engine. The Lexicon business rules engine is not Rete based. It has a predicate evaluator that includes a unique power: it can evaluate small, in-line Java expressions.
  • Hammurapi Rules – Hammurapi rules has the following distinguishing features: (1) Rules and facts are written in Java; (2) leverages Java language semantics to express relationships between facts and (3) builds derivation trees for validation, debugging and to detect logic loops.
  • MINS Reasoner – MINS stands for Mins Is Not Silri. MINS is a reasoner for Datalog programs with negation and function symbols. MINS supports the Well-Founded Semantics.
  • Zilonis – An extremelly efficient, multithreaded Rules engine based on a variation of the forward chainning Rete algorithm. It has a unique scoping framework where you can define a scope for a user or group of users with inheritance of rules between them. The rules language is similar to CLIPS.
  • JCHR – JCHR is an embedding of Constraint Handling Rules (CHR) in

    Java. The multi-paradigmatic integration of declarative, forward

    chaining CHR rules and constraint (logic) programming within the

    imperative, OO host language Java offers clear synergetic advantages to

    the software developer. High performance is achieved through an

    optimized compilation to Java code. The rule engine is suited for the

    high-level development of expert systems, incremental constraint

    solvers and constraint-based>

  • Esper – Esper enables rapid development of applications that process large volumes of incoming messages or events. Esper filters and analyzes events in various ways, and responds to conditions of interest in real-time. Supports Event Stream Processing

    : Time-based, interval-based, length-based and sorted windows; Grouping, aggregation, sorting, filtering and merging of event streams; Tailored SQL-like query language using insert into, select, from, where, group-by, having and order-by clauses; Inner-joins and outer joins (left, right, full) of an unlimited number of windows; Output rate limiting and stabilizing.

  • mProlog – mProlog is a sub-product of the 3APL-M project. It delivers a reduced Prolog engine, optimized for J2ME applications. The mProlog engine was developed based on the W-Prolog project from Michael Winikoff. The 3APL-M project a platform for building applications using Artificial Autonomous Agents Programming Language (3APL) as the enabling logic for the deliberation cycles and internal knowledge representation.
  • OpenL Tablets – Create Decision Tables in Excel and use them in Java application in a convenient type-safe manner. Use Data Tables in Excel for data setup and testing. Eclipse plugin controls validity of Excel tables.
  • Jamocha – Jamocha is a rule engine and expert system shell environment. Jamocha comes with a FIPA-compliant agent. The agent is based on the Multiagent System JADE that supports speech-acts and the FIPA agent interaction protocol.
  • JSL: Java Search Library – JSL is a library written in Java that provides a framework for general searching on graphs. Standard search algorithms depth-first, breadth-first and A* are provided by JSL, in addition you can plug in any other search algorithms.
  • Termware – TermWare is Term Processing System. It’s use is applicable to computational algebra systems and various formal models analysis.
  • Take – Take consists of a scripting language for defining rules, and a compiler that creates executable Java code. Take is based on Mandarax, it has a similar API but implements its own inference engine.
  • Datalog – Datalog is a logical query language. It exists somewhere between relational algebra (the formal theory behind SQL) and Prolog. Its primary addition to the semantics of databases is recursive queries.
  • IRIS Reasoner – Integrated Rule Inference System is an extensible reasoning engine for expressive rule-based languages. IRIS supports safe or un-safe Datalog, a comprehensive and extensible set of built-in predicates and support for all the primitive XML schema data types.
  • CEL – A polynomial-time Classifier for the description logic EL+. CEL is the first reasoner for the description logic EL+, supporting as its main reasoning task the computation of the subsumption hierarchy induced by EL+ ontologies. The most distinguishing feature of CEL is that, unlike other modern DL reasoners, it implements a polynomial-time algorithm. The supported description logic EL+ offers a selected set of expressive means that are tailored towards the formulation of medical and biological ontologies.

Please let me know if I’ve missed something.

Share the article!

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>