Computation you can verify.
Every result traceable, every result trusted.

Every answer shows its work: where the number came from, and how far you can trust it.

Physics checked against the published paper. A legal figure against the statute that governs it.

It runs on the machine in front of you. Nothing to install, nothing uploaded.

A live compute API.
Run the engines over HTTP.

Authenticate, POST a function, and the job runs on your connected browser node - the real engine on your own GPU - returned when you poll for it. The compute stays on your device, not a rented server farm; the API routes the work and hands back the answer with its trust verdict. The same engines the app uses, now scriptable.

Every legal figure,
computed against the statute.

Garnishment caps, filing and statute-of-limitations deadlines, copyright and patent terms, overtime and ACA-affordability tests - computed deterministically and cited to the exact USC, CFR, or IRC section each figure came from. No black box, no per-check subscription, and the work never leaves your device. The same engine that validates a physics result computes a legally-defensible number.

LIGO's GW150914 final black-hole mass,
reproduced to 0.13% in the browser.

The final black-hole mass lands within 0.13% of the published value and the final spin within 0.65%, checked against Abbott et al. (LIGO/Virgo). The result is computed and compared, not fitted to the detection, and it runs on the device in front of you.

Double precision gives up at 171 factorial.
We keep going, and show our work.

IEEE 754 returns Infinity at 171 factorial and the computation stops there. GDBS stays in log space and returns log10(171!) = 309.0938, past the 308.2547 where a double runs out of exponent. Every step carries its accumulated drift forward, so each result tells you how much of it you can trust.

Anomalies a ledger hides,
flagged before the audit.

Screen a column of invoices or transactions against Benford's law - the first-digit distribution natural ledgers follow and edited ones break - with the chi-square statistic and conformity verdict computed deterministically and cited to Nigrini. It is a red flag for closer review, not a verdict of fraud, and it runs on the same engine that reproduces a gravitational-wave result, on your own device.

2.37e-4|div B| on a GPU
accretion torus
0.13%GW150914 final mass
vs LIGO (Abbott et al.)
0.0052%Hawking temperature
vs Hawking (1975)
AnyDevice: phone, laptop,
or workstation

Before & After

researcher@hpc-login On the cluster
GRMHD torus · rendered locally In GDBS

GDBS is the honest front end to the cluster, not a replacement for it. Do the validation work before you pay for the cluster.

gdbs.getvaultsync.com client-side / real-time / 0 ms queue

This is rendering on your device, right now - no upload, no cloud queue, no latency.

The real engines run the same way: deterministic, drift-tracked, local.

How It Works

Three steps. Compute, verify, trust.

Run it on your own device, get a result bound to its source with a verdict on whether to trust it, and act on an answer you can defend.

Prototype

Open a browser tab and run real, validated computation on your own device. No install, no allocation grant, no job queue.

Change a parameter and see the result, with its trust verdict, in seconds.

Validate

Every result carries a transparent trust verdict, and where a published reference exists the error is measured against it, reproducibly, not tuned to it.

Trust it, then scale it

Act on an answer you can defend, because it traces to its source and carries its verdict.

For scientific work needing production scale, the proven setup carries to HPC, with the queue and iteration cost already spent in the browser.

0.41%GW150914 chirp mass vs LIGO
0.27%GW170817 chirp mass vs LIGO
256³in-browser NR grid ceiling
Reportedconstraint residual and its drift

A Fishbone-Moncrief accretion torus is separately confirmed as a general-relativistic equilibrium. All of it reproducible in your browser.

Access Tiers

Start Free. Scale to Research.

From exploratory tools to full research workflows.

Or build a la carte: pick only the modules you need, month to month, and run them as much as you want.

No metered compute, no per-run fees. Prepare an HPC run, or reach as far as you can without one.

STANDARD
Free

No credit card. Runs on your own hardware in the browser - no metered compute, no per-run fees.

  • GDBS database + Theoretical Foundations
  • Free legal, finance and science calculators
  • Unlimited runs
  • Sandbox, Worklog or Gate as add-ons - $29.99/user/mo each
PRO
$89.99/user/mo

Everything in Standard, plus the professional domains and engines. Cancel anytime.

  • Practice tools for legal, finance and compliance
  • Advanced science domains + batch sweeps
  • Sandbox and Worklog included
  • Unlimited runs
HPC
$99.99/user/mo

Everything in Pro, plus the HPC-class engines. Prepare an HPC run, or reach as far as you can without one.

  • HPC Lab + DFT engine
  • BSSN / Z4c numerical relativity
  • LIGO / NRSur waves + GRMHD accretion
  • Sandbox + Worklog Automation included
ENTERPRISE
Same/user/mo

Pro at $89.99 or HPC at $99.99 per user - the same rate you would pay for one. Add-ons get cheaper as the team grows.

  • No per-seat premium and no minimum
  • Add-on cost falls with every seat added
  • At 100+ seats every add-on is included
  • Seats by invite; members keep their rate

Compare all plans

Every plan runs on your own device, reports a trust verdict on every number, and has no metered compute or per-run fees.

StandardFree Pro$89.99 HPC$99.99 EnterpriseSame rate
Legal and compliance
Deadline calculatorYesYesYesYes
Deadline engine-YesYesYes
Conflicts checkBasicFullFullFull
Caselaw, litigation, damages, drafting, estate-YesYesYes
IOLTA reconciliation-YesYesYes
Statutes of limitation, garnishment, court date mathYesYesYesYes
Legal and tax tools included9283434
Finance and forensic
Loan amortisation, MACRS depreciationYesYesYesYes
Cash-flow projection, IRR and NPV, compound interest-YesYesYes
R&D tax credit, sales tax nexus, claim depreciation-YesYesYes
Benford first-digit analysis--YesYes
Science and engineering
Materials, geophysics, fluids, quantumYesYesYesYes
Plasma and fusion, medical and molecular, cosmology-YesYesYes
Multi-physics coupling and batch parameter sweeps-YesYesYes
HPC Lab and DFT engine--YesYes
BSSN / Z4c numerical relativity--YesYes
LIGO / NRSur gravitational waves, GRMHD accretion--YesYes
Workspace
Sandbox workspaceAdd-onIncludedIncludedIncluded
Worklog case managementAdd-onIncludedIncludedIncluded
Gate client portalAdd-onAdd-onAdd-onIncluded at 100+ seats
Every plan
Unlimited runsYesYesYesYes
Runs on your device, nothing uploadedYesYesYesYes
Trust verdict reported on every resultYesYesYesYes
Metered compute or per-run feesNoneNoneNoneNone
Credit card to startNot neededRequiredRequiredInvoiced

See every tool in the catalogue, or browse by industry.

The Platform

One engine, many domains. Every result, a verdict you can check.

Deterministic computation in a browser tab: no install, no queue, and the work never leaves your device.

Every legal figure, computed against the statute.

Garnishment cap15 U.S.C. § 1673(a)
Disposable earnings$1,120.00
Maximum withheld$280.00
VerdictCITED

A live compute API. Run the engines over HTTP.

POST/api/compute
functionrun_euler_sod
runs onyour GPU
server computenone

Your data never leaves this browser, and the browser enforces it.

Not a policy you have to trust. Open your network tab and check.

connect-src'self'
Outbound requests0
Enforced bythe browser

The GeoNum precision layer carries each result's drift forward, and binds every answer to the source it came from.

Double precision gives up at 171 factorial. We keep going, and show our work.

Every step carries its accumulated drift forward.

IEEE 754 at 171!Infinity
double ceilinglog₁₀ 308.2547
GDBS returnslog₁₀ 309.0938

LIGO's GW150914 final black-hole mass, reproduced to 0.13% in the browser.

Measured against the published value, not fitted to it.

GDBS final mass63.02 M☉
Abbott et al.63.1 M☉
Deviation0.13%
Final spin0.65%

Anomalies a ledger hides, flagged before the audit.

A red flag for closer review, not a verdict of fraud. Cited to Nigrini.

Benford first-digitdigit 5 low
123456789

Multi-Physics Coupling

Chain MD to FEM to Fluids in automated feedback loops. Turbine blade erosion, reactor degradation, hypersonic materials: problems that normally require dedicated clusters.

Batch Parameter Sweeps

Screen hundreds of alloy compositions or simulation parameters in parallel. Explore the full design space, not a single data point.

HPC Lab Sandbox

Direct engine access for researchers who know exactly what they need. Run raw simulations, inspect intermediate states, export validated results.

For Scientific Work

GDBS and HPC do different jobs.

In the scientific domain GDBS is the stage before the cluster, not a replacement. Most other domains it serves, from legal to finance, need no cluster at all.

