Python made data accessible. TL makes it fast, safe, and intelligent — in one compiled language. 1,322 tests passing across 34 implementation phases — AI agents with tool-use, full MCP ecosystem (client + server), generics, pattern matching, Python FFI, LLVM & WASM backends, package manager, full LSP, and a comprehensive security audit 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.
run_agent(agent, message, history) maintains context across multi-turn sessions. No external memory store needed.
stream_agent() delivers real-time token-by-token output via Server-Sent Events.
Automatic exponential backoff on 429/5xx errors. output_format: "json" for guaranteed structured output.
Model Context Protocol — the open standard that lets AI tools and data systems talk to each other. TL implements both sides: connect to any MCP server as a client, or expose TL functions to any AI tool as a server.
// Connect to any MCP server let github = mcp_connect("github-server") // Discover available tools let tools = mcp_list_tools(github) // Call any tool directly let issues = mcp_call_tool(github, "list_issues", { repo: "myorg/myrepo" }) // Read resources from server let schema = mcp_read_resource(github, "repo://myorg/myrepo/schema") // Get prompt templates let prompt = mcp_get_prompt(github, "summarize_pr", { pr: "42" }) mcp_disconnect(github)
// Expose TL functions as MCP tools fn query_sales(region, quarter) { postgres("warehouse", "sales") |> filter(region == region) |> filter(q == quarter) } fn run_report(name) { read_csv("reports/" + name + ".csv") |> aggregate(sum(revenue)) } // Start the MCP server mcp_serve() // Claude Desktop, Cursor, Windsurf etc. // can now discover & call these functions // Config: { "command": "tl run server.tl" }
mcp_connect() auto-detects stdio or HTTP transport. 10 builtins for tools, resources, prompts, and ping.
mcp_serve() turns TL functions into MCP tools. Claude Desktop, Cursor, Windsurf can discover and call them.
mcp_servers: [...] in agent definitions. LLM sees one unified tool list — MCP and native tools dispatched transparently.
MCP servers can request LLM completions back through TL. Bidirectional AI communication over the protocol.
// Connect to multiple MCP servers let github = mcp_connect("github-server") let db = mcp_connect("database-server") // Agent auto-discovers tools from all MCP servers agent ops_bot { model: "claude-sonnet-4-20250514", system: "You are a DevOps assistant.", mcp_servers: [github, db], tools { // Native TL tools alongside MCP tools deploy: { description: "Deploy to production", parameters: { type: "object", properties: { service: { type: "string" } } } } } } // LLM sees unified tool list: GitHub + DB + native let result = run_agent(ops_bot, "Check open PRs, verify staging DB, then deploy")
TL agents gain access to the entire MCP ecosystem — filesystem, GitHub, databases, Slack, and hundreds more — without building each integration natively. Any AI tool gains access to TL's data engine via MCP server. Connect or serve. Your choice.
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, MCP server integration, and 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.
19 connectors shipped — more coming with every 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, document symbols, rename refactoring, and find-references across files.
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 debug — breakpoints, variable inspection, source listing, and stack traces. Debug pipelines interactively.
tl inspect, tl profile, tl lineage — preview data, statistical profiles, and lineage graphs.
Rich standard library methods, native DateTime, window functions, and data engineering primitives — all built in.
First-class VmValue::DateTime type with full arithmetic.
DataFusion UDWF-backed analytics on tables.
Pipeline-native data manipulation.
Full Model Context Protocol client + server.
The only language where data pipelines, SQL-like queries, ML training, AI agents, MCP ecosystem, and real-time streaming are all first-class features — not libraries.
ThinkingLanguage is licensed under Apache 2.0.