A Prolog transpiler that turns logic programs into LINQ-style data pipelines.

One codebase → Bash streams, C# queries, Go binaries, SQL views, and more.

📚 Extended Documentation | 🎓 Educational Materials

Write your data relationships and queries once in Prolog, then compile to the target that fits your environment:

• Shell scripts for Unix pipelines and automation
• Native binaries for portable, dependency-free deployment
• SQL views for database integration
• .NET assemblies for enterprise applications
• Multi-language pipelines via cross-target glue

UnifyWeaver handles the hard parts—recursion, transitive closures, cycle detection, deduplication—so your generated code is correct and efficient.

UnifyWeaver supports multiple compilation strategies depending on the target and predicate complexity:

Different targets support different recursion patterns. Choose based on your needs:

Additional language targets for native compilation, FFI, and functional programming:

Key:

• ✅ Full support with optimizations (BFS, loops, memoization, semi-naive)
• — Not supported or limited

Stream-based compilation to Unix shell scripts with pipes and process substitution.

• BFS optimization for transitive closures
• Cycle detection and duplicate prevention
• Template-based code generation
• Enhanced Chaining — Fan-out, merge, conditional routing, and filtering stages

Docs: Enhanced Chaining

Standalone native binaries with no runtime dependencies.

• JSON I/O with schemas and nested path extraction
• Regex matching with capture groups
• Embedded bbolt database storage
• Parallel workers for high-throughput processing
• Enhanced Chaining — Fan-out, merge, conditional routing, and filtering stages
• Binding System — Map predicates to Go stdlib functions

Docs: Go Target Guide | Enhanced Chaining

Memory-safe native binaries via Cargo.

• Serde JSON integration
• Semantic crawling support
• Full Cargo project scaffolding
• Enhanced Chaining — Fan-out, merge, conditional routing, and filtering stages
• Binding System — Map predicates to Rust stdlib and crates

Two compilation modes for different needs:

• Stream Target (csharp_codegen) — LINQ pipelines for simple predicates
• Query Runtime (csharp_query) — IR + semi-naive fixpoint for complex recursion

Features: LiteDB integration, mutual recursion via SCC, arithmetic constraints.

• Enhanced Chaining — Fan-out, merge, conditional routing, and filtering stages
• Binding System — Map predicates to .NET APIs and LINQ

Docs: C# Compilation Guide | Enhanced Chaining

Generator-based streaming with Python ecosystem integration and multi-runtime support.

• Pipeline Mode — Streaming JSONL I/O with typed object output
• Runtime Selection — Auto-select CPython, IronPython, PyPy, or Jython based on context
• Pipeline Chaining — Connect multiple predicates with yield from composition
• Enhanced Chaining — Fan-out, merge, conditional routing, and filtering stages
• Cross-Runtime Pipelines — Stage-based orchestration for mixed Python/C# workflows
• C# Hosting — IronPython in-process or CPython subprocess with JSONL glue
• Binding System — Map predicates to Python built-ins and libraries
• Native XML via lxml, semantic runtime with SQLite and vector search

Docs: Python Target Guide | Enhanced Chaining

Compiles predicates to SQL queries for database execution.

• Recursive CTEs for hierarchical data
• Window functions (RANK, ROW_NUMBER, LAG, LEAD)
• All JOIN types, aggregations, subqueries
• Works with SQLite, PostgreSQL, MySQL, SQL Server

Docs: SQL Target Design

Windows automation and .NET orchestration with full object pipeline support.

