The Cover PagesThe OASIS Cover Pages: The Online Resource for Markup Language Technologies
Advanced Search
Site Map
CP RSS Channel
Contact Us
Sponsoring CP
About Our Sponsors

Cover Stories
Articles & Papers
Press Releases

XML Query

XML Applications
General Apps
Government Apps
Academic Apps

Technology and Society
Tech Topics
Related Standards
Last modified: May 23, 2007
Rule Markup Language (RuleML)



"Rules in (and for) the Web have become a mainstream topic since inference rules were marked up for E-Commerce and were identified as a Design Issue of the Semantic Web, and since transformation rules were put to practice for document generation from a central XML repository (as used here). Moreover, rules have continued to play an important role in AI shells for knowledge-based systems and in Intelligent Agents, today both needing a Web interchange format, and such XML/RDF-standardized rules are now also usable for the declarative specification of Web Services.

The Rule Markup Initiative has taken steps towards defining a shared Rule Markup Language (RuleML), permitting both forward (bottom-up) and backward (top-down) rules in XML for deduction, rewriting, and further inferential-transformational tasks. The initiative started during PRICAI 2000, as described in the Original RuleML Slide, and was launched in the Internet on 2000-11-10. Besides the previous XML-only RuleML and the current XML/RDF-combining RuleML, there is also an approach towards an RDF-only RuleML. Complementary efforts consist of the development of (Java-based) rule engines such as jDREW and Mandarax RuleML, as well as XSB-RDF RuleML. RuleML's earlier design evolved into DTDs-Schemas for positional-slotted RuleML sublanguages including Object-Oriented RuleML (OO RuleML). Efforts also went into defining MOF-RuleML: The Abstract Syntax of RuleML as a MOF Model. [summary from 2007-05-23]

[November 17, 2000] The RuleML Initiative represents a collaborative research effort by an international team of participants seeking to develop shared Rule Markup Language (RuleML). The project is consciously related to other standards work, including Mathematical Markup Language (MathML), DARPA Agent Markup Language (DAML), Predictive Model Markup Language (PMML), Attribute Grammars in XML (AG-markup), and Extensible Stylesheet Language Transformations (XSLT). From the web site description: "The participants of the RuleML Initiative constitute an open network of individuals and groups from both industry and academia. We are not commencing from zero but have done some work related to rule markup or have actually proposed some specific tag set for rules. Our main goal is to provide a basis for an integrated rule-markup approach that will be beneficial to all involved and to the rule community at large. This shall be achieved by having all participants collaborate in establishing translations between existing tag sets and in converging on a shared rule-markup vocabulary. This RuleML kernel language can serve as a specification for immediate rule interchange and can be gradually extended - possibly together with related initiatives - towards a proposal that could be submitted to the W3C. Rules can be stated (1) in natural language, (2) in some formal notation, or (3) in a combination of both. Being in the third, 'semiformal' category, the RuleML Initiative is working towards an XML-based markup language that permits Web-based rule storage, interchange, retrieval, and firing/application. Rules in (and for) the Web have become a mainstream topic since inference rules were marked up for E-Commerce and were identified as a Design Issue of the Semantic Web, and since transformation rules were put to practice for document generation from a central XML repository (as used here). Rules have also continued to play an important role in Intelligent Agents and AI shells for knowledge-based systems, which need a Web interchange format, too. The Rule Markup Initiative has taken initial steps towards defining a shared Rule Markup Language (RuleML), permitting both forward (bottom-up) and backward (top-down) rules in XML for deduction, rewriting, and further inferential-transformational tasks. The initiative started during PRICAI 2000, as described in the Original RuleML Slide, and was launched in the Internet on 2000-11-10. A complementary effort coordinates the development of Java rule engines. A Rule Markup Workshop is planned in conjunction with the third International Conference on Electronic Commmerce, ICEC2001, in Vienna, Austria, in October 2001."

"RuleML largely grows out of the design approach and design criteria of Business Rules Markup Language (BRML) which was developed in my previous work at IBM Research and which is implemented in IBM CommonRules 4 available under free trial license from IBM alphaWorks. The design approach and design criteria of CommonRules and BRML are described in [Grosof et al., 1999; Grosof and Labrou, 2000], and in the documentation in the CommonRules download package. BRML's expressive class is situated courteous logic programs, i.e., declarative logic programs with negation-as-failure, (limited) classical negation, prioritized conflict handling, and disciplined procedural attachments for queries and actions. RuleML differs in several significant respects from its BRML predecessor, however. One respect is that it defines a family of DTDs. More deeply, however, these differences largely revolve around 'Webizing' the KR: (1) URIs for logical vocabulary and knowledge subsets; (2) labels for rules/rulebases, import/export; (3) headers: metadata describes the XML document's expressive class; (4) procedural attachments using Web protocols/services, queries or actions via CGI/servlets/SOAP/..." [from the IJCAI 2001 Workshop paper of B. Grosof]

