Warehouse, streaming, transformations, a semantic layer, git-style branching, in-engine ML, and governance — collapsed into a single Postgres-compatible Rust binary. One system. One language. No orchestrator, no glue, no 2 a.m. pages.
Single binary · 60-second install · Source-available (BSL → Apache 2 in 2029)
Ingest in one tool, store in a second, transform in a third, define metrics in a fourth, visualize in a fifth. Then bolt on Kafka + Flink when someone needs real-time, a feature store when someone needs ML, and a git-for-data layer when someone needs to experiment safely. That's the dozen.
Every box is its own wire format, credential set, upgrade cycle, and pager. Data crawls from write to dashboard in 8 seconds on a good day, 90 on a bad one. The cloud bill clears five figures before a single user sees a feature.
You're not building a product. You're operating a supply chain.
FluxOS is the whole path above — ingest, store, transform, stream, branch, model, and govern — in a single Rust binary that speaks Postgres. The row your app writes is the row the dashboard reads, the model scores, and the audit log records. No copies. No seams. No glue.
Transactional and analytical on the same tables. ACID, MVCC snapshot isolation, and pgwire on port 5432 — so psql, Prisma, SQLAlchemy, or any ORM just connects — over columnar storage with time-travel built in. The app writes and the dashboard reads the same data. No ETL, no reverse ETL, no warehouse sync.
Change data capture, pipelines, and continuous materialized views that stay fresh as rows arrive — no separate streaming cluster, no checkpoint files, no TaskManagers. Kafka and Kinesis connectors when you need to talk to the outside world. The transform layer lives where the data does.
Git-style branches for safe experiments, in-engine ML with lineage, a semantic metrics layer, and row/column security with a tamper-proof audit log and GDPR cascade. Four more products you don't have to buy, integrate, or reconcile — they're already in the box.
FluxOS isn't a headless database you wrap in five SaaS tools. Open a browser and you're in a full data operating system — explore, query, build, model, branch, monitor, and govern, all in one place, on the same data.
Write Flux or SQL with schema autocomplete, syntax highlighting, and a built-in profiler that shows the execution plan node by node.
Python, Flux, and SQL cells in one notebook with managed kernels and package install. Explore, chart, and export to .ipynb.
Spin up a copy-on-write branch of the whole database in milliseconds. Diff against main, experiment safely, merge atomically.
Define governed, versioned metrics once. Non-technical users explore them by point-and-click — no Flux, no metric drift, one source of truth.
Train models, forecast time series, and detect anomalies in-engine — with model lineage. Wire an LLM for natural-language insights.
Pipelines and DAG workflows, materialized views, connectors, triggers, CDC streams, visual lineage, and column-level data-quality profiling.
Flux-backed widgets are first-class catalog objects. A no-code chart wizard turns a table + a measure into a live dashboard in seconds.
Live queries, slow-query log, latency percentiles, and alerts — plus an advisor that explains plans and suggests indexes and rewrites.
Roles, row/column security, masking policies, a tamper-proof audit log, GDPR erasure, and per-query / per-user cost limits — all in one console.
Self-host it and the workbench is included. On Cloud, you sign up and land in it — no install, no setup.
The dozen-tool stack is also a dozen-dialect stack: SQL in the warehouse, Jinja in dbt, YAML in the semantic layer, Python in the feature store, another SQL for the stream processor. FluxOS speaks one — Flux. The same pipes that run a query define a materialized view, a metric, a model, and a branch. Learn it once; operate the whole layer.
SELECT customer_id,
SUM(amount) AS revenue
FROM orders
WHERE status = 'paid'
GROUP BY customer_id
ORDER BY revenue DESC;from orders
| where status == "paid"
| group customer_id {
revenue: sum(amount)
}
| sort -revenue-- models/top_products.sql
{{ config(materialized='incremental') }}
select product_id,
sum(amount) as revenue
from {{ ref('orders') }}
{% if is_incremental() %}
where created_at > (select max(created_at)
from {{ this }})
{% endif %}
group by product_idcreate materialized view top_products as
from orders
| group product_id {
revenue: sum(amount)
}
# stays fresh as rows arrive# semantic_layer.yml
metrics:
- name: paid_revenue
type: sum
sql: amount
filters:
- "status = 'paid'"
dimensions:
- customer_countrycreate metric paid_revenue as
from orders
| where status == "paid"
| sum(amount)import pandas as pd
from sklearn.ensemble import GradientBoostingClassifier
df = warehouse.read("select * from customers")
X, y = featurize(df), df["churned"]
clf = GradientBoostingClassifier().fit(X, y)
feature_store.register("churn", clf) # + servingtrain model churn
from customers
| features { tenure, plan, monthly_usage }
| label churned
from customers | predict churn# a separate system, just to branch
lakectl branch create \
lakefs://repo/experiment-q4 \
--source lakefs://repo/main
# then re-point dbt, BI & configs
# at the new branch by hand…branch create experiment_q4
-- experiment freely, then:
from main | branch merge experiment_q4This editor is connected to a live, public, sandboxed FluxOS instance running on AWS. No signup. No fake data. The queries below run against a real LSM tree with millions of rows. Edit, experiment, break things.
The sandbox is rate-limited to 60 queries / minute / IP, capped at 10s wall time per query, and read-only on a curated dataset. For full access, start free above.
Every capability below is shipped and runs in the default flux-server process. No add-on. No agent. No license tier required for the core.
Drop-in for psql, pgcli, Prisma, SQLAlchemy. ORMs work. Pooling works. Migrations work.
Real transactions. Real isolation. Not eventual consistency dressed up.
Kafka + Kinesis sources and sinks. Windows. ASOF joins. Watermarks. In-process.
Streaming MVs that update as data arrives. The Materialize feature, without the separate cluster.
At-least-once event stream of every row change. Webhooks. Cursor checkpointing. Replay.
Query any past point in time. Built-in slowly-changing-dimension history. No audit-table boilerplate.
Leader election with epoch fencing. WAL replication. Split-brain prevention. Automatic failover.
Hot WAL + catalog stay local. Cold SSTs land in S3 (or any S3-compatible). Pay for storage, not nodes.
Roles, permissions, token TTL, brute-force lockout, password policy. No external IdP required.
Append-only NDJSON, hash-chained. SOC 2 evidence-as-a-feature. Exportable to your SIEM.
One DELETE FROM users cascades through every dependent table, MV, and stream — and records the chain.
AES-256-GCM. Per-key envelopes. Key rotation. TLS at every public surface.
Every item above maps to a feature flag, a source file, and one of 8,900+ tests in the codebase. We can show you the line.
Every feature below is in the core binary, not behind a paywall or a separate sidecar. Bring FluxOS to a SOC 2 audit, a HIPAA review, or a GDPR DPA without bolting on three more vendors.
Append-only NDJSON, hash-chained, exportable to your SIEM. Designed for SOC 2 evidence and incident forensics.
One DELETE FROM users cascades through every dependent table, materialized view, and stream — and records the chain in the audit log.
Built-in roles and permissions, brute-force lockout, password policy, key expiry. No external IdP required to ship v1. SSO / SAML on Enterprise.
AES-256-GCM with per-key envelopes and rotation. TLS at every public surface: pgwire-over-TLS, HTTPS for the API and dashboard.
Reading these features straight from the source code? Same. Every line above maps to a file, a test, and a Phase commit in the public history.
Every paid tier is a flat base plus metered usage — and the per-hour rate drops as you climb. Idle costs nothing; there are no minimums and no credits to pre-buy.
A real managed workspace that scales to zero. For evaluating and small projects — pay nothing while it's idle.
Start freeProduction for a team. Automated backups with point-in-time restore, every warehouse size, roles, and an uptime SLA.
Start free → upgradeYour own isolated, always-on node — no neighbors, no cold starts, predictable performance. Everything in Pro, on hardware that's yours.
Get a nodeSSO/SAML, your VPC, SIEM audit export, HA + replication, and 24×7 named support. For regulated teams and scale.
Talk to usPrefer to run it yourself? Self-host the source-available OSS edition — free, all core features, BSL → Apache 2 after three years. Install in 60 seconds →
Sign up free and you land straight in your workspace — no install, scale-to-zero, pay only for what you run. Or self-host the OSS edition with one command. Whatever you do, please stop running a dozen tools.
docker run -p 5432:5432 -p 8080:8080 \
fluxdb/fluxdb-cloudThen point psql at localhost:5432 — or start free in the cloud.