BigOWLIM 3.0b5 represents the first public release of BigOWLIM, which is compliant with the Sesame 2.x and uses the new Unified TRREE architecture. The most important differences, compared to the previous versions of BigOWLIM (ver. 0.9.x/2.0) are:

• efficient native support for a "rich RDF model", including named graphs and triplesets;
• SPARQL support, based on the parser of Sesame and proprietary query optimization techniques;
• smooth data loading - in the previous generation, BigOWLIM 0.9.x needed to rebuild its indices after some amount of data is loaded and this operation was causing growing overheads for larger datasets, limiting its scalability. Such operation is not required any longer, which allows smooth operation as the datasets grow;
• better scalability, through 40-bit statement identifiers.

BigOWLIM 3.0 sets the new threshold for scalable reasoning: it is the first engine that managed to demonstrate efficient reasoning against 2.7 billion statements. In the framework of the LUBM benchmark BigOWLIM managed to load the LUBM(20000, 0) dataset. The forward-chaining reasoning over this dataset resulted in materialization of about 1.9 billion statements, thus the total amount of the statements stored in the repository went up to 4.6 billion. Loading, storing and indexing (without inference) of the data took as little as 17 hours, demonstrating a minimal slowdown compared with the load of 1 billion statements (from 48 KSt./sec. for 1BSt. to 44 KSt./sec. in the 2.7BSt). This result indicates excellent scalability in terms of speed. Loading, together with inference, took 72 hours, delivering inference speed above 10K st./sec. - unmatched by any competitor at any comparable scale.

SwiftOWLIM 3.0 represents the first public release of SwiftOWLIM, which is compliant with the Sesame 2.x and uses SwiftTRREE engine, based on the so-called Unified TRREE architecture. The latter allows for much higher level of code sharing between SwiftTRREE and BigTRREE as much greater flexibility. An essential difference is that the new TRREE architecture supports the so-called rich RDF data model, which allows for efficient management of named graphs and triplesets (please, see the data model specification of ORDI for more information on the data model).

The major functional changes in SwiftOWLIM 3.0b7 compared to version 2.9.1 can be summarized as follows:

• Sesame 2.x: from version 3.0 onwards SwiftOWLIM is compliant with Sesame 2.x (instead of 1.2.x). The newer version of Sesame comes along with serious re-engineering of its architecture and multiple new features. One of the most notable changes is the adoption of a quadruple data model in its APIs; although the fourth element is named "context", it facilitates smooth support for named graphs. Further, it supports a range of new languages and syntaxes, e.g. SPARQL, TRIX, TRIG;
• SPARQL support: multiple optimizations in the basic SPARQL query evaluation support of Sesame allow for better query evaluation performance;
• Single-threaded inference: the mutli-threaded inference capability of SwiftOWLIM 2.9 is still not implemented in the new architecture;
• Instant initialization: the contents of the repository (including the inferred statements) is kept in a proprietary binary format which allows for instant initializatoin;
• Multi-threaded rule compiler: making the scenario of launching multiple OWLIM repositories, which use different custom rulesets, within a single process;
• Multiple bug-fixes and improvements: earlier beta versions of SwiftOWLIM 3.0 have been provided to partners and pilot customers, which allowed early identification of various issues and corresponding fixes.

Major changes in SwiftOWLIM version 2.9.1, 10 September 2007, as compared to version 2.9.0:

• 1000 properties fix: an internal limitation of TRREE for handling up to 1000 unique properties was removed.
• Fix for usage of custom rule-sets under OSGI: two JVM properties (Dtrree.jar.file and Dopenrdf-model.jar.file) are now considered to allow for usage of custom rule-sets in environments which use custom class-loader schemes, e.g. the OSGI frameworks.
• Minor extensions of the OWL support: rules and axioms added to rule-set owl-maxRules_builtin.pie to support the reflexivity of owl:sameAs and the fact that all OWL classes are sub-classes of owl:Thing and their instances are owl:Thing-s.
• Minor fix in the owl-max rule-set: an incorrect rule was causing significant degradation in performance for some datasets when the partialRDFS parameter is set to false.
• partialRDFS versions of the rule-set files discarded: in previous versions, there was a pair of rule-set files for each of the predefined rule-sets, except empty - one version with partialRDF optimizations and one without them. The versions with the optimizations are now excluded because they can be derived automatically, following the behavior of TRREE's rule compiler which is duly documented.
• Sesame 1.2.7 bundled in the release.

Major changes in SwiftOWLIM version 2.9.0, 12 June 2007, as compared to version 2.8.4:

• Multi-threaded inference: loading speed improves 37-71% on a dual-CPU (4-core) server, depending on the rule-set; 33% speed up on a desktop machine (P4 with hyper-threading);
• Improved transaction isolation: corresponding to READ COMMITTED level in RDBMS;
• Transitive closure optimization: the materialization of the “closure” of transitive properties can be switched off. This prevents the generation of O(N2) implicit statements, for a chain of N individuals connected through a transitive property. This optimization improves dramatically the scalability and performance on datasets with long “chains” over transitive properties;
• Stack-safe inference: in ver. 2.8.3/4 a “stack-safe” mode, was allowing handling very “deep” inference chains; in this mode, OWLIM was slower. Now the reasoning algorithm is stack-safe without performance penalty or need of a specific configuration parameter;
• Improved management of implicit and explicit statements: separate retrieval of explicit and implicit statements is straightforward;
• Rule compiler fix: now it can process rules with virtually unlimited number of premises.
• Getting-started introduced: a sample application setup (incl. source code, binaries, scripts, and configurations), allowing for easy bootstrapping of applications, which use OWLIM;
• Wordnet: a sample application loading W3C's RDF/OWL representation of Wordnet is provided;
• Distribution improvements: OWLIM is now packed with all the libraries necessary to run it; numerous improvements to the accompanying scripts make running OWLIM trivial.

