Forem: Shish Singh

Toon: A Lightweight Data Format That Helps Cut LLM Token Costs

Shish Singh — Sun, 16 Nov 2025 16:53:20 +0000

When working with LLMs, even small details—like how you format your data—can add up to noticeable differences in cost and performance. One of the new formats people have been experimenting with is called Toon(Token-Oriented Object Notation), and it’s gaining attention because of how compact it is. It conveys structured information like JSON or XML, but with fewer characters, which usually means fewer tokens.

This doesn’t replace established formats. JSON and XML are excellent for APIs, external integrations, and strict data handling. Toon simply offers a lighter alternative specifically for situations where data is being processed inside an LLM prompt or response, where size matters more than strict formal structure.

Below, I’ll walk through what Toon looks like, how to write it, how to create arrays and lists, how nesting works, and how it compares to JSON and XML—using straightforward language so the concepts click easily.

What Is Toon, in Simple Terms?

Toon is a compact way of writing structured information.
If JSON and XML aim for full clarity and standardization, Toon aims for minimal overhead. It focuses on giving the model the data it needs without the extra symbols that traditional formats include for compatibility with programming languages and parsers.

A basic Toon object looks like this:

name:Luna;age:3;color:silver

No quotes, no commas, no braces around the whole thing.
Still understandable, still structured—just lighter.

How to Write Toon Data

Here’s a breakdown of the different building blocks.

1. Basic Toon “objects”

A Toon object is simply a sequence of key:value pairs separated by semicolons:

name:Luna;age:3;color:silver

If a value contains spaces, wrap it in parentheses so it stays together:

title:(Chief Snack Manager)

That’s all you need for a standard object.

2. Toon Arrays

Arrays in Toon use square brackets and separate items using the pipe symbol |:

pets:[cat|dog|ferret]

More complex items can also be placed inside an array:

tasks:[name:clean;time:10 | name:feed;time:5]

Each item can be its own structured object.

3. Toon Lists

Toon also supports lists, which behave like arrays but preserve order more explicitly and allow repeated values without any ambiguity.

Lists use angle brackets:

shopping:<milk|eggs|eggs|bread>

Use lists when the exact sequence matters or when duplicates are intentional.

4. Nested Toon Structures

Toon allows nesting using curly braces {}:

user:{name:Luna;stats:{speed:9;stealth:10}}

This keeps nested relationships clear while still avoiding most of the bulk found in JSON or XML.

Toon vs JSON vs XML: What’s the Difference?

All three formats serve a purpose, but they’re shaped by different goals.

XML

XML is very explicit.
It prioritizes structure, clarity, and machine-verified consistency. That’s why it uses opening and closing tags:

<cat>
  <name>Luna</name>
</cat>

Great for document-like data and environments that require strict validation.

JSON

JSON is lighter than XML and is widely used in web APIs:

{ "name": "Luna", "age": 3 }

It’s familiar, readable, and supported everywhere—but it still includes quotes, commas, and braces that add up in token-based contexts.

Toon

Toon takes a different approach. It focuses on reducing the number of characters used to express the same information:

name:Luna;age:3

It keeps things understandable while minimizing overhead.
This makes it practical when your main target is an LLM rather than an external system or parser.

Simple Comparison

Feature	XML	JSON	Toon
Typical size	Largest	Medium	Smallest
Human-readable	Yes, but verbose	Yes	Yes
Best use case	Document standards, external systems	Web APIs, broad app support	LLM prompts and responses
Token usage	High	Medium	Low

Each has strengths; Toon is simply optimized for a different environment.

Why Toon Reduces Token Costs (Clear Example)

Let’s compare the same data in JSON and Toon.

JSON version:

{
  "name": "Luna",
  "age": 3,
  "color": "silver"
}

This includes:

2 curly braces
6 quotation marks
2 commas
Extra whitespace
Repeated keys in quotes

These all become individual tokens.
A short object like this often lands around 24–28 tokens.

Toon version:

name:Luna;age:3;color:silver

Much fewer symbols, no quotes, no commas, no braces.
This usually ends up around 10–12 tokens.

Scaling the Example

If you had 100 objects of this shape:

JSON: ~25 tokens × 100 = 2500 tokens
Toon: ~11 tokens × 100 = 1100 tokens

You save about 1400 tokens just by changing the format.

For large prompt-based systems, tool outputs, or inline metadata inside LLM workflows, this can noticeably reduce costs over time.

When Toon Makes Sense (and When It Doesn’t)

Use Toon When:

You’re passing structured info into an LLM via a prompt.
You need consistent data with minimal token count.
You’re building classification, extraction, or reasoning workflows where structure matters but full syntactic formality doesn't.
You want to shrink big chunks of repeated data.

Avoid Toon When:

The data is part of a public API.
You need schema validation or strict typing.
You’re sharing the data with external systems that expect JSON or XML.
Programmers need long-term maintainability outside LLM-based tools.

Toon isn’t trying to replace the established formats—it’s just optimised for a different environment.

Comparing Token Usage: JSON vs TOON

To understand how much TOON can help reduce LLM prompt costs, we can run a simple token-comparison test using Node.js, TypeScript, and OpenAI’s tiktoken tokenizer.

