T2S Text2System
Text Defined Systems Engineering

Software has source code. Why doesn’t it have schematics?

Text2System is an open, human-readable language for defining software and embedded systems. Architecture, contracts, requirements, packaging, deployment, documentation, and projections live in one canonical plain-text source.

Text2System brings software engineering the equivalent of electrical schematics: one canonical, human-readable system definition from which documentation, diagrams, validation, and implementation artifacts are projected.

Read the specification Quick start Project roadmap

T2S defines what a system is.

Programming languages define how it behaves.

system.t2s
Example System

  system:
    id: ExampleSystem

  module:
    id: Core

  interface:
    id: Service

  function:
    id: process
Strict by design

One source. Two readable layers. Many projectors.

T2S combines human-oriented narrative with machine-readable semantics, while keeping target languages and renderers outside the canonical system definition.

Narrative

Readable by engineers

Architecture rationale, design intent, explanations, requirements context, and documentation remain ordinary readable text.

Semantics

Deterministic system definition

Systems, modules, interfaces, functions, types, relationships, tests, packages, and deployments are declared explicitly.

Projectors

Artifacts without redefining the system

Documentation, diagrams, Rust, Zig, Python, C ABI, validation reports, and other outputs are projections of one model.

Processing model

From plain text to system artifacts.

The canonical model sits between source syntax and target-specific output.

01T2S Source
02Narrative + Source AST
03Semantic Builder
04Canonical System Model
05Projector
06Artifacts
What T2S defines

System structure and contracts

  • Systems and modules
  • Interfaces and functions
  • Portable data types
  • Error contracts
  • Requirements and tests
  • Relationships
  • Packages
  • Deployments
What T2S does not replace

Algorithms stay in real languages

  • Not UML
  • Not traditional MBSE
  • Not a programming language
  • Not a visual editor
  • Not a hidden binary model
  • Not implementation intelligence
Quick start

Initialize. Define. Project.

The current Rust bootstrap includes the T2D narrative parser, T2S Semantic Builder, documentation projector, deterministic HTML output, and regression testing against the official specification.

terminal
# create a project
text2system-cli init my_project

# build documentation
text2system-cli project documentation my_project

# validate the current implementation
cargo test --workspace
cargo clippy --workspace --all-targets -- -D warnings
Project status

A specification-first open toolchain.

The project is deliberately built in small, testable compiler stages.

✓ T2S 1.0 language specification complete draft
✓ Rust parser and Semantic Builder working
✓ Documentation projector working
✓ HTML rendering and regression pipeline working
→ Canonical model validation next
○ Rust, Zig, Python, and C ABI projectors planned
○ Public source repository coming soon
Open specification

Language knowledge belongs to everyone.

The T2S language specification is dedicated to the public domain under CC0-1.0.

Open tools

Minimal permission. Maximum reuse.

The reference tools are released under the 0BSD license.

The missing schematic language for software engineering.

Text2System treats text as the canonical system definition. Documentation and implementation artifacts stay synchronized because they are projected from the same source.

Read the specification Contact the project