@toon-format/toon
Advanced tools
Token-Oriented Object Notation (TOON) – Compact, human-readable, schema-aware encoding of JSON for LLM prompts
Token-Oriented Object Notation is a compact, human-readable encoding of the JSON data model that minimizes tokens and makes structure easy for models to follow. It's intended for LLM input as a drop-in, lossless representation of your existing JSON.
TOON combines YAML's indentation-based structure for nested objects with a CSV-style tabular layout for uniform arrays. TOON's sweet spot is uniform arrays of objects (multiple fields per row, same structure across items), achieving CSV-like compactness while adding explicit structure that helps LLMs parse and validate data reliably. For deeply nested or non-uniform data, JSON may be more efficient.
The similarity to CSV is intentional: CSV is simple and ubiquitous, and TOON aims to keep that familiarity while remaining a lossless, drop-in representation of JSON for Large Language Models.
Think of it as a translation layer: use JSON programmatically, and encode it as TOON for LLM input.
[!TIP] The TOON format is stable, but also an idea in progress. Nothing's set in stone – help shape where it goes by contributing to the spec or sharing feedback.
AI is becoming cheaper and more accessible, but larger context windows allow for larger data inputs as well. LLM tokens still cost money – and standard JSON is verbose and token-expensive:
{
"context": {
"task": "Our favorite hikes together",
"location": "Boulder",
"season": "spring_2025"
},
"friends": ["ana", "luis", "sam"],
"hikes": [
{
"id": 1,
"name": "Blue Lake Trail",
"distanceKm": 7.5,
"elevationGain": 320,
"companion": "ana",
"wasSunny": true
},
{
"id": 2,
"name": "Ridge Overlook",
"distanceKm": 9.2,
"elevationGain": 540,
"companion": "luis",
"wasSunny": false
},
{
"id": 3,
"name": "Wildflower Loop",
"distanceKm": 5.1,
"elevationGain": 180,
"companion": "sam",
"wasSunny": true
}
]
}
context:
task: Our favorite hikes together
location: Boulder
season: spring_2025
friends:
- ana
- luis
- sam
hikes:
- id: 1
name: Blue Lake Trail
distanceKm: 7.5
elevationGain: 320
companion: ana
wasSunny: true
- id: 2
name: Ridge Overlook
distanceKm: 9.2
elevationGain: 540
companion: luis
wasSunny: false
- id: 3
name: Wildflower Loop
distanceKm: 5.1
elevationGain: 180
companion: sam
wasSunny: true
TOON conveys the same information with even fewer tokens – combining YAML-like indentation with CSV-style tabular arrays:
context:
task: Our favorite hikes together
location: Boulder
season: spring_2025
friends[3]: ana,luis,sam
hikes[3]{id,name,distanceKm,elevationGain,companion,wasSunny}:
1,Blue Lake Trail,7.5,320,ana,true
2,Ridge Overlook,9.2,540,luis,false
3,Wildflower Loop,5.1,180,sam,true
By convention, TOON files use the .toon extension and the provisional media type text/toon for HTTP and content-type–aware contexts. TOON documents are always UTF-8 encoded; the charset=utf-8 parameter may be specified but defaults to UTF-8 when omitted. See SPEC.md §18.2 for normative details.
TOON excels with uniform arrays of objects, but there are cases where other formats are better:
See benchmarks for concrete comparisons across different data structures.
Benchmarks are organized into two tracks to ensure fair comparisons:
Benchmarks test LLM comprehension across different input formats using 209 data retrieval questions on 4 models.
| Dataset | Rows | Structure | CSV Support | Eligibility |
|---|---|---|---|---|
| Uniform employee records | 100 | uniform | ✓ | 100% |
| E-commerce orders with nested structures | 50 | nested | ✗ | 33% |
| Time-series analytics data | 60 | uniform | ✓ | 100% |
| Top 100 GitHub repositories | 100 | uniform | ✓ | 100% |
| Semi-uniform event logs | 75 | semi-uniform | ✗ | 50% |
| Deeply nested configuration | 11 | deep | ✗ | 0% |
| Valid complete dataset (control) | 20 | uniform | ✓ | 100% |
| Array truncated: 3 rows removed from end | 17 | uniform | ✓ | 100% |
| Extra rows added beyond declared length | 23 | uniform | ✓ | 100% |
| Inconsistent field count (missing salary in row 10) | 20 | uniform | ✓ | 100% |
| Missing required fields (no email in multiple rows) | 20 | uniform | ✓ | 100% |
Structure classes:
CSV Support: ✓ (supported), ✗ (not supported – would require lossy flattening)
Eligibility: Percentage of arrays that qualify for TOON's tabular format (uniform objects with primitive values)
Each format's overall performance, balancing accuracy against token cost:
TOON ████████████████████ 26.9 │ 73.9% acc │ 2,744 tokens
JSON compact █████████████████░░░ 22.9 │ 70.7% acc │ 3,081 tokens
YAML ██████████████░░░░░░ 18.6 │ 69.0% acc │ 3,719 tokens
JSON ███████████░░░░░░░░░ 15.3 │ 69.7% acc │ 4,545 tokens
XML ██████████░░░░░░░░░░ 13.0 │ 67.1% acc │ 5,167 tokens
TOON achieves 73.9% accuracy (vs JSON's 69.7%) while using 39.6% fewer tokens.
Note on CSV: Excluded from ranking as it only supports 109 of 209 questions (flat tabular data only). While CSV is highly token-efficient for simple tabular data, it cannot represent nested structures that other formats handle.
Accuracy across 4 LLMs on 209 data retrieval questions:
claude-haiku-4-5-20251001
→ TOON ████████████░░░░░░░░ 59.8% (125/209)
JSON ███████████░░░░░░░░░ 57.4% (120/209)
YAML ███████████░░░░░░░░░ 56.0% (117/209)
XML ███████████░░░░░░░░░ 55.5% (116/209)
JSON compact ███████████░░░░░░░░░ 55.0% (115/209)
CSV ██████████░░░░░░░░░░ 50.5% (55/109)
gemini-2.5-flash
→ TOON ██████████████████░░ 87.6% (183/209)
CSV █████████████████░░░ 86.2% (94/109)
JSON compact ████████████████░░░░ 82.3% (172/209)
YAML ████████████████░░░░ 79.4% (166/209)
XML ████████████████░░░░ 79.4% (166/209)
JSON ███████████████░░░░░ 77.0% (161/209)
gpt-5-nano
→ TOON ██████████████████░░ 90.9% (190/209)
JSON compact ██████████████████░░ 90.9% (190/209)
JSON ██████████████████░░ 89.0% (186/209)
CSV ██████████████████░░ 89.0% (97/109)
YAML █████████████████░░░ 87.1% (182/209)
XML ████████████████░░░░ 80.9% (169/209)
grok-4-fast-non-reasoning
→ TOON ███████████░░░░░░░░░ 57.4% (120/209)
JSON ███████████░░░░░░░░░ 55.5% (116/209)
JSON compact ███████████░░░░░░░░░ 54.5% (114/209)
YAML ███████████░░░░░░░░░ 53.6% (112/209)
XML ███████████░░░░░░░░░ 52.6% (110/209)
CSV ██████████░░░░░░░░░░ 52.3% (57/109)
[!TIP] Results Summary TOON achieves 73.9% accuracy (vs JSON's 69.7%) while using 39.6% fewer tokens on these datasets.
| Question Type | TOON | JSON compact | JSON | CSV | YAML | XML |
|---|---|---|---|---|---|---|
| Field Retrieval | 99.6% | 99.3% | 99.3% | 100.0% | 98.2% | 98.9% |
| Aggregation | 54.4% | 47.2% | 48.8% | 44.0% | 47.6% | 41.3% |
| Filtering | 56.3% | 57.3% | 50.5% | 49.1% | 51.0% | 47.9% |
| Structure Awareness | 88.0% | 83.0% | 83.0% | 85.9% | 80.0% | 80.0% |
| Structural Validation | 70.0% | 45.0% | 50.0% | 80.0% | 60.0% | 80.0% |
| Format | Accuracy | Tokens | Correct/Total |
|---|---|---|---|
csv | 72.0% | 2,352 | 118/164 |
toon | 73.8% | 2,518 | 121/164 |
json-compact | 69.5% | 3,953 | 114/164 |
yaml | 68.3% | 4,982 | 112/164 |
json-pretty | 68.3% | 6,360 | 112/164 |
xml | 69.5% | 7,324 | 114/164 |
| Format | Accuracy | Tokens | Correct/Total |
|---|---|---|---|
toon | 81.1% | 7,232 | 133/164 |
json-compact | 76.8% | 6,794 | 126/164 |
yaml | 75.6% | 8,347 | 124/164 |
json-pretty | 76.2% | 10,713 | 125/164 |
xml | 74.4% | 12,023 | 122/164 |
| Format | Accuracy | Tokens | Correct/Total |
|---|---|---|---|
csv | 73.3% | 1,406 | 88/120 |
toon | 72.5% | 1,548 | 87/120 |
json-compact | 71.7% | 2,349 | 86/120 |
yaml | 71.7% | 2,949 | 86/120 |
json-pretty | 68.3% | 3,676 | 82/120 |
xml | 68.3% | 4,384 | 82/120 |
| Format | Accuracy | Tokens | Correct/Total |
|---|---|---|---|
toon | 62.9% | 8,779 | 83/132 |
csv | 61.4% | 8,527 | 81/132 |
yaml | 59.8% | 13,141 | 79/132 |
json-compact | 55.3% | 11,464 | 73/132 |
json-pretty | 56.1% | 15,157 | 74/132 |
xml | 48.5% | 17,105 | 64/132 |
| Format | Accuracy | Tokens | Correct/Total |
|---|---|---|---|
json-compact | 63.3% | 4,819 | 76/120 |
toon | 57.5% | 5,799 | 69/120 |
json-pretty | 59.2% | 6,797 | 71/120 |
yaml | 48.3% | 5,827 | 58/120 |
xml | 46.7% | 7,709 | 56/120 |
| Format | Accuracy | Tokens | Correct/Total |
|---|---|---|---|
json-compact | 92.2% | 574 | 107/116 |
toon | 95.7% | 666 | 111/116 |
yaml | 91.4% | 686 | 106/116 |
json-pretty | 94.0% | 932 | 109/116 |
xml | 92.2% | 1,018 | 107/116 |
| Format | Accuracy | Tokens | Correct/Total |
|---|---|---|---|
toon | 100.0% | 544 | 4/4 |
json-compact | 100.0% | 795 | 4/4 |
yaml | 100.0% | 1,003 | 4/4 |
json-pretty | 100.0% | 1,282 | 4/4 |
csv | 25.0% | 492 | 1/4 |
xml | 0.0% | 1,467 | 0/4 |
| Format | Accuracy | Tokens | Correct/Total |
|---|---|---|---|
csv | 100.0% | 425 | 4/4 |
xml | 100.0% | 1,251 | 4/4 |
toon | 0.0% | 474 | 0/4 |
json-compact | 0.0% | 681 | 0/4 |
json-pretty | 0.0% | 1,096 | 0/4 |
yaml | 0.0% | 859 | 0/4 |
| Format | Accuracy | Tokens | Correct/Total |
|---|---|---|---|
csv | 100.0% | 566 | 4/4 |
toon | 75.0% | 621 | 3/4 |
xml | 100.0% | 1,692 | 4/4 |
yaml | 75.0% | 1,157 | 3/4 |
json-compact | 50.0% | 917 | 2/4 |
json-pretty | 50.0% | 1,476 | 2/4 |
| Format | Accuracy | Tokens | Correct/Total |
|---|---|---|---|
csv | 75.0% | 489 | 3/4 |
yaml | 100.0% | 996 | 4/4 |
toon | 100.0% | 1,019 | 4/4 |
json-compact | 75.0% | 790 | 3/4 |
xml | 100.0% | 1,458 | 4/4 |
json-pretty | 75.0% | 1,274 | 3/4 |
| Format | Accuracy | Tokens | Correct/Total |
|---|---|---|---|
csv | 100.0% | 329 | 4/4 |
xml | 100.0% | 1,411 | 4/4 |
toon | 75.0% | 983 | 3/4 |
yaml | 25.0% | 960 | 1/4 |
json-pretty | 25.0% | 1,230 | 1/4 |
json-compact | 0.0% | 755 | 0/4 |
| Format | Accuracy | Correct/Total |
|---|---|---|
toon | 59.8% | 125/209 |
json-pretty | 57.4% | 120/209 |
yaml | 56.0% | 117/209 |
xml | 55.5% | 116/209 |
json-compact | 55.0% | 115/209 |
csv | 50.5% | 55/109 |
| Format | Accuracy | Correct/Total |
|---|---|---|
toon | 87.6% | 183/209 |
csv | 86.2% | 94/109 |
json-compact | 82.3% | 172/209 |
yaml | 79.4% | 166/209 |
xml | 79.4% | 166/209 |
json-pretty | 77.0% | 161/209 |
| Format | Accuracy | Correct/Total |
|---|---|---|
toon | 90.9% | 190/209 |
json-compact | 90.9% | 190/209 |
json-pretty | 89.0% | 186/209 |
csv | 89.0% | 97/109 |
yaml | 87.1% | 182/209 |
xml | 80.9% | 169/209 |
| Format | Accuracy | Correct/Total |
|---|---|---|
toon | 57.4% | 120/209 |
json-pretty | 55.5% | 116/209 |
json-compact | 54.5% | 114/209 |
yaml | 53.6% | 112/209 |
xml | 52.6% | 110/209 |
csv | 52.3% | 57/109 |
This benchmark tests LLM comprehension and data retrieval accuracy across different input formats. Each LLM receives formatted data and must answer questions about it. This does not test the model's ability to generate TOON output – only to read and understand it.
Eleven datasets designed to test different structural patterns and validation capabilities:
Primary datasets:
Structural validation datasets:
[N] length detection)209 questions are generated dynamically across five categories:
Field retrieval (33%): Direct value lookups or values that can be read straight off a record (including booleans and simple counts such as array lengths)
750003John DoeAggregation (30%): Dataset-level totals and averages plus single-condition filters (counts, sums, min/max comparisons)
1745123.5023Filtering (23%): Multi-condition queries requiring compound logic (AND constraints across fields)
58Structure awareness (12%): Tests format-native structural affordances (TOON's [N] count and {fields}, CSV's header row)
100id, name, email, department, salary, yearsExperience, activeSalesStructural validation (2%): Tests ability to detect incomplete, truncated, or corrupted data using structural metadata
YES (control dataset) or NO (corrupted datasets)[N] length validation and {fields} consistency checking50000 = $50,000, Engineering = engineering, 2025-01-01 = January 1, 2025) without requiring an LLM judge.claude-haiku-4-5-20251001, gemini-2.5-flash, gpt-5-nano, grok-4-fast-non-reasoninggpt-tokenizer with o200k_base encoding (GPT-5 tokenizer)Token counts are measured using the GPT-5 o200k_base tokenizer via gpt-tokenizer. Savings are calculated against formatted JSON (2-space indentation) as the primary baseline, with additional comparisons to compact JSON (minified), YAML, and XML. Actual savings vary by model and tokenizer.
The benchmarks test datasets across different structural patterns (uniform, semi-uniform, nested, deeply nested) to show where TOON excels and where other formats may be better.
Datasets with nested or semi-uniform structures. CSV excluded as it cannot properly represent these structures.
🛒 E-commerce orders with nested structures ┊ Tabular: 33%
│
TOON █████████████░░░░░░░ 72,771 tokens
├─ vs JSON (−33.1%) 108,806 tokens
├─ vs JSON compact (+5.5%) 68,975 tokens
├─ vs YAML (−14.2%) 84,780 tokens
└─ vs XML (−40.5%) 122,406 tokens
🧾 Semi-uniform event logs ┊ Tabular: 50%
│
TOON █████████████████░░░ 153,211 tokens
├─ vs JSON (−15.0%) 180,176 tokens
├─ vs JSON compact (+19.9%) 127,731 tokens
├─ vs YAML (−0.8%) 154,505 tokens
└─ vs XML (−25.2%) 204,777 tokens
🧩 Deeply nested configuration ┊ Tabular: 0%
│
TOON ██████████████░░░░░░ 631 tokens
├─ vs JSON (−31.3%) 919 tokens
├─ vs JSON compact (+11.9%) 564 tokens
├─ vs YAML (−6.2%) 673 tokens
└─ vs XML (−37.4%) 1,008 tokens
──────────────────────────────────── Total ────────────────────────────────────
TOON ████████████████░░░░ 226,613 tokens
├─ vs JSON (−21.8%) 289,901 tokens
├─ vs JSON compact (+14.9%) 197,270 tokens
├─ vs YAML (−5.6%) 239,958 tokens
└─ vs XML (−31.0%) 328,191 tokens
Datasets with flat tabular structures where CSV is applicable.
👥 Uniform employee records ┊ Tabular: 100%
│
CSV ███████████████████░ 46,954 tokens
TOON ████████████████████ 49,831 tokens (+6.1% vs CSV)
├─ vs JSON (−60.7%) 126,860 tokens
├─ vs JSON compact (−36.8%) 78,856 tokens
├─ vs YAML (−50.0%) 99,706 tokens
└─ vs XML (−66.0%) 146,444 tokens
📈 Time-series analytics data ┊ Tabular: 100%
│
CSV ██████████████████░░ 8,388 tokens
TOON ████████████████████ 9,120 tokens (+8.7% vs CSV)
├─ vs JSON (−59.0%) 22,250 tokens
├─ vs JSON compact (−35.8%) 14,216 tokens
├─ vs YAML (−48.9%) 17,863 tokens
└─ vs XML (−65.7%) 26,621 tokens
⭐ Top 100 GitHub repositories ┊ Tabular: 100%
│
CSV ███████████████████░ 8,513 tokens
TOON ████████████████████ 8,745 tokens (+2.7% vs CSV)
├─ vs JSON (−42.3%) 15,145 tokens
├─ vs JSON compact (−23.7%) 11,455 tokens
├─ vs YAML (−33.4%) 13,129 tokens
└─ vs XML (−48.8%) 17,095 tokens
──────────────────────────────────── Total ────────────────────────────────────
CSV ███████████████████░ 63,855 tokens
TOON ████████████████████ 67,696 tokens (+6.0% vs CSV)
├─ vs JSON (−58.8%) 164,255 tokens
├─ vs JSON compact (−35.2%) 104,527 tokens
├─ vs YAML (−48.2%) 130,698 tokens
└─ vs XML (−64.4%) 190,160 tokens
Savings: 13,130 tokens (59.0% reduction vs JSON)
JSON (22,250 tokens):
{
"metrics": [
{
"date": "2025-01-01",
"views": 5715,
"clicks": 211,
"conversions": 28,
"revenue": 7976.46,
"bounceRate": 0.47
},
{
"date": "2025-01-02",
"views": 7103,
"clicks": 393,
"conversions": 28,
"revenue": 8360.53,
"bounceRate": 0.32
},
{
"date": "2025-01-03",
"views": 7248,
"clicks": 378,
"conversions": 24,
"revenue": 3212.57,
"bounceRate": 0.5
},
{
"date": "2025-01-04",
"views": 2927,
"clicks": 77,
"conversions": 11,
"revenue": 1211.69,
"bounceRate": 0.62
},
{
"date": "2025-01-05",
"views": 3530,
"clicks": 82,
"conversions": 8,
"revenue": 462.77,
"bounceRate": 0.56
}
]
}
TOON (9,120 tokens):
metrics[5]{date,views,clicks,conversions,revenue,bounceRate}:
2025-01-01,5715,211,28,7976.46,0.47
2025-01-02,7103,393,28,8360.53,0.32
2025-01-03,7248,378,24,3212.57,0.5
2025-01-04,2927,77,11,1211.69,0.62
2025-01-05,3530,82,8,462.77,0.56
Savings: 6,400 tokens (42.3% reduction vs JSON)
JSON (15,145 tokens):
{
"repositories": [
{
"id": 28457823,
"name": "freeCodeCamp",
"repo": "freeCodeCamp/freeCodeCamp",
"description": "freeCodeCamp.org's open-source codebase and curriculum. Learn math, programming,…",
"createdAt": "2014-12-24T17:49:19Z",
"updatedAt": "2025-10-28T11:58:08Z",
"pushedAt": "2025-10-28T10:17:16Z",
"stars": 430886,
"watchers": 8583,
"forks": 42146,
"defaultBranch": "main"
},
{
"id": 132750724,
"name": "build-your-own-x",
"repo": "codecrafters-io/build-your-own-x",
"description": "Master programming by recreating your favorite technologies from scratch.",
"createdAt": "2018-05-09T12:03:18Z",
"updatedAt": "2025-10-28T12:37:11Z",
"pushedAt": "2025-10-10T18:45:01Z",
"stars": 430877,
"watchers": 6332,
"forks": 40453,
"defaultBranch": "master"
},
{
"id": 21737465,
"name": "awesome",
"repo": "sindresorhus/awesome",
"description": "😎 Awesome lists about all kinds of interesting topics",
"createdAt": "2014-07-11T13:42:37Z",
"updatedAt": "2025-10-28T12:40:21Z",
"pushedAt": "2025-10-27T17:57:31Z",
"stars": 410052,
"watchers": 8017,
"forks": 32029,
"defaultBranch": "main"
}
]
}
TOON (8,745 tokens):
repositories[3]{id,name,repo,description,createdAt,updatedAt,pushedAt,stars,watchers,forks,defaultBranch}:
28457823,freeCodeCamp,freeCodeCamp/freeCodeCamp,"freeCodeCamp.org's open-source codebase and curriculum. Learn math, programming,…","2014-12-24T17:49:19Z","2025-10-28T11:58:08Z","2025-10-28T10:17:16Z",430886,8583,42146,main
132750724,build-your-own-x,codecrafters-io/build-your-own-x,Master programming by recreating your favorite technologies from scratch.,"2018-05-09T12:03:18Z","2025-10-28T12:37:11Z","2025-10-10T18:45:01Z",430877,6332,40453,master
21737465,awesome,sindresorhus/awesome,😎 Awesome lists about all kinds of interesting topics,"2014-07-11T13:42:37Z","2025-10-28T12:40:21Z","2025-10-27T17:57:31Z",410052,8017,32029,main
Try TOON instantly with npx:
# Convert JSON to TOON
npx @toon-format/cli input.json -o output.toon
# Pipe from stdin
echo '{"name": "Ada", "role": "dev"}' | npx @toon-format/cli
See the CLI section for all options and examples.
# npm
npm install @toon-format/toon
# pnpm
pnpm add @toon-format/toon
# yarn
yarn add @toon-format/toon
Example usage:
import { encode } from '@toon-format/toon'
const data = {
users: [
{ id: 1, name: 'Alice', role: 'admin' },
{ id: 2, name: 'Bob', role: 'user' }
]
}
console.log(encode(data))
// users[2]{id,name,role}:
// 1,Alice,admin
// 2,Bob,user
Streaming large datasets:
import { encodeLines } from '@toon-format/toon'
const largeData = await fetchThousandsOfRecords()
// Memory-efficient streaming for large data
for (const line of encodeLines(largeData)) {
process.stdout.write(`${line}\n`)
}
[!TIP] For streaming decode APIs, see
decodeFromLines()anddecodeStream().
Experiment with TOON format interactively using these community-built tools for token comparison, format conversion, and validation:
TOON Language Support - Syntax highlighting, validation, conversion, and token analysis.
code --install-extension vishalraut.vscode-toon
tree-sitter-toon - Grammar for Tree-sitter-compatible editors (Neovim, Helix, Emacs, Zed).
toon.nvim - Lua-based plugin.
Use YAML syntax highlighting as a close approximation.
Command-line tool for quick JSON↔TOON conversions, token analysis, and pipeline integration. Auto-detects format from file extension, supports stdin/stdout workflows, and offers delimiter options for maximum efficiency.
# Encode JSON to TOON (auto-detected)
npx @toon-format/cli input.json -o output.toon
# Decode TOON to JSON (auto-detected)
npx @toon-format/cli data.toon -o output.json
# Pipe from stdin (no argument needed)
cat data.json | npx @toon-format/cli
echo '{"name": "Ada"}' | npx @toon-format/cli
# Output to stdout
npx @toon-format/cli input.json
# Show token savings
npx @toon-format/cli data.json --stats
[!TIP] See the full CLI documentation for all options, examples, and advanced usage.
Detailed syntax references, implementation guides, and quick lookups for understanding and using the TOON format.
TOON works best when you show the format instead of describing it. The structure is self-documenting – models parse it naturally once they see the pattern. Wrap data in ```toon code blocks for input, and show the expected header template when asking models to generate TOON. Use tab delimiters for even better token efficiency.
Follow the detailed LLM integration guide for strategies, examples, and validation techniques.
Comprehensive guides, references, and resources to help you get the most out of the TOON format and tools.
[!NOTE] When implementing TOON in other languages, please follow the Specification (currently v2.1) to ensure compatibility across implementations. The conformance tests provide language-agnostic test fixtures that validate your implementations.
[!TIP] These implementations are actively being developed by dedicated teams. Contributions are welcome! Join the effort by opening issues, submitting PRs, or discussing implementation details in the respective repositories.
MIT License © 2025-PRESENT Johann Schopplich
FAQs
Token-Oriented Object Notation (TOON) – Compact, human-readable, schema-aware encoding of JSON for LLM prompts
The npm package @toon-format/toon receives a total of 841,398 weekly downloads. As such, @toon-format/toon popularity was classified as popular.
We found that @toon-format/toon demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
/Research
A fake corepack.org site is impersonating the Node.js tool and delivers an infostealer and proxyware to developers who download it.
Research
/Security News
A large-scale campaign abused GitHub Actions in compromised repositories to exploit CVE-2026-41940 in cPanel and WHM and steal server credentials.
Security News
Five frontier LLMs generated the same nonexistent package names, leaving 53 available for potential slopsquatting across PyPI and npm.