Python made data accessible. TL makes it fast, safe, and intelligent — in one compiled language. 1,315 tests passing across 34 implementation phases — AI agents with tool-use, 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, agent 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> }
No frameworks. No glue code. Define autonomous AI agents with tool-use, multi-provider LLM support, and lifecycle hooks — all with a single keyword.
// Define tool functions in pure TL fn search(query) { let resp = http_request("GET", "https://api.search.com/v1?q=" + query, none, none) json_parse(resp.body) } // Declare the agent agent research_bot { model: "gpt-4o", system: "You are a research assistant.", tools { search: { description: "Search the web", parameters: { type: "object", properties: { query: { type: "string" } } } } }, max_turns: 5, on_tool_call { println("[LOG] " + tool_name) } } // Run it let result = run_agent(research_bot, "What is quantum computing?") println(result.response)
agent is a language keyword, not a library import. Tools are TL functions wired directly to the LLM.
OpenAI, Anthropic, Ollama, or any OpenAI-compatible endpoint. Auto-detects protocol from model name. One base_url field to switch.
The runtime handles multi-turn tool calling, JSON arg conversion, and result formatting. You just write the function.
on_tool_call and on_complete blocks for logging, metrics, or custom logic at each step.
Agents use the same table, stream, and connectors as your data pipelines — no serialization layer needed.
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.
Autonomous AI agent with tool-use. Multi-provider LLM, lifecycle hooks.
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, AI agents, and real-time streaming are all first-class features — not libraries.
ThinkingLanguage is licensed under Apache 2.0.