GDBS (browser)HPC cluster
Best forPrototyping, validation, teaching, parameter scansProduction-scale runs (AMR, matter coupling, multi-node)
To startOpen a browser tabRequest an allocation, wait in the queue
Iteration speedSeconds, on your own deviceHours to days per scheduled job
SetupNo install, no scheduler, no infrastructureMesh, modules, job scripts, scheduler
Trust per resultA trust verdict reported on every valueAssumed; checked separately
Scale ceilingSingle-GPU / browserEffectively unbounded
Cost modelLicence, no metered compute feesAllocation plus core-hours

The point is not that one beats the other. GDBS removes the queue, allocation and iteration cost of getting a method right. The cluster runs it at production scale once it is.

Sign In

Forgot password? No account? Create one

Connected to GDBS
UI refresh now live. Open the new Theme menu in the top-right to switch dark/light, change accent hue, font, density, and corner radius. Your preferences persist per browser. Compute logging is now active on all 17 new research engines - if anything looks off, the Help & Support widget auto-captures context.
GQL / SQL
Run a query to see results

            
0 rows
Schema
Connect to a database to browse schema
Select a tile or hub to view details
1 Upload
2 Preview
3 Import

Drop CSV file here or click to browse

0 rows · 0 columns

Column Mapping

Importing...

Plasma Stability - Ideal-MHD δW Solver

0 (13D)
Constants
Aspect Ratios
Constants
Configuration
Shapes (name,kappa,delta)
Configuration
Delta Values
Configs (name,A,iota0,iota_edge,well_depth per line)
Configs (name, R_s(m), x_s, E, B_ext(T), n_e(10¹&sup9;m³), T_i(keV) per line)

<β> = 1 − x_s²  |  s* = R_s/δ_i  |  Tilt stable when E > E_crit(s*)

Configuration
Stellarator/FRC
Resolution
Configuration Type
Constants
Geometry
Simulation Settings

Optimizer - Auto-Tuning

Grid search across the full parameter space to find optimal plasma configurations. Evaluates thousands of candidates and ranks them by your target metric.

PRO

Upgrade to unlock auto-tuning and advanced features.

Predictor - Trajectory Planner

Given a target outcome (Q > 1, ITER-class β_N), the Predictor chains optimizer waypoints into a step-by-step adjustment roadmap with go/no-go coherence gates at each stage.

PRO

Available on the HPC tier ($99.99/user/mo).

Custom Constraints

Define your specific machine parameters, engineering limits, and operational constraints. Set bounds on field strength, current, wall loading, and divertor heat flux.

PRO

Available on the HPC tier ($99.99/user/mo).

Export Full Datasets

Export complete simulation datasets in CSV, JSON, and HDF5 formats. Includes full grid data, eigenmode profiles, and convergence diagnostics.

PRO

Available on the HPC tier ($99.99/user/mo).

Analytic Equilibrium (Soloviev)

Closed-form Grad-Shafranov solution. Benchmark anchor for any equilibrium claim, with 2D poloidal flux-surface rendering.

PRO

Ballooning Stability (s-α diagram)

Infinite-n local ballooning eigenvalue scan across magnetic shear and pressure gradient - the standard publication figure.

PRO

Mercier Interchange Criterion

Local stability across the flux surfaces, decomposed into well, shear, and current contributions. Fast - runs in optimizer loop.

PRO

Multi-mode δW Scan

(m,n) family scan with mode-coupling matrix. Identifies dominant unstable mode and resonant surface location.

PRO

Parameter Sensitivity

Central-difference ∂β_N/∂x · x/β_N elasticity. Ranks which knob dominates your design.

PRO

Convergence Study

Richardson extrapolation across n_radial. Proves your result is grid-converged with observed convergence order.

PRO

EFIT g-eqdsk Import

Load any EFIT / JET / DIII-D / NSTX equilibrium file. We parse it, render the poloidal cross-section, and feed it to downstream solvers.

PRO

Canonical Validation Suite

One-click verify against ITER, DIII-D, JET, NSTX, W7-X, LHD, TAE Norman, and Soloviev analytic. Each row shows the source paper and tolerance band.

PRO

Stellarator Design Package

Bundle this session's stellarator runs — Mercier stability profile, parameter-optimizer ranking, and trajectory plan — into one shareable package for a partner engineering team.

PRO

Medical Module - Molecular Nanoinformatics

Drug-target binding, protein stability, nanoparticle design, drug interactions, and molecular QSAR. Powered by the same 13D geometric engine.

MODULE

Contact sales to unlock the Medical Module.

Cosmos Module

Galaxy rotation curves, CMB power spectrum, black hole jets, fundamental constants from golden ratio, and cosmic energy budget. Powered by the same 13D geometric engine.

MODULE

Contact sales to unlock the Cosmos Module.

Anomaly Detector Module

Tukey-Exponential closed-form anomaly detection. O(n) analysis with no iterative solvers - real-time outlier identification for exponentially distributed data.

Unlock with Pro $89.99/user/mo or HPC $99.99/user/mo · the free Standard tier covers the standard domains

Physics Workbench

Pick an engine your plan unlocks, edit its JSON, and run it on the engine in your browser.

Loading engines...
Select an engine  

            

Saved Runs

Click Refresh to load saved runs

HPC Lab Module

Plasma transport, binary phase diagrams, 2D FEM solvers, molecular dynamics, parametric sweeps, and batch processing - browser-based HPC without the cluster.

Included in the HPC tier - $99.99/user/mo (HPC Lab + DFT). BSSN, LIGO and GRMHD are $39.99/mo add-ons on any tier.

API Documentation

REST surface for the GDBS platform. Engine sections are shown based on your licensed modules, and engine access is enforced server-side against your plan.

Your bearer token
Loading...

Hidden by default - hover (or focus) the value to reveal it; Copy works without revealing. Send it as Authorization: Bearer <token>. The value shown is your current session JWT, which expires. For long-lived programmatic access, mint an API key (prefix gdbs_api_) via POST /api/keys/generate - available on paid tiers. API keys act at user level and never carry admin rights.

Base URL https://gdbs.getvaultsync.com
Authentication & account
MethodEndpointDescription
POST/api/auth/registerCreate an account - returns a JWT and a trial license
POST/api/auth/loginLogin - returns JWT, user profile, and license
POST/api/auth/refreshExchange a valid JWT for a fresh one
GET/api/auth/meCurrent user profile and license info (auth required)
GET/v1/check?key={licenseKey}Validate a license key (anonymous, rate-limited)

Credential endpoints are rate-limited per IP (10/min).

API keys
Loading your keys...
Issues a new gdbs_api_ key and revokes your previous key(s). Shown once.
MethodEndpointDescription
POST/api/keys/rotateRevoke existing key(s) and issue a fresh one (paid tiers only). The plaintext is returned once. Backs the button above.
POST/api/keys/generateMint an additional long-lived gdbs_api_ key without revoking others
GET/api/keys/listList your keys (prefix + metadata only, never the secret)
POST/api/keys/revokeRevoke a specific key (by its plaintext value)
Engine compute

All physics engines are driven through one endpoint by function name (see the per-module catalogs below for the names). On this hosted deployment the engine runs in the browser, so server-side execution is unavailable: add ?via=client to route the job to your own connected Compute Node (enable it from the user menu), then poll for the result. Calls are checked against your plan server-side.

MethodEndpointDescription
GET/api/computeList runnable functions and the active execution mode
POST/api/compute/{function}?via=clientQueue a run on your connected browser node - returns a jobId (auth required)
GET/api/compute/job/{jobId}Poll job status and result (owner only)
Query & schema (GDBS database)
MethodEndpointDescription
POST/api/query/executeExecute a GDBS query (SHOW DATABASES, SELECT, STORE, DELETE, CREATE)
GET/api/schema/tablesList collections
GET/api/schema/columnsList columns for a collection
Sessions
MethodEndpointDescription
POST/api/sessionSave per-view UI state
GET/api/sessionList saved sessions
GET/api/session/{module}/{tab}Get a saved session
DELETE/api/session/{module}/{tab}Delete a saved session
Saved Runs
MethodEndpointDescription
POST/api/runsSave a computation run (module, scanType, headers, rows)
GET/api/runsList saved runs (optional ?module= filter)
GET/api/runs/{id}Get full run details with results table
DELETE/api/runs/{id}Delete a saved run
Plasma & Fusion
MethodFunctionDescription
POSTrun_circular_scanCircular tokamak stability scan
POSTrun_shaped_scanShaped tokamak scan (κ, δ)
POSTrun_neg_tri_scanNegative triangularity scan
POSTrun_stellarator_scanStellarator scan (W7-X, HSX, LHD)
POSTrun_frc_scanField-Reversed Configuration scan
POSTrun_eigenmodeMHD ballooning eigenmode analysis
POSTrun_optimizerOptimizer grid search (multi-parameter)
Medical / Molecular
MethodFunctionDescription
POSTrun_binding_scanDrug-target binding & selectivity
POSTrun_stability_simProtein folding stability
POSTrun_nanoparticle_scanNanoparticle design & uptake
POSTrun_interaction_scanDrug interaction screening
POSTrun_qsar_scanMolecular QSAR descriptors
Cosmology
MethodFunctionDescription
POSTrun_rotation_scanGalaxy rotation curves (SPARC + RAR)
POSTrun_cmb_scanCMB power spectrum analysis
POSTrun_blackhole_scanBlack hole & AGN physics

