Python made data accessible. TL makes it fast, safe, and intelligent — in one compiled language. 1,272 tests passing across 33 implementation phases — generics, pattern matching, Python FFI, LLVM & WASM backends, package manager, and a full LSP already shipping.
source users = postgres("db").table("users") -> User transform active_users(src: table<User>) -> table<User> { src |> filter(is_active == true) |> clean(nulls: { name: "unknown" }) |> with { tenure = today() - signup_date } } model churn = train xgboost { data: active_users(users) target: "is_active" features: [tenure, monthly_spend] }
Tables, Streams, Tensors are native types in the language.
ETL/ELT flows are composable first-class constructs.
train, predict, embed are keywords — not libraries.
No GIL, automatic partitioning across cores.
Built-in error handling for unreliable data sources.
Python-like readability, Rust-like safety guarantees.
Compiled to native code with lazy evaluation. Performance is the default, not an afterthought.
Stop duct-taping together a dozen tools. TL unifies the modern data stack into one language.
schema User { id: int64 name: string email: string signup_date: date is_active: bool } source users = postgres("db") .table("users") -> User
transform clean_users(src: table<User>) { src |> filter(is_active == true) |> clean(nulls: { name: "unknown" }) |> with { tenure = today() - signup_date } } pipeline daily_etl { users |> clean_users }
model churn_predictor = train xgboost { data: clean_users(users) target: "is_active" features: [ tenure, monthly_spend ] split: 0.8 } // Use the model let result = predict(churn_predictor, new_user)
match load_users("data.csv") { Ok(users) => process(users) Err(DataError::FileNotFound(p)) => log("Missing: {p}") Err(e) => alert("{e}") } // Destructuring + guards let [head, ...tail] = items let Point { x, y } = origin
fn top_n<T: Comparable>( data: table<T>, col: fn(T) -> float64, n: int ) -> table<T> { data |> sort(col, desc) |> limit(n) } trait Connectable { fn connect() -> result<Conn, Error> }
Columnar, lazy-evaluated, and partitionable. The core data type for batch processing.
Infinite, windowed, real-time. For continuous data processing and event streams.
N-dimensional arrays for AI and machine learning. Shape-checked at compile time.
A trained AI model as a first-class value. Serialize, version, deploy natively.
Rust-inspired ownership without lifetime annotations. The compiler guarantees memory safety and data-race freedom at compile time.
Built entirely in Rust. TL-IR doubles as a query plan — enabling data-aware optimizations like predicate pushdown, column pruning, and join reordering.
TL's compiler sees the entire pipeline as one program — eliminating serialization boundaries between tools.
Targets based on architecture analysis. Benchmarks will be published with reproducible scripts.
Rust-inspired result<T, E> with data-specific error types and declarative cleaning — not try/catch bolted on as an afterthought.
fn load_users(path: string) -> result<table<User>, DataError> { let raw = read_csv(path)? let valid = raw |> validate_schema(User)? Ok(valid) } match load_users("data.csv") { Ok(users) => process(users) Err(DataError::SchemaViolation(d)) => alert("Drift: {d}") Err(e) => log("{e}") }
let users = load("raw_users.csv") |> clean { nulls: { name: fill("UNKNOWN") email: drop_row age: fill(median) } duplicates: dedupe(by: email) outliers: { age: clamp(0, 150) } } |> validate { assert null_rate(email) == 0.0 assert unique(id) }
First-class connectors for databases, object storage, message queues, and APIs. All type-safe and schema-aware.
BigQuery, Snowflake, and more connectors are planned for the production release.
Bidirectional Python FFI via pyo3. Import Python modules, call functions, convert tensors to NumPy — all from TL code.
// Import any Python library let np = py_import("numpy") let pd = py_import("pandas") let sklearn = py_import("sklearn.metrics") // Call Python functions with TL values let score = py_call( sklearn.accuracy_score, y_true, y_pred ) // TL Tensor <-> NumPy ndarray let pi = np.pi let arr = np.sqrt(16)
int, float, string, bool, list, map, set — all auto-converted between TL and Python.
TL tensors convert seamlessly to/from NumPy ndarrays for ML workflows.
Use natural math.sqrt(16) syntax on Python objects via method dispatch.
Python FFI is opt-in via feature flag. Zero overhead when not used.
Syntax highlighting, diagnostics, go-to-definition, hover docs, and document symbols.
tl add, tl update, tl outdated — full dependency management with lockfile and transitive resolution.
tl fmt, tl lint, tl check — AST-guided formatting, naming conventions, and compile-time type safety.
tl doc generates HTML, Markdown, or JSON docs from /// doc comments with cross-references.
tl inspect, tl profile, tl lineage — preview data, statistical profiles, and lineage graphs.
The only language where data pipelines, SQL-like queries, ML training, and real-time streaming are all first-class features — not libraries.
ThinkingLanguage is dual-licensed under MIT and Apache 2.0.