The VVL language

Everything is a bracketed command

A single syntax rule — [command args…] — applies everywhere: a calculation, a class, a network call, an LLM query. Code is data: a list evaluates, or is quoted with the backtick to be handled as a syntax tree.

# Prefix form [command args…] — eager evaluation, innermost first
[print [+ 1 2 3]]          # → 6

# Variables ($), assignment (=), sugared infix arithmetic (…)
$prix = 100
$ttc  = ($prix * 1.20)          # → 120.0

# Quasiquote (backtick) = literal data; unquote (,) injects a value
$n = 5
`[1 ,$n ,[+ 1 2]]            # → [1 5 3]

# String interpolation: ${ VVL expression }
$msg = "n*n = ${[* $n $n]}"     # → "n*n = 25"

# Dotted accessors, chainable
$s = "  42  "
$s.trim.int                     # → 42

# Lambda (params → $__name) + map / pmap (parallel)
$double = [lambda [x] [* $__x 2]]
[map $double `[1 2 3 4]]          # → [2 4 6 8]
[pmap $extract $documents]      # N LLM calls in parallel

Four roles, zero pipeline

The LLM is not an external service: it is an operator of the language. The semantic operand [§ "..."] (type VVL_Semantic) flips the same dispatcher from arithmetic mode to neuro-symbolic mode: [§ "cat"] == [§ "feline"] returns 1. Four families, plus @.

[§ "chat"] == [§ "félin"]   # → 1
[§ "voiture"] + [§ "électrique"]
# → electric car (concept)

$fn = ($orders @ [§ "total_amount > 1000"])
[filter $fn $orders]   # local lambda, 0 LLM

$soleil = [@ "Soleil"]
$soleil.masse_kg     # → 1.989e30
($soleil ~~ "Étoile")  # → ~0.95

[§§ "consommation BMW Série 3 diesel 2024 ?"] # → ~5.1

[generic "masse de @{Saturne} ?"]
[get-mass-kg-of-concept "Jupiter"] # reusable

One language model, four distinct roles, zero integration pipeline. That is what makes VVL a neuro-symbolic language — not an API wrapper.

The twenty semantic operators

Activated by the [§ "…"] operand, these are the same operators as on numbers — the operand type makes them switch. Four families, plus @.

Fine distinction: projection / extracts a dimension already contained in the description; property % queries the LLM general knowledge. Semantic results compose like arithmetic. Projected on a scale ([§ ["low" "mid" "high"]]), / returns a score: a calibrated position with its confidence.

Decide fast, reason when needed

With [semanticMode "jev"], typed decisions go first to Jev (TypeSafe AI): a model that does not write but decides — yes/no, choice, position on a scale — with a calibrated confidence, in ~0.4 s. When it hesitates (confidence below the threshold, 0.8 by default), the LLM takes over. Same syntax, same cache; every decision is traced in semantic.log (Semantic tab of :log).

[semanticMode "jev"]
[§ "a trumpet"] == [§ "a refrigerator"]         # → 0   (Jev, 0.4 s)
[match [§ $ticket]
    [§ "Payments, refunds"]  "billing"
    [§ "Bugs, outages"]      "technical"
    "escalade"]                                   # branch chosen by meaning
([§ $review] / [§ ["calm" "annoyed" "angry"]])   # → <approx: 1.99 [high]>
[fuzzy:degree [§ $mail] "spam"]                  # → 0.98

AI cost pays once

How does a probabilistic system become as reliable as a native operator? Through four guarantees built into the engine — not left to the developer: (1) automatic output typing (you never parse a string), (2) a deterministic cache persisted to disk — same expression, same result across all sessions, API cost → 0 and reproducible tests, (3) validated retry until success, (4) few-shot XML specifications. Without typing you would parse; without the cache latency would be prohibitive; without retry the slightest model drift would break the program. It is the whole set that sets VVL apart from a mere wrapper.

From neural to guaranteed reasoning

The same language ships the symbolic side: guaranteed deductive reasoning, typed schemas and proven optimisation. Reified concepts become the operands of this algebra — this is the neuro-symbolic bridge.

A state that proves itself and replays

A [keyword] whose [contract] names a ledger becomes a smart contract: every call is a transaction, written in a chained, signed block. The conditions of the contract are proved before execution, checked at every call, and the whole history replays — all in the language, with no external blockchain.

[keyword transfer
    [contract
        [args from to [amount :type Integer :min 1]]
        [ledger bank]
        [state [src "account:{from}" :required] [dst "account:{to}" :required]]
        [require "amount <= src"]
        [ensure  "src + dst = old(src) + old(dst)"]]
    [do [state:put src ([state:get src] - @3)]
        [state:put dst ([state:get dst] + @3)]]]

[contract:verify transfer].status        # → "proved"   (for every state)
[transfer "alice" "bob" 30]              # → one signed block
[transfer "alice" "bob" 500]             # → refused, nothing written
[ledger:verify bank].ok                  # → 1   (chain, signatures, full replay)

Interpreted, compiled, then distributed

The same code moves from the interpreter to a native virtual machine, then across several machines — without being rewritten. What decides is not a setting but a verifiable property of the code: its purity.

VVL vs Python + LangChain

A single AI server, driven by a language whose paradigm is built for it. That is the difference between integrating AI and programming with it.