Note: run_constants_scan and run_ratios_scan are not exposed via the API.

Materials Science
MethodFunctionDescription
POSTrun_bandgap_scanBand gap & ionicity analysis
POSTrun_elastic_scanElastic moduli (B, G, E, Poisson, Debye)
POSTrun_phase_scanPhase diagram & Gibbs free energy
POSTrun_thermal_scanThermal conductivity (κ lattice + electronic)
POSTrun_defect_scanPoint defect energies & diffusion
Geophysics
MethodFunctionDescription
POSTrun_seismic_scanSeismic velocity & moduli (PREM)
POSTrun_stress_scanTectonic plate stress & flexure
POSTrun_heatflow_scanGeothermal gradient & Moho temperature
POSTrun_gravity_scanGravity anomalies & isostasy
POSTrun_earthquake_scanEarthquake statistics (Gutenberg-Richter)
Fluid Dynamics
MethodFunctionDescription
POSTrun_boundary_scanBoundary layer analysis (Blasius)
POSTrun_pipeflow_scanPipe flow & friction factor
POSTrun_drag_scanDrag coefficient & terminal velocity
POSTrun_heattransfer_scanConvective heat transfer (Nusselt)
POSTrun_compressible_scanCompressible flow & shock relations
POSTrun_lbm_scanLattice Boltzmann D2Q9 (Taylor-Green, Poiseuille, lid cavity)
Quantum Information
MethodFunctionDescription
POSTrun_fidelity_scanQubit gate fidelity analysis
POSTrun_errorcorrection_scanQuantum error correction (surface code)
POSTrun_entanglement_scanEntanglement metrics (CHSH, concurrence)
POSTrun_decoherence_scanDecoherence times & thermal population
POSTrun_circuit_scanCircuit depth & quantum volume
HPC Lab in-app only

These run interactively inside the HPC Lab views in the browser; they are not exposed as API functions. Listed here for discoverability.

ToolDescription
Transport1D radial plasma transport evolution
Phase diagramBinary phase diagram (regular solution model)
2D FEM2D FEM Laplace/Poisson solver (SOR)
Molecular dynamicsLennard-Jones MD (Velocity Verlet)
Batch runnerParametric sweep & batch processing
Payments
MethodEndpointDescription
POST/api/stripe/create-checkoutCreate multi-module Stripe checkout session (auth required)
GET/api/stripe/my-purchasesList your completed purchases (auth required)
GET/api/stripe/configGet the Stripe publishable key
POST/api/stripe/webhookStripe payment webhook (server-to-server, signature-verified)
Admin (admin role required)
MethodEndpointDescription
GET/api/admin/usersList all users with license info
GET/api/admin/users/{id}Get single user detail
PUT/api/admin/users/{id}/roleChange user role (admin/user)
POST/api/admin/users/{id}/modulesGrant module to user
DELETE/api/admin/users/{id}/modules/{m}Revoke module from user
PUT/api/admin/users/{id}/tierChange license tier
DELETE/api/admin/users/{id}Delete user and license
POST/api/admin/users/{id}/email-licenseEmail license key to user
Python Example
import requests, time

API = "https://gdbs.getvaultsync.com"
KEY = "YOUR_API_KEY"   # a gdbs_api_ key, or a session JWT
HDR = {"Authorization": f"Bearer {KEY}", "Content-Type": "application/json"}

# --- Discover the runnable engine functions for your plan ---
print(requests.get(f"{API}/api/compute", headers=HDR).json()["functions"])

# --- Run an engine. On the hosted deployment the engine runs in YOUR browser,
#     so route the job to your connected Compute Node and poll for the result. ---
job = requests.post(f"{API}/api/compute/run_optimizer?via=client", json={
    "config_type": "shaped", "target": "balanced",
    "grid_resolution": 20, "top_n": 10
}, headers=HDR).json()
jid = job["jobId"]

while True:
    j = requests.get(f"{API}/api/compute/job/{jid}", headers=HDR).json()
    if j["status"] in ("done", "error"):
        break
    time.sleep(1)
print(j["result"])

# --- GDBS database query ---
resp = requests.post(f"{API}/api/query/execute",
    json={"query": "SHOW DATABASES"}, headers=HDR)
print(resp.json())

# --- Save and list runs ---
requests.post(f"{API}/api/runs", json={
    "module": "plasma", "scanType": "optimizer",
    "label": "My run", "headers": ["Name", "Beta"], "rows": [["ITER", "1.8"]]
}, headers=HDR)
print(requests.get(f"{API}/api/runs?module=plasma", headers=HDR).json())
cURL Examples
# Login -> returns a JWT in .data.token
curl -X POST https://gdbs.getvaultsync.com/api/auth/login \
  -H "Content-Type: application/json" \
  -d '{"email":"user@example.com","password":"pass"}'

# List runnable engine functions
curl https://gdbs.getvaultsync.com/api/compute \
  -H "Authorization: Bearer YOUR_API_KEY"

# Run an engine on your connected browser node -> returns a jobId
curl -X POST "https://gdbs.getvaultsync.com/api/compute/run_optimizer?via=client" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"config_type":"shaped","target":"balanced","grid_resolution":15}'

# Poll for the result
curl https://gdbs.getvaultsync.com/api/compute/job/JOB_ID \
  -H "Authorization: Bearer YOUR_API_KEY"

# GDBS database query
curl -X POST https://gdbs.getvaultsync.com/api/query/execute \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query":"SHOW DATABASES"}'

User Management

Founding Beta load users to view set cap
EmailNameRoleTier ModulesCreated
Click refresh to load users

GQL Reference

Complete query language guide for the Geometric Database System. Search by command, keyword, or topic.

Quick Start

Tip: Open the Query tab, type any GQL command, and press Ctrl+Enter or click Run. Results appear instantly in the table, JSON, or messages pane. Use the Browser tab for point-and-click navigation of all stored data.
Your First Query
List all databases (collections) in the system:
SHOW DATABASES
Returns: Database | Records for each collection
Inspect a Database
See all records (keys) stored inside a specific database:
SHOW TABLES IN runs
Returns: Key | Type for each record in the "runs" collection
Read a Record
Retrieve a specific record by key name:
SELECT FROM runs WHERE table='my_scan_001'
Returns: the full JSON record as a tabular result

Core Commands

SHOW DATABASES READ
Lists all collections (databases) in the GDBS instance along with record counts. Alias: SHOW TILES.
SHOW DATABASES SHOW TILES
-- List everything in the system SHOW DATABASES
Database | Records runs | 42 payments | 3
Note: System collections (users, licenses) are hidden from non-admin users for security.
SHOW TABLES IN READ
Lists all keys (records) inside a specific database/collection. Think of each key as a row identifier.
SHOW TABLES IN <database_name>
-- See all saved runs SHOW TABLES IN runs
Key | Type plasma_circular_001 | Object materials_elastic_002 | Object
SELECT FROM READ
Retrieves records from a database. Use WHERE table='key' for a specific record, or omit it to return all records (max 1000).
SELECT FROM <database> SELECT FROM <database> WHERE table='<key>'
-- Get a specific saved run SELECT FROM runs WHERE table='plasma_circular_001' -- Get all records in a collection (up to 1000) SELECT FROM runs
STORE INTO WRITE
Writes a JSON value into a database under a specific key (hub name). Creates the database if it doesn't exist.
STORE '<json_string>' INTO <database> HUBNAME='<key>'
-- Store a custom result STORE '{"material":"Diamond","B_GPa":443,"source":"GDBS"}' INTO my_results HUBNAME='diamond_elastic' -- Store configuration data STORE '{"b0":5.0,"q0":1.0,"qa":3.5}' INTO configs HUBNAME='iter_baseline'
DELETE FROM DELETE
Removes a specific key from a database collection.
DELETE <key> FROM <database>
-- Remove an old result DELETE diamond_elastic FROM my_results
CREATE DATABASE WRITE
Creates a new empty database (collection). You can also create databases implicitly by STORE-ing into a name that doesn't exist yet.
CREATE DATABASE <name>
-- Create a collection for your project CREATE DATABASE fusion_optimization_2026

