Get started

Open compute / explicit control

Run data workloads on an engine you can inspect.

Krishiv Engine brings batch SQL and Preview stateful streaming onto one Rust-native foundation. Start from source today; add the upcoming Platform control plane only when your team needs it.

Build from source Explore architectureView on GitHub
Engine · Apache-2.0 developer preview Platform · coming soon
A query enters Krishiv Engine through a public API, is planned with DataFusion, executes over Arrow, and returns a RecordBatch result.
engine / execution trace source-built
SQLRustPythonFlight
01 / EntrySession + catalogPublic API boundary
parse · bind
02 / PlanDataFusion + KrishivLogical → physical plan
execute
03 / ComputeArrow operatorsExplicit placement
answerInt64
421 RecordBatch
RustArrowDataFusionTokio
01 / LicenseApache-2.0 Engine
02 / RuntimeRust + Tokio
03 / Data modelApache Arrow
04 / PlanningDataFusion
05 / Current pathSource-built preview

01 / Product system

Open compute first. An integrated control plane later.

Two products with a clean public boundary. Engine stands alone; Platform will consume the same interfaces available to every Engine user.

Krishiv Engine Developer preview

Apache-2.0 compute layer

Own the runtime boundary.

Plan, execute, move, and maintain data through public Engine contracts.

Batch SQLAvailable
Stateful streamingPreview
Incremental viewsExperimental
EmbeddedAvailable
Single nodeAvailable
DistributedPreview
Explore Engine Read Engine docs
Krishiv Platform Coming soon

Self-hosted control plane

Bring the team around the Engine.

A planned workspace for SQL, catalog administration, jobs, governance, and operations.

  • WorkspaceConsole · API · CLI · MCP
  • DataSQL · catalog · pipelines
  • OperationsJobs · governance · audit

No download, public preview, or availability date is being announced.

See the product direction

02 / Placement

Change the topology, not the front door.

Start with an in-process session. Exercise service boundaries on one host. Move remote only when the Preview distributed path fits the evaluation.

  1. 01
    AvailableIn process

    Embedded

    Planner and execution run inside your Rust or Python application.

    No network boundary required
  2. 02
    AvailableOne host

    Single node

    Coordinator, executor, HTTP, and Flight boundaries share one machine.

    Service seams without a cluster
  3. 03
    PreviewRemote workers

    Distributed

    Work is assigned through an explicit coordinator and executor topology.

    Evaluation path · not an HA claim
Same public session model
Compare execution modes

03 / Workload model

Three shapes. One execution spine.

Workloads share Arrow data, planning, runtime, state, and connector seams while retaining explicit maturity boundaries.

01Available

Batch SQL

Plan finite SQL and DataFrame work over Arrow data, then collect RecordBatch results.

Finite input · bounded result
02Preview

Stateful streaming

Model event-time windows, watermarks, keyed state, checkpoints, and continuous joins.

Long-lived · stateful
03Experimental

Incremental views

Propagate weighted inserts and retractions through local-first maintained computations.

Changing input · delta-driven

04 / Developer proof

A real query, through documented APIs.

These examples use the current source-built CLI and public Rust and Python facades. No fictional package command or hosted endpoint is implied.

terminalbash
$ cargo run -p krishiv -- sql \
  --query "SELECT 42 AS answer"
Execution trace Complete
  1. 01
    SessionEmbedded placement
    ready
  2. 02
    DataFusion planLogical → physical
    planned
  3. 03
    Arrow executionIn-process operators
    1 batch
answerInt64
42

One public entry point. Placement remains explicit.

Continue in the docs

Choose the contract you need next.

View all Engine docs
01

Run your first query

Build the CLI and execute embedded SQL from a source checkout.

Open guide 02

Choose a placement

Compare embedded, single-node, and distributed runtime boundaries.

Open guide 03

Configure the runtime

Resolve placement, state, checkpoints, authentication, and tuning.

Open guide 04

Verify feature maturity

Separate available paths from Preview and Experimental surfaces.

Open guide

05 / Evidence over claims

Maturity stays visible.

A capability can exist without being a stable operating contract. Every public surface keeps its current status attached.

Review the full maturity map
01Available

Batch and local placement

02Preview

Streaming and distributed paths

03Experimental

Incremental view maintenance

04Coming soon

Krishiv Platform

Start with what exists

Build the Engine from source.

Pin a revision, run an embedded query, and expand placement only when the workload requires it.

Run the quickstart Inspect the repository