Major changes in BigOWLIM version 0.9.2-Beta, 4 Oct. 2006, as compared to version 0.9-Beta:

• Query evaluation fixes: few problems, related to proper handling of Sesame construct queries, were fixed in BigTRREE; those were detected after a bug report from a user;
• Equivalence classes support fixes: some owl:sameAs statements were not properly inferred in the previous version;
• Initialization from file images fixed: some bugs related to the generation of B-Nodes and some of the in-memory structures were fixed;
• Temporary file creation fixed: improper handling of relative storage folder name was causing problems with temporary file creation;
• The new features from SwiftOWLIM v.2.8.4, got introduced into the BigOWLIM version as well: semantics customization support; command line parameters; fixes in the owl-max rule-set; Linux shell scripts were added.

An updated to the distribution package of SwiftOWLIM v.2.8.4 also took place on 30 Sept. 2006 - it includes updated documentation and some fixes to the accompanying scripts.

Major changes in SwiftOWLIM version 2.8.4, 16 Sept. 2006, as compared to version 2.8.3:

• Custom inference: the TRREE rule compiler became part of the distribution, which allows the usage of custom rule-sets for inference (see section 6.3 of the System Documentation for more on it). This way one can specify semantics which best fits the concrete application in terms of expressivity and performance;
• Command line parameters: some of the parameters of OWLIM can now be passed through the command line. In the previous versions, those could have only been specified as SAIL parameters in the system.conf file of Sesame or programmatically.
• Minor fixes in the owl-max rule-set: those allow for covering some extra cases of A-Box reasoning and eliminate most of the cases when B-Nodes have been generated.
• Linux shell scripts: Linux scripts have been added to the distribution, which allow for controlling (start/stop) of a standalone version of OWLIM and running tests. Such scripts were available only for Windows in previous versions.

Major changes in version 2.8.3, as compared to version 2.8.2:

• Improved concurrency: several improvements took place to allow swift handling of hundreds of simultaneous users.
• Stack-safe mode: a new stackSafe parameter allows switching the engine in a slower mode, which prevents stack overflows that could happen for some datasets and ontologies in the standard mode.
• Namespace fix: improper handling of namespaces in queries and elsewhere was fixed.
• Serialization fix: the main storage file has been serialized in NTriples, disregarding the dataFormat parameter – fixed, Turtle and RDF-XML are properly supported now.
• Persistency control fix: the noPersist parameter was not supported properly – fixed; this parameter switches off any persistence, i.e. OWLIM runs 100% in-memory.
• eLUBM benchmark: eLUBM is an extended version of the LUBM benchmark, developed by IBM’s IODT team, to allow evaluation of more comprehensive reasoning over OWL DL and Lite. eLUBM is provided with OWLIM as an extension of the standard LUBM benchmark.

Major changes in version 2.8.2, as compared to version 2.8:

• TRREE: OWLIM uses TRREE engine for in-memory reasoning and query evaluation. TRREE is a newer version of the IRRE engine, which was part of OWLIM v.2.8.
• 7 different inference modes: OWLIM can be configured to work with one of three pre-build sets of rules that support respectively the semanntics of RDFS, OWL Horst, and a specific fragment we name owl-max (combining OWL Lite with unrestricted RDFS). These rulests can be altered to “partial-rdfs” mode, when some of the normative RDFS entailments are discharged for performance reasons. In addition, the entailment is made optional, so that it is possible to switch it off completely and to use OWLIM as a plain RDF store.
• Extended OWL support: owl:oneOf, owl:minCardinality, owl:maxCardinality, owl:cardinality; partial OWL-Lite T-Box (schema-level) reasoning added.
• Configurable index size: allows the user to manage the tradeoff between RAM required and performance.

Major changes in version 2.8, as compared to version 2.0:

• IRRE: OWLIM uses IRRE for in-memory reasoning and query evaluation. Sesame's standard in-memory SAIL, implementing the RDFSchemaRepository, is not used any longer.
• Upload and reasoning speed up: there is a major improvement to the upload and reasoning speed due to the usage of IRRE.
• Persistence: Persistence implementation get changed , but it is still compatible with previous releases of OWLIM in terms of storage formats and SAIL configuration options.
• Multi-threading: The inference process is not multi-threaded and even it is not thread-safe, so, it requires a special attention if used in a multi-thread context. OWLIM still uses multi-threading for other functions (e.g. persistence).
• Extended support for OWL: intersectionOf, unionOf, AllDifferernt, someValuesFrom are already handled in this version.

Major changes in version 2.0, as compared to version 1.0:

• Sesame 1.2.1: compliance with Sesame release 1.2.1 (the previous version was compatible with Sesame 1.1).
• Upload speed up: there is a major improvement to the upload speed, through caching add triples operation.
• Persistence alignment with Sesame: persistence organization is now converged to the standard Sesame mechanism for synchronization of the repository contents with its persistence file.
• Concurrent multi-thread inference: it delivers serious improvements of the inference (and thus repository modification) speed for machines with multiple processors or Hyper-Threading.
• Extended support for OWL: support for allValuesFrom, hasValue, equivalentClass was added; the support for equivalentProperty was improved.
• RMI access enhancements: the SailAccessor interface was enriched with some methods to retrieve the access rights of a repository and extract/export its content.