Working With Physics Results

Workflow: Run a physics scan (e.g., Plasma → Circular), click Save, then query or browse the result from the data platform.
Saving & Retrieving Scan Results
When you click "Save" on any physics scan, it stores the result in the runs collection. Each run has a module, scanType, headers, and rows.
-- View all saved runs SELECT FROM runs -- View the keys in runs to find a specific one SHOW TABLES IN runs -- Get the details of a specific run SELECT FROM runs WHERE table='<run_id>'
Storing Custom Physics Data
You can store arbitrary JSON - comparison datasets, external measurements, configuration presets - alongside your GDBS results.
-- Store experimental reference data STORE '{"material":"Si","B_exp_GPa":98,"source":"NIST"}' INTO reference_data HUBNAME='silicon_bulk' -- Store a parameter preset for plasma scans STORE '{"b0":5.3,"q0":1.0,"qa":4.0,"aspect_ratio":3.1,"label":"ITER Q=10"}' INTO presets HUBNAME='iter_q10' -- Store a CMB observation for comparison STORE '{"l_peak":220,"amplitude":5775,"dataset":"Planck2018"}' INTO observations HUBNAME='cmb_first_peak'
Building a Results Database
Organize your physics work into purpose-built collections for easy cross-referencing and comparison.
-- Create project databases CREATE DATABASE tokamak_optimization CREATE DATABASE material_screening CREATE DATABASE quantum_benchmarks -- Store results into each STORE '{"A":3.1,"kappa":1.8,"delta":0.5,"beta_n":3.2}' INTO tokamak_optimization HUBNAME='diii_d_baseline' STORE '{"A":2.5,"kappa":2.0,"delta":0.3,"beta_n":2.8}' INTO tokamak_optimization HUBNAME='compact_design_1' -- Later, retrieve and compare SELECT FROM tokamak_optimization

Domain-Specific Examples

Plasma & Fusion
Store and retrieve tokamak stability results, stellarator configs, and FRC parameters.
-- After running a circular scan and saving it SHOW TABLES IN runs SELECT FROM runs WHERE table='<circular_run_id>' -- Store a reference equilibrium STORE '{"config":"ITER","A":3.1,"B0":5.3,"beta_n":1.8,"q95":3.0}' INTO plasma_reference HUBNAME='iter_baseline' -- Store optimizer result STORE '{"A":2.8,"kappa":1.9,"delta":0.45,"beta_n":3.4,"rank":1}' INTO plasma_reference HUBNAME='optimal_shaped_1'
Materials Science
Build material property databases with elastic moduli, phase boundaries, and defect energies.
-- Build a materials database STORE '{"name":"Diamond","B":443,"G":535,"E":1141,"nu":0.07}' INTO materials_db HUBNAME='diamond' STORE '{"name":"Iron","B":170,"G":82,"E":211,"nu":0.29}' INTO materials_db HUBNAME='iron' STORE '{"name":"Aluminum","B":77,"G":26,"E":70,"nu":0.35}' INTO materials_db HUBNAME='aluminum' -- Retrieve all materials SELECT FROM materials_db
Cosmology
Store rotation curve fits, CMB peak data, and cluster observations.
-- Store galaxy observations STORE '{"galaxy":"MW","v_flat":220,"r_max":20,"M_halo":1.0e12}' INTO galaxy_data HUBNAME='milky_way' STORE '{"galaxy":"M31","v_flat":250,"r_max":30,"M_halo":1.5e12}' INTO galaxy_data HUBNAME='andromeda' -- Store CMB comparison STORE '{"omega_dm":0.261,"l_1":220,"rs_Mpc":147}' INTO cmb_results HUBNAME='gdbs_planck_comparison'
Geophysics
-- Store seismic profile data STORE '{"depth_km":35,"vp":8.1,"vs":4.5,"label":"Moho"}' INTO seismic_profiles HUBNAME='continental_moho' -- Store earthquake catalog entry STORE '{"region":"San Andreas","b_value":1.0,"M_max":8.0}' INTO earthquake_catalog HUBNAME='san_andreas'
Fluid Dynamics
-- Store pipe flow analysis STORE '{"Re":50000,"f":0.021,"dP_Pa":4500,"regime":"turbulent"}' INTO pipe_studies HUBNAME='industrial_pipe_1' -- Store drag coefficient comparison STORE '{"shape":"sphere","Re":1e5,"Cd":0.44,"source":"experiment"}' INTO drag_db HUBNAME='sphere_subcritical'
Quantum Information
-- Store qubit benchmark data STORE '{"device":"IBM_Eagle","qubits":127,"T1_us":120,"T2_us":80,"gate_error":0.001}' INTO quantum_benchmarks HUBNAME='ibm_eagle' STORE '{"device":"IonQ_Forte","qubits":32,"T1_ms":10,"gate_error":0.0003}' INTO quantum_benchmarks HUBNAME='ionq_forte' -- Compare all devices SELECT FROM quantum_benchmarks
Medical / Molecular
-- Store drug screening results STORE '{"drug":"Aspirin","MW":180,"LogP":1.2,"violations":0,"bioavail":0.95}' INTO drug_screening HUBNAME='aspirin' STORE '{"drug":"Imatinib","MW":493,"LogP":2.5,"violations":0,"bioavail":0.88}' INTO drug_screening HUBNAME='imatinib' -- Retrieve all screenings SELECT FROM drug_screening

REST API Integration

Automate everything. Every GQL command can be executed programmatically via POST /api/query/execute with your JWT token.
Python
import requests API = "https://gdbs.getvaultsync.com" HDR = {"Authorization": "Bearer YOUR_TOKEN", "Content-Type": "application/json"} # Execute any GQL command r = requests.post(f"{API}/api/query/execute", json={"query": "SHOW DATABASES"}, headers=HDR) for row in r.json()["data"]["rows"]: print(f"{row[0]}: {row[1]} records") # Store data requests.post(f"{API}/api/query/execute", json={ "query": "STORE '{\"B\":443}' INTO results HUBNAME='diamond'" }, headers=HDR) # Retrieve data r = requests.post(f"{API}/api/query/execute", json={ "query": "SELECT FROM results WHERE table='diamond'" }, headers=HDR) print(r.json()["data"]["rows"])
cURL
# List all databases curl -X POST https://gdbs.getvaultsync.com/api/query/execute \ -H "Authorization: Bearer YOUR_TOKEN" \ -H "Content-Type: application/json" \ -d '{"query":"SHOW DATABASES"}' # Store a result curl -X POST https://gdbs.getvaultsync.com/api/query/execute \ -H "Authorization: Bearer YOUR_TOKEN" \ -H "Content-Type: application/json" \ -d '{"query":"STORE \u0027{\"x\":1}\u0027 INTO test HUBNAME=\u0027key1\u0027"}'
JavaScript (fetch)
const API = 'https://gdbs.getvaultsync.com'; const token = localStorage.getItem('gdbs_token'); const res = await fetch(`${API}/api/query/execute`, { method: 'POST', headers: { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ query: 'SHOW DATABASES' }) }); const data = await res.json(); console.table(data.data.rows);

Concepts & Terminology

Database (Tile)
A named collection of key-value records. Equivalent to a table in SQL or a collection in MongoDB. Examples: runs, payments, materials_db. In GDBS terminology, also called a Tile.
Key (Hub)
A unique identifier for a record within a database. Equivalent to a primary key in SQL. In GDBS terminology, called a Hub. Specified via HUBNAME='key_name' when storing.
Record
A JSON value stored under a key. Can be any valid JSON: objects, arrays, numbers, strings. Records are stored as-is with no schema enforcement - you define the structure.
Collection
Synonym for Database/Tile. Used interchangeably in the API and Browser views.
GQL (Geometric Query Language)
The SQL-like query language native to GDBS. Supports SHOW, SELECT, STORE, DELETE, and CREATE operations. Designed for fast, simple data operations with physics workflows in mind. Executes via the Query tab in the UI or POST /api/query/execute via REST.
Tiered Coherence
The 13D geometric metric that measures how self-consistent a set of physical parameters are. Decomposed into Core (7D), Magnitude (9D), Phase (11D), and Proportion (13D) tiers, plus recursive relational layers. High coherence = physics is well-determined. Appears in every physics scan result as a gradient bar.
Precision Level
Controls the depth of relational coherence evaluation. Level 0 = 13D (base tiers only). Level 1 = 19D. Level 2 = 25D. Level 3 = 31D (maximum). Higher precision adds more cross-tier relational layers at the cost of slightly more computation time. Available via the precision slider in Plasma and Quantum modules.
Scan Type
A specific computation mode within a physics module. Each module has 4-8 scan types. Examples: Plasma has circular, shaped, negtri, stellarator, frc, eigenmode, optimizer, simulation. Materials has bandgap, elastic, phase, thermal, defect.

