Skip to content


Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?

Latest commit


Git stats


Failed to load latest commit information.
Latest commit message
Commit time


CI Status Coverage Status version docs MIT/APACHE-2.0 Required rustc minimum version

A relational logic programming language embedded in Rust. It started as a yet another miniKanren, but has already evolved into its own language with miniKanren at its core.

In addition to core miniKanren language, proto-vulcan currently provides support for:

  • miniKanren-like breadth-first and Prolog-like depth-first search.
  • Compound types (Example)
  • Disequality constraints CLP(Tree)
  • Finite-domain constraints CLP(FD)
  • Various operators: anyo, conda, condu, onceo, project
  • Pattern matching: match, matche, matcha, matchu
  • Writing goals in Rust embedded inline within proto-vulcan
  • User extension interface

The language is embedded into Rust with macros which parse the language syntax and convert it into Rust. The language looks a lot like Rust, but isn't. For example, fresh variables are presented with Rust closure syntax, and pattern matching looks like Rust match.


extern crate proto_vulcan;
use proto_vulcan::prelude::*;

fn main() {
    let query = proto_vulcan_query!(|q| {
        conde {
            q == 1,
            q == 2,
            q == 3,

    for result in {
        println!("q = {}", result.q);

The example program produces three solutions:

q = 1
q = 2
q = 3

Embedding in Rust

To embed proto-vulcan in Rust, four macros are used: proto_vulcan!, proto_vulcan_closure!, proto_vulcan_query!, and lterm!.

  • proto_vulcan!(<goal>) declares a Proto-vulcan goal, and returns a Rust variable of type Goal.
  • proto_vulcan_closure!(<goal>) declares a Proto-vulcan goal, and returns a Rust variable of type Goal. The goal expression is evaluated lazily when the goal is evaluated. The closure takes ownership of all variables referenced within the closure.
  • proto_vulcan_query!(|a, b, c| { <goal> }) defines a Proto-vulcan query with query-variables a, b and c. The returned value is a Query-struct, that when run, produces an iterator that can be used to iterate over valid solutions to the logic program. The iterator returns a struct with fields named after the query variables.
  • lterm!(<tree-term>) declares a logic tree-term in Rust code, which can be passed to proto-vulcan program within proto_vulcan! or proto_vulcan_query!, or compared with results.


Licensed under either of

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.


A relational logic programming language embedded in Rust.








No packages published