New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Toon

by butttons in butttons/dora

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.

MITAuto-check passedDatabases

Install Toon

skills CLI
$ npx skills add butttons/dora --skill toon -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install butttons/dora toon --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/butttons/dora.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.pi/skills/toon .claude/skills/toon && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
toon
GitHub stars
109
Token cost
~9.4k tokens
SKILL.md length
2,469 words
Files
1
Skills in repo
1
Repo updated
First seen
Licence
MIT

At a glance

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.

  • Works in 6 steps: Tabular (100 employee records): Uniform… → Nested (50 e-commerce orders): Complex… → Analytics (60 days of metrics):… → …
  • Databases work in your project
  • SKILL.md covers Table of Contents, Why TOON?, Key Features and Media Type & File Extension, plus 12 more sections
  • Calls npx, npm and pnpm

What it does

Toon is an agent skill from butttons/dora. 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.

Its SKILL.md is about 9.4k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Databases. It works with SQLite. The repository describes itself as: CLI built for AI agents to help navigate codebases better. An alternative to grep/find/glob. The licence is MIT.

When your agent uses it

  • Databases work in your project

Example prompts

  • “/toon”

Workflow steps

6 steps, taken from the first numbered list in SKILL.md.

  1. Tabular (100 employee records): Uniform objects with identical fields – optimal for TOON's tabular format.
  2. Nested (50 e-commerce orders): Complex structures with nested customer objects and item arrays.
  3. Analytics (60 days of metrics): Time-series data with dates and numeric values.
  4. GitHub (100 repositories): Real-world data from top GitHub repos by stars.
  5. Event Logs (75 logs): Semi-uniform data with ~50% flat logs and ~50% with nested error objects.
  6. Nested Config (1 configuration): Deeply nested configuration with minimal tabular eligibility.

What it can do on your machine

Read from SKILL.md and the folder at commit f4edb8f. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • npx
    • npm
    • pnpm
    • yarn

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • toonformat.dev
    • github.com
    • img.shields.io
    • npmjs.com
    • curiouslychase.com
    • toontools.vercel.app
    • marketplace.visualstudio.com
    • toon-format.org
    • x.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Toon loads about 9.4k tokens when it runs. Until then it costs about 64 tokens; SKILL.md has 2,469 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~64
When it runs · the whole SKILL.md, loaded when a task matches
~9.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from butttons/dora at commit f4edb8f, republished under its MIT licence (© butttons). 2,469 words, ~9,441 tokens.

Download SKILL.mdSave it as .claude/skills/toon/SKILL.md (or your agent's skills folder).
name
toon
description
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.

Image: TOON logo with step‑by‑step guide

Token-Oriented Object Notation (TOON)

Image: CI Image: npm version Image: SPEC v3.0 Image: npm downloads (total) Image: License: MIT

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.

Table of Contents

Why TOON?

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:

json
{
  "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
    }
  ]
}
<details>
<summary>YAML already conveys the same information with <strong>fewer tokens</strong>.</summary>
yaml
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
</details>

TOON conveys the same information with even fewer tokens – combining YAML-like indentation with CSV-style tabular arrays:

yaml
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

