OWL API: Which OWL reasoners to use

Disclaimer: I am not trying to present the results of benchmarking here. For that, you should look at competition results such as the ORE reasoner competition or similar. This post merely reflects my personal, very subjective, tastes after 6 years of OWL API development.

• OWL API 3
  • ELK 0.4.2
  • HermiT 1.3.8.4
    • Note: this branch of HermiT is not maintained anymore (at all). The reason why I keep using it is that I trust it, more than any other implementation of a DL reasoner. I do not have the numbers however to proof at the moment that the implementation is indeed more reliable than the alternatives.
    • As far as I know, HermiT is now only sporadically maintained by Phil Lord and Ignazio Palmisano
      • Maven
      • GitHub
• OWL API 4
  • ELK 0.4.3
    • ELK 0.4.3 is probably my favourite reasoner, if there can be such a thing. It is fast and reliable: Even on huge ontologies in the multi million axiom area, I do not get it to crash (short of out-of-memory issues). In the life sciences, they even use ELK for ontologies beyond OWL 2 EL like some sort of an “approximate reasoner”; they claim it is often good enough. Also one of the reasons I keep being stuck with OWL API 4, despite the really awesome new features of the OWL API 5 (lots of Java 8 joy around streams). My only qualms with ELK is the lack of an isEntailedBy() method implementation, which make it incompatible with some awesome frameworks, such as the OWL Explanation Workbench by Matthew Horridge.
  • HermiT 1.4.0.432
    • Careful: The maintainers chose a slightly confusing naming scheme for the versions: It is the first number after the third, not the first, period that indicates which OWL API version a release pertains to.
• OWL API 5:
  • HermiT 1.4.1.513
  • ELK
    • Currently under development
  • I was recently recommended to try Openllet, which is based on Pellet, but I have not yet gotten around to that yet. Maybe worth a shot.

I have worked a lot with other reasoners. Here are some some of the ones I sometimes use, but remain second choices:

• FaCT++: The pro-point is that is is fast. I would probably still consider this for certain OWL 2 DL applications. But dealing with JNI is a nightmare when you want to build applications that run on any system (Unix or otherwise).
• Pellet: It is quite outdated, and I did remember it to have a handfull of bugs. But it almost made it to my list, because I like the fact that it can dynamically switch between saturation and tableau reasoning, and that it has incremental reasoning built in.
• JFact: Port of FaCT++ to Java: I did find it buggy at times, and it is not as fast as FaCT++. It is, however maintained, if not that frequently.
• Konclude: The fastest reasoner on the block. If only there was a GitHub repo, some evidence of development (there is none since 2 years) and, most importantly, a nice OWLReasoner interface implementation. I do not like to use OWLlink, and I do not like my reasoner to be some kind of web server 😛 But I have some pretty tough OWL 2 DL reasoning tasks to crack at the moment, so I might have to go back to it.
• TrOWL: The only approximate reasoner I ever used. I have no good reason why I would not use it; It is just that I tend to use ELK now for EL ontologies, and HermiT for DL, and TrOWL applies more to cases where you have tough DL problems that you are happy to classify using an incomplete (approximate) procedure. Now that I think of it I might even give it another shot.

There are many other more specialised reasoners out there, many of which or OWL API compatible. I have not yet had the need to use them. The OWL API mainters keep a list of compliant reasoners here.