TML: A Programming Language Designed for the AI Era

TML (Templated Meta Language) is a programming language tailored for large language models (LLMs) to enable deterministic code generation and analysis. It addresses key pain points in AI-assisted coding, such as parsing ambiguity, refactoring fragility, and vague semantic contracts. Core features include:

• Deterministic parsing to eliminate ambiguity
• Stable semantic identifiers for reliable refactoring
• Formal contracts for clear semantic boundaries
• Built-in MCP server for native AI-compiler interaction
• All-in-one toolchain (one binary, zero external dependencies)
• Embedded LLVM/LLD for efficient compilation
• Hybrid document retrieval (BM25 + HNSW) for fast info access

This thread will dive into TML's design, features, and significance.

Traditional programming languages (like C, Java, Python) were designed for human developers, not LLMs. They pose three key challenges for AI-assisted coding:

1. Parsing Ambiguity: Many languages have syntax with multiple valid interpretations. Humans use context to resolve ambiguity, but LLMs struggle, leading to unreliable code generation.

2. Refactoring Fragility: Text-based identifiers make renaming or moving code risky—LLMs may accidentally modify unrelated strings or comments.

3. Contract Vagueness: Type systems, preconditions, and postconditions are often scattered and lack formal expression, making it hard for LLMs to understand code intent.

TML was built to solve these issues, providing a solid foundation for AI-assisted development.

TML's design revolves around three core principles:

Deterministic Parsing

TML's syntax is designed to have exactly one valid parse for any code snippet. It avoids issues like the 'dangling else' problem and ambiguous operator precedence, ensuring LLMs generate predictable, syntactically correct code.

Stable Semantic Identifiers

Each code entity (function, variable, type) gets a stable, semantic-based ID that remains unchanged during refactoring (renaming, moving files). This allows LLMs to refactor safely without text replacement side effects.

Formal Contracts

TML requires (or encourages) formal contracts (preconditions, postconditions, invariants) written in its built-in contract language. These contracts are compiler-checked and LLM-understandable, helping AI grasp code intent and constraints.

TML integrates a Model Context Protocol (MCP) server directly into its compiler. MCP is an open protocol for AI tools to communicate with external systems. Compatible AI assistants (Claude, GPT) can interact with TML via JSON-RPC 2.0 to perform:

• Compile, run, or type-check code
• Generate LLVM IR for analysis
• Run tests (with coverage/performance)
• Format, lint, or search docs

This native integration eliminates the need for shell commands or text parsing, giving AI access to structured compiler outputs and diagnostics—just like human developers.

TML packs all development tools into a single binary, removing the need for external tools. Here's a comparison with traditional setups:

Feature	Traditional方案	TML方案
Compilation	gcc/clang + ld/lld	Built-in LLVM + LLD (in-process)
Testing	gtest/pytest	@test decorator + DLL runner
Coverage	gcov/tarpaulin	--coverage flag
Benchmarking	criterion/hyperfine	@bench decorator + baseline compare
Fuzz Testing	AFL/libFuzzer	@fuzz decorator + corpus management
Formatting	rustfmt/gofmt	tml fmt
Linting	clippy/golint	tml lint (style + semantic)
Documentation	rustdoc/godoc	tml doc (JSON/HTML/Markdown)
Performance Profiling	perf/valgrind	--profile (Chrome DevTools format)
Package Management	cargo/npm	tml deps / tml add
AI Integration	None/LSP workarounds	Native MCP server

This simplifies setup—just download the TML binary to start coding.

TML doesn't rely on external compilers/linkers. It embeds ~55 LLVM static libraries and the LLD linker into its binary. The compilation process is fully in-process:

Lexical Analysis → Syntax Analysis → Type Check → Borrow Check → LLVM IR Generation → Optimization → Linking

Benefits:

1. Faster compilation (no inter-process overhead)
2. Better error reporting (full control over diagnostics)
3. Easier integration (AI tools can link directly to TML's library)
4. Consistent cross-platform experience

This ensures efficient and reliable code compilation.

TML's document system uses hybrid retrieval to quickly find relevant info:

• BM25: Lexical scoring for keyword matching
• HNSW: Semantic vector search for context-aware results

Results are merged via Reciprocal Rank Fusion, with query expansion (65+ TML synonyms), MMR diversification, and multi-signal ranking. The index is cached to disk, enabling sub-10ms queries on 6000+ docs—critical for AI assistants to quickly access documentation while coding.

TML marks a shift in programming language design—prioritizing both human and AI usability. Its impact includes:

• More reliable AI code generation (no parsing ambiguity)
• Safer refactoring (stable semantic IDs)
• Better code understanding (formal contracts)
• Simplified development (one binary toolchain)

While still in early stages, TML's design shows great potential. As LLMs become more integral to coding, we may see more AI-native languages like TML—bridging humans and AI for efficient, low-misunderstanding collaboration in software development.