KRONOS_ENGINE

Commercial licenses

Modules

Production-ready systems extracted from the Kronos engine and licensed for use in your own projects. Each one is the same code Kronos ships with, not a demo rewritten for sale.

Materials

PBR Material System (Cook-Torrance)

A physically based metallic-roughness material pipeline built on the Cook-Torrance BRDF, with image-based lighting support.

What’s included

  • GGX / Smith / Schlick Cook-Torrance BRDF
  • Metallic-roughness material model and texture slots
  • IBL: irradiance, prefiltered specular & BRDF LUT

Renderer

Forward+ Renderer Core

A tiled Forward+ rendering core that handles hundreds of dynamic lights while keeping MSAA and transparent materials working.

What’s included

  • Depth pre-pass and compute-based light culling
  • Per-tile light lists for point and spot lights
  • Frame graph glue for integrating your own passes

Physics

Jolt Physics Integration Helpers

Glue code that wires Jolt Physics into an engine cleanly, covering setup, body management, and fixed-step transform sync.

What’s included

  • World setup, layers and broadphase configuration
  • Body / shape creation helpers from scene data
  • Fixed-tick stepping with interpolated transform sync
  • Character controller wrapper

Coming Soon

More modules in development

Further Kronos systems are being prepared for commercial release.

  • Vulkan Ray Tracing Renderer
  • Compute Particles GPU
  • Node-based GPU VFX System VFX

Questions about licensing, or a Kronos system you’d like to see offered as a module? Get in touch before purchasing.

Enterprise Grade Engines

Eight production Rust engines, licensed for your infrastructure.

Each engine is a self-contained, zero-dependency Rust core with a C ABI — drop it into your stack instead of building it. Every performance figure below is measured in-repo on an AMD Ryzen 9 5950X and is reproducible; full methodology and caveats are in the benchmark report. Licensed per engine as an annual subscription, node-locked to your deployment.

Anvil Vault vault

encryption · key mgmt

Envelope encryption, key wrapping, format-preserving encryption and Shamir secret sharing, built on audited RustCrypto primitives. Key material and plaintext live in RAM-locked memory that zeroes on drop.

Use it to

  • Encrypt PII/PHI at the field level with per-record data keys
  • Tokenize card PANs, SSNs and IBANs while preserving their format for legacy systems
  • Split a master key k-of-n across officers with Shamir sharing
AES-256-GCMChaCha20-Poly1305 FF1 / FF3-1Shamir k-of-n HW AES/SHA
819 MiB/sAES-256-GCM seal, per core
464K/sFF3-1 PAN encrypt
NISTFF3-1 vs SP 800-38G vectors

Anvil Match matching

trading · market data

A price-time-priority matching engine with FIX 4.4 and ITCH/MoLD codecs. The match hot path performs no heap allocation — verified by a test that asserts it.

Use it to

  • Run an exchange, dark pool or internal crossing engine
  • Encode and parse FIX 4.4 order flow
  • Ingest and translate ITCH market-data feeds
limit/marketcancel/amend FIX 4.4ITCH + MoLD zero-alloc
10.1M/sorders matched (99 ns/order)
5.6M/sFIX 4.4 parse + decode
475 MiB/sITCH translate + frame

Anvil Authz rebac

access control

Relationship-based access control in the Zanzibar style: a policy DSL, a tuple store, permission checks and reverse lookups — answer "can user X do Y to Z?" in microseconds.

Use it to

  • Model fine-grained permissions across teams, folders and documents
  • Check access on the request path with predictable tail latency
  • List every resource a principal can reach (reverse lookup)
policy DSLtuple store reverse lookupprepared checks
0.59M/schecks, single thread
1.53 µsp50 view check
3.35 µsp99 (532K-tuple graph)

Anvil Ledger audit

compliance · audit

A tamper-evident audit log: hash-chained entries with Merkle inclusion proofs, optional PII redaction on the write path, and crash-recovery replay — proof that a record was never altered.

Use it to

  • Keep compliance trails you can cryptographically prove weren't tampered with
  • Produce an inclusion proof for a single entry on demand
  • Redact PII as it's written for SOC 2 / regulatory logging
SHA-256 / BLAKE3Merkle proofs PII redactioncrash replay
0.89M/sappend (BLAKE3, raw)
<1 µsentry verify
108 Bper entry on disk

Anvil Vector vector

similarity search

In-memory HNSW similarity search with recall measured against brute-force ground truth, and a tunable ef knob to trade recall for latency. mmap save/load for fast cold starts.

Use it to

  • Power semantic search and RAG retrieval over embeddings
  • Find nearest neighbours with a recall target you can quote
  • Generate recommendation candidates at low latency
HNSWcosine / L2 tunable efmmap load
0.94 @ 6.3K QPSrecall@10 / QPS, ef=256
0.82 @ 20K QPSrecall@10 / QPS, ef=64

In-memory, single node · 100k × 128-dim. Quote recall and QPS together.

Anvil Query columnar

analytics · OLAP

A columnar store with vectorized (AVX2) scan, filter and aggregation operators, native encoding with LZ4, zone-map pruning, and the ability to read Parquet — embedded analytics without a separate database.

Use it to

  • Run analytical scans and group-bys over millions of rows in-process
  • Embed OLAP into an app without standing up a warehouse
  • Query existing Parquet (snappy) data directly
AVX2 kernelszone maps LZ4Parquetgroup-by / filter
~20M rows/sgroup-by, in-memory, 5M rows
330M rows/sfilter + sum, in-memory

Validated against Parquet (snappy) on the same data.

Anvil Stream stream

stream processing · CEP

In-process stream processing: tumbling, sliding and session windows, p50/p99 quantile sketches, and complex-event patterns including absence detection. Steady state performs no allocation.

Use it to

  • Compute real-time aggregations and rolling metrics over event streams
  • Track p50/p99 latency with bounded-memory sketches
  • Detect patterns like "A not followed by B within 100 ms"
tumbling/sliding/sessionp50/p99 sketches CEP + absencezero-alloc
37M events/stumbling window
14.5M events/swindow + p50/p99 sketches

Anvil Parse docparser

documents · redaction

A zero-dependency PDF and DOCX parser with text extraction and term + regex redaction. Validated against real Ghostscript-produced PDFs — classic xref, object streams and encrypted.

Use it to

  • Extract text from PDFs and DOCX in an ingestion pipeline
  • Redact sensitive terms and patterns before storage
  • Process documents without a native/OS dependency
PDF (xref / obj-streams / enc)DOCX text extractionterm + regex redaction
5.6K docs/sPDF parse + text extraction
1.6K docs/sPDF redaction (term + regex)

Figures are per-doc overhead on small fixtures; a practical PDF/DOCX subset, not a full renderer.

Anvil Suite — all eight engines

Standardize on the whole stack with a single node-locked key. Priced well below buying the engines individually.

Licensing & terms

Annual subscriptionPer-engine, auto-renewing yearly. Renewal extends your license automatically.
Node-locked keysStartup keys activate on 3 production machines. Enterprise scales to your deployment, set per contract.
Offline verificationEngines verify a signed, machine-bound license at start-up — no runtime phone-home.
Need more nodes?Exceed your device cap and activation tells you to contact us for additional keys.

You receive compiled libraries (C ABI, static/shared, plus WASM) and headers — not source, and not a redistribution right; the license is for your own deployment. Enterprise adds priority support with a response-time target. Verification is node-locked and offline; like any embedded-library license it deters casual copying rather than acting as unbreakable DRM. Full, reproducible benchmark methodology and per-engine caveats are published in the benchmark report.