• Dual-mode: pure PowerShell or Bash-as-a-Service via WSL
• Cross-platform (PowerShell 7+)
• Binding system: 68+ bindings for cmdlets, .NET methods, Windows automation
• Auto-transpilation: Rules like sqrt(X, Y) compile directly to [Math]::Sqrt($X)
• Enhanced Chaining — Fan-out, merge, conditional routing, and filtering stages
• Object pipeline: ValueFromPipeline parameters, PSCustomObject output
• Advanced joins: Hash-based and pipelined N-way joins with O(n+m) complexity
• Firewall security: Per-predicate mode control (pure/baas/auto)
• Ideal for orchestrating .NET targets (C#, IronPython)

Docs: PowerShell Target Guide | Enhanced Chaining

Lightweight, portable text processing.

• Tail recursion to while loops
• Aggregations (sum, count, max, min, avg)
• Regex matching with capture groups
• Enhanced Chaining — Fan-out, merge, conditional routing, and filtering stages
• Runs on any POSIX system

Docs: Enhanced Chaining

Prolog-to-Prolog transpilation for dialect compatibility.

• SWI-Prolog and GNU Prolog support
• Native binary compilation via gplc
• Executable script generation

Compose predicates across multiple languages in unified pipelines:

• Shell Integration — TSV/CSV/JSON I/O between AWK, Python, Bash
• .NET Bridges — In-process C# ↔ PowerShell ↔ IronPython
• Python/C# Glue — IronPython in-process hosting or CPython subprocess with JSONL
• Pipeline Chaining — Multi-stage orchestration with automatic runtime grouping
• Native Orchestration — Go/Rust compilation with parallel workers
• Network Communication — HTTP servers/clients, TCP streaming
• Service Registry — Distributed service routing

Docs: Cross-Target Glue Guide

Built-in data source plugins for real-world pipelines:

Security and configuration for production deployments:

• Firewall — Multi-service security for external tools
• Network ACLs — Host pattern matching and restrictions
• Import Restrictions — Python module whitelisting
• File Access Patterns — Read/write permission management
• Preferences — Layered configuration (global, rule-specific, runtime)

Requirements:

• SWI-Prolog 8.0 or higher
• Bash 4.0+ (for associative arrays)

git clone https://github.com/s243a/UnifyWeaver.git
cd UnifyWeaver

# Set up local data directories
./scripts/setup_local.sh

The .local/ directory holds project-specific data and tools that are not checked into git:

For Pearltrees integration, clone the harvester tools:

git clone git@github.com:s243a/pt-harvester.git .local/tools/browser-automation

UnifyWeaver includes a convenient test environment with auto-discovery:

# Linux/WSL
cd scripts/testing
./init_testing.sh

# Windows (PowerShell)
cd scripts\testing
.\Init-TestEnvironment.ps1

Then in the test environment:

?- test_all.           % Run all tests
?- test_stream.        % Test stream compilation
?- test_recursive.     % Test basic recursion
?- test_advanced.      % Test advanced recursion patterns
?- test_constraints.   % Test constraint system

?- use_module(unifyweaver(core/recursive_compiler)).
?- test_recursive_compiler.

This generates bash scripts in the output/ directory:

cd output
bash test_recursive.sh

Define your Prolog predicates:

% Facts
parent(alice, bob).
parent(bob, charlie).

% Rules
ancestor(X, Y) :- parent(X, Y).
ancestor(X, Z) :- parent(X, Y), ancestor(Y, Z).

Compile to bash:

?- compile_recursive(ancestor/2, [], BashCode).
?- write_bash_file('ancestor.sh', BashCode).

Use the generated script:

source parent.sh
source ancestor.sh

ancestor_all alice  # Find all descendants of alice
ancestor_check alice charlie && echo "Yes" || echo "No"  # Check specific relationship

See Extended Documentation for advanced recursion patterns, data sources, and complete examples.

UnifyWeaver follows a modular compilation pipeline:

1. Classification - Analyzes predicate to determine recursion pattern
2. Constraint Analysis - Detects unique/ordering constraints
3. Pattern Matching - Tries tail → linear → tree → mutual → basic recursion
4. Optimization - Applies pattern-specific optimizations (BFS, loops, memoization)
5. Target Selection - Chooses Bash, PowerShell, or C# backend based on requested target/1 preference
6. Code Generation / Plan Emission - Renders shell templates, C# source, or query plans for the selected backend

See ARCHITECTURE.md and Extended Documentation for detailed architecture.

ancestor(X, Y)    % Transitive closure of parent
descendant(X, Y)  % Reverse of ancestor
sibling(X, Y)     % Same parent, different children

% CSV/TSV data processing
:- source(csv, users, [csv_file('data/users.csv'), has_header(true)]).

% AWK text processing
:- source(awk, extract_fields, [
    awk_program('$3 > 100 { print $1, $2 }'),
    input_file('data.txt')
]).

% HTTP API integration with caching
:- source(http, github_repos, [
    url('https://api.github.com/users/octocat/repos'),
    cache_duration(3600)
]).

% Python with SQLite
:- source(python, get_users, [
    sqlite_query('SELECT name, age FROM users WHERE active = 1'),
    database('app.db')
]).

% JSON processing with jq
:- source(json, extract_names, [
    jq_filter('.users[] | {name, email} | @tsv'),
    json_file('data.json')
]).

See Extended Documentation for complete examples.

% Compile predicates to a chained Python pipeline
compile_pipeline(
    [parse_user/2, filter_adult/2, format_output/3],
    [runtime(cpython), pipeline_name(user_pipeline)],
    PythonCode
).

Generated Python uses efficient generator chaining:

def user_pipeline(input_stream):
    """Chained pipeline: [parse_user, filter_adult, format_output]"""
    yield from format_output(filter_adult(parse_user(input_stream)))

For cross-runtime workflows (Python + C#):

compile_pipeline(
    [python:extract/1, csharp:validate/1, python:transform/1],
    [pipeline_name(data_processor)],
    Code
).

• Divide-and-conquer patterns (quicksort, mergesort) not yet supported
• Tree recursion uses list representation only

cd scripts/testing
./init_testing.sh  # or Init-TestEnvironment.ps1 on Windows

In SWI-Prolog:

?- test_all.          % Run all tests
?- test_stream.       % Stream compilation
?- test_recursive.    % Basic recursion
?- test_advanced.     % Advanced patterns

See TESTING_GUIDE.md for adding tests.

Issues and pull requests welcome! See CONTRIBUTING.md for details.

Key areas:

• Additional recursion patterns (divide-and-conquer, N-ary trees)
• Performance optimizations
• Additional data source plugins
• Native PowerShell code generation (pure mode enhancements)

Licensed under either of:

• Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

Developed as an exploration of compiling declarative logic to efficient executable code across multiple target languages—making Prolog's power accessible everywhere from shell scripts to native binaries to database queries.

Contributors:

• John William Creighton (@s243a) - Core development
• GPT-5/5.1-Codex (via OpenAI) - Fixed-point architecture, query engine, generator approaches
• Gemini (via gemini-cli) - Constraint awareness features
• Claude (via Claude Code) - Advanced recursion system, test infrastructure, educational materials