Rocky – Rust SQL engine with branches, replay, column lineage

Hi HN, I'm Hugo. I've been building Rocky over the past month, shipping fast in the open. The binary is on GitHub Releases, `dagster-rocky` on PyPI, and the VS Code extension on the Marketplace. I held off on a broader announcement until the trust-system surface was coherent enough to talk about as one thing. The governance waveplan — column classification, per-env masking, 8-field audit trail on every run, `rocky compliance` rollup, role-graph reconciliation, retention policies — landed end-to-end last week in engine-v1.16.0 and rounded out in v1.17.4 (tagged 2026-04-26). That's the milestone I'd been waiting for.The pitch: keep Databricks or Snowflake. Bring Rocky for the DAG. Rocky is a Rust-based control plane for warehouse pipelines. Storage and compute stay with your warehouse. Rocky owns the graph — dependencies, compile-time types, drift, incremental logic, cost, lineage, governance. The things your current stack can't give you because it doesn't own the DAG.A few things I think are interesting:- Branches + replay. `rocky branch create stg` gives you a logical copy of a pipeline's tables (schema-prefix today; native Delta SHALLOW CLONE and Snowflake zero-copy are next). `rocky replay <run_id>` reconstructs which SQL ran against which inputs. Git-grade workflow on a warehouse.- Column-level lineage from the compiler, not a post-hoc graph crawl. The type checker traces columns through joins, CTEs, and windows. VS Code surfaces it inline via LSP.- Governance as a first-class surface. Column classification tags plus per-env masking policies, applied to the warehouse via Unity Catalog (Databricks) or masking policies (Snowflake). 8-field audit trail on every run. `rocky compliance` rollup that CI can gate on. Role-graph reconciliation via SCIM + per-catalog GRANT. Retention policies with a warehouse-side drift probe.- Cost attribution. Every run produces per-model cost (bytes, duration). `[budget]` blocks in `rocky.toml`;

Hacker NewsToolAISource
0Sign in to voteCopy link

FL score

72

out of 100

Verdict

VALIDATE

high confidence

Competition

No competitor data yet

Trend

No signal yet

A Rust-based DAG control plane for data warehouses that adds Git-like workflows, compile-time column lineage, and governance to Databricks/Snowflake without replacing them.

The pain

Data teams lack visibility and control over pipeline dependencies, data lineage, and governance. Current warehouse-native tools (dbt, Airflow) either don't own the DAG semantically or lack compile-time guarantees. Compliance, cost attribution, and reproducibility require manual post-hoc work. Branching/testing pipelines is expensive and risky.

The gap

No tool currently owns the semantic DAG while staying storage-agnostic. dbt is SQL-focused without strong governance; Dagster/Airflow are orchestrators without warehouse-native lineage. The gap is a thin, high-leverage control plane that adds type safety, compliance, and Git workflows to existing warehouses.

Build angle

Hugo has shipped fast with real features (branches, replay, column lineage, governance rollup). The Rust foundation is solid for performance. The positioning, 'keep your warehouse, bring Rocky for the DAG', is clean and non-threatening. Early traction signals (GitHub releases, PyPI, VS Code extension, HN post) suggest product-market fit exploration is underway. The governance surface (Unity Catalog integration, SCIM, audit trails) is table-stakes for enterprise but rarely done well.

Strengths

  • Shipped with depth: branches, replay, column lineage, governance, cost attribution, not a toy
  • Non-disruptive positioning: complements rather than replaces Databricks/Snowflake
  • Compile-time lineage is technically superior to post-hoc crawling; LSP integration is UX-smart
  • Governance-first design (masking, classification, audit, compliance rollup) addresses real enterprise pain
  • Rust foundation enables performance and reliability at scale
  • Founder shipping in the open builds trust and attracts early adopters
  • Multi-warehouse support (Databricks, Snowflake) reduces lock-in risk

Risks

  • Positioning is complex: 'control plane for DAG' is harder to explain than 'better dbt' or 'Airflow alternative'
  • Adoption requires buy-in from both data and security teams; slow sales cycle likely
  • Competitive moat unclear: dbt could add governance; Databricks/Snowflake could own the DAG natively
  • Pricing model not mentioned; unclear if this is open-source, freemium, or enterprise SaaS
  • Market size constrained to teams already using Databricks/Snowflake at scale (not SMBs)
  • Governance features may be table-stakes but not differentiating; cost attribution is nice-to-have
  • Founder solo (appears to be); scaling team and sales will be critical
  • Timing risk: if Databricks/Snowflake ship native DAG ownership, Rocky becomes a layer
  • Column lineage is powerful but only valuable if teams actually use it for decisions

Questions about this idea?

FlyBot reads the scoring and gives you a second opinion on “Rocky – Rust SQL engine with branches, replay, column lineage”.

Open FlyBot