Key Features

  • 📊 Token-Efficient & Accurate: TOON reaches 74% accuracy (vs JSON's 70%) while using ~40% fewer tokens in mixed-structure benchmarks across 4 models.
  • 🔁 JSON Data Model: Encodes the same objects, arrays, and primitives as JSON with deterministic, lossless round-trips.
  • 🛤️ LLM-Friendly Guardrails: Explicit [N] lengths and {fields} headers give models a clear schema to follow, improving parsing reliability.
  • 📐 Minimal Syntax: Uses indentation instead of braces and minimizes quoting, giving YAML-like readability with CSV-style compactness.
  • 🧺 Tabular Arrays: Uniform arrays of objects collapse into tables that declare fields once and stream row values line by line.
  • 🌐 Multi-Language Ecosystem: Spec-driven implementations in TypeScript, Python, Go, Rust, .NET, and other languages.

Media Type & File Extension

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.

When Not to Use TOON

TOON excels with uniform arrays of objects, but there are cases where other formats are better:

  • Deeply nested or non-uniform structures (tabular eligibility ≈ 0%): JSON-compact often uses fewer tokens. Example: complex configuration objects with many nested levels.
  • Semi-uniform arrays (~40–60% tabular eligibility): Token savings diminish. Prefer JSON if your pipelines already rely on it.
  • Pure tabular data: CSV is smaller than TOON for flat tables. TOON adds minimal overhead (~5-10%) to provide structure (array length declarations, field headers, delimiter scoping) that improves LLM reliability.
  • Latency-critical applications: If end-to-end response time is your top priority, benchmark on your exact setup. Some deployments (especially local/quantized models like Ollama) may process compact JSON faster despite TOON's lower token count. Measure TTFT, tokens/sec, and total time for both formats and use whichever is faster.

See benchmarks for concrete comparisons across different data structures.

Benchmarks

Benchmarks are organized into two tracks to ensure fair comparisons:

  • Mixed-Structure Track: Datasets with nested or semi-uniform structures (TOON vs JSON, YAML, XML). CSV excluded as it cannot properly represent these structures.
  • Flat-Only Track: Datasets with flat tabular structures where CSV is applicable (CSV vs TOON vs JSON, YAML, XML).
Retrieval Accuracy
<!-- automd:file src="./benchmarks/results/retrieval-accuracy.md" -->

Benchmarks test LLM comprehension across different input formats using 209 data retrieval questions on 4 models.

<details>
<summary><strong>Show Dataset Catalog</strong></summary>
Dataset Catalog
DatasetRowsStructureCSV SupportEligibility
Uniform employee records100uniform✓100%
E-commerce orders with nested structures50nested✗33%
Time-series analytics data60uniform✓100%
Top 100 GitHub repositories100uniform✓100%
Semi-uniform event logs75semi-uniform✗50%
Deeply nested configuration11deep✗0%
Valid complete dataset (control)20uniform✓100%
Array truncated: 3 rows removed from end17uniform✓100%
Extra rows added beyond declared length23uniform✓100%
Inconsistent field count (missing salary in row 10)20uniform✓100%
Missing required fields (no email in multiple rows)20uniform✓100%

Structure classes:

  • uniform: All objects have identical fields with primitive values
  • semi-uniform: Mix of uniform and non-uniform structures
  • nested: Objects with nested structures (nested objects or arrays)
  • deep: Highly nested with minimal tabular eligibility

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)

</details>
Efficiency Ranking (Accuracy per 1K Tokens)

Each format ranked by efficiency (accuracy percentage per 1,000 tokens):

TOON           ████████████████████   26.9 acc%/1K tok  │  73.9% acc  │  2,744 tokens
JSON compact   █████████████████░░░   22.9 acc%/1K tok  │  70.7% acc  │  3,081 tokens
YAML           ██████████████░░░░░░   18.6 acc%/1K tok  │  69.0% acc  │  3,719 tokens
JSON           ███████████░░░░░░░░░   15.3 acc%/1K tok  │  69.7% acc  │  4,545 tokens
XML            ██████████░░░░░░░░░░   13.0 acc%/1K tok  │  67.1% acc  │  5,167 tokens

Efficiency score = (Accuracy % ÷ Tokens) × 1,000. Higher is better.

[!TIP] 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.