Tips & Best Practices

Keyboard Shortcuts
Ctrl+Enter or F5 runs the query. Tab inserts two spaces (code-friendly indentation). Use the Messages tab to see execution details and errors.
Naming Conventions
Use descriptive, lowercase names with underscores for databases and keys. Examples: tokamak_optimization, iter_baseline_v2, materials_screening_2026. This makes it easy to find things later via SHOW TABLES.
JSON Escaping
When using STORE, wrap your JSON in single quotes. If your JSON contains single quotes, escape them or use the REST API instead. Numbers, booleans, arrays, and nested objects all work.
-- Good: single-quoted JSON string STORE '{"name":"Diamond","B":443,"phases":["alpha","gamma"]}' INTO materials HUBNAME='diamond' -- Good: nested objects STORE '{"config":{"b0":5.0,"q0":1.0},"results":{"beta_n":1.8}}' INTO plasma HUBNAME='iter'
Export & Backup
Use SELECT FROM <db> to dump all records, then click Export CSV in the results status bar. For programmatic backup, use the REST API to iterate over databases and keys.
Access Control
System collections (users, licenses, users_by_id, licenses_by_user) are admin-only. Querying them as a regular user returns a 403 error. All user-created collections are accessible by the authenticated user.
Max Results
SELECT without a WHERE clause returns up to 1000 records. For larger datasets, query specific keys or filter programmatically via the REST API.

Command Reference (Cheat Sheet)

CommandSyntaxReturnsAccess
SHOW DATABASESSHOW DATABASESAll collections + countsAll users
SHOW TILESSHOW TILESAlias for SHOW DATABASESAll users
SHOW TABLES INSHOW TABLES IN <db>All keys in collectionAll users*
SELECT (all)SELECT FROM <db>Up to 1000 recordsAll users*
SELECT (key)SELECT FROM <db> WHERE table='<key>'Single recordAll users*
STORESTORE '<json>' INTO <db> HUBNAME='<key>'ConfirmationAll users
DELETEDELETE <key> FROM <db>ConfirmationAll users*
CREATE DATABASECREATE DATABASE <name>ConfirmationAll users

* System collections (users, licenses) require admin role.

Q-Desic - Quantum Chemistry Workbench

Dense Schwarz-screened Kohn-Sham DFT on WebGPU: full SCF with LDA, PBE, and B3LYP functionals, with Schwarz screening applied to the two-electron integrals. Conventional dense SCF scaling; no zone decomposition. McMurchie-Davidson two-center integrals validated against Szabo & Ostlund. Basis sets: STO-3G through def2-TZVP.

Validation notes: HF/STO-3G integrals validated to 0.001% against Szabo & Ostlund (1996). Polyatomic HF energies within 0.2% of NIST CCCBDB references. B3LYP uses LDA-converged SCF with post-SCF GGA energy correction; self-consistent GGA potential (including ∇·[∂ε/∂(∇ρ)] terms) is in development. GGA XC errors are typically 1-3% vs published values. Becke-Lebedev quadrature grid (50×50 per atom) - accuracy improves with denser grids on heavy atoms. All results should be compared against the built-in validation suite (Validate button) before use in publications.

Molecule
Method

GRMHD Accretion (HARM) addon - conservative GR-MHD (con2prim, accretion, shock tubes, Fishbone-Moncrief torus, MRI): a single-GPU testbed for method development and validation. Production accretion runs stay on HPC; this bridges to them.

Conservative general-relativistic magnetohydrodynamics in the HARM family (Gammie, McKinney & Toth, ApJ 589, 444, 2003), on a fixed analytic Kerr background (Cowling approximation, as in HARM accretion runs). The primitive-variable inversion is the Noble et al. 2D (W, v2) scheme (ApJ 641, 626, 2006); every reported quantity carries a Rust GeoNum drift / trust tag, exercised precisely where the inversion is hard - the high-magnetization sigma = b2/rho funnel regime. Scope is honest: 2D-axisymmetric / closed-form initial data and a 1D Riemann solver, not 3D MRI-saturated turbulence.
Problem
Parameters

Observables (Rust GeoNum drift)

QuantityValueTrust

Closed-form / conservation checks

CheckExpectedComputedVerdict
References: Gammie, McKinney & Toth, "HARM", ApJ 589, 444 (2003). Noble, Gammie, McKinney & Del Zanna, "Primitive Variable Solvers for Conservative GRMHD", ApJ 641, 626 (2006) [the 2D inversion]. Fishbone & Moncrief, ApJ 207, 962 (1976); Kozlowski, Jaroszynski & Abramowicz, A&A 63, 209 (1978) [constant-l torus]. Komissarov, MNRAS 303, 343 (1999); Balsara, ApJS 132, 83 (2001) [SRMHD Riemann tests]. Balbus & Hawley, ApJ 376, 214 (1991) [MRI]. Background metric is a fixed analytic Kerr spacetime - this module does not evolve the spacetime (no coupling to the BSSN evolver).

BSSN addon

Vacuum dynamical general relativity on the GMDBS toroid - 1+log slicing, gamma-driver shift, RK4 integration, Hamiltonian/momentum constraint monitoring.

Measured: constraint convergence 3.86 (Hamiltonian) and 3.92 (momentum) against the analytic zero, scaling exponent 3.048, bounded long-time 5 light crossings. Self-convergence 3.946 is a consistency check, not validation. Validation results →

Citation: Garrett, J. (2026). GDBS BSSN+Z4c: Vacuum Numerical Relativity on the GMDBS Toroid. VaultSync Solutions. https://gdbs.getvaultsync.com/validation/bssn-z4c-numerical-relativity.html

Set m₁/m₂/spins/distance once - values flow to the LIGO panel without re-typing. They seed the template parameters; the matched filter itself is not wired, so no SNR or triggers are produced.
BSSN Evolution - Vacuum GR
DiagnosticValue

LIGO Analyzer addon

Gravitational-wave signal conditioning on the GMDBS toroid - Welch PSD, frequency-domain whitening, and Q-transform spectrogram run GPU-side, drift tracked in WGSL. The matched filter, the Allen χ² veto, and MCMC parameter estimation are not wired in this build: no detection search or parameter estimation is performed, and the run reports that status rather than an empty result.

GPU pipeline: gpu-fft.js (radix-2 Cooley-Tukey, drift in shader) · gpu-ligo-pipeline.js (Welch / whiten / Q-transform; the matched-filter shader exists but is not called).

Built on the Bloom/BSSN heritage - bloom-boundary frequency reported per detection.

Triggers

Bloom Boundary

Bloom-framework boundary frequency for the manifest chirp mass of the selected event. The matched filter is not wired, so there is no measured peak to cross-check against.

GPU GeoNum Drift Tracking - ZONES_GRAVITATIONAL_WAVE, drift propagated in WGSL butterflies

Welch PSD
-
Whitening
-
Matched Filter
-
Q-transform
-
Max (worst-case)
-

Drift is accumulated in the WGSL FFT butterfly stages and reduced on-GPU (no CPU spread). Units are ULPs of f32. Sub-2 ULP across 17 butterfly stages = healthy.

HPC Sim

CFD, Thermal Analysis, Radiation, and Natural Convection - GeoNum precision-tracked

2D Navier-Stokes - Projection Method on Staggered Grid

MAC grid, pressure Poisson, GeoNum drift on velocity divergence. Validated against Ghia et al. (1982) for lid-driven cavity.

Preset:

Velocity Magnitude + Arrows

Pressure Field

Vorticity Field

2D Pseudospectral Navier-Stokes - Taylor-Green Decay (WebGPU)

Vorticity-stream pseudospectral, RK4 in spectral space, 2/3 dealiasing (Orszag 1971). Numerical decay overlaid on the analytic Taylor & Green (1937) solution E(t) = E(0) exp(-4νt). Native dGPU test: 6.6e-7 max relative energy error at N=32². Researcher sets N / ν / t / dt / sample interval.

