12th.ai

⟨T⟩

Outline Language

Write values, not types.
GCP infers everything.

Outline is a structurally-typed language powered by GCP (Gradual Constraint Propagation). You never declare types — the compiler reverse-engineers all constraints from how you use values, down to field names, higher-order function chains, and deep structural constraints.

🦆

Zero-annotation structural types

No interfaces, no generic parameters. GCP infers the precise entity type from how your functions access fields. Missing fields are caught at compile time; extra fields are silently allowed — true duck typing with iron-clad type safety.

🔀

Backward constraint propagation

GCP is the only practical language that flows constraints backward from call sites to parameter declarations, without explicit generics. Higher-order function combinators, deep nesting — constraints follow the entire chain.

🔁

Covariant Self type

When a method returns this, it always resolves to the concrete receiver type. Subtypes inherit parent methods with the full call chain intact — no F-bounded generics, no Self annotations.

⚡

Unbounded inference depth

Church numerals, generic HOF combinators, deeply nested entities — GCP handles them all. Poly union types, literal types, default field autofill — inference depth has no preset limit.

Example: ADT + Pattern Matching

Example: Backward Constraint Propagation

Open Outline Playground →

⬡

Entitir · Ontology World

One company. One ontology world.
Semantics determined. Inference automatic.

Entitir formalizes enterprise business entities and their relations as an "ontology world" in Outline code. Lazy VirtualSet query semantics, an MCP-style Action registry, and an intent–decision state machine form a three-layer architecture that lets AI make verifiable decisions in a type-safe semantic space.

🗺️

Ontology World

One company = one ontology world. Define Employee, Department, Product and their relations in Outline code. GCP validates structural correctness automatically. Modular by domain — import/export forms the ontology network.

🔍

VirtualSet Queries

Lazy query semantics. employees.filter(…).map(…) does not execute immediately — it accumulates into a QuerySpec and fires a single SQL on terminal operators. Type-safe throughout; field name errors are caught at inference time.

⚙️

Action + Decision

An MCP-style Action registry lets LLMs discover and invoke business functions. The Decision system implements an intent → decided → executed state machine with explicit Trigger expressions — every AI action is traceable, auditable, and hallucination-free.

World Outline Definition

VirtualSet Query

Open Entitir Playground →

Py⟨T⟩

Meridian · Python Type Inference

Write Python. Skip the annotations.
GCP infers. mypyc compiles. 2–8× faster.

Meridian brings GCP's demand-driven type inference to Python. Feed it your untyped functions; give it a usage context that calls them with real arguments. GCP propagates concrete types backward through the entire call chain, producing mypyc-ready annotations that let the compiler turn Python into a native C extension — no manual work, no hallucinations, no type stubs to maintain.

🔍

Zero-annotation inference

Just write Python the way you always do — no type hints, no decorators. GCP parses the AST and applies the same backward constraint propagation it uses for Outline: each call site pins the parameter types; each arithmetic operation pins the return type.

🔁

Demand-driven propagation

Provide a two-liner usage context — the concrete argument types (list[float], dict[str, int], int) propagate backward into every unannotated parameter. list[list[float]], dict[K, V], Iterator[T] — all resolved automatically, with no explicit generic annotations.

⚡

mypyc native compilation

GCP-annotated code feeds directly into mypyc, which compiles Python to native C extensions — the same technology that accelerates mypy's own type checker. Generators get Iterator[T], dicts get dict[K, V], and compute-intensive loops run 2–8× faster than CPython.

Before: untyped Python (you write this)

After: GCP-annotated (auto-generated)

Open GCP-Python Playground →

Write values, not types.GCP infers everything.

One company. One ontology world.Semantics determined. Inference automatic.

Write Python. Skip the annotations. GCP infers. mypyc compiles. 2–8× faster.

Online Playground

Write values, not types.
GCP infers everything.

One company. One ontology world.
Semantics determined. Inference automatic.

Write Python. Skip the annotations.
GCP infers. mypyc compiles. 2–8× faster.