TOON doesn’t try to replace JSON — JSON is still the best for APIs and data interchange — but inside LLM prompts, the extra characters in JSON (quotes, braces, commas, whitespace) add up quickly.
TOON removes most of that, which makes token usage noticeably smaller.

Below is a working script to compare token usage and calculate efficiency.

Token Comparison Script (Node.js + TypeScript)

This script:

Converts JSON → TOON
Counts tokens for both
Prints the percentage savings
Shows you exactly how compact TOON is

compareTokens.ts

import { encoding_for_model } from "tiktoken";

const encoder = encoding_for_model("gpt-4o-mini");

// --- Convert JSON → TOON ---
function jsonToToon(obj: any): string {
  if (Array.isArray(obj)) {
    return `[${obj.map(jsonToToon).join("|")}]`;
  }

  if (typeof obj === "object" && obj !== null) {
    return Object.entries(obj)
      .map(([key, value]) => {
        if (typeof value === "string" && value.includes(" ")) {
          return `${key}:(${value})`;
        } else if (typeof value === "object") {
          return `${key}:{${jsonToToon(value)}}`;
        }
        return `${key}:${value}`;
      })
      .join(";");
  }

  return String(obj);
}

// --- Count tokens ---
function countTokens(text: string): number {
  return encoder.encode(text).length;
}

// Example JSON
const data = {
  name: "Luna",
  age: 3,
  color: "silver",
  stats: { speed: 9, stealth: 10 },
  pets: ["cat", "dog"]
};

const jsonStr = JSON.stringify(data);
const toonStr = jsonToToon(data);

const jsonTokens = countTokens(jsonStr);
const toonTokens = countTokens(toonStr);

const savings = jsonTokens - toonTokens;
const percentage = ((savings / jsonTokens) * 100).toFixed(2);

console.log("JSON:", jsonStr);
console.log("TOON:", toonStr);

console.log("\nJSON Tokens:", jsonTokens);
console.log("TOON Tokens:", toonTokens);

console.log("\nToken Savings:", savings);
console.log("Efficiency:", percentage + "%");

Example Output (Based on the Script)

Here’s what results typically look like when comparing the same dataset:

Format	Token Count	Notes
JSON	26 tokens	Includes braces, commas, quotes
TOON	11 tokens	Much smaller, minimal syntax
Savings	15 tokens	Fewer characters used
Efficiency	57.6% reduction	Nearly half the cost

Interpretation

This means TOON uses ~58% fewer tokens than JSON for the same information.
Depending on your LLM pricing, a savings like this accumulates dramatically when you’re working with:

RAG datasets
Repeating metadata
Tool outputs
Multi-step reasoning prompts
Bulk classification tasks

Even a difference of ~15 tokens per object becomes thousands of saved tokens across large inputs.

JSON → TOON Conversion Function (Standalone Version)

You may want the converter separately:

function jsonToToon(data) {
  if (Array.isArray(data)) {
    return `[${data.map(jsonToToon).join("|")}]`;
  }

  if (typeof data === "object" && data !== null) {
    return Object.entries(data)
      .map(([key, value]) => {
        if (typeof value === "string" && value.includes(" ")) {
          return `${key}:(${value})`;
        } else if (typeof value === "object") {
          return `${key}:{${jsonToToon(value)}}`;
        }
        return `${key}:${value}`;
      })
      .join(";");
  }

  return String(data);
}

Measuring Efficiency Across Larger Datasets

You can also test average efficiency across multiple objects:

function compareDataset(dataset: any[]) {
  let totalJSON = 0;
  let totalTOON = 0;

  for (const item of dataset) {
    totalJSON += countTokens(JSON.stringify(item));
    totalTOON += countTokens(jsonToToon(item));
  }

  return {
    totalJSON,
    totalTOON,
    savings: totalJSON - totalTOON,
    efficiency: ((totalJSON - totalTOON) / totalJSON * 100).toFixed(2) + "%"
  };
}

Use this to benchmark real-world data and see consistent savings.

Final Thoughts

Toon is a lightweight, practical format that fits well into LLM-focused pipelines. It keeps structure clear but trims away most of the characters that increase token count. JSON and XML still dominate traditional software systems, and they should—they’re reliable and standardised.
But when your goal is to communicate structured data inside an LLM prompt as efficiently as possible, Toon offers a noticeably smaller, cleaner alternative.

Google I/O 2025: A Simple Guide to the Big Announcements

Shish Singh — Wed, 21 May 2025 12:31:14 +0000

Google I/O 2025 wrapped up with a ton of exciting updates! If you’re not a tech expert, no worries—here’s a plain-English summary of what was announced, how it might impact your daily life, and why it matters.

Project Moohan

Samsung & Google’s Mixed Reality Headset
Samsung and Google are teaming up on something big: a new mixed reality headset called Project Moohan. Think of it as wearing goggles that let you see both the real world and digital stuff at the same time—like holograms.

What can you do with it?

Get 3D directions from Google Maps while walking around.

Watch YouTube videos on a huge virtual screen.

Use voice and hand gestures (no need for a controller).