Methodology & references
Engine: wasm/src/gpu/fluids/spectral_ns_2d.rs (substrate-native, all evolution on GPU; 2D FFT composed from gpu/spectral.rs WGSL BIT_REVERSE + BUTTERFLY + TRANSPOSE + NORM). State on-device across all RK4 substages; energy sampled by GPU reduce with GeoNum-style drift compartment on the host partial-sum range.
Initial condition: ω(x,y,0) = 2 sin(x) sin(y) on the 2π periodic box (Taylor-Green eigenmode pair at (±1,±1), |k|² = 2).
Analytic decay: E(t) = E(0)·exp(-2ν|k|²t) per mode → E(t) = E(0)·exp(-4νt) summed over the four excited modes.
References: Taylor & Green 1937 Proc. Roy. Soc. A 158, 499 (analytic); Orszag 1971 J. Atmos. Sci. 28, 1074 (2/3 dealiasing); Canuto, Hussaini, Quarteroni & Zang 2006 Spectral Methods in Fluid Dynamics; Boyd 2001 Chebyshev and Fourier Spectral Methods, 2nd ed.

Lattice Boltzmann D2Q9 - WebGPU

BGK collision, bounce-back/Zou-He BCs. Each lattice node = one GPU thread. GeoNum drift-tracked precision.

Benchmark:

Velocity Magnitude

2D Heat Equation - Convection-Coupled

Explicit or ADI time stepping. Forced convection from NS2D velocity field. GeoNum drift on energy conservation. Built-in 1D analytical validation.

Temperature Field + Isotherms

Radiation - Surface-to-Surface Radiosity

View factor matrix (Hottel crossed-strings). Iterative radiosity solver: J = εσT&sup4; + (1-ε)ΣFijJj. GeoNum drift on radiosity convergence.

Preset:

View Factor Matrix Fij

Rayleigh-Bénard Convection

Coupled NS + heat with Boussinesq buoyancy. Rac = 1708 onset detection (Chandrasekhar 1961). Nusselt number tracking. GeoNum drift on energy balance.

Temperature Field + Velocity Arrows

Batch Processing

Queue multi-parameter sweeps across CFD, thermal, and radiation solvers. Automatic result aggregation with GeoNum drift reports.

Data Pipeline

Chain solvers: CFD → Thermal → Radiation. Export results as CSV/JSON. Coupled multi-physics feedback loops.

Import

Import boundary conditions, geometry, or initial fields

Export

Export velocity, temperature, pressure fields

Coupling

Feed velocity/temperature between solvers

Custom Workflows

Build multi-physics chains from solver nodes. Parameterized templates for common engineering analyses.

Select a template above or drag solver nodes to build a custom workflow

Audit Trail

Full computation history with GeoNum drift logs. Every simulation tracked for compliance and reproducibility.

0 records
TimeSolverGridParamsResultDriftTrust

Team Management

Multi-user administration. Role-based access, shared simulation libraries, per-member usage analytics.

Team Members
--
Total Runs (30d)
--
Compute Hours
--
NameEmailRoleRuns (30d)Last Active

API Dashboard

Usage metrics, rate limits, API key management. Real-time monitoring across all solvers.

API Calls (24h)
--
Rate Limit
--
Avg Latency
--
Error Rate
--

HPC-IO

Form Generator · Report Builder · Flux CSS - JSON-driven, offline-capable

Drag Fields

Text Input
Number
Textarea
Select
Checkbox
Radio
Date
File Upload
Data Table
Chart
Section
Columns
Signature

Drag fields from the toolbox to build your form

Report Builder

Generate downloadable reports from computation results. JSON-templated, offline-capable. Include tables, charts, GeoNum precision, and citations.

Load a template or paste JSON, then click Generate

arXiv Equation Solver

Paste an arXiv ID → extract equations → parameterize variables → compute through GeoNum pipeline with full precision tracking. Auto-citation included.

Enter an arXiv ID and click Fetch to extract equations

Click an equation to open the solver

Run History

Diff Viewer

Console - access WASM functions, GeoNum, run computations

Notebook - markdown + code cells, Jupyter-style

Flux CSS v0.2

Lightweight config-driven design system. oklch() palette, <10KB, no JS, no build step. Powers HPC-IO forms and reports.

Flux Config

Configure the design system for generated forms and reports.

VaultSync Authentication

Passwordless, device-bound sign-in. Enroll this device, then add others by QR. Opt-in - your existing sign-in keeps working untouched.

Loading...

GDBSPro

v1.6426 - Geometric Database System - Browser-Based Physics Computing

GDBS does not replace HPC, and it does not claim new physics.
It is a bridge to the cluster - a place to develop, check, and validate a method in your browser, with no queue, allocation, or cost, before you commit it to a production HPC run.

The Problem: Physics Computing Is Locked Behind HPC

Computational physics - fusion reactor design, materials discovery, cosmological modeling, quantum device engineering - has historically required High Performance Computing (HPC) clusters. Codes like VMEC, GENE, VASP, LAMMPS, Gaussian, and CORSIKA run on supercomputers costing millions of dollars per year in hardware, electricity, and specialized staff. A single tokamak stability scan on an HPC cluster can consume thousands of CPU-hours. A materials screening campaign can take weeks. Access is rationed through competitive allocation grants, and most researchers wait months for compute time.

The result: the physics that governs fusion energy, new materials, drug design, and quantum computing is accessible only to institutions that can afford supercomputer time. Everyone else is locked out.

What GDBS Does

GDBS runs real, established physics - from full numerical solvers (numerical relativity, GRMHD, real-space DFT) to reduced-order and analytic models - compiled to WebAssembly so they execute client-side in your browser. No install, no job scheduler, no cluster bill. The same equations and methods the field already uses, with the queue, the allocation grant, and the wall-time cost removed from in front of them.

The point isn't to out-compute the supercomputer - it's to remove everything around it. You prototype, develop a method, and validate it in-browser at single-GPU scale, then take a setup you trust to HPC for the production run. Every result is deterministic (same inputs, same outputs - no RNG, no training data, no surrogate) and carries a tracked uncertainty and trust verdict from the GeoNum precision system, so you know how far to trust each number. Honest about scope: where a full mesh solve needs a cluster, the in-browser path uses a reduced-order or analytic model - fast and good enough to develop and de-risk against, not a substitute for the production run.

The Production Run on HPC, the Prototype Before It on GDBS

These are not the same computation. On the left is the full production solve that belongs on a cluster. On the right is the fast, reduced-order check GDBS runs in your browser - to develop, size, and de-risk the setup before you spend the allocation. Same problem, different fidelity, different job: the browser prototype gets you ready for the cluster; it does not replace it.

Traditional HPC

MHD Stability (Tokamak)

VMEC + DCON + COBRAVMEC on 512 cores. Mesh: 200 flux surfaces, 32 poloidal, 32 toroidal modes. Wall time: 2-8 hours per equilibrium. Queue wait: days to weeks.

GDBS (browser prototype)

MHD Stability (Tokamak)

δW energy-integral estimate with 256 radial points, safety factor q(s), trial function ξ(s) - a reduced-order stability check, not a full VMEC+DCON equilibrium. Runs in your browser via WebAssembly in <100 ms. No queue, no cluster.

Traditional HPC

Materials Elastic Properties

VASP (DFT) on 128+ cores. Plane-wave basis, PAW pseudopotentials, ionic relaxation. Wall time: 4-48 hours per material. Requires licensed software ($15K+/yr).

GDBS (browser prototype)

Materials Elastic Properties

Born model with structure-dependent Vatom, coordination-calibrated α, Pugh ratio G/B, Debye temperature from acoustic velocities. Diamond: 443 GPa (lit: 442). Instant results, no cluster.

Traditional HPC

Galaxy Rotation Curves

N-body simulation (GADGET, AREPO). 106-109 particles, gravitational softening, adaptive timesteps. Wall time: hours to days on 1000+ cores.

GDBS (browser prototype)

Galaxy Rotation Curves

NFW dark-matter halo profile with baryon mass and scale radius, fit against Milky Way, M31, M33, NGC 3198, NGC 2403 rotation curves. A reduced model for in-browser curve fitting, not a full N-body run.

Traditional HPC

Quantum Error Correction

Stim / PyMatching stabilizer simulation. Monte Carlo sampling over 105-107 shots per code distance. Wall time: minutes to hours per data point.

GDBS (browser prototype)

Quantum Error Correction

Surface code threshold pL ≈ (p/pth)(d+1)/2 with physical noise model (T1, T2, gate error, crosstalk). Benchmarks IBM Eagle, Google Sycamore, IonQ, Rigetti. Instant sweep across code distances.

How It Works

GDBS pairs two things: established domain physics, and a precision system that travels with every number.

The physics. Each module implements the accepted method for its domain - the Troyon / δW energy-integral estimate for tokamak β-limits, real-space Kohn-Sham DFT for materials, the BSSN/Z4c evolution for numerical relativity, Noble con2prim GR-MHD for accretion, the surface-code threshold relation for QEC, and so on. Some are full numerical solvers (finite differences, RK4, multigrid, finite volume); some are reduced-order or analytic where speed matters more than a cluster-scale mesh. None of it is machine learning, a surrogate, or fitted to your inputs.

