Warehouse, streaming, transformations, a semantic layer, git-style branching, in-engine ML, and governance, collapsed into a single platform with one language. No orchestrator, no glue.
FluxOS is in private beta while we harden the core. We're letting people in a few at a time.
Invite-only · Free during the beta · Known limits
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 platform. 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 transactions and MVCC snapshot isolation 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 (experimental) for talking to the outside world. The transform layer lives where the data does.
Git-style branches and in-engine ML with lineage (both experimental), a semantic metrics layer, and row/column security with an audit log and GDPR erasure. Four more products you don't have to buy, integrate, or reconcile.
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 branch of the database, diff it against main, and merge it back. Branching from a branch and merging have known data-loss bugs.
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 and GDPR erasure (self-hosted for now), an audit log, and per-query cost limits, all in one console.
Beta testers land straight in the workbench: 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_q4Every capability below runs in the flux-server process. No add-on, no agent. The ones marked experimental work but have known gaps; see known limits.
Self-hosted servers accept psql and Postgres drivers on port 5432 (with known gaps). Not on Cloud yet, and most ORMs don't work yet.
Transactions with snapshot isolation, not eventual consistency.
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.
An event stream of every row change. Webhooks. Cursor checkpointing. Replay. A destination that falls far behind can miss changes.
Query a past point in time, with built-in slowly-changing-dimension history. After compaction, older points can return wrong results; see known limits.
Leader election with epoch fencing and WAL replication. Self-hosted only; not offered on Cloud.
Hot WAL + catalog stay local. Cold SSTs land in S3 (or any S3-compatible store).
Roles, permissions, token TTL, brute-force lockout, password policy. No external IdP required.
An append-only NDJSON record of who did what. Its hash chain can't be verified yet.
gdpr erase finds and removes a person's rows across tables by column value. Self-hosted only for now.
AES-256-GCM on self-hosted servers. Cloud workspaces use storage-level encryption for now.
Every item above maps to a source file and to tests among the 11,000+ in the codebase.
FluxOS is invite-only while we harden durability, Postgres connections on Cloud, and the experimental subsystems. It's free during the beta. We publish what doesn't work yet, so you can decide what to trust it with.
Every feature below is in the core platform, not a separate sidecar.
An append-only NDJSON record of who did what, for incident forensics. Its hash chain can't be verified yet.
gdpr erase finds and removes a person's rows across tables by column value, and records it in the audit log. Self-hosted only for now.
Built-in roles and permissions, brute-force lockout, password policy, key expiry. No external IdP required.
AES-256-GCM at rest on self-hosted servers; Cloud workspaces use storage-level encryption for now. HTTPS for the API and the workbench.
We're letting people in a few at a time. Leave your email and we'll be in touch.
Free during the beta. Already invited? Log in.