CLIPS

CLIPS (C Language Integrated Production System) is a rule-based expert system tool developed at NASA’s Lyndon B. Johnson Space Center beginning in 1985. Created by a team led by Gary Riley in the Software Technology Branch, CLIPS provides a forward-chaining inference engine based on the Rete algorithm, combined with procedural and object-oriented programming capabilities. Originally built as a portable, embeddable alternative to expensive commercial Lisp-based expert system tools, CLIPS has been in the public domain since 1996 and remains actively maintained, with the most recent release (version 6.4.2) published in January 2025.

History & Origins

In the mid-1980s, NASA’s Johnson Space Center was evaluating expert system technology for aerospace applications. The Artificial Intelligence Section of the Software Technology Branch had been using ART*Inference, a commercial expert system tool, but found it expensive and tied to Lisp platforms that limited portability and integration with existing C-based systems.

Gary Riley, along with colleagues Chris Culbert, Bob Savely, and Frank Lopez, began developing CLIPS in the spring of 1985. The prototype version 1.0 was built in approximately two months on a UNIX environment, primarily to gain practical experience with expert system implementation and evaluate integration challenges. The project was originally referred to internally as NASA’s AI Language (NAIL) before receiving the CLIPS name.

The first version distributed outside NASA was version 3.0, released in July 1986. By version 4.3 in 1989, CLIPS had grown to over 2,500 users spanning NASA, the U.S. military, universities, and commercial organizations. Its appeal was straightforward: written in C for portability, it could be embedded in other applications, ran on commodity hardware, and was freely available from NASA.

Expansion Beyond Rules

CLIPS was initially a pure rule-based system, but version 5.0 (released around 1991) significantly expanded the language by adding two new programming paradigms. Procedural programming support brought functions, control structures, and imperative programming constructs. COOL (CLIPS Object-Oriented Language) added class definitions, multiple inheritance, message-passing, and the ability to combine object-oriented programming with rule-based reasoning.

Version 6.0, released in 1993, completed this integration by enabling rules to pattern-match directly against objects, unifying the three paradigms into a single coherent system.

Transition to Public Domain

In the mid-1990s, NASA’s Johnson Space Center shifted its focus away from expert system tool development. By 1996, CLIPS was released to the public domain, and Gary Riley continued its development independently. This transition ensured the tool’s survival and ongoing evolution well beyond its NASA origins.

Design Philosophy

CLIPS was designed around several core principles that reflect both its NASA heritage and its intended role as a practical engineering tool:

Portability: Written in C with minimal external dependencies, CLIPS compiles and runs across platforms including Windows, macOS, Linux, and BSD. This was a direct response to the platform lock-in of commercial Lisp-based expert system tools of the 1980s.

Embeddability: CLIPS was designed from the start to be embedded within larger C applications. Its API allows host programs to create CLIPS environments, assert facts, fire rules, and retrieve results programmatically.

Multi-paradigm integration: Rather than forcing developers to choose between rule-based, procedural, and object-oriented approaches, CLIPS allows all three to coexist and interact within a single program. Rules can trigger procedural code, procedural code can manipulate objects, and rules can pattern-match against objects.

Simplicity and self-containment: The entire CLIPS system, including the inference engine, parser, and interactive environment, compiles from a single set of C source files with no external library dependencies.

Key Features

Rule-Based Programming

The core of CLIPS is its forward-chaining inference engine, based on Charles Forgy’s Rete algorithm (1982). Facts are asserted into a fact list, and rules whose conditions match the current facts are placed on an agenda for execution. The engine repeatedly selects and fires the highest-priority rule until no more rules are applicable:

1
2
3
4

(defrule greet-user
   (user-name ?name)
   =>
   (printout t "Hello, " ?name "!" crlf))

Rules support pattern matching against structured facts (deftemplates), wildcards, variable binding, logical connectives, and salience-based priority control.

COOL (CLIPS Object-Oriented Language)

COOL provides a full object-oriented programming system including:

• Class definitions with slots (instance variables)
• Multiple inheritance
• Message-passing with before, after, and around methods
• Direct pattern matching of objects in rules

1
2
3

(defclass PERSON (is-a USER)
   (slot name (type STRING))
   (slot age (type INTEGER)))

Procedural Programming

CLIPS includes deffunctions for defining procedural functions, along with control structures such as if/then/else, while, loop-for-count, switch, and progn. This allows straightforward imperative programming when rule-based reasoning is not the best fit for a particular task.

Templates and Structured Facts

Deftemplates define structured fact types with named slots, optional type constraints, default values, and cardinality specifications. They serve a role analogous to structs in C or records in Pascal:

1
2
3
4

(deftemplate patient
   (slot name (type STRING))
   (slot temperature (type FLOAT) (default 98.6))
   (slot symptoms (multislot) (type SYMBOL)))

Modules

The defmodule construct partitions a CLIPS program into separate namespaces, each with its own rules, facts, and agenda. Modules can control the flow of execution and manage the visibility of constructs, enabling the development of larger, more organized expert systems.

Evolution

CLIPS has evolved steadily over four decades:

• 1985-1989: Pure rule-based system focused on forward chaining. Rapid adoption across government and academic institutions.
• 1991-1993: Addition of procedural programming and COOL, transforming CLIPS from a single-paradigm tool into a multi-paradigm language. Version 6.0 unified all three paradigms.
• 1996-2015: Public domain era begins. Gary Riley maintains and incrementally improves CLIPS outside NASA. Version 6.30 (2015) added 64-bit integer support and performance enhancements.
• 2021-present: Version 6.40 brought a major overhaul including a redesigned C API, wrapper classes for .NET and Java integration, new IDEs with Unicode support, and continued modernization. Version 6.4.2 (January 2025) added new utility functions and improved UTF-8 handling.

Throughout this evolution, CLIPS has maintained backward compatibility, and its core architecture — the Rete-based inference engine with integrated procedural and OOP capabilities — has remained stable.

Derivatives and Influenced Systems

CLIPS’s public domain status and clean C implementation have made it a foundation for numerous derivative systems:

• Jess (Java Expert System Shell): Created by Ernest Friedman-Hill at Sandia National Laboratories, Jess reimplemented the rule-based portion of CLIPS in Java. It later diverged significantly, adding backward chaining and direct Java object manipulation.
• FuzzyCLIPS: Developed by the National Research Council of Canada’s Integrated Reasoning Group, FuzzyCLIPS extended CLIPS with fuzzy logic reasoning capabilities.
• Several commercial expert system tools were derived from the CLIPS source code, and numerous organizations have used CLIPS as the foundation for custom expert system tools tailored to their specific domains.

Current Relevance

CLIPS remains actively maintained by Gary Riley, with version 6.4.2 released in January 2025. The project is hosted on SourceForge and the official site at clipsrules.net. It is public domain software, freely available for any use.

While the expert systems era of the 1980s and 1990s has passed, CLIPS continues to serve several roles:

• Education: CLIPS is widely used in university AI courses to teach rule-based programming, knowledge representation, and inference engine concepts.
• Embedded rule engines: Its small footprint and C API make it suitable for embedding rule-based reasoning in larger applications.
• Research: CLIPS provides a stable, well-documented platform for expert system and knowledge engineering research.
• Legacy systems: Expert systems originally built with CLIPS at NASA, in the military, and in industry continue to operate, and CLIPS’s backward compatibility ensures they can be maintained with current versions.

The official documentation includes a three-volume Reference Manual and User’s Guide. The textbook “Expert Systems: Principles and Programming” (4th edition), co-authored by Gary Riley, uses CLIPS as its primary implementation language.

Why It Matters

CLIPS represents one of the most successful knowledge transfer efforts in NASA’s history. What began as an internal tool to reduce dependency on commercial AI software became reportedly the most widely distributed expert system tool in the world, reaching thousands of users across government, military, academic, and commercial organizations.

Its design decisions — writing in C for portability, making the source freely available, supporting embeddability, and eventually moving to the public domain — anticipated the open-source software movement by years. CLIPS demonstrated that expert system technology did not require expensive Lisp machines or proprietary environments; it could run on standard hardware, be integrated with conventional software, and be maintained by a broad community of users.

For the field of artificial intelligence, CLIPS serves as a durable bridge between the symbolic AI era and modern computing. Its Rete-based inference engine remains an efficient and well-understood approach to production rule systems, and its multi-paradigm design — combining rules, procedures, and objects — influenced how subsequent expert system tools approached language design.