The precision. Load-bearing arithmetic runs on GeoNum, a log-space number system that tracks accumulated rounding error as a first-class quantity and reports a trust verdict (Exact → Unreliable) on each result - so multi-scale chains that silently corrupt under IEEE 754 stay accountable instead of quietly going wrong.

The delivery. All of it compiles Rust → WebAssembly and runs in the browser, deterministically: the same inputs produce the same outputs on every machine, with no server round-trip for the computation. (The "geometric" in the name is the GMDBS data/retrieval substrate the platform is built on - the database layer, not a claim that the physics solvers are exact geometry.)

What Makes GDBS Different

7Physics Domains
35+Scan Types
300+Validation Tests
<100msPer Prototype Run
$0To Prototype
No HPC to Prototype

The physics runs as WebAssembly in your browser - no supercomputer, no cloud GPU, no job scheduler - to develop, check, and validate. The production-scale run still belongs on HPC; this gets you ready for it without the queue or the bill.

Deterministic & Reproducible

Not AI, not ML, not a surrogate model. Established methods plus a precision system that tracks its own error. No training data, no loss function, no gradient descent. Same inputs = same outputs, always - with a trust verdict on each.

Validated Against Literature

300+ automated tests against NIST, CRC Handbook, CODATA, Planck 2018, ITER Physics Basis, PREM, and dozens of peer-reviewed papers. Typical agreement: <5% of published values.

Multi-Physics in One Platform

Plasma fusion, materials science, cosmology, geophysics, fluid dynamics, quantum information, and molecular/medical physics - all on the same platform and precision core.

Democratized Access

A grad student with a laptop can develop and validate a method before requesting an allocation grant, a queue slot, or a sysadmin - then take the validated setup to the cluster for the production run.

Integrated Data Platform

Query engine, database browser, saved runs, CSV import/export, and REST API. Store results, compare across runs, and automate workflows via the API.

Physics Validation - Representative Results

The flagship results below are independently computed - from first principles or a standard method, then compared to a published or exact reference. Nothing here is fit to the answer; reproduce it and check the number yourself. Per-domain reference comparisons (many are reduced-order models) follow.

Conformance & authority. Each engine is held to the published reference values and industry-standard benchmarks for that domain - the same standards used to certify HPC codes (NIST & CODATA, NIST CCCBDB, the LIGO/Virgo GWTC catalogs, Szabo & Ostlund, Clementi-Roetti, and the foundational literature per engine). GDBS is the authority on its engine - its correctness, numerical precision, and reproducibility - not on the physics. The reference values and literature are external and authoritative; we conform to them, we do not define them. Where an engine needs a benchmark we cite, add, or make the published source available - but the standard is always the field's, not ours.

Flagship Results - Independently Computed

ResultGDBSReferenceSource
GW150914 final black-hole mass63.02 M☉ (0.13%)63.1 M☉Abbott et al. (GWTC-1)
GW150914 final spin0.6855 (0.65%)0.69Abbott et al. (GWTC-1)
BSSN constraint convergence3.86 / 3.924.0 (theoretical)Hamiltonian / momentum vs the analytic zero
GR-MHD ∇·B (constrained transport)2.37×10−4→ 0Noble 2006 / CT, on-GPU
Hawking temperature (64 orders of magnitude)drift 0exact analyticHawking formula
Blasius boundary layer f″(0)0.469600.46960Blasius 1908; value Howarth 1938
DFT H2 ground state (HF/STO-3G)−1.1167 Ha (0.07%)−1.1175 HaSzabo & Ostlund Table 3.17
Elastic constants, Si - C11/C12/C44151.4 / 76.5 / 56.4 GPapublished SWStillinger-Weber potential

Per-Domain Reference Comparisons

Reduced-order and reference checks across the seven domains - quick in-browser comparisons, not the full production solve.

Plasma & Fusion

QuantityConfigurationGDBSLiteratureSource
βN LimitCircular tokamak2.5-3.52.5-3.5Troyon et al. (1984)
ITER βNA=3.1, B0=5.3T~1.8~1.8ITER Physics Basis
W7-X βStellarator A≈5.54-5%4-5%Grieger et al. (1992)
FRC <β>C-2W config1 − xs²Equilibrium identityTuszewski (1988)

Cosmology

QuantityGDBSLiteratureSource
CMB 1st Peak~220220.0 ± 0.5Planck 2018
Sound Horizon~147 Mpc147.09 ± 0.26 MpcPlanck 2018

Geophysics

QuantityGDBSLiteratureSource
Moho Vp8.1 km/s8.1 km/sPREM
Himalayas Bouguer< −100 mGal< −100 mGalGravity surveys
Gutenberg-Richter b1.000~1.0Global seismicity

Fluid Dynamics

QuantityRegimeGDBSLiteratureSource
Blasius δLaminar flat plate< 1% error5L/√ReBlasius (1908)
Sphere CDSubcritical turbulent~0.440.44Experimental data
Normal Shock M2M1=2.00.57740.5774Gas dynamics tables

Quantum Information

QuantityGDBSLiteratureSource
Trapped Ion Fidelity99.97%99.97%Ion trap benchmarks
Surface Code pth~1%~1%Fowler et al. (2012)
CHSH Bell Parameter2.0 < S ≤ 2√22.0 < S ≤ 2.828Bell (1964)

Medical / Molecular

QuantityGDBSLiteratureSource
Lipinski ViolationsAspirin: 0, Paclitaxel: ≥2Aspirin: 0, Paclitaxel: ≥2Lipinski criteria
Protein Tmf ≈ 0.5 at TmThermodynamic identityProtein stability

300+ automated tests pass across all physics domains. Sources include: NIST, CRC Handbook, CODATA 2018, Planck 2018, PREM, ITER Physics Basis, Troyon et al., McGaugh et al., Kanamori, Fowler et al., Blasius, Stokes, Lipinski, Bell, Wootters, and more.

HPC-Grade Numerical Precision

Many physics calculations span dozens of orders of magnitude - quantum constants near 10−34, cosmological scales beyond 1030 - where standard IEEE 754 floating-point arithmetic accumulates catastrophic precision loss. Traditional solutions require expensive HPC clusters with extended-precision libraries. GDBS implements a proprietary geometric number system (GeoNum) that holds extended precision directly in the browser, validated against analytic and standard reference values.

This system tracks uncertainty transparently through multi-scale calculation chains, enabling precision comparisons previously available only on supercomputers. The approach is domain-polymorphic: the same core architecture adapts to each physics domain's characteristic scales - electron-volt precision for quantum systems, kilometer-scale accuracy for geophysics, frequency-aligned precision for plasma oscillations.

IEEE 754 Double Precision

Hawking Radiation (Kerr Black Hole)

Where IEEE 754 actually breaks down is range, cancellation, and silent instability, not multiplication. A pure multiply chain spanning ℏ (10−34) to M⊙ (1030) is accurate in double precision, because exponents are exact. The cases below are the ones where double precision is not accurate, and where a drift figure changes what you do next.

GDBS Precision System

Hawking Radiation (Kerr Black Hole)

Same calculation: agrees with the exact analytic Hawking formula, with zero tracked drift. The value matches double precision here; what is added is the statement that the match is sound rather than coincidental.

Validated Performance - Theory Module (Black Hole Thermodynamics)

MetricResultSignificance
Tracked drift0 shadesIEEE 754 agrees on value but reports no drift at all
Precision Tiers2048 → 1024 → 512 → 256Tunable speed/accuracy tradeoff
Scale Range10−35 to 103065 orders of magnitude (Planck to cosmic)
Drift Accumulation0.345Well below 1.0 threshold across multiply chains
Uncertainty TrackingTransparent, quantifiedgetUncertainty() API at every calculation step
Domains SupportedMultipleTheory, Quantum, Fluids, Plasma, Materials, Geophysics, Ballistics, and more

Example Outputs - Hawking Temperature (M = 10 M☉, a/M = 0.9)

CaseIEEE 754GDBSWhat it shows
171 factorialInfinity, computation stopslog10 = 309.0938Range: 171! is the first factorial past a double's exponent (max 308.2547)
Muller's recurrenceconverges to 100converges to 100, flagged unreliableReliability: the true limit is 6; IEEE gives no warning
Forward/reverse harmonic sum5.33e-15, reported as exactsame value, drift reportedCancellation: the true difference is 0
Hawking T, 64-order operand spancorrect value, no drift figuresame value, drift 0Agreement here is real, and GDBS says so

Calculation: T = ℏκc / (2πkB) where κ = surface gravity of rotating (Kerr) black hole. Spans quantum scales (ℏ ≈ 10−34) to thermodynamic scales (kB ≈ 10−23).

