GeoNum Engine.
Every result ships with its own trust verdict.

Precision you can audit.

Not a faster float. A number system that carries its own uncertainty forward and tells you when to stop trusting a result.

Two commands. Honest output.

Self-documenting CLI: geonum help · geonum docs · geonum support "..." (emails the maintainer directly).

# single expression with built-in constants
geonum compute --expression "hbar*c^3/(8*pi*G*1.989e30*kb)"

# label = rhs and bound variables from a file
geonum compute --expression "E = D*C^2" --params domain.json

# batched JSON in, JSON out (array of jobs in -> array of
# results out; per-item zone/precision/label override)
geonum compute --input batch.json --output results.json

geonum validate --domain hawking --precision 60

# JSON report for CI / audit pipelines
geonum validate --domain hawking --output report.json

geonum version

Honest by design: an unknown identifier or unsupported function returns a clear unsupported status with trust ERROR - never a fabricated number. --precision is recorded as the requested precision; GeoNum precision is drift-tracked, not a claimed digit count.

Call GeoNum from your stack.

There is no SDK to install and no service to call. You shell out to the licensed binary and parse the JSON it prints to stdout - the same JSON shape geonum compute emits on the command line. Exit code 2 means licensing; the trust verdict rides along on every result.

# Call the licensed binary, parse the JSON it prints to stdout.
import json, subprocess

def geonum_compute(expression, params=None):
    cmd = ["geonum", "compute", "--expression", expression]
    if params:
        cmd += ["--params", json.dumps(params)]
    proc = subprocess.run(cmd, capture_output=True, text=True)
    if proc.returncode == 2:            # exit 2 = licensing
        raise RuntimeError("GeoNum licensing: " + proc.stderr.strip())
    return json.loads(proc.stdout)

r = geonum_compute("E = D*C^2", {"D": 1.989e30, "C": 2.99792458e8})
print(r["value"], r["trust"])   # value + PRECISE / DRIFTING / UNRELIABLE / ERROR

// Call the licensed binary, parse the JSON it prints to stdout.
using System.Diagnostics;
using System.Text.Json;

static JsonElement GeonumCompute(string expression, string? paramsJson = null)
{
    var psi = new ProcessStartInfo("geonum")
    {
        RedirectStandardOutput = true,
        RedirectStandardError  = true,
        UseShellExecute        = false
    };
    psi.ArgumentList.Add("compute");
    psi.ArgumentList.Add("--expression");
    psi.ArgumentList.Add(expression);
    if (paramsJson is not null)
    {
        psi.ArgumentList.Add("--params");
        psi.ArgumentList.Add(paramsJson);
    }

    using var p = Process.Start(psi)!;
    string stdout = p.StandardOutput.ReadToEnd();
    p.WaitForExit();
    if (p.ExitCode == 2)                 // exit 2 = licensing
        throw new InvalidOperationException("GeoNum licensing: " + p.StandardError.ReadToEnd());
    return JsonDocument.Parse(stdout).RootElement;
}

var r = GeonumCompute("E = D*C^2", "{\"D\":1.989e30,\"C\":2.99792458e8}");
JsonElement value = r.GetProperty("value");
string trust = r.GetProperty("trust").GetString()!;
Console.WriteLine($"{value}  {trust}");   // value + PRECISE / DRIFTING / UNRELIABLE / ERROR

// Call the licensed binary, parse the JSON it prints to stdout.
function geonum_compute(string $expression, ?array $params = null): array {
    $cmd = ['geonum', 'compute', '--expression', $expression];
    if ($params !== null) {
        $cmd[] = '--params';
        $cmd[] = json_encode($params);
    }
    // array form passes args directly - no shell, no injection
    $proc = proc_open($cmd, [1 => ['pipe', 'w'], 2 => ['pipe', 'w']], $pipes);
    $stdout = stream_get_contents($pipes[1]);
    $stderr = stream_get_contents($pipes[2]);
    fclose($pipes[1]); fclose($pipes[2]);
    $code = proc_close($proc);
    if ($code === 2) {                       // exit 2 = licensing
        throw new RuntimeException('GeoNum licensing: ' . trim($stderr));
    }
    return json_decode($stdout, true);
}

$r = geonum_compute('E = D*C^2', ['D' => 1.989e30, 'C' => 2.99792458e8]);
printf("%s  %s\n", $r['value'], $r['trust']);

Same contract in every language: an unknown identifier or unsupported function comes back as status: "unsupported" with trust ERROR - never a fabricated number. For high throughput, write a JSON array of jobs and call geonum compute --input batch.json --output results.json once instead of spawning the binary per calculation. The binary must be on PATH (or pass its full path); set GEONUM_LICENSE_KEY in the process environment.

Get the binary. Trial starts on first run.

The download is the full engine - not a feature-gated demo. On first run it self-enforces a 3-day evaluation. Subscribe to a tier for a license key and the same binary keeps running.

Flat pricing. No contracts.

Every tier is the same binary with no feature gating. 3-day free trial. No discounts. No annual contracts. Cancel anytime.

OEM / sub-licensing (embedding GeoNum Engine in another product) is a separate written agreement: licensing@getvaultsync.com.

GeoNum Open vs GeoNum Engine

Your computational data never leaves your device.

That's not a policy - it's the architecture. GeoNum Engine runs entirely in a native binary on your machine. Inputs, parameter files, batched JSON, computed results, drift figures, trust verdicts, validation reports - none of it is transmitted to or stored on VaultSync servers. There is no server-side repository of your computation, so there is nothing to breach, subpoena, or leak. The only network traffic the binary ever emits is a periodic license check that carries your license key (which is the entitlement, not your data), with a 14-day offline grace so the engine keeps working even when our license server doesn't.

Documentation: the proprietary EULA ships inside every release zip as LICENSE. Procurement and security questions: support@getvaultsync.com or run geonum support "..." from the CLI. Patent pending - U.S. Provisional 63/970,430.

Trial → subscribe → run.