Skip to content

Zero-deps · security · performance

Own your data, apps, and infrastructure without dependency sprawl

Qirava is a first-party software ecosystem for teams that want to own the whole stack: DMS provides governance, database, planned KMS, and workers; Quill builds apps on top; q* packages keep the substrate reusable; Cloud will orchestrate DMS as managed thread/RAM/storage capacity.

0third-party dependencies in shipped JS and first-party crates
3ordered authorization checkpoints before data access
4core product areas: DMS, Cloud, Quill, q* packages
SSOTarchitecture, docs, and roadmap live on this site

Plain English

What is Qirava?

A zero-dependency ecosystem for building and running data-backed products: one governed DMS, one Rust UI/app framework, one reusable q* foundation, and a planned managed Cloud layer.

DMS

Governance + DB + workers

The DMS is the core product: QQL, tables, WAL, jobs, API catalog, Studio, compliance building blocks, and RBAC all behind one execute() path.

Quill

Host apps on the DMS

Quill renders Rust-authored apps and docs with SSR, islands, design tokens, motion, and a component library that now has full route coverage.

Cloud

Managed DMS orchestration

Cloud is the planned managed-service layer: sell thread/RAM/storage, scale vertically and horizontally, and keep built/simulated/planned status explicit.

Products

One ecosystem, clear boundaries

Products are distinct repos with one-way dependencies: products may depend on q* packages; q* packages never depend on product code.

Qirava DMS

qdms
built

The data system: one execute primitive and one function registry for governance, database, jobs, replication, workers, and planned KMS.

  • Embedded · standalone · cluster install modes
  • Every DB read/mutate reaches the planner
  • Compliance building blocks now; KMS/compliance package planned
Understand the DMS

Quill

qquill
built

The UI/app framework: Rust view authoring, native SSR, islands, full component docs coverage, motion, and static export with a hand-written runtime.

  • Theme/density/radius/surface/motion axes
  • Secure DMS app-boundary docs
  • This site dogfoods the framework
See Quill

The q* stdlib

qpkgs
built

Shared zero-dependency crates: qexec, qvalue, and focused utility crates used by products without pulling product code back in.

  • Executor and value substrate
  • First-party utility crates
  • One-way dependency rule
Read stdlib role

Qirava Cloud

qcloud
planned

The managed-DMS control plane. The control-plane catalogs/functions/console are built; real tenant DMS spawn, resource caps, scaling, billing, and confidential compute are planned/simulated.

  • Thread/RAM/storage capacity model
  • Built on the DMS
  • No simulated infra presented as shipped
Check cloud plan

How to use it

A human path from first visit to shipped app

The site now teaches the system in the order a person needs: pick the product, run the DMS, learn the access model, build the UI, then check status.

  1. 01

    Pick the product

    DMS governs data and workers. Quill builds DMS-hosted apps. q* crates are reusable. Cloud is planned managed DMS capacity.

    Compare products
  2. 02

    Run the DMS

    Install directly as embedded, standalone, or cluster. Start with standalone quick-start before building on top.

    DMS quick start
  3. 03

    Learn safe data access

    Understand L1 worker auth, L2 execute scope, and L3 planner RBAC before writing app data.

    Access model
  4. 04

    Build the UI

    Use Quill components, server rendering, islands, theme tokens, motion, and the security-boundary rule: secrets never go to island props.

    Browse Quill components
  5. 05

    Check what is real

    Use the roadmap SSOT to separate completed, partial, and planned work before depending on a capability.

    Open roadmap

Roadmap SSOT

Built, partial, and planned are visible from the front page

No reader should have to reverse-engineer repository state. Open the product roadmap for the full board; this summary keeps the landing page honest.

Qirava DMS

SSOT
Built

Engine, workers, execute registry, QQL/DDL, RBAC, governance, WAL, jobs, and Studio seams.

Planned

KMS backend, worker secret/env reads, packaged compliance mode, and deeper cluster/Cloud orchestration.

Quill

SSOT
Built

Rust view authoring, SSR, islands, component library, theme tokens, static export, and CLI scaffold.

Planned

Deep playground upgrades for newer component pages, richer app examples, palette generation, and motion presets.

q* stdlib

SSOT
Built

Zero-dependency substrate crates used by products: qexec, qvalue, and utility crates.

Planned

Additional crypto primitives behind the provider trait and broader stdlib coverage.

Qirava Cloud

SSOT
Built

Control-plane DMS, _cp_* catalogs, cloud.* functions, RBAC console, and simulated capacity operations.

Planned

Real tenant DMS spawn, OS/cgroup caps, no-disruption vertical/horizontal scaling, billing/payment, node agents, and confidential compute.

Start with the docs, not guesswork

If you want to build, run the DMS first. If you want to evaluate, use the roadmap/status registry. If you want UI proof, Quill docs now show every implemented component plus motion and secure app-boundary rules.