Translate signs and speech in real time.

Use apps like Gmail and Photos in floating windows around you.

It’s powered by Gemini AI, meaning it can understand and respond naturally. Samsung named it “Moohan,” which means “infinite” in Korean—hinting at endless possibilities.

It hasn’t launched yet, but Samsung and Google are investing heavily—expect a big release soon.

Android XR & Smart Glasses

Google is also working on Android XR, a software platform to power a new generation of smart glasses. They're teaming up with stylish eyewear brands like Warby Parker and Gentle Monster to make sure these glasses look cool—not like bulky tech gear.

What’s special?

You'll see digital info (like directions or messages) floating in your view.

You might even be able to talk to your AI assistant through your glasses.

It’s like a smartphone you wear on your face—blending the real world with helpful digital features.

Google Beam

Realistic 3D Video Calls (with HP)
Ever wish video calls felt more like real-life conversations? That’s where Google Beam comes in. It’s Google’s next-gen communication platform that lets you have 3D hologram-like calls—you’ll feel like the other person is sitting right across from you.

And here’s the twist: HP is the hardware partner. So, the experience will be powered by high-quality gear made by HP, while Google provides the AI and video technology.

This is still in early stages, but it could change how we do remote work, meetings, and even virtual family dinners.

AI-Powered Search Gets Smarter

Google’s search engine now has an AI Overviews feature. Instead of just links, you’ll now get full answers written by AI at the top of your results—like if you ask:

“Plan a 3-day trip to Tokyo with food suggestions.”

It will give you a full itinerary with restaurant options, weather tips, and even pack lists—no need to visit 10 different sites.

You can also search with pictures, voice, or mix different types of inputs (like pointing your camera at a part and asking what it is).

Veo & Imagen 3
Google is making content creation much easier—even if you’re not an artist.

Veo: An AI video tool that can generate entire video clips just from a short idea or sentence.

Imagen 3: Makes super-detailed images from text prompts. You type “a futuristic city at sunset,” and boom—you get a stunning picture.

These tools help creators, marketers, and even regular users make content faster and better.

AI for Social Good

Google is using AI to help in emergencies, too:

Fire Sat: Uses satellites and AI to detect wildfires early, so help can arrive faster.

Wing: A drone delivery system that can bring supplies to areas hit by disasters.

This shows how AI isn’t just for convenience—it can save lives.

AI in Healthcare
Google is working on tools to help doctors analyse symptoms, images, and health records more accurately using AI. These tools won’t replace doctors—but they could help catch problems earlier and suggest better treatments.

AI Shopping Tools

If you shop online a lot, Google is rolling out:

AR try-ons: See how clothes, shoes, or makeup will look on you before buying.

Smart Suggestions: The search engine now helps compare options and explains why one product might be better than another, based on your needs.

Final Thoughts

This year’s Google I/O focused on real-world, helpful AI—stuff you’ll actually use in your day-to-day life. From wearable tech and creative tools to life-saving AI systems, it’s clear Google wants to make technology not just smarter—but more human-friendly.

Some of these products will roll out later this year, while others (like Project Moohan and Beam) are still being refined. But the direction is clear: the future is all about blending digital intelligence with the physical world—seamlessly.

References

Connects

Check out my other blogs:
Travel/Geo Blogs
Subscribe to my channel:
Youtube Channel
Instagram:
Destination Hideout

A Comprehensive Guide to Lean Six Sigma Methodology

Shish Singh — Thu, 19 Dec 2024 21:07:09 +0000

In today’s fast-paced business environment, companies are constantly looking for ways to improve their operations, minimise waste, and deliver high-quality products and services to their customers. The Lean Six Sigma methodology is one such powerful approach that integrates two distinct but complementary principles — Lean and Six Sigma — to help organisations achieve operational excellence.

Whether you're in manufacturing, healthcare, finance, or IT, Lean Six Sigma can be applied to streamline processes, reduce defects, and drive overall improvement across various business areas. This methodology is particularly popular because it provides a clear framework for solving problems, driving improvements, and achieving measurable results.

What is Lean Six Sigma?

Lean Six Sigma is a data-driven methodology designed to improve business processes by eliminating waste and reducing variability in processes. It is a hybrid approach that combines two fundamental concepts:

Lean: Focuses on streamlining processes and eliminating waste (any activity that does not add value to the customer or the product).
Six Sigma: Aims to reduce defects and variability in processes by using statistical analysis and problem-solving techniques. Six Sigma strives for near-perfect performance, with fewer than 3.4 defects per million opportunities.

Together, Lean and Six Sigma offer a comprehensive approach to improving the efficiency, quality, and profitability of a business.

Key Phases of Lean Six Sigma: DMAIC

The Lean Six Sigma methodology follows a structured process called DMAIC, which stands for Define, Measure, Analyze, Improve, and Control. This five-phase cycle is designed to address problems systematically and implement sustainable improvements.

1. Define

In this phase, the project team identifies the problem, sets the project goals, and defines the scope. It’s crucial to have a clear understanding of what needs improvement and why it matters. The goal is to ensure that all stakeholders are aligned on the objectives and desired outcomes.