Beyond Prolog

The comparisons show Tln matching Prolog rule-for-rule. These pages show where Tln goes further than ISO Prolog:

MCP tools & workflows — call real tools, react to fact changes, and ingest data on a schedule. Prolog is a pure inference engine with no standard tool I/O; Tln makes it first-class.
Built-in ML — predict, forecast, classify, cluster, find similar — 11 explainable primitives, no external pipeline.
Testing — a .tln.test framework with given / when / expect, so rules are verified, not hoped.
Metaprogramming — compile-time macros (defmacro / quote / unquote, Elixir-style) that generate rules before validation, keeping the runtime pure.
Workflows & agents — reactive on triggers firing workflow steps of tool calls: deterministic automations the LLM authors once, with no equivalent construct in Prolog.

MCP tools & workflows

Prolog is a pure inference engine. It answers queries; it does not do things. There is no standard way to call an external tool, and nothing reactive — a fact changing can’t fire an action, because the language has no notion of “an action” or of “changing.” In practice you bolt on non-standard extensions and hand-roll all the orchestration yourself. Tln makes tools and reactivity first-class, through the Model Context Protocol (MCP). This is the capability that turns a ruleset into a running agent — and it’s what powers OpenTalon in production. ...

Built-in ML

Expert systems hit a wall the moment a decision needs a learned judgement — “is this reading anomalous?”, “what’s this incident’s likely cause?”, “when will we run out?”. In Prolog you leave the language: export the data, run a Python/R pipeline, glue the answer back. Tln builds the common cases in as blocks, each returning an explanation alongside its value — so an ML result is as auditable as any rule. ...

Testing

A ruleset that decides claims, or blocks a deployment, or reorders stock, needs to be tested — not eyeballed. ISO Prolog has no standard test framework (SWI ships the non-standard plunit); Tln has one built in, and it needs no database. given / when / expect A .tln.test file seeds facts in a given block, runs a named block with when, and asserts on the result: test "greets the world" { given { record 1 type "greeting" attr 1 "name" "World" } when detect "Hello, World" expect { flagged 1 label contains "Hello, World!" count == 1 } } The given block is the fact schema you’d otherwise load from an external system — record and attr triples — so tests are hermetic and fast (the runner materializes them in memory; no FactStore required). ...

Metaprogramming

Tln does metaprogramming the Elixir way: macros are code that writes code, and they run at compile time. A defmacro expands into ordinary blocks before validation and planning — so the validator, planner, and runtime never see a macro, and the engine stays exactly as deterministic and terminating as always. The one place unbounded computation is allowed is expansion itself, bounded by a step budget (a compile error, never a runtime hang). That’s also why macros live in core, not a plugin: only core owns the grammar and the compile phases. ...