Ziglog

A high-performance Prolog interpreter written in Zig 0.15.2, implementing core logic programming features with modern optimizations.

Overview

Ziglog is a Prolog-like logic programming language interpreter featuring:

Complete Prolog core: Unification, SLD resolution with backtracking, and cut operator
DCG support: Definite Clause Grammars with automatic transformation
Full arithmetic: Integer and floating-point arithmetic with automatic type promotion
Unicode support: Full UTF-8 support with SWI-Prolog-compatible character escape sequences
Performance optimizations: First-argument indexing, choice point elimination, partial tail-call optimization
Interactive REPL: Full-featured read-eval-print loop with live syntax highlighting, tab completion, syntax hints, and command history (powered by replxx)
Comprehensive testing: 67 unit tests + 311 integration tests across 16 test files

Quick Start

Building

zig build

Running the REPL

zig build run

Running Tests

# Unit tests only
zig build test

# Integration tests only
zig build test-integration

# All tests
zig build test-all

Language Reference

Facts

Facts are assertions about the world. They define relationships between terms.

% Facts are atoms or structures followed by a period
parent(john, mary).
parent(john, bob).
parent(jane, mary).

% Facts with numbers
age(john, 45).
age(mary, 20).

% Facts with strings
greeting("Hello, World!").

Rules

Rules define logical relationships with conditions.

% Rule syntax: Head :- Body.
% Read as "Head is true if Body is true"
grandparent(X, Y) :- parent(X, Z), parent(Z, Y).

% Rules can have multiple clauses
ancestor(X, Y) :- parent(X, Y).
ancestor(X, Y) :- parent(X, Z), ancestor(Z, Y).

% Rules with arithmetic
adult(X) :- age(X, Age), Age >= 18.

Queries

Queries ask questions to the interpreter. Use ?- to start a query.

% Simple query
?- parent(john, mary).
true.

% Query with variables (finds all solutions)
?- parent(john, X).
X = mary
X = bob

% Query with multiple goals
?- parent(X, Y), parent(Y, Z).
X = john, Y = mary, Z = <child_of_mary>
...

% Query that fails
?- parent(alice, bob).
false.

Terms

Atoms

Atoms are constants starting with lowercase letters or enclosed in single quotes.

atom               % lowercase atom
hello_world        % atom with underscore
'Atom'            % quoted atom (can contain uppercase, spaces)
'atom with spaces' % quoted atom with spaces
[]                % special atom (empty list)

Variables

Variables start with uppercase letters or underscore.

X                 % named variable
Person            % named variable
_                 % anonymous variable (matches anything, doesn't bind)
_Name             % anonymous variable (for readability, not bound)

Numbers

Both integers and floating-point numbers are supported. Ziglog supports non-decimal number notation following SWI-Prolog syntax.

% Decimal integers
42                % positive integer
-17               % negative integer
0                 % zero

% Floats (must have decimal point)
3.14              % positive float
2.71828           % float with multiple decimals
0.5               % float less than 1

Non-Decimal Numbers: Ziglog supports both ISO and Edinburgh notation for non-decimal integers:

% ISO Syntax (prefix notation)
0b1010            % Binary (decimal 10)
0o755             % Octal (decimal 493)
0xFF              % Hexadecimal (decimal 255)
0XFF              % Uppercase prefix also works

% Edinburgh Syntax (radix'number, base 2-36)
2'1010            % Binary (decimal 10)
8'755             % Octal (decimal 493)
16'FF             % Hexadecimal (decimal 255)
36'Z              % Base-36 (decimal 35)

% Examples in expressions:
?- X is 0b100 + 0x10.
X = 20

?- X is 16'FF =:= 255.
true.

?- X is 2'101 * 8'10.
X = 40

Note: Non-decimal numbers are always unsigned (as per SWI-Prolog specification).

Digit Grouping: Following SWI-Prolog, Ziglog supports digit grouping for improved readability of large numbers:

% Underscore separators (works with all number bases)
1_000_000         % One million (decimal)
0b1111_0000       % Binary with grouping (240)
0xDEAD_BEEF       % Hexadecimal with grouping
16'FF_00          % Edinburgh syntax with grouping

% Space separators (only for radix ≤ 10)
1 000 000         % One million (decimal)
0b1111 0000       % Binary with spaces (240)
0o777 000         % Octal with spaces

% Comments within digit groups
1_000_/*thousands*/000   % Block comments allowed

% Floats with digit grouping
3.141_592_653     % Pi with digit separators

% Examples in expressions:
?- X is 1_000 + 2_000.
X = 3000

?- 0xDEAD_BEEF =:= 3735928559.
true.

Note: This is a SWI-Prolog extension and not part of ISO Prolog. Underscore separators can include optional whitespace and block comments. Space separators are restricted to bases 10 and lower.

Infinity and NaN: Following SWI-Prolog, Ziglog supports special float values for infinity and not-a-number:

% Positive infinity
?- X is 1.0Inf.
X = 1.0Inf

% Negative infinity (via arithmetic)
?- X is 0 - 1.0Inf.
X = -1.0Inf

% NaN (Not-a-Number) - literal syntax
?- X is 1.5NaN.
X = 1.5NaN

% NaN via nan/0 function
?- X is nan.
X = 1.5NaN

% Infinity in comparisons
?- 1.0Inf > 999999999.
true.

% NaN fails all arithmetic comparisons
?- X is 1.5NaN, Y is 1.5NaN, X =:= Y.
false.

% But NaN unifies structurally
?- X is 1.5NaN, Y is 1.5NaN, X = Y.
true.

% Infinity with digit grouping
?- X is 1_000.0Inf.
X = 1.0Inf

Note: Infinity uses the syntax <digit>.<digit>+Inf, and NaN can use either the literal syntax <digit>.<digit>+NaN or the nan/0 function. All infinities display as 1.0Inf or -1.0Inf, and all NaN values display as 1.5NaN. These are SWI-Prolog extensions and not part of ISO Prolog.

Strings

Strings are enclosed in double quotes. Strings fully support UTF-8 Unicode characters and SWI-Prolog-compatible escape sequences.

"hello"           % string literal
"Hello, World!"   % string with punctuation
""                % empty string
"café"            % direct UTF-8 characters
"Hello 👋 World"  % emoji support
"日本語"          % Japanese text

Character Escape Sequences: Strings and atoms support escape sequences for special characters:

% Standard escapes
"\n"              % newline
"\t"              % tab
"\r"              % carriage return
"\\"              % backslash
"\""              % double quote
"\'"              % single quote

% Special escapes
"\a"              % alert/bell (ASCII 7)
"\b"              % backspace
"\e"              % escape (ASCII 27)
"\f"              % form feed
"\v"              % vertical tab
"\s"              % space

% Numeric escapes
"\x41"            % hex escape (A)
"\u00e9"          % Unicode 4-digit (é)
"\U0001F600"      % Unicode 8-digit (😀)
"\101"            % octal escape (A)

Example:

?- X = "Line 1\nLine 2\tTabbed", write(X).
Line 1
Line 2	Tabbed
X = "Line 1\nLine 2\tTabbed"

Structures

Structures (compound terms) represent complex data with a functor and arguments.

person(john, 25)              % functor: person, arity: 2
point(3, 4)                   % functor: point, arity: 2
tree(node, left(1), right(2)) % nested structures

Lists

Lists are sequences of terms with special syntax.

[]                % empty list
[1, 2, 3]         % list of numbers
[a, b, c]         % list of atoms
[X, Y, Z]         % list of variables
[H|T]             % list with head H and tail T
[1, 2|Rest]       % list with first two elements and Rest
[_|Tail]          % ignore head, capture tail

Internal representation: Lists are syntactic sugar for the dot structure:

[1, 2, 3] = .(1, .(2, .(3, [])))

Operators

Logical Operators

% Conjunction (AND) - both goals must succeed
?- parent(X, Y), age(X, A).

% Disjunction (OR) - at least one goal must succeed
?- parent(X, mary); parent(X, bob).

% Negation (NOT) - succeeds if goal fails
?- \+ parent(alice, bob).
?- not(parent(alice, bob)).  % alternative syntax

% Cut (!) - prevents backtracking
first_solution(X) :- option(X), !.

Cut operator semantics: The cut operator ! prevents backtracking beyond the point where it occurs:

% Without cut - explores all solutions
max(X, Y, X) :- X >= Y.
max(X, Y, Y) :- X < Y.

% With cut - commits to first matching clause
max(X, Y, X) :- X >= Y, !.
max(X, Y, Y).

Arithmetic Operators

Arithmetic evaluation uses the is/2 predicate. Ziglog supports both integer and floating-point arithmetic with automatic type promotion.

Type Semantics:

% Division (/) always returns float
?- X is 7 / 2.
X = 3.5

% Integer operators only work on integers
?- X is 7 div 3.
X = 2

% Mixed int/float arithmetic promotes to float
?- X is 2 + 1.5.
X = 3.5

?- X is 3 * 2.5.
X = 7.5

Binary Operators:

+, -, *, /      % Basic arithmetic (/ returns float)
//              % Integer division (truncate towards zero, int only)
div             % Floored division (rounds towards -infinity, int only)
mod             % Modulo (uses floored division, int only)
rem             % Remainder (uses truncated division, int only)
min, max        % Minimum and maximum (works with mixed types)

% Integer examples:
?- X is 5 + 3.
X = 8

?- Z is 7 div 3.
Z = 2

?- R is 7 mod 3.
R = 1

% Float examples:
?- X is 2.5 + 1.5.
X = 4.0

?- Y is 7.0 / 2.0.
Y = 3.5

% Mixed type examples:
?- M is min(5, 2.5).
M = 2.5

?- N is max(3.14, 2).
N = 3.14

Unary Operators:

abs(X)    % Absolute value (preserves type)
sign(X)   % Returns -1, 0, or 1 Read the rest on GitHub

muse-code	1 · avg 2.0
codex	3 · avg 1.3
lovable	1 · avg 1.0
claude-code	52 · avg 0.8
claude	27 · avg 0.7

listed slop	461
in the trough	0
slopsmiths	5
votes	545
comments	0

ziglog

I'm not calling your project slop! Geeze, it's a joke... Do you own this repo?

Disclosures, inferred by the Cap'm

The Cap'm's log