Per-Model Accuracy

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] TOON achieves 73.9% accuracy (vs JSON's 69.7%) while using 39.6% fewer tokens on these datasets.

<details>
<summary><strong>Performance by dataset, model, and question type</strong></summary>
Performance by Question Type
Question TypeTOONJSON compactJSONCSVYAMLXML
Field Retrieval99.6%99.3%99.3%100.0%98.2%98.9%
Aggregation54.4%47.2%48.8%44.0%47.6%41.3%
Filtering56.3%57.3%50.5%49.1%51.0%47.9%
Structure Awareness88.0%83.0%83.0%85.9%80.0%80.0%
Structural Validation70.0%45.0%50.0%80.0%60.0%80.0%
Performance by Dataset
Uniform employee records
FormatAccuracyTokensCorrect/Total
csv72.0%2,352118/164
toon73.8%2,518121/164
json-compact69.5%3,953114/164
yaml68.3%4,982112/164
json-pretty68.3%6,360112/164
xml69.5%7,324114/164
E-commerce orders with nested structures
FormatAccuracyTokensCorrect/Total
toon81.1%7,232133/164
json-compact76.8%6,794126/164
yaml75.6%8,347124/164
json-pretty76.2%10,713125/164
xml74.4%12,023122/164
Time-series analytics data
FormatAccuracyTokensCorrect/Total
csv73.3%1,40688/120
toon72.5%1,54887/120
json-compact71.7%2,34986/120
yaml71.7%2,94986/120
json-pretty68.3%3,67682/120
xml68.3%4,38482/120
Top 100 GitHub repositories
FormatAccuracyTokensCorrect/Total
toon62.9%8,77983/132
csv61.4%8,52781/132
yaml59.8%13,14179/132
json-compact55.3%11,46473/132
json-pretty56.1%15,15774/132
xml48.5%17,10564/132
Semi-uniform event logs
FormatAccuracyTokensCorrect/Total
json-compact63.3%4,81976/120
toon57.5%5,79969/120
json-pretty59.2%6,79771/120
yaml48.3%5,82758/120
xml46.7%7,70956/120
Deeply nested configuration
FormatAccuracyTokensCorrect/Total
json-compact92.2%574107/116
toon95.7%666111/116
yaml91.4%686106/116
json-pretty94.0%932109/116
xml92.2%1,018107/116
Valid complete dataset (control)
FormatAccuracyTokensCorrect/Total
toon100.0%5444/4
json-compact100.0%7954/4
yaml100.0%1,0034/4
json-pretty100.0%1,2824/4
csv25.0%4921/4
xml0.0%1,4670/4
Array truncated: 3 rows removed from end
FormatAccuracyTokensCorrect/Total
csv100.0%4254/4
xml100.0%1,2514/4
toon0.0%4740/4
json-compact0.0%6810/4
json-pretty0.0%1,0960/4
yaml0.0%8590/4
Extra rows added beyond declared length
FormatAccuracyTokensCorrect/Total
csv100.0%5664/4
toon75.0%6213/4
xml100.0%1,6924/4
yaml75.0%1,1573/4
json-compact50.0%9172/4
json-pretty50.0%1,4762/4
Inconsistent field count (missing salary in row 10)
FormatAccuracyTokensCorrect/Total
csv75.0%4893/4
yaml100.0%9964/4
toon100.0%1,0194/4
json-compact75.0%7903/4
xml100.0%1,4584/4
json-pretty75.0%1,2743/4
Missing required fields (no email in multiple rows)
FormatAccuracyTokensCorrect/Total
csv100.0%3294/4
xml100.0%1,4114/4
toon75.0%9833/4
yaml25.0%9601/4
json-pretty25.0%1,2301/4
json-compact0.0%7550/4
Performance by Model
claude-haiku-4-5-20251001
FormatAccuracyCorrect/Total
toon59.8%125/209
json-pretty57.4%120/209
yaml56.0%117/209
xml55.5%116/209
json-compact55.0%115/209
csv50.5%55/109
gemini-2.5-flash
FormatAccuracyCorrect/Total
toon87.6%183/209
csv86.2%94/109
json-compact82.3%172/209
yaml79.4%166/209
xml79.4%166/209
json-pretty77.0%161/209
gpt-5-nano
FormatAccuracyCorrect/Total
toon90.9%190/209
json-compact90.9%190/209
json-pretty89.0%186/209
csv89.0%97/109
yaml87.1%182/209
xml80.9%169/209
grok-4-fast-non-reasoning
FormatAccuracyCorrect/Total
toon57.4%120/209
json-pretty55.5%116/209
json-compact54.5%114/209
yaml53.6%112/209
xml52.6%110/209
csv52.3%57/109
</details>
What's Being Measured

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.

Show full SKILL.md (1,020 more words)Show less
Datasets Tested

Eleven datasets designed to test different structural patterns and validation capabilities:

Primary datasets:

  1. Tabular (100 employee records): Uniform objects with identical fields – optimal for TOON's tabular format.
  2. Nested (50 e-commerce orders): Complex structures with nested customer objects and item arrays.
  3. Analytics (60 days of metrics): Time-series data with dates and numeric values.
  4. GitHub (100 repositories): Real-world data from top GitHub repos by stars.
  5. Event Logs (75 logs): Semi-uniform data with ~50% flat logs and ~50% with nested error objects.
  6. Nested Config (1 configuration): Deeply nested configuration with minimal tabular eligibility.

Structural validation datasets:

  1. Control: Valid complete dataset (baseline for validation)
  2. Truncated: Array with 3 rows removed from end (tests [N] length detection)
  3. Extra rows: Array with 3 additional rows beyond declared length
  4. Width mismatch: Inconsistent field count (missing salary in row 10)
  5. Missing fields: Systematic field omissions (no email in multiple rows)
Question Types

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)

    • Example: "What is Alice's salary?" → 75000
    • Example: "How many items are in order ORD-0042?" → 3
    • Example: "What is the customer name for order ORD-0042?" → John Doe

  • Aggregation (30%): Dataset-level totals and averages plus single-condition filters (counts, sums, min/max comparisons)

    • Example: "How many employees work in Engineering?" → 17
    • Example: "What is the total revenue across all orders?" → 45123.50
    • Example: "How many employees have salary > 80000?" → 23

  • Filtering (23%): Multi-condition queries requiring compound logic (AND constraints across fields)

    • Example: "How many employees in Sales have salary > 80000?" → 5
    • Example: "How many active employees have more than 10 years of experience?" → 8

  • Structure awareness (12%): Tests format-native structural affordances (TOON's [N] count and {fields}, CSV's header row)

    • Example: "How many employees are in the dataset?" → 100
    • Example: "List the field names for employees" → id, name, email, department, salary, yearsExperience, active
    • Example: "What is the department of the last employee?" → Sales

  • Structural validation (2%): Tests ability to detect incomplete, truncated, or corrupted data using structural metadata

    • Example: "Is this data complete and valid?" → YES (control dataset) or NO (corrupted datasets)
    • Tests TOON's [N] length validation and {fields} consistency checking
    • Demonstrates CSV's lack of structural validation capabilities
Evaluation Process
  1. Format conversion: Each dataset is converted to all 6 formats (TOON, JSON compact, JSON, CSV, YAML, XML).
  2. Query LLM: Each model receives formatted data + question in a prompt and extracts the answer.
  3. Validate deterministically: Answers are validated using type-aware comparison (e.g., 50000 = $50,000, Engineering = engineering, 2025-01-01 = January 1, 2025) without requiring an LLM judge.
Models & Configuration
  • Models tested: claude-haiku-4-5-20251001, gemini-2.5-flash, gpt-5-nano, grok-4-fast-non-reasoning
  • Token counting: Using gpt-tokenizer with o200k_base encoding (GPT-5 tokenizer)
  • Temperature: Not set (models use their defaults)
  • Total evaluations: 209 questions × 6 formats × 4 models = 5,016 LLM calls
<!-- /automd -->
Token Efficiency

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.

<!-- automd:file src="./benchmarks/results/token-efficiency.md" -->
Mixed-Structure Track

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
Flat-Only Track

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,512 tokens
   TOON                ████████████████████     8,744 tokens   (+2.7% vs CSV)
   ├─ vs JSON          (−42.3%)                15,144 tokens
   ├─ vs JSON compact  (−23.7%)                11,454 tokens
   ├─ vs YAML          (−33.4%)                13,128 tokens
   └─ vs XML           (−48.9%)                17,095 tokens

──────────────────────────────────── Total ────────────────────────────────────
   CSV                 ███████████████████░    63,854 tokens
   TOON                ████████████████████    67,695 tokens   (+6.0% vs CSV)
   ├─ vs JSON          (−58.8%)               164,254 tokens
   ├─ vs JSON compact  (−35.2%)               104,526 tokens
   ├─ vs YAML          (−48.2%)               130,697 tokens
   └─ vs XML           (−64.4%)               190,160 tokens
<details>
<summary><strong>Show detailed examples</strong></summary>
📈 Time-series analytics data

Savings: 13,130 tokens (59.0% reduction vs JSON)

JSON (22,250 tokens):

json
{
  "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
⭐ Top 100 GitHub repositories

Savings: 6,400 tokens (42.3% reduction vs JSON)

JSON (15,144 tokens):

json
{
  "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,744 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
</details>
<!-- /automd -->

Installation & Quick Start

CLI (No Installation Required)

Try TOON instantly with npx:

bash
# 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.

TypeScript Library
bash
# npm
npm install @toon-format/toon

# pnpm
pnpm add @toon-format/toon

# yarn
yarn add @toon-format/toon

Example usage:

ts
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:

ts
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() and decodeStream().

Transforming values with replacer:

ts
import { encode } from "@toon-format/toon";

// Remove sensitive fields
const user = { name: "Alice", password: "secret", email: "alice@example.com" };
const safe = encode(user, {
  replacer: (key, value) => (key === "password" ? undefined : value),
});
// name: Alice
// email: alice@example.com

// Transform values
const data = { status: "active", count: 5 };
const transformed = encode(data, {
  replacer: (key, value) =>
    typeof value === "string" ? value.toUpperCase() : value,
});
// status: ACTIVE
// count: 5

[!TIP] The replacer function provides fine-grained control over encoding, similar to JSON.stringify's replacer but with path tracking. See the API Reference for more examples.

Playgrounds

Experiment with TOON format interactively using these tools for token comparison, format conversion, and validation.

Official Playground

The TOON Playground lets you convert JSON to TOON in real-time, compare token counts, and share your experiments via URL.

Community Playgrounds

Editor Support

VS Code

TOON Language Support - Syntax highlighting, validation, conversion, and token analysis.

bash
code --install-extension vishalraut.vscode-toon
Tree-sitter Grammar

tree-sitter-toon - Grammar for Tree-sitter-compatible editors (Neovim, Helix, Emacs, Zed).

Neovim

toon.nvim - Lua-based plugin.

Other Editors

Use YAML syntax highlighting as a close approximation.

CLI

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.

bash
# 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.

Format Overview

Detailed syntax references, implementation guides, and quick lookups for understanding and using the TOON format.

Using TOON with LLMs

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.

Documentation

Comprehensive guides, references, and resources to help you get the most out of the TOON format and tools.

Getting Started
Tools & Integration
References

Other Implementations

TOON has official and community implementations across multiple languages including Python, Rust, Go, Java, Swift, .NET, and many more.

See the full list of implementations in the documentation.

Credits

License

MIT License © 2025-PRESENT Johann Schopplich

© butttons, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .pi/skills/toon of butttons/dora.

Open the folder on GitHubat commit f4edb8f

Compare with similar skills

Toon next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Toon compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Toon this skillbutttons/dora109—~9.4kAutomated safety check: PassMIT
Iptvnator Sqlite DB Worker4gray/iptvnator7.3k—~824Automated safety check: PassMIT
Analyze Nsys Profilemlc-ai/pith-train355—~1.9kAutomated safety check: PassApache-2.0
Reactive Sqlite UIfastrepl/anarlog9.5k—~699Automated safety check: PassMIT
Composer Forensicsdxos/dxos525—~3.1kAutomated safety check: PassCustom licence
Sqlite Schema Designfastrepl/anarlog9.5k—~1.9kAutomated safety check: PassMIT

Similar skills

  • Iptvnator Sqlite DB Worker

    4gray/iptvnator

    A skill your agent uses when changing Electron SQLite IPC, database-worker operations, request-scoped progress or cancellation, worker packaging, or runtime verification of non-EPG database work.

    7.3k GitHub stars~824 tokensUpdated today
    DatabasesAuto-check passed

  • Analyze Nsys Profile

    mlc-ai/pith-train

    Query a captured PithTrain Nsight Systems profile to measure compute/communication overlap, locate exposed comm by DualPipeV stage, and inspect per-rank stream behavior.

    355 GitHub stars~1.9k tokensUpdated 5 days ago
    DatabasesAuto-check passed

  • Reactive Sqlite UI

    fastrepl/anarlog

    Build SQLite-backed reactive UI in apps/desktop using stable patterns for reads, selection, forms, writes, and loading states.

    9.5k GitHub stars~699 tokensUpdated today
    DatabasesAuto-check passed

  • Composer Forensics

    dxos/dxos

    Forensically inspect and repair Composer browser profiles — offline (Chrome OPFS / SQLite extract) or live via /recovery.html debug port.

    525 GitHub stars~3.1k tokensUpdated today
    DatabasesAuto-check passed

  • Sqlite Schema Design

    fastrepl/anarlog

    Design or review schemas for crates/cloudsync using SQLite Sync constraints, not generic SQLite advice.

    9.5k GitHub stars~1.9k tokensUpdated today
    DatabasesAuto-check passed

  • Makemigrations

    deusXmachina-dev/memorylane

    Create SQLite migrations for MemoryLane storage schema changes.

    121 GitHub stars~973 tokensUpdated yesterday
    DatabasesAuto-check passed

Works with

Categories

Questions about Toon

What does Toon do?

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. Toon is an agent skill from butttons/dora. 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.

When should I use Toon?

Toon fits situations like: databases work in your project.

How do I install Toon in Claude Code?

Run `npx skills add butttons/dora --skill toon -a claude-code`. Or copy the skill folder (.pi/skills/toon in butttons/dora) into .claude/skills/toon in your project. Claude Code loads it when a task matches its description.

How do I install Toon in Codex?

Run `npx skills add butttons/dora --skill toon -a codex`. Or copy the skill folder (.pi/skills/toon in butttons/dora) into .agents/skills/toon in your project. Codex loads it when a task matches its description.

Can I use Toon in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add butttons/dora --skill toon -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/toon, .gemini/skills/toon, .github/skills/toon and .opencode/skills/toon in your project.

What does Toon need to run?

Going by SKILL.md and its folder, Toon needs the command-line tools its instructions call (npx, npm, pnpm and yarn).

Does Toon access the network?

SKILL.md names 9 domains. As links in the text: toonformat.dev, github.com, img.shields.io, npmjs.com, curiouslychase.com, toontools.vercel.app, marketplace.visualstudio.com, toon-format.org and x.com. This is read from the text; nothing was executed.

Is Toon safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Toon use?

Toon is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Toon use?

About 9.4k tokens (SKILL.md is roughly 38k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Toon?

Skills that share tags, products or a category with Toon: Iptvnator Sqlite DB Worker (4gray/iptvnator, 7.3k stars), Analyze Nsys Profile (mlc-ai/pith-train, 355 stars), Reactive Sqlite UI (fastrepl/anarlog, 9.5k stars) and Composer Forensics (dxos/dxos, 525 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Toon?

butttons (a GitHub user) maintains it in butttons/dora, which has 109 GitHub stars. The repository was last updated on March 10, 2026.

Source: butttons/dora on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.