"Engines: "One or more rule engines will be needed for executing RuleML modules. On 2000-11-15, the RuleML Initiative thus joined forces with the Java Specification Request JSR-000094 Java Rule Engine API. This cooperation will enable a direct cross-fertilization between the complementary specifications of the open XML-based Rule Markup Language and of the Java runtime API for rule engines."

General: Articles, Papers, Reports, News

  • [May 23, 2007] "Call for Papers: The International RuleML Symposium on Rule Interchange and Applications (RuleML-2007)." The International RuleML Symposium on Rule Interchange and Applications (RuleML-2007) will take place, October 25-26, 2007, in Orlando, Florida co-located with The 10th International Business Rules Forum. RuleML-2007 is devoted to practical distributed rule technologies and rule-based applications which need language standards for rules operating in the context of, e.g., the Semantic Web, Intelligent Multi-Agent Systems, Event-Driven Architectures and Service-Oriented Computing Applications. A RuleML-2007 Challenge with prizes will be organized to demonstrate tools, use cases, and applications. Abstracts are due June 15, 2007; papers are due June 29, 2007. The goal of RuleML-2007 is to bring together rule system providers, representatives of, and participants in, rule standardization efforts (e.g., RuleML, RIF, PRR, CL, SBVR) and open source rules communities (e.g., jBoss Rules , Jess, Prova, OO jDrew, Mandarax, XSB, XQuery), practitioners and technical experts, developers, users, and researchers. They will be offered an exciting venue to exchange new ideas, practical developments and experiences on issues related to the engineering, management, integration, interoperation and interchange of rules in open distributed environments such as the Web. A particular focus will be on practical issues such as technical contributions and show case demonstrations of effective, practical, deployable rule-based technologies, rule interchange formats and applications as well as discussions of lessons learned that have to be taken into account when employing rule-based technologies in distributed, (partially) open, heterogeneous environments..."

  • [November 05, 2002] CommonRules version 3.3 from IBM alphaWorks now offers "improved performance; faster processing speed due to a better fact-matching algorithm; a new object-mapping system; improved documentation; and additional built-in functions. CommonRules is a rule-based framework for developing rule-based applications with major emphasis on maximum separation of business logic and data, conflict handling, and interoperability of rules. It is a pure Java library, and it provides a platform that enables the rapid development of rule-based applications through its situated rule engine via dynamic and real-time connection with business objects. CommonRules can be integrated with existing applications at a specific point of interest, or it can be used to create applications composed only of rules. CommonRules uses a sematically-rich rule language called CLP (Courteous Logic Program) to enable direct conflict resolution through conditional mutual exclusion and prioritized override. It contains a set of APIs for efficient application integration, as well as data and function bindings. Also included is a prototype for rule interlingua, which is currently based on CLP; later, it will be based on RuleML (the proposed standard rule format) in order to enable interoperability of different rules... CommonRules provides innovative XML interoperability and prioritized conflict-handling capabilities. These modularly augment a wide variety of rule-based systems and programming mechanisms already available in the market. CommonRules 3.3 includes an API set for enhancing Java or non-Java applications. It also includes extensive documentation and example rule sets. Using CommonRules, a seller Web site or application can communicate in XML its business policy rules about pricing, promotions, customer service provisions for refunds and cancellation, ordering lead time, and other contractual terms and conditions, to a customer application or agent, even when the seller's rules are implemented using a different rule system (such as OPS5-style production rules) than that in which the buyer's rules are implemented (such as Prolog). The customer application or agent can then understand and assimilate those rules into its own business logic, and it can automatically execute those rules to make plans or decisions."

  • [March 26, 2002] "Standardizing XML Rules: Rules for E-Business on the Semantic Web." Invited Presentation (45-minutes, presentation, with slides in PDF format). By Benjamin N. Grosof (MIT Sloan Professor in E-Commerce Information Technology). August 5, 2001. Presented at the Workshop on E-business and the Intelligent Web at the International Joint Conference on Artificial Intelligence (IJCAI-01). See also the short paper; preliminary prose outline of the talk, and appears in the Workshop Proceedings. The principal topic of discussion is the Rule Markup Language (RuleML). [alt URL for paper; cache]

  • [September 21, 2001] ICEC 2001 Workshop on Semantic Web-based E-Commerce and Rules Markup Language. October 31 - November 4th, 2001. Vienna, Austria. "... an exchange of information and ideas, and to facilitate the discussion of current and emerging topics related to E-Commerce, the Semantic Web and Rules Markup Languages."

  • [October 22, 2001] "The Rule Markup Language: RDF-XML Data Model, XML Schema Hierarchy, and XSL Transformations." By Harold Boley. Invited presentation at the 14th International Conference of Applications of Prolog (INAP2001), October 20-22, 2001. The University of Tokyo, Sanjo Conference Hall, Japan. 16 pages. See also the slides.

  • [May 19, 2001] "RuleML DTDs." By Harold Boley, Benjamin Grosof, and Said Tabet. Version 0.7 (2001-01-25) or later. "This is a preliminary DTD draft for RuleML. Each DTD in the evolving hierarchy corresponds to a specific RuleML sublanguage. The DTDs use a modularization approach similar to the one in XHTML in order to offer appropriate flexibility and accomodate different implementations and approaches. We will write a technical report on this system of RuleML DTDs..."

  • [February 26, 2001] RuleML for W3C face-to-face Technical Plenary Meeting.. By Benjamin Grosof. February 26 to March 2, 2001. Materials include (1) The One-pager: A Flyer announcing the Rules Birds Of a Feather session held at the W3C meeting, and summarizing what RuleML is. (2) 15-minute Overview Talk -- Slides: RuleML Overview Slides presented at the Birds Of a Feather session held at the W3C meeting. (3) More Technical Details on the Strawman-version RuleML Syntax -- Talk Slides: RuleML Syntax: Examples and DTDs -- Talk Slides presented at the Birds Of a Feather session held at the W3C meeting."

  • "Design Rationale of RuleML: A Markup Language for Semantic Web Rules." By Harold Boley, Said Tabet, and Gerd Wagner. "This paper lays out the design rationale of RuleML, a rule markup language for the Semantic Web. We give an overview of the RuleML Initiative as a Web ontology effort. Subsequently, the modular syntax and semantics of RuleML and the current RuleML 0.8 DTDs are presented (focusing on the Datalog and URI sublanguages). Then we discuss negation handling, priorities/evidences, as well as agents and RuleML. We next proceed to RuleML implementations via XSLT and rule engines. In our conclusions, we continue to explore the bigger picture of ontologies and discuss some requirements for a future RuleML. An appendix shows our Semantic Web scenario in the insurance industry... To accomodate the various (Web) rule-user communities from Knowledge-Based Systems to Intelligent Agents to E-Commerce, a modular hierarchy of sublanguages will be discussed. Rule extensions will concern first-class URIs, Web-suited negations, labelings, certainties/priorities, and packages. The Initiative also examines where current description methods and implementation techniques (e.g., XML DTDs vs. Schemas and C- vs. Java-based rule engines) are sufficient for such rule markup and where they would need revisions/extensions. This paper further attempts to contribute to some open issues of Notation 3 (N3) and DAML-Rules in relation to RuleML. Finally, by studying issues of combining rules and taxonomies via sorted logics, description logics, or frame systems, the paper also touches on the US-European proposal DAML+OIL..."

  • [May 19, 2001] "Standardizing XML Rules." By Benjamin N. Grosof (MIT Sloan School of Management, Cambridge, MA, USA. Email: or Invited paper for the IJCAI 2001 Workshop on E-Business and the Intelligent Web [August 5 2001], part of the Seventeenth International Joint Conference on Artificial Intelligence. ['The author provides an overview of current efforts to standardize rules knowledge representation in XML, with special focus on the design approach and criteria of RuleML, an emerging standard. With Harold Boley of DFKI (Germany) and Said Tabet of Nisus Inc. (USA), Benjamin N. Grosof leads an early-phase standards effort on a markup language for exchange of rules in XML, called RuleML (Rule Markup Language); the goal of this effort is eventual adoption as a Web standard, e.g., via the World Wide Web Consortium'] "RuleML is, at its heart, an XML syntax for rule knowledge representation (KR), that is inter-operable among major commercial rule systems. It is especially oriented towards four commercially important families of rule systems: SQL (relational database), Prolog, production rules (cf. OPS5, CLIPS, Jess) and Event-Condition-Action rules (ECA). These kinds of rules today are especially found embedded in Object-Oriented (OO) systems, and are often used for business process connectors / workflow. These four families of rule systems all have common core abstraction: declarative logic programs (LP). 'Declarative' here means in the sense of KR theory. Note that this supports both backward inferencing and forward inferencing. RuleML is actually a family (lattice) of rule KR expressive classes: each with a DTD (syntax) and an associated KR semantics (KRsem). These expressive classes form a generalization hierarchy (lattice). The KRsem specifies what set of conclusions are sanctioned for any given set of premises. Being able to define an XML syntax is relatively straightforward. Crucial is the semantics (KRsem) and the choice of expressive features. The motivation to have syntax for several different expressive classes, rather than for one most general expressive class, is that: precision facilitates and maximizes effective interoperability, given heterogeneity of the rule systems/applications that are exchanging rules. The kernel representation in RuleML is: Horn declarative logic programs. Extensions to this representation are defined for several additional expressive features: (1) negation: negation-as-failure and classical negation; (2) prioritized conflict handling: e.g., cf. courteous logic programs; (3) disciplined procedural attachments for queries and actions: e.g., cf. situated logic programs; (4) equivalences, equations, and rewriting; (5) and other features as well. In addition, RuleML defines some useful expressive restrictions (e.g., Datalog, facts-only, binary-relations-only), not only expressive generalizations... In January 2001, we released a first public version of a family of DTDs for several flavors of rules in RuleML. This was presented at the W3C's Technical Plenary Meeting held February 26 to March 2, 2001. Especially since then, RuleML has attracted a considerable degree of interest in the R&D community. Meanwhile, the design has been evolving to further versions." [cache]

  • [January 16, 2001] "Rules and Facts: Inference engines vs Web." By Tim Berners-Lee. January 16, 2001. Series: Axioms of Web Architecture. [An attempt to explain part of the relationship between the Semantic Web and inference engines, either existing or legacy, and to discuss the relationship between inference rules and logical facts.] "The Semantic Web is a universal space for anything which can be expressed in classical logic. In the world of knowledge Representation (KR) there are many different systems, and the following is an attempt to generalize. Each system typically has a distinction between data and rules. The data is a pool of information in one language (sometimes very simple without negation like basic RDF) . The rules control the inference steps which the inference engine makes. The rules are written in a restricted language so as to preserve some property computability property. Algernon restricts its rules to forward chaining but assures Socratic completeness... Exposing rules as classic logic facts strips the (pragmatically useful) hint information which controls the actual sequence of operation of a local inference engine. When the facts corresponding to all the rules of all the inference engines are put onto the web, then the great thing is that all the knowledge is represented in the same space. The drawback is that there is no one inference engine which can answer arbitrary queries. But that is not a design goal of the semantic web. The goal is to unify everything which can be expressed in classical logic (including more mathematics when we get to it) without futher constraint. We must be able to describe the world, and our hopes and needs and terms and conditions. A system which tries to constrain the expressive power cannot be universal... Is there a way to limit the domain of trust in a key while allowing information to be processed in a consistent way throughout the system? Yes - maybe - there are many. Each KR system which uses a limited logic does do in order (partly) to solve this problem. We just qualify 'can be inferred' be the type of inference rules which may be used. This means the generic proof engine eitehr has to work though a reified version of the rules or it has to know the sets - incorporate each proof engine. Maybe we only need one..."

  • Rule Markup Initiative. By Harold Boley. Presented at The Sixth Pacific Rim International Conference on Artificial Intelligence (PRICAI 2000) Melbourne, Australia, on 31 August 2000.

  • [November 10, 2000] RuleML Announcement. From Harold Boley and Said Tabet. 10-November-2000.

  • JSR-000094 Java Rule Engine API. "This specification defines a Java runtime api for rule engines; it targets the J2EE and J2SE platforms...This specification assumes the existence of a parallel effort to specify an open, XML-based rule language. The result of this effort will be an XML Schema that will be registered at a site such as [...] The API prescribes an object model and a set of fundamental rule engine operations. The object model and set of operations are based upon the assumption that most clients will need to be able to execute a basic multi-step rule engine cycle, which consists of parsing rules, adding objects to an engine, firing rules and getting resultant objects from the engine. The object model and the set of operations also support variations of the basic cycle, particularly variations that would occur in J2EE server deployments. A primary input to a rule engine is a collection of rules called a ruleset. The rules in a ruleset are expressed in a rule language. This specification defines api support for parsing rulesets that have been authored in vendor-specific rule languages. Additionally, to help simplify the task of creating rule-authoring tools and because business-to-business exchange of rules is anticipated, this specification defines api support for parsing rulesets that have been authored in XML-based, vendor-independent rule languages."

  • [September 07, 2000] "Tutorial on Knowledge Markup Techniques." By Harold Boley, Stefan Decker, and Michael Sintek. '07-Sep-2000'. Also available as PDF and Postscript.

  • Contacts: Benjamin N. Grosof (MIT Sloan School of Management), Harold Boley. and Said Tabet

Hosted By
OASIS - Organization for the Advancement of Structured Information Standards

Sponsored By

IBM Corporation
ISIS Papyrus
Microsoft Corporation
Oracle Corporation


XML Daily Newslink
Receive daily news updates from Managing Editor, Robin Cover.

 Newsletter Subscription
 Newsletter Archives
Globe Image

Document URI:  —  Legal stuff
Robin Cover, Editor: