EyeProlog combines ISO Prolog and W3C RDF 1.2 to turn portable rules and linked data into answers with inspectable proofs.
The name reflects this dual standards foundation: ISO Prolog provides the executable rule language, while RDF provides the interoperable linked-data model.
Its central design choice is composition rather than invention: use an established international standard for the rule language, use the Web’s standard graph data model, and define the smallest practical bridge between them.
EyeProlog arguably provides one of the strongest standards-based foundations for Web rules because it combines ISO Prolog as the rule language with the W3C RDF 1.2 data model and defines the missing operational bridge between them—including RDF term mappings, named graphs, triple terms, serialization, querying, and proofs.
This is a strong architectural claim, not a claim that the complete EyeProlog system is itself an ISO or W3C standard.
A Web rule system needs both a rule language and a data model.
ISO/IEC 13211-1 standardizes the Prolog general core, including its syntax, semantic rules, data representation, input and output, and processor behavior. The standard is intended to promote the portability of Prolog programs and data across processors.
RDF 1.2 defines the graph data model used by EyeProlog for linked data. It includes IRIs, blank nodes, literals, datasets, named graphs, and triple terms. RDF 1.2 is currently a W3C Candidate Recommendation, while RDF 1.1 remains the latest completed Recommendation.
EyeProlog brings these foundations together:
rdf/4 facts, queried with rules, and serialized back to RDF datasets.The exact status wording matters. EyeProlog is grounded in a current ISO International Standard and the W3C RDF 1.2 standards track. It should not imply that RDF 1.2 has already completed the W3C Recommendation process.
Prolog and RDF solve complementary problems, but neither standard defines their integration.
ISO Prolog does not specify:
RDF does not specify:
EyeProlog fills that gap with an explicit Prolog–RDF integration profile. The profile belongs to EyeProlog’s documented and tested behavior; it is not itself an ISO or W3C standard.
That limitation should be stated plainly:
EyeProlog is standards-based, but its Prolog–RDF integration profile has not itself been standardized by ISO or W3C.
A new rule language must establish its own syntax, semantics, implementation model, tooling, teaching material, and interoperability story. It can also become isolated if its original implementation or community disappears.
EyeProlog instead composes standards that remain useful independently:
This is why removing hidden extensions strengthens EyeProlog.
For example, false/0 is the ISO built-in predicate that always fails. EyeProlog does not overload clauses headed by false as automatically executed inference fuses. Integrity checks are ordinary predicates that the host invokes explicitly. The standardized construct keeps its standardized meaning, and application policy remains visible.
The governing design rule is:
Standards define the core. EyeProlog extensions must be explicit, minimal, documented, and testable.
Notation3 is a Web-native logic language that extends the RDF family with quoted formulae, implication, variables, built-in relations, and rules. Facts, rules, queries, and conclusions can all be expressed in one compact notation.
That design gives N3 distinctive strengths:
N3 is therefore not merely an RDF serialization with rule syntax added. It offers an integrated model in which data, rules, and quoted graphs belong to the same language.
Its standards position differs from EyeProlog’s. The W3C N3 Community Group develops language, built-in, and semantics specifications, but Community Group reports are not W3C Standards and are not currently on the W3C Standards Track. N3 also defines a complete logic notation beyond RDF, so interoperability depends on processors agreeing on that additional syntax, semantics, and built-in vocabulary.
EyeProlog explores a complementary standards architecture:
The trade-off is clear.
N3 is stronger when rules should themselves be Web data, or when quoted formulae and graph-level metareasoning are central. EyeProlog is stronger when users want conventional Prolog syntax and semantics, an ISO-defined language core, direct term-level programming, or a sharply separated interface between executable logic and RDF data.
The two approaches can interoperate at the language and data-model level. N3 can serve as a Web-native exchange and publication form, while compatible rules or data are translated into EyeProlog for ISO-Prolog execution. EyeProlog conclusions and proofs can in turn be serialized as RDF or N3.
In brief:
Notation3 provides an integrated, Web-native language for data and rules; EyeProlog separates an ISO-standard rule language from the RDF data model and makes the bridge explicit.
The W3C Rule Interchange Format remains stronger in the narrow formal sense. Its principal dialects, datatype framework, and RDF and OWL compatibility specifications are W3C Recommendations. RIF was explicitly designed for exchanging rules among heterogeneous rule systems.
RIF therefore has the stronger claim when the requirement is:
EyeProlog takes a different architectural approach. It reuses ISO Prolog as the executable rule language and RDF as the data model instead of defining another complete family of rule dialects.
That may be more durable for executable Web rules because both foundations are mature and independently useful. The trade-off is that EyeProlog’s bridge between them is an implementation profile rather than a formally standardized interchange specification.
In brief:
RIF is stronger as a standardized interchange framework; EyeProlog may be stronger as a small executable architecture built by composing existing standards.
SHACL 1.2 Rules is the closest emerging RDF-native comparison.
The current draft defines declarative rules that derive new RDF triples from a base graph. It provides:
infer operation that produces an inference graph;query operation that determines whether a goal pattern is derivable;SHACL 1.2 Rules has important advantages:
Its present limitations relative to EyeProlog are different rather than absolute:
SHACL 1.2 Rules is therefore not merely a competitor. It is also a potential interoperability target.
EyeProlog could eventually:
The positioning should remain balanced:
SHACL 1.2 Rules is stronger as an RDF-native rules specification on the W3C Recommendation track. EyeProlog is stronger where applications need an established general-purpose logic language, direct Prolog execution, richer term-level computation, and inspectable derivations.
SPARQL is the standard choice for querying RDF graphs. It provides graph-pattern matching, filters, aggregation, property paths, federation, and standardized result formats. SPARQL Update provides standardized graph modification.
SPARQL should be preferred when the task is fundamentally an interoperable RDF query or update.
EyeProlog is preferable when the task depends on:
The two approaches are complementary. RDF data queried by SPARQL can also be reasoned over by EyeProlog, and EyeProlog results can be serialized back into RDF.
Systems such as SWI-Prolog, SICStus Prolog, Scryer Prolog, and Trealla Prolog provide broader Prolog environments, richer libraries, or stronger implementation maturity in particular deployment settings.
They are preferable when an application needs:
EyeProlog does not need to compete on feature count. Its distinction is the deliberately small and visible combination of:
A general Prolog system can provide RDF through libraries. EyeProlog makes the Prolog–RDF boundary part of its central language and interoperability story.
Custom engines can optimize aggressively for one domain, data model, or deployment environment. They may offer specialized forward chaining, incremental materialization, distributed execution, or domain-specific syntax.
Their cost is often a proprietary semantic model.
EyeProlog avoids requiring users to adopt an isolated rule language. Its programs begin with recognizable Prolog, and its data begins with recognizable RDF. EyeProlog-specific behavior remains concentrated in the bridge between them.
A concise positioning statement is:
EyeProlog combines a conformance-tested ISO Prolog profile with W3C RDF 1.2 linked data, explicit extensions, and inspectable proofs in a lightweight JavaScript implementation.
A stronger comparative statement is:
EyeProlog arguably provides one of the strongest standards-based foundations for executable Web rules because it composes ISO Prolog and RDF 1.2 instead of introducing another complete rule language.
Both claims require qualifications:
These qualifications make the standards argument more credible, not less.
The standards-based position creates a useful filter for future features.
EyeProlog should resist:
New capabilities should normally take one of three forms:
Syntax or semantics outside those categories should need a strong justification.
EyeProlog’s most important contribution is not a novel rule syntax.
It is the proposition that Web rules can be built by joining two established foundations:
RIF demonstrates the value of formal rule interchange. SHACL 1.2 Rules demonstrates renewed demand for standardized RDF-native inference. SPARQL demonstrates the value of a shared graph-query language.
EyeProlog occupies a complementary position: a small executable system in which standard Prolog rules operate directly over faithfully represented RDF data and produce answers that can be explained.
That is a focused and defensible reason for EyeProlog to exist.