SYNX

A modern, lightweight data format.
Simple for humans. Optimized for AI. Built for logic.

GitHub npm i @aperturesyndicate/synx-format pip install synx-format

Clean & Simple

Just key, space, value. No quotes, no commas, no braces. Indentation creates hierarchy — 2 spaces per level, always.

Active by Design

Add !active to unlock logic — read env variables, compute values with :calc, inherit blocks with :inherit, localize with :i18n. All built into the format itself.

How It Works

Two stages. Parsing is always fast — the engine only runs when you need it.

.synx file

Your config in plain text — key, space, value

→

Parser

Builds key-value tree, records markers as metadata

→

Engine

Resolves :env :calc :i18n …

only if !active

→

JS Object

Plain data — ready to use in your app

Auto engine switching — Node.js

Pure TypeScript < 5 KB zero startup overhead

Native Rust (NAPI) ≥ 5 KB compiled speed

Token Efficiency

110-key config, GPT-4 tokenizer. Every token costs money when you're talking to an LLM.

JSON

~3 300 chars ~980 tokens

YAML

~2 500 chars ~760 tokens

SYNX ✦

~2 000 chars ~580 tokens

~40% fewer tokens vs same config as JSON (benchmark)

Try It Live

Write SYNX, see JSON instantly. No server — runs entirely in your browser.

Examples

What makes SYNX different?

SYNX goes beyond simple key-value storage. Its syntax eliminates quotes and commas in favor of clean space-separated structures, drastically accelerating both creation and parsing. Its flagship !active mode unlocks programmable configs — read env variables, compute values, localize strings, and validate data — all from within the format itself. For streaming datasets, the companion SYNXL (.synxl) format applies the same syntax record-by-record — a SYNX-native alternative to JSONL and CSV.

Open Guide Page

Performance Benchmarks

Native Rust core with pure TypeScript fallback. Adding markers does not slow down parsing.

Rust core — criterion (110-key config, 2.5 KB)

synx-core parse

~36 µs

synx to JSON

~43.5 µs

Python — 10 000 iterations

json.loads

13 µs

synx_native

46.5 µs

yaml.safe_load

3 698 µs

Node.js — 50 000 iterations

JSON.parse

6 µs

synx-js pure TS

19.99 µs

js-yaml

83 µs

Built Secure by Default

SYNX is a declarative config format — no code execution, no surprises.

No Code Execution

Purely declarative — no eval, no scripts, no dynamic imports. Parsing can never run arbitrary code.

Path Jail

All file references (!include, :watch) are locked to the working directory. ../ traversal is blocked at the parser level.

10 MB File Cap

Input files exceeding 10 MB are rejected immediately — preventing memory exhaustion from oversized configs.

Depth & Include Limits

Nesting capped at 64 levels. Recursive !include depth capped at 10 — circular includes are impossible.

Calc Expression Cap

:calc expressions are limited to 4 096 characters, preventing regex-based denial-of-service attacks.

Audit-Friendly

Plain text, human-readable format. Every config value is visible at a glance — no hidden binary state, no obfuscation.

LLM Benchmark

Suite is in the repo (benchmarks/llm-tests). Results depend on current model versions and your API keys.

Reproducible benchmark suite

Parsing

run it

Generation

run it

Open LLM benchmark suite on GitHub

Built with SYNX

Real projects running on SYNX in production.

Your project could be listed here. If you built something with SYNX, send us a short description at [email protected].