Data contracts enforced at compile time
Fast, type-safe data pipelines with built-in lineage and compliance. Schemas validated before your code runs, errors caught before production.
Four Pillars of Data Reliability
Data Contracts at Compile Time
CSV, Parquet, and JSON schemas validated when you compile, not when you run. Data contracts enforced by the type system, not by documentation.
Compile-Time Column Safety
Reference a column that doesn't exist? The compiler tells you before deployment. Schema drift caught immediately with helpful 'Did you mean?' suggestions.
Automatic Data Lineage
Every transformation tracked automatically. Full data provenance from source to result without writing extra code or using external tools.
Built for Compliance
Automatic audit trails for SOC2, GDPR, and financial regulations. Lineage tracking provides transparency for regulatory requirements.
Code Examples
-- Type-safe column operations validated at compile time
import DataFrame
import DataFrame.Expr as Expr
let sales = DataFrame.readParquet "public/data/sales.parquet"
-- Type-safe transformations - compiler validates column names and types
sales
|> DataFrame.filterGt "amount" 500
|> DataFrame.withColumns
[ Expr.col "amount" |> Expr.mul (Expr.lit 0.08) |> Expr.named "tax"
, Expr.col "amount" |> Expr.add (Expr.col "tax") |> Expr.named "total"
]
|> DataFrame.select ["transaction_id", "amount", "tax", "total"]
-- Schema drift caught at compile time, not in productionWho Uses Keel
Built for teams that need data contracts, lineage, and compliance.
Data Engineers
Build data pipelines with data contracts enforced at compile time. Schema changes detected immediately, not in production.
Financial Services
SOC2 and regulatory compliance with automatic audit trails. Full data lineage for transaction processing and risk calculations.
Healthcare & Life Sciences
HIPAA and GDPR compliance with provenance tracking. Every transformation documented for regulatory audits.
Data Governance Teams
Enforce data quality with compile-time validation. Data contracts prevent schema drift and ensure downstream reliability.
Data Contracts: Compile Time vs Runtime
Keel validates data contracts at compile time, catching issues before deployment rather than in production.
| Feature | Keel | Python/Pandas | dbt | Great Expectations |
|---|---|---|---|---|
| Data Contracts | Compile-time (enforced by compiler) | Runtime (manual checks) | Test-time (separate layer) | Runtime (validation library) |
| Schema Validation | Automatic at compile | Manual (try/except) | YAML definitions + tests | Python schemas + validation |
| Column Safety | Type-checked before run | KeyError at runtime | SQL compilation | Runtime assertions |
| Data Lineage | Built-in automatic | Manual tracking | Metadata in dbt docs | Separate expectation history |
| When Errors Found | Before deployment | In production | CI/CD pipeline | In production |
| Performance | Optimized execution | Interpreted overhead | SQL engine dependent | Python runtime |
Installation
# Run directly without installing
nix run git+https://codeberg.org/Keel/keel-cli
# Or build the package
nix build git+https://codeberg.org/Keel/keel-cli
# Enter a development shell
nix develop git+https://codeberg.org/Keel/keel-cliPrerequisites: Rust 1.70+ and Cargo (for building from source) or Nix with flakes enabled (for Nix installation)
Roadmap
What's coming next for Keel.
Core Language
CompletedType system, pattern matching, modules, REPL
Standard Library
In ProgressCollections, I/O, networking, concurrency primitives
Package Manager
In ProgressDependency resolution, versioning, registry
GPU Backend
PlannedCUDA and HIP support for parallel computation
DataFrame Library
CompletedPolars-backed columnar data with window functions, schema validation, and metadata
ML Framework
PlannedAutomatic differentiation and neural networks
Frequently Asked Questions
Keel is currently in alpha (v0.1.0). The core language is stable, but the ecosystem is still growing. It's great for experimentation and side projects, but we recommend caution for production workloads.
Keel offers Python-like simplicity with compile-time safety and performance that matches or exceeds Python. The type system catches errors at compile time rather than runtime, and there's no GIL limiting parallelism. For data processing workloads, Keel delivers at least the same speed as Python. However, Python's ecosystem is vastly larger.
Not directly. Keel has its own ecosystem. However, you can interop through FFI for C libraries, and we're working on Python bindings for embedding Keel in Python projects.
Keel delivers at least the same performance as Python, and typically faster for data-intensive workloads. For numeric operations, SIMD optimizations are automatic. Unlike Python, there's no GIL constraints on parallelism. GPU acceleration is planned for compute-intensive tasks.
Primarily functional with immutable-by-default values, first-class functions, and pattern matching. However, you can opt into mutable state when needed for performance-critical code.
Check out our Codeberg repository! We welcome contributions of all kinds: code, documentation, examples, and bug reports. Join the community chat to get started.