DTL, Domain Transport Language

DTL is AlifZetta's native configuration and data-transport format, a JSON successor with 10 typed primitives, indent-based structure, and sub-microsecond parsing. It replaces JSON, YAML, and XML across the AlifZetta platform.

Human-first syntax. Machine-precise types. Rust reference implementation. Dual-licensed MIT / Apache 2.0.

By Padam Sundar Kafle · Founder & Chief Engineer, AlifZetta · Kathmandu, Nepal · Last updated September 16, 2026

Why not just use JSON, YAML, or TOML?

Configuration and data-transport formats set the ceiling on how readable a system can be. JSON, YAML, and TOML each get parts of that right, and each carries decades of accumulated ceremony that a modern format can shed. DTL is what happens when a data format is designed from the ground up for both human eyes and machine precision, in 2024 rather than 2001.

DTL vs JSON

JSON is universal, but it was designed for JavaScript object literals, not humans typing configs. It has no comments (a decision the format's inventor publicly regrets), no typed sizes or durations, and forces you to quote every key and comma-separate every field. The result is visual noise that adds nothing.

DTL vs YAML

YAML fixed some of JSON's readability problems and introduced entire new ones. Indentation is significant, but so is the distinction between null, nil, ~, and blank, three of which parse differently in different implementations. The Norway problem (NO parsing as false) is still real. DTL uses one clear rule: @key value with two-space indent, and typed primitives inferred from value shape rather than declared.

DTL vs TOML

TOML is clean for flat configs but visibly strains at nested data, deep structures require bracket-heavy table paths like [server.tls.certificates]. DTL's indent-based blocks feel natural at any depth and read top-to-bottom in the same shape they were written.

DTL vs JSON, side by side

The same service definition, expressed in DTL and in JSON. Count the characters that carry no meaning, the braces, the quotes, the commas, the trailing whitespace fights.

@server AlifZetta API
  @host 0.0.0.0
  @port 3000
  @workers 8
  @memory 32GB
  @timeout 30s
  @tls enabled

{
  "server": {
    "_header": "AlifZetta API",
    "host": "0.0.0.0",
    "port": 3000,
    "workers": 8,
    "memory": "32GB",
    "timeout": "30s",
    "tls": "enabled"
  }
}

DTL: 104 bytes. JSON: 190 bytes. A 45% reduction, before you count the readability. And JSON lost the typed memory and timeout along the way.

Syntax at a glance

Every DTL value is one of ten types. Type is inferred from the shape of the value, no annotations, no schemas required. The parser recognises each pattern deterministically, so @port 3000 is always an integer, @ram 8GB is always a size, and @active true is always a boolean.

The 10 types

Multi-line text (heredoc)

End the key line with a bare |, then indent continuation lines. Newlines are preserved literally; the parser strips the common leading indent.

@readme |
  Welcome to AlifZetta.
  This paragraph is preserved
  with all newlines and indentation
  relative to the opening indent.

Comments

Any line starting with # is a comment. Inline comments (trailing the value on the same line) are reserved for a future minor release and currently parse as string content.

Rules on one page

• KeysEvery line starts with @key. No exceptions.
• BlocksTwo-space indentation nests. No braces.
• CommentsAny line starting with # is skipped.
• StringsEverything after the key is the value. No quotes needed.
• ListsSpace-separated numbers become a list automatically.
• Multi-lineEnd the key line with |, indent continuation.
• BooleansSix spellings, true false yes no enabled disabled.
• UnitsNumbers with GB, MB, s, ms are typed values, not strings.

Try DTL live

Type or paste DTL on the left, press Parse, and see the parsed JSON on the right. The Parse button posts to https://axz.si/api/dtl/parse, which runs the actual Rust reference parser server-side, the same one shipped in the dtl-parser crate. A local in-browser fallback also runs live for offline use.

Click Parse to run the DTL reference parser on the AlifZetta server.

The endpoint returns:
  {
    "ok": true,
    "json": { ... parsed document ... },
    "bytes_in": N,
    "bytes_out": M
  }

For local parsing while you type, the in-browser reader also runs as a preview.

Using DTL

DTL ships in three shapes: a Rust crate you embed in your application, a command-line tool for shell workflows, and a public HTTP API for any language that can send a POST request.

1 · Install, pick your runtime

DTL ships across five runtimes today. All four language packages are authored by Padam Sundar Kafle (AlifZetta) and dual-licensed MIT / Apache 2.0. The Rust reference crate is bundled with ZettaOS and awaiting crates.io publication.

2 · Parse from Rust

use dtl::DtlDocument;

let doc = dtl::parse("@name AlifZetta\n@port 3000\n@active true").unwrap();
assert_eq!(doc.get_str("name"), Some("AlifZetta"));
assert_eq!(doc.get_int("port"), Some(3000));
assert_eq!(doc.get_bool("active"), Some(true));

// Nested access via dot-path
let config = dtl::parse(source).unwrap();
config.at_int("server.port");            // Some(3000)
config.at_bool("server.tls.enabled");     // Some(true)

// Typed sizes and durations
doc.root.get_bytes("ram");       // Some(34_359_738_368) for "32GB"
doc.root.get_millis("timeout");  // Some(30_000) for "30s"

3 · Build DTL programmatically

use dtl::DtlBuilder;
use dtl::value::SizeUnit;

let doc = DtlBuilder::new()
    .str("name", "ZettaOS")
    .int("port", 3000)
    .bool("gpu_required", false)
    .size("ram", 8, SizeUnit::GB)
    .block("compute", |b| b
        .int("cores", 6)
        .str("simd", "neon")
        .bool("speculative", true))
    .build();

println!("{}", doc.to_dtl());

4 · The dtl command-line tool

# Everyday commands
dtl parse config.dtl              # Parse and pretty-print
dtl validate config.dtl           # Validate syntax without emitting output
dtl to-json config.dtl            # DTL → JSON on stdout
dtl from-json package.json        # JSON → DTL on stdout
dtl get config.dtl server.port    # Read a value at a dot-path
dtl compare config.dtl            # Show byte-count vs equivalent JSON
dtl info                          # Version, license, capabilities

5 · The public HTTP API

Any language that can send a POST request can parse DTL server-side using https://axz.si/api/dtl/parse. Send {"text": "..."} and get back {"ok": true, "json": {...}}.

# From curl
curl -sS -X POST https://axz.si/api/dtl/parse \
    -H 'Content-Type: application/json' \
    -d '{"text":"@name AlifZetta\n@port 3000\n@active true"}'

# Response
{
  "ok": true,
  "json": { "name": "AlifZetta", "port": 3000, "active": true },
  "bytes_in": 39,
  "bytes_out": 60
}

The DTL specification, condensed

DTL is a text format. Files use the .dtl extension. The recommended MIME type is text/vnd.dtl. Encoding is UTF-8, without a byte-order mark. Line endings are LF or CRLF, both parse identically. Indentation is fixed at two spaces per level.

Grammar (EBNF-style, informative)

Well-formedness rules

1. Every non-blank, non-comment line begins with @ or with whitespace followed by @.
2. The number of leading spaces on any line must be a multiple of two.
3. A child line's indent must be exactly two spaces deeper than its parent's, no skipping levels.
4. Keys within a single block are unique. Duplicate keys are an error, not a silent overwrite.
5. Type is deterministic, the first rule that matches wins. Order: integer, float, boolean, size, duration, list, heredoc, then string as fallback.

Reserved directives (v2.1 roadmap)

Two directives are reserved for the next minor release and will parse as string values in v2.0:

• @include ./other.dtl, inline another DTL document at this point, with circular-include detection.
• @schema path/to/schema.dtl, declare an expected shape; the parser will validate types and required keys against it.

Ecosystem & applications

DTL is production infrastructure. It runs live inside AlifZetta's operating system and behind axz.si's public services. The reference tooling is deliberately small and boring, a well-tested Rust parser, a plain CLI, and a converter round-trippable to JSON. That is the whole surface area.

Where DTL runs today

• AlifZetta ZettaOS, every system configuration file, every vGPU compute descriptor, every service definition speaks DTL natively.
• axz.si predictive substrate, 46+ domain knowledge bases published as DTL documents at axz.si/substrate/. Every entry carries @predicts_next, @leading_indicators, @confidence, @horizon, @evidence.
• AlifZetta blog + docs, front-matter, service manifests, and page metadata across the site all use DTL rather than YAML front-matter.
• zetta-daemon, the AlifZetta system daemon accepts and emits DTL over its HTTP+WebSocket API.

More editor support

VS Code has a first-party extension (DTLAz.dtl-language) with syntax highlighting, validation, and IntelliSense, install it from the Marketplace. Neovim and Sublime Text plugins are on the near-term roadmap; until they ship, YAML syntax highlighting is a serviceable stand-in, the visual shape is close enough that most editors get the colours right by accident.planned

More language bindings

DTL is already shipping in five runtimes (Rust reference, Node.js, .NET, Python, and VS Code). Additional community bindings for Go, Ruby, Elixir, and Swift are welcome. The specification section above is complete enough to implement DTL in an afternoon; the JSON converter is a good first test target.

Contact & contribute

DTL is a small, well-tested format. Feedback, bug reports, and language-binding contributions are welcome. If you want a DTL parser in your favourite language, the specification section on this page is complete enough to implement one in an afternoon.