Domain-Specific Precision Calibration

Each physics domain uses optimized precision grids tailored to its characteristic scales:

  • Theory: Logarithmic zones spanning quantum to cosmological scales (10−35 to 1030)
  • Quantum: eV-scale linear zones for atomic/molecular energy eigenvalues (−100 to +100 eV)
  • Fluids: Uniform spatial grids for CFD calculations (micron to kilometer scales)
  • Plasma: Frequency-aligned zones preserving oscillatory phase coherence (kHz to THz)
  • Materials: Lattice-symmetric zones at Angstrom scale (0.1 to 10 Å)
  • Geophysics: Spherical harmonic zones for Earth-scale multipole expansions (1 to 10,000 km)
  • Ballistics: Velocity-scaled zones across subsonic to hypersonic regimes (0.1 m/s to 10 km/s)

Positioning: This does not compete with HPC clusters - it bridges to them. The cluster still runs the production-scale work (long mergers, AMR, matter coupling); GDBS removes the cost around it - prototyping, method development, validation, and sizing at single-GPU scale: instant, no queue, no allocation grant, no specialized infrastructure. The Standard tier is free (registration required); Pro is $89.99/user/mo and HPC is $99.99/user/mo, cancel anytime - the HPC tier adds HPC Lab + DFT, and the BSSN, LIGO and GRMHD engines are $39.99/mo add-ons that attach to any tier. It reduces the cost to schedule, run, and extract value from HPC, not the FLOPs.

Precision System Documentation: available to licensees

Implementation details are proprietary. The precision architecture, zone configurations, and drift tracking algorithms are proprietary trade secrets.

Architecture

LayerTechnologyWhat It Does
Physics EngineRust → WebAssembly6,300+ LOC across 59 modules. Compiles to WASM - runs at near-native speed in the browser. No server round-trips for computation.
API & Auth.NET 8 / C#REST API with JWT authentication, role-based access, license management, Stripe payments. Handles persistence and admin operations.
FrontendVanilla JS + Chart.jsZero-framework UI with ES modules. Interactive forms, real-time chart rendering, result tables. No build step, no bundler.
Data LayerGDBS LocalStore + GQLJSON collections with SQL-like query language. Store, retrieve, filter, and export physics results. See the GQL Reference for the full syntax.

What GDBS Can Do Today

Fusion Reactor Design

Scan tokamak, stellarator, and FRC configurations. Optimize aspect ratio, elongation, triangularity. Find βcrit stability limits. Compare ITER, DIII-D, W7-X, C-2W parameters.

Materials Discovery

Predict elastic moduli, band gaps, phase transitions, thermal properties, and defect energies from bond-level inputs. Screen candidates in-browser before committing DFT cluster time.

Cosmological Analysis

Fit galaxy rotation curves with dark matter halos. Compute CMB power spectra. Model black hole accretion. Predict fundamental constant ratios.

Geophysics & Seismology

Model seismic velocity structure, tectonic stress, geothermal gradients, gravity anomalies, and earthquake statistics. Validated against PREM and USGS data.

Fluid Dynamics & Aerodynamics

Compute boundary layers, pipe flow friction, drag coefficients, heat transfer, and compressible flow shocks. From Stokes to Mach 5.

Quantum Computing

Benchmark qubit fidelity, error correction thresholds, entanglement metrics, and decoherence for IBM, Google, IonQ, and Rigetti hardware.

Drug Discovery & Molecular

Screen drug binding, protein stability, nanoparticle uptake, drug interactions, and QSAR descriptors. Lipinski analysis, Debye-Hückel electrostatics.

Data Platform & API

Save runs, query the database via GQL, browse collections, import CSVs, export results, and automate everything through the REST API with Python, curl, or any HTTP client.

Citation & References

If you use GDBS in published research, please cite:

© 2024-2026 Vaultsync Solutions Inc. All rights reserved.

Licensing Terms & Conditions

GDBS licenses grant a non-exclusive, non-transferable right to use the GDBS platform and selected modules for the duration of the license term. The following license types are available:

License TypeAccessDurationNotes
FreeDatabase + TheoryPermanentGDBS database & Theoretical Foundations; citation required
TrialAll modules14 daysFull access for evaluation; auto-enrolls to Free on expiry
StandardPer-module1 yearSelect individual modules
ProAll modules1 yearUnlimited access to all modules
ResearchAll modules1 yearCitation required; annual re-enrollment

Prohibited Activities: Redistribution, reverse engineering, decompilation, sublicensing, or any attempt to derive source code from GDBS binaries or WASM modules is strictly prohibited.

Pricing

Standard is free (registration required; runs on your own hardware). Pro is $89.99/user/mo and HPC is $99.99/user/mo, billed monthly, cancel anytime. Full details at getvaultsync.com. For volume or research-access inquiries contact sales@getvaultsync.com.

Research Program & Citation Requirements

Research users receive full access to all GDBS modules at no cost for one year. In exchange, research users must cite GDBS in all published work, presentations, and reports that utilize GDBS outputs:

Computational analysis performed using GDBS (Geometric Database System), developed by VaultSync Solutions Inc. https://gdbs.getvaultsync.com

Annual Re-enrollment: Research access must be re-requested each year. Enrollment is not automatic and is subject to review.

Revocation: VaultSync Solutions Inc. reserves the right to revoke research access at any time, with or without notice.

Research Access

Standard is free for everyone - no verification, no card, every standard domain and the free plugin catalog, unlimited runs on your own hardware.

Academic and research licensing

Need the HPC-class engines (BSSN, LIGO, GRMHD, HPC Lab) for published research? Academic and research licensing is handled case by case - tell us about the work and we will quote it. Research licensees must cite GDBS in published work.

Request Research Access

Tell us about the research and which engines it needs. We review each request and respond by email with licensing options. Research licensees cite GDBS in published work.

Data Retention Policy

If you don't save it, we don't keep it. GDBS computations run entirely in your browser. Results are only stored on our servers if you explicitly save them using the Save Run feature.

What we store: User account credentials (email, hashed password) and license metadata only. Simulation inputs, parameters, and outputs are processed locally in your browser and are never transmitted to or stored on GDBS servers unless you explicitly use the Save Run feature.

License Expiration / Revocation / Disablement: When a license expires, is revoked, or is disabled, all associated data - saved runs, history, and simulation results - is permanently deleted and cannot be recovered.

All user-generated data stays with the user. You can export your data at any time via CSV download or the REST API.

GDBS does not perform analytics tracking of computation inputs or outputs.

Support

GDBS provides direct email support only. There is no phone, chat, or ticket system.

For account issues, access problems, licensing questions, or sales inquiries, contact:

sales@getvaultsync.com

Alternatively, submit a research-access request using the form above and our team will reach out.

Limitation of Liability & Indemnification

Use at Your Own Risk. GDBS is a computational tool. All outputs are numerical results produced by algorithms running in your browser. VaultSync Solutions Inc. makes no representations or warranties, express or implied, regarding the accuracy, completeness, fitness for a particular purpose, or suitability of any computation result for any decision, design, engineering, medical, scientific, or commercial application.

No Liability for Decisions. VaultSync Solutions Inc. shall not be held liable for any direct, indirect, incidental, special, consequential, or punitive damages arising from the use or inability to use GDBS, or from reliance on any result produced by GDBS, including but not limited to: engineering failures, design errors, financial losses, regulatory non-compliance, or harm to persons or property.

Client Data Responsibility. All simulation inputs, parameters, and data you provide remain your sole property and responsibility. GDBS does not store, transmit, or retain computation data unless explicitly saved by the user. You are solely responsible for the legality, accuracy, and appropriateness of any data you submit to GDBS.

Indemnification. By using GDBS, you agree to indemnify, defend, and hold harmless VaultSync Solutions Inc., its officers, directors, employees, and agents from and against any and all claims, liabilities, damages, losses, costs, and expenses (including reasonable legal fees) arising out of or in connection with: (a) your use or misuse of GDBS; (b) any decisions, designs, or actions taken in reliance on GDBS outputs; (c) your violation of these terms; or (d) your violation of any applicable law or third-party rights.

No Warranty of Correctness. Physics computations involve inherent numerical approximation. GDBS displays uncertainty and drift metrics (GeoNum precision layer) as informational indicators only. These indicators do not constitute a guarantee of result accuracy for any specific application. Users are responsible for independently validating results before relying on them in any consequential application.

For questions about these terms, contact sales@getvaultsync.com. These terms are governed by the laws of the applicable jurisdiction without regard to conflict-of-law principles.

CORA Agent ● Live
Ask CORA anything about the current computation - interpretation, parameter suggestions, anomalies, or next steps.

Context from the active module is sent automatically.