Skip to content
BranchesTags

Repository files navigation

Toon4D Library - LLM Data Optimization

Token-Oriented Object Notation (TOON) Encoder for Delphi

Overview

Toon4D is a Delphi library that encodes JSON data to TOON format - a compact, human-readable serialization format designed specifically for Large Language Model (LLM) applications. TOON achieves 30-60% token reduction compared to standard JSON while maintaining or improving LLM comprehension.

Key Features

  • Full TOON 2.0 Specification Compliance - Complete implementation of all required features
  • Token Efficiency - 30-60% token reduction on typical LLM payloads
  • Zero Dependencies - Uses only Delphi RTL (System.JSON)
  • Cross-Platform - Windows, macOS, Linux, iOS, Android
  • Comprehensive Test Suite - 300+ unit tests covering all edge cases
  • Clean API - Embarcadero-style static class methods

TOON Format Benefits

TOON is specifically designed for LLM prompts and provides:

  1. Tabular Arrays: Objects with uniform structure encoded as CSV-style rows

    users[3]{id,name,role}:
1,Alice,admin
2,Bob,user
3,Charlie,viewer

  2. Minimal Syntax: Removes redundant punctuation (braces, brackets, quotes)

  3. Explicit Structure: Array lengths and field names declared upfront for validation

  4. Indentation-Based: YAML-like nesting for readability

Quick Start

Installation

// Add to your uses clauseuses
Toon4D,
Toon4D.Types;

Basic Usage

var
JsonString := '{"name":"Alice","age":30,"active":true}';
ToonOutput := TToon.JsonToToon(JsonString);
// Result:// name: Alice// age: 30// active: true

Tabular Arrays

var
JsonString := ''' { "employees": [ {"id": 1, "name": "Alice Johnson", "role": "admin"}, {"id": 2, "name": "Bob Smith", "role": "user"}, {"id": 3, "name": "Charlie Brown", "role": "user"} ] }''';
ToonOutput := TToon.JsonToToon(JsonString);
// Result:// employees[3]{id,name,role}:// 1,Alice Johnson,admin// 2,Bob Smith,user// 3,Charlie Brown,user

Configuration Options

var
Options: TToonOptions := [
TToonOption.Indent4Spaces, // Use 4 spaces instead of 2
TToonOption.DelimiterPipe, // Use pipe delimiter instead of comma
TToonOption.KeyFoldingAggressive, // Aggressive key folding
TToonOption.PreferTabular // Prefer tabular format for arrays
];
ToonOutput := TToon.JsonToToon(JsonString, Options);

Project Structure

Toon4D/
├── Source/
│ ├── Toon4D.pas // Main API (TToon static class)
│ ├── Toon4D.Types.pas // Types, enums, options, exceptions
│ ├── Toon4D.Consts.pas // Constants and resourcestrings
│ └── Toon4D.Utils.pas // Utility functions
├── Tests/
│ ├── Toon4D.Tests.dpr // Test project
│ ├── Toon4D.Tests.Primitives.pas
│ ├── Toon4D.Tests.Arrays.pas
│ ├── Toon4D.Tests.ArrayEdgeCases.pas
│ ├── Toon4D.Tests.RootArrays.pas
│ ├── Toon4D.Tests.Nesting.pas
│ ├── Toon4D.Tests.KeyFolding.pas
│ ├── Toon4D.Tests.KeyEdgeCases.pas
│ ├── Toon4D.Tests.Delimiters.pas
│ ├── Toon4D.Tests.EdgeCases.pas
│ ├── Toon4D.Tests.ObjectEdgeCases.pas
│ ├── Toon4D.Tests.Whitespace.pas
│ ├── Toon4D.Tests.Integration.pas
│ ├── Toon4D.Tests.Conformance.pas
│ ├── Toon4D.Tests.OfficialFixtures.pas
│ └── Toon4D.Tests.Helpers.pas
├── SPEC.md // Detailed technical specification
└── README.md // This file

Configuration Options

TToonOption Enumeration

type
TToonOption = (
// Indentation (mutually exclusive)
Indent2Spaces, // Default: 2 spaces per level
Indent4Spaces, // 4 spaces per level
IndentCustom, // Use CustomIndentSize// Delimiter selection (mutually exclusive)
DelimiterComma, // Default: comma separator
DelimiterTab, // Tab separator
DelimiterPipe, // Pipe separator// Key folding strategy (mutually exclusive)
KeyFoldingNone, // No key folding
KeyFoldingSafe, // Default: fold safe identifier chains
KeyFoldingAggressive, // Aggressive folding// Array format preferences
PreferTabular, // Default: prefer tabular for uniform arrays
PreferList, // Prefer list format
ForceInlineForPrimitives, // Force inline for primitive arrays// Validation strictness
StrictValidation, // Strict TOON validation
LenientValidation, // Lenient validation// Quote minimization
MinimalQuoting, // Default: minimal quotes
AlwaysQuoteStrings, // Always quote string values// Number formatting
NormalizeNumbers, // Default: canonical form
PreserveNumberFormat, // Preserve JSON number format// Whitespace handling
NoTrailingWhitespace, // Remove trailing whitespace
CompactOutput, // Minimize whitespace// Error handling
GracefulDegradation, // Default: convert invalid to valid
StrictConformance // Raise exceptions on errors
);
TToonOptions = setof TToonOption;

API Reference

TToon Class

JsonToToon (TJSONValue overload)

classfunctionJsonToToon(
JsonValue: TJSONValue;
Options: TToonOptions = []
): string;

Encodes a TJSONValue to TOON format.

Parameters:

  • JsonValue: The JSON value to encode (must not be nil)
  • Options: Encoding options (defaults to safe defaults)

Returns: TOON formatted string

Raises:

  • EToonInvalidJsonException - When JsonValue is nil or invalid
  • EToonEncodingException - When encoding fails in strict mode

JsonToToon (String overload)

classfunctionJsonToToon(
const JsonString: string;
Options: TToonOptions = []
): string;

Encodes a JSON string to TOON format.

Parameters:

  • JsonString: Valid JSON string
  • Options: Encoding options

Returns: TOON formatted string

Raises:

  • EToonInvalidJsonException - When JSON string is malformed
  • EToonEncodingException - When encoding fails in strict mode

Validate

classfunctionValidate(
const ToonString: string;
out ErrorMessage: string
): Boolean;

Validates a TOON string against the specification.

Parameters:

  • ToonString: TOON formatted string to validate
  • ErrorMessage: Output parameter with error details

Returns: True if valid, False otherwise

GetLibraryVersion

classfunctionGetLibraryVersion: string;

Returns the library version string (e.g., "1.0.0").

References

Official TOON Resources

  1. TOON Specification v2.0https://github.com/toon-format/spec

  2. TOON Format Repositoryhttps://github.com/toon-format/toon

  3. Official Test Fixtures (340+ tests) https://github.com/toon-format/spec/tree/main/tests/fixtures

Delphi Resources

  1. System.JSON Documentationhttps://docwiki.embarcadero.com/Libraries/en/System.JSON

  2. DUnitX Testing Frameworkhttps://github.com/VSoftTechnologies/DUnitX

License

MIT License - See LICENSE file for details

Contributing

Contributions welcome! Please open an issue or pull request on GitHub.

Commercial Support

This library is MIT licensed and free to use. For companies that depend on it commercially we offer support and maintenance agreements with guaranteed response times, and sponsored development of features you need. Contact us at gdksoftware.com/contact-us or open an issue to get in touch.

About

Delphi JSON to TOON encoder - 30-60% token reduction for LLM prompts

gdksoftware.com

Topics

delphi

Resources

Readme
MIT license
Activity
Custom properties

Stars

18 stars

Watchers

1 watching

Forks

4 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - GDKsoftware/Toon4D: Delphi JSON to TOON encoder - 30-60% token reduction for LLM prompts · GitHub
Skip to content
BranchesTags
Repository files navigation
Toon4D Library - LLM Data Optimization
Token-Oriented Object Notation (TOON) Encoder for Delphi
Overview
Toon4D is a Delphi library that encodes JSON data to TOON format - a compact, human-readable serialization format designed specifically for Large Language Model (LLM) applications. TOON achieves 30-60% token reduction compared to standard JSON while maintaining or improving LLM comprehension.
Key Features
  • Full TOON 2.0 Specification Compliance - Complete implementation of all required features
  • Token Efficiency - 30-60% token reduction on typical LLM payloads
  • Zero Dependencies - Uses only Delphi RTL (System.JSON)
  • Cross-Platform - Windows, macOS, Linux, iOS, Android
  • Comprehensive Test Suite - 300+ unit tests covering all edge cases
  • Clean API - Embarcadero-style static class methods
TOON Format Benefits
TOON is specifically designed for LLM prompts and provides:
  1. Tabular Arrays: Objects with uniform structure encoded as CSV-style rows
    users[3]{id,name,role}:
1,Alice,admin
2,Bob,user
3,Charlie,viewer

  2. Minimal Syntax: Removes redundant punctuation (braces, brackets, quotes)
  3. Explicit Structure: Array lengths and field names declared upfront for validation
  4. Indentation-Based: YAML-like nesting for readability
Quick Start
Installation
// Add to your uses clauseuses
Toon4D,
Toon4D.Types;
Basic Usage
var
JsonString := '{"name":"Alice","age":30,"active":true}';
ToonOutput := TToon.JsonToToon(JsonString);
// Result:// name: Alice// age: 30// active: true
Tabular Arrays
var
JsonString := ''' { "employees": [ {"id": 1, "name": "Alice Johnson", "role": "admin"}, {"id": 2, "name": "Bob Smith", "role": "user"}, {"id": 3, "name": "Charlie Brown", "role": "user"} ] }''';
ToonOutput := TToon.JsonToToon(JsonString);
// Result:// employees[3]{id,name,role}:// 1,Alice Johnson,admin// 2,Bob Smith,user// 3,Charlie Brown,user
Configuration Options
var
Options: TToonOptions := [
TToonOption.Indent4Spaces, // Use 4 spaces instead of 2
TToonOption.DelimiterPipe, // Use pipe delimiter instead of comma
TToonOption.KeyFoldingAggressive, // Aggressive key folding
TToonOption.PreferTabular // Prefer tabular format for arrays
];
ToonOutput := TToon.JsonToToon(JsonString, Options);
Project Structure
Toon4D/
├── Source/
│ ├── Toon4D.pas // Main API (TToon static class)
│ ├── Toon4D.Types.pas // Types, enums, options, exceptions
│ ├── Toon4D.Consts.pas // Constants and resourcestrings
│ └── Toon4D.Utils.pas // Utility functions
├── Tests/
│ ├── Toon4D.Tests.dpr // Test project
│ ├── Toon4D.Tests.Primitives.pas
│ ├── Toon4D.Tests.Arrays.pas
│ ├── Toon4D.Tests.ArrayEdgeCases.pas
│ ├── Toon4D.Tests.RootArrays.pas
│ ├── Toon4D.Tests.Nesting.pas
│ ├── Toon4D.Tests.KeyFolding.pas
│ ├── Toon4D.Tests.KeyEdgeCases.pas
│ ├── Toon4D.Tests.Delimiters.pas
│ ├── Toon4D.Tests.EdgeCases.pas
│ ├── Toon4D.Tests.ObjectEdgeCases.pas
│ ├── Toon4D.Tests.Whitespace.pas
│ ├── Toon4D.Tests.Integration.pas
│ ├── Toon4D.Tests.Conformance.pas
│ ├── Toon4D.Tests.OfficialFixtures.pas
│ └── Toon4D.Tests.Helpers.pas
├── SPEC.md // Detailed technical specification
└── README.md // This file

Configuration Options
TToonOption Enumeration
type
TToonOption = (
// Indentation (mutually exclusive)
Indent2Spaces, // Default: 2 spaces per level
Indent4Spaces, // 4 spaces per level
IndentCustom, // Use CustomIndentSize// Delimiter selection (mutually exclusive)
DelimiterComma, // Default: comma separator
DelimiterTab, // Tab separator
DelimiterPipe, // Pipe separator// Key folding strategy (mutually exclusive)
KeyFoldingNone, // No key folding
KeyFoldingSafe, // Default: fold safe identifier chains
KeyFoldingAggressive, // Aggressive folding// Array format preferences
PreferTabular, // Default: prefer tabular for uniform arrays
PreferList, // Prefer list format
ForceInlineForPrimitives, // Force inline for primitive arrays// Validation strictness
StrictValidation, // Strict TOON validation
LenientValidation, // Lenient validation// Quote minimization
MinimalQuoting, // Default: minimal quotes
AlwaysQuoteStrings, // Always quote string values// Number formatting
NormalizeNumbers, // Default: canonical form
PreserveNumberFormat, // Preserve JSON number format// Whitespace handling
NoTrailingWhitespace, // Remove trailing whitespace
CompactOutput, // Minimize whitespace// Error handling
GracefulDegradation, // Default: convert invalid to valid
StrictConformance // Raise exceptions on errors
);
TToonOptions = setof TToonOption;
API Reference
TToon Class
JsonToToon (TJSONValue overload)
classfunctionJsonToToon(
JsonValue: TJSONValue;
Options: TToonOptions = []
): string;
Encodes a TJSONValue to TOON format.
Parameters:
  • JsonValue: The JSON value to encode (must not be nil)
  • Options: Encoding options (defaults to safe defaults)
Returns: TOON formatted string
Raises:
  • EToonInvalidJsonException - When JsonValue is nil or invalid
  • EToonEncodingException - When encoding fails in strict mode
JsonToToon (String overload)
classfunctionJsonToToon(
const JsonString: string;
Options: TToonOptions = []
): string;
Encodes a JSON string to TOON format.
Parameters:
  • JsonString: Valid JSON string
  • Options: Encoding options
Returns: TOON formatted string
Raises:
  • EToonInvalidJsonException - When JSON string is malformed
  • EToonEncodingException - When encoding fails in strict mode
Validate
classfunctionValidate(
const ToonString: string;
out ErrorMessage: string
): Boolean;
Validates a TOON string against the specification.
Parameters:
  • ToonString: TOON formatted string to validate
  • ErrorMessage: Output parameter with error details
Returns: True if valid, False otherwise
GetLibraryVersion
classfunctionGetLibraryVersion: string;
Returns the library version string (e.g., "1.0.0").
References
Official TOON Resources
  1. TOON Specification v2.0https://github.com/toon-format/spec
  2. TOON Format Repositoryhttps://github.com/toon-format/toon
  3. Official Test Fixtures (340+ tests)
https://github.com/toon-format/spec/tree/main/tests/fixtures
Delphi Resources
  1. System.JSON Documentationhttps://docwiki.embarcadero.com/Libraries/en/System.JSON
  2. DUnitX Testing Frameworkhttps://github.com/VSoftTechnologies/DUnitX
License
MIT License - See LICENSE file for details
Contributing
Contributions welcome! Please open an issue or pull request on GitHub.
Commercial Support
This library is MIT licensed and free to use. For companies that depend on it commercially we offer support and maintenance agreements with guaranteed response times, and sponsored development of features you need. Contact us at gdksoftware.com/contact-us or open an issue to get in touch.
About
Delphi JSON to TOON encoder - 30-60% token reduction for LLM prompts
gdksoftware.com
Topics
delphi
Resources
Readme
MIT license
Activity
Custom properties
Stars
18 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - GDKsoftware/Toon4D: Delphi JSON to TOON encoder - 30-60% token reduction for LLM prompts · GitHub
Skip to content
BranchesTags
Repository files navigation
Toon4D Library - LLM Data Optimization
Token-Oriented Object Notation (TOON) Encoder for Delphi
Overview
Toon4D is a Delphi library that encodes JSON data to TOON format - a compact, human-readable serialization format designed specifically for Large Language Model (LLM) applications. TOON achieves 30-60% token reduction compared to standard JSON while maintaining or improving LLM comprehension.
Key Features
  • Full TOON 2.0 Specification Compliance - Complete implementation of all required features
  • Token Efficiency - 30-60% token reduction on typical LLM payloads
  • Zero Dependencies - Uses only Delphi RTL (System.JSON)
  • Cross-Platform - Windows, macOS, Linux, iOS, Android
  • Comprehensive Test Suite - 300+ unit tests covering all edge cases
  • Clean API - Embarcadero-style static class methods
TOON Format Benefits
TOON is specifically designed for LLM prompts and provides:
  1. Tabular Arrays: Objects with uniform structure encoded as CSV-style rows
    users[3]{id,name,role}:
1,Alice,admin
2,Bob,user
3,Charlie,viewer

  2. Minimal Syntax: Removes redundant punctuation (braces, brackets, quotes)
  3. Explicit Structure: Array lengths and field names declared upfront for validation
  4. Indentation-Based: YAML-like nesting for readability
Quick Start
Installation
// Add to your uses clauseuses
Toon4D,
Toon4D.Types;
Basic Usage
var
JsonString := '{"name":"Alice","age":30,"active":true}';
ToonOutput := TToon.JsonToToon(JsonString);
// Result:// name: Alice// age: 30// active: true
Tabular Arrays
var
JsonString := ''' { "employees": [ {"id": 1, "name": "Alice Johnson", "role": "admin"}, {"id": 2, "name": "Bob Smith", "role": "user"}, {"id": 3, "name": "Charlie Brown", "role": "user"} ] }''';
ToonOutput := TToon.JsonToToon(JsonString);
// Result:// employees[3]{id,name,role}:// 1,Alice Johnson,admin// 2,Bob Smith,user// 3,Charlie Brown,user
Configuration Options
var
Options: TToonOptions := [
TToonOption.Indent4Spaces, // Use 4 spaces instead of 2
TToonOption.DelimiterPipe, // Use pipe delimiter instead of comma
TToonOption.KeyFoldingAggressive, // Aggressive key folding
TToonOption.PreferTabular // Prefer tabular format for arrays
];
ToonOutput := TToon.JsonToToon(JsonString, Options);
Project Structure
Toon4D/
├── Source/
│ ├── Toon4D.pas // Main API (TToon static class)
│ ├── Toon4D.Types.pas // Types, enums, options, exceptions
│ ├── Toon4D.Consts.pas // Constants and resourcestrings
│ └── Toon4D.Utils.pas // Utility functions
├── Tests/
│ ├── Toon4D.Tests.dpr // Test project
│ ├── Toon4D.Tests.Primitives.pas
│ ├── Toon4D.Tests.Arrays.pas
│ ├── Toon4D.Tests.ArrayEdgeCases.pas
│ ├── Toon4D.Tests.RootArrays.pas
│ ├── Toon4D.Tests.Nesting.pas
│ ├── Toon4D.Tests.KeyFolding.pas
│ ├── Toon4D.Tests.KeyEdgeCases.pas
│ ├── Toon4D.Tests.Delimiters.pas
│ ├── Toon4D.Tests.EdgeCases.pas
│ ├── Toon4D.Tests.ObjectEdgeCases.pas
│ ├── Toon4D.Tests.Whitespace.pas
│ ├── Toon4D.Tests.Integration.pas
│ ├── Toon4D.Tests.Conformance.pas
│ ├── Toon4D.Tests.OfficialFixtures.pas
│ └── Toon4D.Tests.Helpers.pas
├── SPEC.md // Detailed technical specification
└── README.md // This file

Configuration Options
TToonOption Enumeration
type
TToonOption = (
// Indentation (mutually exclusive)
Indent2Spaces, // Default: 2 spaces per level
Indent4Spaces, // 4 spaces per level
IndentCustom, // Use CustomIndentSize// Delimiter selection (mutually exclusive)
DelimiterComma, // Default: comma separator
DelimiterTab, // Tab separator
DelimiterPipe, // Pipe separator// Key folding strategy (mutually exclusive)
KeyFoldingNone, // No key folding
KeyFoldingSafe, // Default: fold safe identifier chains
KeyFoldingAggressive, // Aggressive folding// Array format preferences
PreferTabular, // Default: prefer tabular for uniform arrays
PreferList, // Prefer list format
ForceInlineForPrimitives, // Force inline for primitive arrays// Validation strictness
StrictValidation, // Strict TOON validation
LenientValidation, // Lenient validation// Quote minimization
MinimalQuoting, // Default: minimal quotes
AlwaysQuoteStrings, // Always quote string values// Number formatting
NormalizeNumbers, // Default: canonical form
PreserveNumberFormat, // Preserve JSON number format// Whitespace handling
NoTrailingWhitespace, // Remove trailing whitespace
CompactOutput, // Minimize whitespace// Error handling
GracefulDegradation, // Default: convert invalid to valid
StrictConformance // Raise exceptions on errors
);
TToonOptions = setof TToonOption;
API Reference
TToon Class
JsonToToon (TJSONValue overload)
classfunctionJsonToToon(
JsonValue: TJSONValue;
Options: TToonOptions = []
): string;
Encodes a TJSONValue to TOON format.
Parameters:
  • JsonValue: The JSON value to encode (must not be nil)
  • Options: Encoding options (defaults to safe defaults)
Returns: TOON formatted string
Raises:
  • EToonInvalidJsonException - When JsonValue is nil or invalid
  • EToonEncodingException - When encoding fails in strict mode
JsonToToon (String overload)
classfunctionJsonToToon(
const JsonString: string;
Options: TToonOptions = []
): string;
Encodes a JSON string to TOON format.
Parameters:
  • JsonString: Valid JSON string
  • Options: Encoding options
Returns: TOON formatted string
Raises:
  • EToonInvalidJsonException - When JSON string is malformed
  • EToonEncodingException - When encoding fails in strict mode
Validate
classfunctionValidate(
const ToonString: string;
out ErrorMessage: string
): Boolean;
Validates a TOON string against the specification.
Parameters:
  • ToonString: TOON formatted string to validate
  • ErrorMessage: Output parameter with error details
Returns: True if valid, False otherwise
GetLibraryVersion
classfunctionGetLibraryVersion: string;
Returns the library version string (e.g., "1.0.0").
References
Official TOON Resources
  1. TOON Specification v2.0https://github.com/toon-format/spec
  2. TOON Format Repositoryhttps://github.com/toon-format/toon
  3. Official Test Fixtures (340+ tests)
https://github.com/toon-format/spec/tree/main/tests/fixtures
Delphi Resources
  1. System.JSON Documentationhttps://docwiki.embarcadero.com/Libraries/en/System.JSON
  2. DUnitX Testing Frameworkhttps://github.com/VSoftTechnologies/DUnitX
License
MIT License - See LICENSE file for details
Contributing
Contributions welcome! Please open an issue or pull request on GitHub.
Commercial Support
This library is MIT licensed and free to use. For companies that depend on it commercially we offer support and maintenance agreements with guaranteed response times, and sponsored development of features you need. Contact us at gdksoftware.com/contact-us or open an issue to get in touch.
About
Delphi JSON to TOON encoder - 30-60% token reduction for LLM prompts
gdksoftware.com
Topics
delphi
Resources
Readme
MIT license
Activity
Custom properties
Stars
18 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - GDKsoftware/Toon4D: Delphi JSON to TOON encoder - 30-60% token reduction for LLM prompts · GitHub
Skip to content
BranchesTags
Repository files navigation
Toon4D Library - LLM Data Optimization
Token-Oriented Object Notation (TOON) Encoder for Delphi
Overview
Toon4D is a Delphi library that encodes JSON data to TOON format - a compact, human-readable serialization format designed specifically for Large Language Model (LLM) applications. TOON achieves 30-60% token reduction compared to standard JSON while maintaining or improving LLM comprehension.
Key Features
  • Full TOON 2.0 Specification Compliance - Complete implementation of all required features
  • Token Efficiency - 30-60% token reduction on typical LLM payloads
  • Zero Dependencies - Uses only Delphi RTL (System.JSON)
  • Cross-Platform - Windows, macOS, Linux, iOS, Android
  • Comprehensive Test Suite - 300+ unit tests covering all edge cases
  • Clean API - Embarcadero-style static class methods
TOON Format Benefits
TOON is specifically designed for LLM prompts and provides:
  1. Tabular Arrays: Objects with uniform structure encoded as CSV-style rows
    users[3]{id,name,role}:
1,Alice,admin
2,Bob,user
3,Charlie,viewer

  2. Minimal Syntax: Removes redundant punctuation (braces, brackets, quotes)
  3. Explicit Structure: Array lengths and field names declared upfront for validation
  4. Indentation-Based: YAML-like nesting for readability
Quick Start
Installation
// Add to your uses clauseuses
Toon4D,
Toon4D.Types;
Basic Usage
var
JsonString := '{"name":"Alice","age":30,"active":true}';
ToonOutput := TToon.JsonToToon(JsonString);
// Result:// name: Alice// age: 30// active: true
Tabular Arrays
var
JsonString := ''' { "employees": [ {"id": 1, "name": "Alice Johnson", "role": "admin"}, {"id": 2, "name": "Bob Smith", "role": "user"}, {"id": 3, "name": "Charlie Brown", "role": "user"} ] }''';
ToonOutput := TToon.JsonToToon(JsonString);
// Result:// employees[3]{id,name,role}:// 1,Alice Johnson,admin// 2,Bob Smith,user// 3,Charlie Brown,user
Configuration Options
var
Options: TToonOptions := [
TToonOption.Indent4Spaces, // Use 4 spaces instead of 2
TToonOption.DelimiterPipe, // Use pipe delimiter instead of comma
TToonOption.KeyFoldingAggressive, // Aggressive key folding
TToonOption.PreferTabular // Prefer tabular format for arrays
];
ToonOutput := TToon.JsonToToon(JsonString, Options);
Project Structure
Toon4D/
├── Source/
│ ├── Toon4D.pas // Main API (TToon static class)
│ ├── Toon4D.Types.pas // Types, enums, options, exceptions
│ ├── Toon4D.Consts.pas // Constants and resourcestrings
│ └── Toon4D.Utils.pas // Utility functions
├── Tests/
│ ├── Toon4D.Tests.dpr // Test project
│ ├── Toon4D.Tests.Primitives.pas
│ ├── Toon4D.Tests.Arrays.pas
│ ├── Toon4D.Tests.ArrayEdgeCases.pas
│ ├── Toon4D.Tests.RootArrays.pas
│ ├── Toon4D.Tests.Nesting.pas
│ ├── Toon4D.Tests.KeyFolding.pas
│ ├── Toon4D.Tests.KeyEdgeCases.pas
│ ├── Toon4D.Tests.Delimiters.pas
│ ├── Toon4D.Tests.EdgeCases.pas
│ ├── Toon4D.Tests.ObjectEdgeCases.pas
│ ├── Toon4D.Tests.Whitespace.pas
│ ├── Toon4D.Tests.Integration.pas
│ ├── Toon4D.Tests.Conformance.pas
│ ├── Toon4D.Tests.OfficialFixtures.pas
│ └── Toon4D.Tests.Helpers.pas
├── SPEC.md // Detailed technical specification
└── README.md // This file

Configuration Options
TToonOption Enumeration
type
TToonOption = (
// Indentation (mutually exclusive)
Indent2Spaces, // Default: 2 spaces per level
Indent4Spaces, // 4 spaces per level
IndentCustom, // Use CustomIndentSize// Delimiter selection (mutually exclusive)
DelimiterComma, // Default: comma separator
DelimiterTab, // Tab separator
DelimiterPipe, // Pipe separator// Key folding strategy (mutually exclusive)
KeyFoldingNone, // No key folding
KeyFoldingSafe, // Default: fold safe identifier chains
KeyFoldingAggressive, // Aggressive folding// Array format preferences
PreferTabular, // Default: prefer tabular for uniform arrays
PreferList, // Prefer list format
ForceInlineForPrimitives, // Force inline for primitive arrays// Validation strictness
StrictValidation, // Strict TOON validation
LenientValidation, // Lenient validation// Quote minimization
MinimalQuoting, // Default: minimal quotes
AlwaysQuoteStrings, // Always quote string values// Number formatting
NormalizeNumbers, // Default: canonical form
PreserveNumberFormat, // Preserve JSON number format// Whitespace handling
NoTrailingWhitespace, // Remove trailing whitespace
CompactOutput, // Minimize whitespace// Error handling
GracefulDegradation, // Default: convert invalid to valid
StrictConformance // Raise exceptions on errors
);
TToonOptions = setof TToonOption;
API Reference
TToon Class
JsonToToon (TJSONValue overload)
classfunctionJsonToToon(
JsonValue: TJSONValue;
Options: TToonOptions = []
): string;
Encodes a TJSONValue to TOON format.
Parameters:
  • JsonValue: The JSON value to encode (must not be nil)
  • Options: Encoding options (defaults to safe defaults)
Returns: TOON formatted string
Raises:
  • EToonInvalidJsonException - When JsonValue is nil or invalid
  • EToonEncodingException - When encoding fails in strict mode
JsonToToon (String overload)
classfunctionJsonToToon(
const JsonString: string;
Options: TToonOptions = []
): string;
Encodes a JSON string to TOON format.
Parameters:
  • JsonString: Valid JSON string
  • Options: Encoding options
Returns: TOON formatted string
Raises:
  • EToonInvalidJsonException - When JSON string is malformed
  • EToonEncodingException - When encoding fails in strict mode
Validate
classfunctionValidate(
const ToonString: string;
out ErrorMessage: string
): Boolean;
Validates a TOON string against the specification.
Parameters:
  • ToonString: TOON formatted string to validate
  • ErrorMessage: Output parameter with error details
Returns: True if valid, False otherwise
GetLibraryVersion
classfunctionGetLibraryVersion: string;
Returns the library version string (e.g., "1.0.0").
References
Official TOON Resources
  1. TOON Specification v2.0https://github.com/toon-format/spec
  2. TOON Format Repositoryhttps://github.com/toon-format/toon
  3. Official Test Fixtures (340+ tests)
https://github.com/toon-format/spec/tree/main/tests/fixtures
Delphi Resources
  1. System.JSON Documentationhttps://docwiki.embarcadero.com/Libraries/en/System.JSON
  2. DUnitX Testing Frameworkhttps://github.com/VSoftTechnologies/DUnitX
License
MIT License - See LICENSE file for details
Contributing
Contributions welcome! Please open an issue or pull request on GitHub.
Commercial Support
This library is MIT licensed and free to use. For companies that depend on it commercially we offer support and maintenance agreements with guaranteed response times, and sponsored development of features you need. Contact us at gdksoftware.com/contact-us or open an issue to get in touch.
About
Delphi JSON to TOON encoder - 30-60% token reduction for LLM prompts
gdksoftware.com
Topics
delphi
Resources
Readme
MIT license
Activity
Custom properties
Stars
18 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - GDKsoftware/Toon4D: Delphi JSON to TOON encoder - 30-60% token reduction for LLM prompts · GitHub
Skip to content
BranchesTags
Repository files navigation
Toon4D Library - LLM Data Optimization
Token-Oriented Object Notation (TOON) Encoder for Delphi
Overview
Toon4D is a Delphi library that encodes JSON data to TOON format - a compact, human-readable serialization format designed specifically for Large Language Model (LLM) applications. TOON achieves 30-60% token reduction compared to standard JSON while maintaining or improving LLM comprehension.
Key Features
  • Full TOON 2.0 Specification Compliance - Complete implementation of all required features
  • Token Efficiency - 30-60% token reduction on typical LLM payloads
  • Zero Dependencies - Uses only Delphi RTL (System.JSON)
  • Cross-Platform - Windows, macOS, Linux, iOS, Android
  • Comprehensive Test Suite - 300+ unit tests covering all edge cases
  • Clean API - Embarcadero-style static class methods
TOON Format Benefits
TOON is specifically designed for LLM prompts and provides:
  1. Tabular Arrays: Objects with uniform structure encoded as CSV-style rows
    users[3]{id,name,role}:
1,Alice,admin
2,Bob,user
3,Charlie,viewer

  2. Minimal Syntax: Removes redundant punctuation (braces, brackets, quotes)
  3. Explicit Structure: Array lengths and field names declared upfront for validation
  4. Indentation-Based: YAML-like nesting for readability
Quick Start
Installation
// Add to your uses clauseuses
Toon4D,
Toon4D.Types;
Basic Usage
var
JsonString := '{"name":"Alice","age":30,"active":true}';
ToonOutput := TToon.JsonToToon(JsonString);
// Result:// name: Alice// age: 30// active: true
Tabular Arrays
var
JsonString := ''' { "employees": [ {"id": 1, "name": "Alice Johnson", "role": "admin"}, {"id": 2, "name": "Bob Smith", "role": "user"}, {"id": 3, "name": "Charlie Brown", "role": "user"} ] }''';
ToonOutput := TToon.JsonToToon(JsonString);
// Result:// employees[3]{id,name,role}:// 1,Alice Johnson,admin// 2,Bob Smith,user// 3,Charlie Brown,user
Configuration Options
var
Options: TToonOptions := [
TToonOption.Indent4Spaces, // Use 4 spaces instead of 2
TToonOption.DelimiterPipe, // Use pipe delimiter instead of comma
TToonOption.KeyFoldingAggressive, // Aggressive key folding
TToonOption.PreferTabular // Prefer tabular format for arrays
];
ToonOutput := TToon.JsonToToon(JsonString, Options);
Project Structure
Toon4D/
├── Source/
│ ├── Toon4D.pas // Main API (TToon static class)
│ ├── Toon4D.Types.pas // Types, enums, options, exceptions
│ ├── Toon4D.Consts.pas // Constants and resourcestrings
│ └── Toon4D.Utils.pas // Utility functions
├── Tests/
│ ├── Toon4D.Tests.dpr // Test project
│ ├── Toon4D.Tests.Primitives.pas
│ ├── Toon4D.Tests.Arrays.pas
│ ├── Toon4D.Tests.ArrayEdgeCases.pas
│ ├── Toon4D.Tests.RootArrays.pas
│ ├── Toon4D.Tests.Nesting.pas
│ ├── Toon4D.Tests.KeyFolding.pas
│ ├── Toon4D.Tests.KeyEdgeCases.pas
│ ├── Toon4D.Tests.Delimiters.pas
│ ├── Toon4D.Tests.EdgeCases.pas
│ ├── Toon4D.Tests.ObjectEdgeCases.pas
│ ├── Toon4D.Tests.Whitespace.pas
│ ├── Toon4D.Tests.Integration.pas
│ ├── Toon4D.Tests.Conformance.pas
│ ├── Toon4D.Tests.OfficialFixtures.pas
│ └── Toon4D.Tests.Helpers.pas
├── SPEC.md // Detailed technical specification
└── README.md // This file

Configuration Options
TToonOption Enumeration
type
TToonOption = (
// Indentation (mutually exclusive)
Indent2Spaces, // Default: 2 spaces per level
Indent4Spaces, // 4 spaces per level
IndentCustom, // Use CustomIndentSize// Delimiter selection (mutually exclusive)
DelimiterComma, // Default: comma separator
DelimiterTab, // Tab separator
DelimiterPipe, // Pipe separator// Key folding strategy (mutually exclusive)
KeyFoldingNone, // No key folding
KeyFoldingSafe, // Default: fold safe identifier chains
KeyFoldingAggressive, // Aggressive folding// Array format preferences
PreferTabular, // Default: prefer tabular for uniform arrays
PreferList, // Prefer list format
ForceInlineForPrimitives, // Force inline for primitive arrays// Validation strictness
StrictValidation, // Strict TOON validation
LenientValidation, // Lenient validation// Quote minimization
MinimalQuoting, // Default: minimal quotes
AlwaysQuoteStrings, // Always quote string values// Number formatting
NormalizeNumbers, // Default: canonical form
PreserveNumberFormat, // Preserve JSON number format// Whitespace handling
NoTrailingWhitespace, // Remove trailing whitespace
CompactOutput, // Minimize whitespace// Error handling
GracefulDegradation, // Default: convert invalid to valid
StrictConformance // Raise exceptions on errors
);
TToonOptions = setof TToonOption;
API Reference
TToon Class
JsonToToon (TJSONValue overload)
classfunctionJsonToToon(
JsonValue: TJSONValue;
Options: TToonOptions = []
): string;
Encodes a TJSONValue to TOON format.
Parameters:
  • JsonValue: The JSON value to encode (must not be nil)
  • Options: Encoding options (defaults to safe defaults)
Returns: TOON formatted string
Raises:
  • EToonInvalidJsonException - When JsonValue is nil or invalid
  • EToonEncodingException - When encoding fails in strict mode
JsonToToon (String overload)
classfunctionJsonToToon(
const JsonString: string;
Options: TToonOptions = []
): string;
Encodes a JSON string to TOON format.
Parameters:
  • JsonString: Valid JSON string
  • Options: Encoding options
Returns: TOON formatted string
Raises:
  • EToonInvalidJsonException - When JSON string is malformed
  • EToonEncodingException - When encoding fails in strict mode
Validate
classfunctionValidate(
const ToonString: string;
out ErrorMessage: string
): Boolean;
Validates a TOON string against the specification.
Parameters:
  • ToonString: TOON formatted string to validate
  • ErrorMessage: Output parameter with error details
Returns: True if valid, False otherwise
GetLibraryVersion
classfunctionGetLibraryVersion: string;
Returns the library version string (e.g., "1.0.0").
References
Official TOON Resources
  1. TOON Specification v2.0https://github.com/toon-format/spec
  2. TOON Format Repositoryhttps://github.com/toon-format/toon
  3. Official Test Fixtures (340+ tests)
https://github.com/toon-format/spec/tree/main/tests/fixtures
Delphi Resources
  1. System.JSON Documentationhttps://docwiki.embarcadero.com/Libraries/en/System.JSON
  2. DUnitX Testing Frameworkhttps://github.com/VSoftTechnologies/DUnitX
License
MIT License - See LICENSE file for details
Contributing
Contributions welcome! Please open an issue or pull request on GitHub.
Commercial Support
This library is MIT licensed and free to use. For companies that depend on it commercially we offer support and maintenance agreements with guaranteed response times, and sponsored development of features you need. Contact us at gdksoftware.com/contact-us or open an issue to get in touch.
About
Delphi JSON to TOON encoder - 30-60% token reduction for LLM prompts
gdksoftware.com
Topics
delphi
Resources
Readme
MIT license
Activity
Custom properties
Stars
18 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - GDKsoftware/Toon4D: Delphi JSON to TOON encoder - 30-60% token reduction for LLM prompts · GitHub
Skip to content
BranchesTags
Repository files navigation
Toon4D Library - LLM Data Optimization
Token-Oriented Object Notation (TOON) Encoder for Delphi
Overview
Toon4D is a Delphi library that encodes JSON data to TOON format - a compact, human-readable serialization format designed specifically for Large Language Model (LLM) applications. TOON achieves 30-60% token reduction compared to standard JSON while maintaining or improving LLM comprehension.
Key Features
  • Full TOON 2.0 Specification Compliance - Complete implementation of all required features
  • Token Efficiency - 30-60% token reduction on typical LLM payloads
  • Zero Dependencies - Uses only Delphi RTL (System.JSON)
  • Cross-Platform - Windows, macOS, Linux, iOS, Android
  • Comprehensive Test Suite - 300+ unit tests covering all edge cases
  • Clean API - Embarcadero-style static class methods
TOON Format Benefits
TOON is specifically designed for LLM prompts and provides:
  1. Tabular Arrays: Objects with uniform structure encoded as CSV-style rows
    users[3]{id,name,role}:
1,Alice,admin
2,Bob,user
3,Charlie,viewer

  2. Minimal Syntax: Removes redundant punctuation (braces, brackets, quotes)
  3. Explicit Structure: Array lengths and field names declared upfront for validation
  4. Indentation-Based: YAML-like nesting for readability
Quick Start
Installation
// Add to your uses clauseuses
Toon4D,
Toon4D.Types;
Basic Usage
var
JsonString := '{"name":"Alice","age":30,"active":true}';
ToonOutput := TToon.JsonToToon(JsonString);
// Result:// name: Alice// age: 30// active: true
Tabular Arrays
var
JsonString := ''' { "employees": [ {"id": 1, "name": "Alice Johnson", "role": "admin"}, {"id": 2, "name": "Bob Smith", "role": "user"}, {"id": 3, "name": "Charlie Brown", "role": "user"} ] }''';
ToonOutput := TToon.JsonToToon(JsonString);
// Result:// employees[3]{id,name,role}:// 1,Alice Johnson,admin// 2,Bob Smith,user// 3,Charlie Brown,user
Configuration Options
var
Options: TToonOptions := [
TToonOption.Indent4Spaces, // Use 4 spaces instead of 2
TToonOption.DelimiterPipe, // Use pipe delimiter instead of comma
TToonOption.KeyFoldingAggressive, // Aggressive key folding
TToonOption.PreferTabular // Prefer tabular format for arrays
];
ToonOutput := TToon.JsonToToon(JsonString, Options);
Project Structure
Toon4D/
├── Source/
│ ├── Toon4D.pas // Main API (TToon static class)
│ ├── Toon4D.Types.pas // Types, enums, options, exceptions
│ ├── Toon4D.Consts.pas // Constants and resourcestrings
│ └── Toon4D.Utils.pas // Utility functions
├── Tests/
│ ├── Toon4D.Tests.dpr // Test project
│ ├── Toon4D.Tests.Primitives.pas
│ ├── Toon4D.Tests.Arrays.pas
│ ├── Toon4D.Tests.ArrayEdgeCases.pas
│ ├── Toon4D.Tests.RootArrays.pas
│ ├── Toon4D.Tests.Nesting.pas
│ ├── Toon4D.Tests.KeyFolding.pas
│ ├── Toon4D.Tests.KeyEdgeCases.pas
│ ├── Toon4D.Tests.Delimiters.pas
│ ├── Toon4D.Tests.EdgeCases.pas
│ ├── Toon4D.Tests.ObjectEdgeCases.pas
│ ├── Toon4D.Tests.Whitespace.pas
│ ├── Toon4D.Tests.Integration.pas
│ ├── Toon4D.Tests.Conformance.pas
│ ├── Toon4D.Tests.OfficialFixtures.pas
│ └── Toon4D.Tests.Helpers.pas
├── SPEC.md // Detailed technical specification
└── README.md // This file

Configuration Options
TToonOption Enumeration
type
TToonOption = (
// Indentation (mutually exclusive)
Indent2Spaces, // Default: 2 spaces per level
Indent4Spaces, // 4 spaces per level
IndentCustom, // Use CustomIndentSize// Delimiter selection (mutually exclusive)
DelimiterComma, // Default: comma separator
DelimiterTab, // Tab separator
DelimiterPipe, // Pipe separator// Key folding strategy (mutually exclusive)
KeyFoldingNone, // No key folding
KeyFoldingSafe, // Default: fold safe identifier chains
KeyFoldingAggressive, // Aggressive folding// Array format preferences
PreferTabular, // Default: prefer tabular for uniform arrays
PreferList, // Prefer list format
ForceInlineForPrimitives, // Force inline for primitive arrays// Validation strictness
StrictValidation, // Strict TOON validation
LenientValidation, // Lenient validation// Quote minimization
MinimalQuoting, // Default: minimal quotes
AlwaysQuoteStrings, // Always quote string values// Number formatting
NormalizeNumbers, // Default: canonical form
PreserveNumberFormat, // Preserve JSON number format// Whitespace handling
NoTrailingWhitespace, // Remove trailing whitespace
CompactOutput, // Minimize whitespace// Error handling
GracefulDegradation, // Default: convert invalid to valid
StrictConformance // Raise exceptions on errors
);
TToonOptions = setof TToonOption;
API Reference
TToon Class
JsonToToon (TJSONValue overload)
classfunctionJsonToToon(
JsonValue: TJSONValue;
Options: TToonOptions = []
): string;
Encodes a TJSONValue to TOON format.
Parameters:
  • JsonValue: The JSON value to encode (must not be nil)
  • Options: Encoding options (defaults to safe defaults)
Returns: TOON formatted string
Raises:
  • EToonInvalidJsonException - When JsonValue is nil or invalid
  • EToonEncodingException - When encoding fails in strict mode
JsonToToon (String overload)
classfunctionJsonToToon(
const JsonString: string;
Options: TToonOptions = []
): string;
Encodes a JSON string to TOON format.
Parameters:
  • JsonString: Valid JSON string
  • Options: Encoding options
Returns: TOON formatted string
Raises:
  • EToonInvalidJsonException - When JSON string is malformed
  • EToonEncodingException - When encoding fails in strict mode
Validate
classfunctionValidate(
const ToonString: string;
out ErrorMessage: string
): Boolean;
Validates a TOON string against the specification.
Parameters:
  • ToonString: TOON formatted string to validate
  • ErrorMessage: Output parameter with error details
Returns: True if valid, False otherwise
GetLibraryVersion
classfunctionGetLibraryVersion: string;
Returns the library version string (e.g., "1.0.0").
References
Official TOON Resources
  1. TOON Specification v2.0https://github.com/toon-format/spec
  2. TOON Format Repositoryhttps://github.com/toon-format/toon
  3. Official Test Fixtures (340+ tests)
https://github.com/toon-format/spec/tree/main/tests/fixtures
Delphi Resources
  1. System.JSON Documentationhttps://docwiki.embarcadero.com/Libraries/en/System.JSON
  2. DUnitX Testing Frameworkhttps://github.com/VSoftTechnologies/DUnitX
License
MIT License - See LICENSE file for details
Contributing
Contributions welcome! Please open an issue or pull request on GitHub.
Commercial Support
This library is MIT licensed and free to use. For companies that depend on it commercially we offer support and maintenance agreements with guaranteed response times, and sponsored development of features you need. Contact us at gdksoftware.com/contact-us or open an issue to get in touch.
About
Delphi JSON to TOON encoder - 30-60% token reduction for LLM prompts
gdksoftware.com
Topics
delphi
Resources
Readme
MIT license
Activity
Custom properties
Stars
18 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - GDKsoftware/Toon4D: Delphi JSON to TOON encoder - 30-60% token reduction for LLM prompts · GitHub
Skip to content
BranchesTags
Repository files navigation
Toon4D Library - LLM Data Optimization
Token-Oriented Object Notation (TOON) Encoder for Delphi
Overview
Toon4D is a Delphi library that encodes JSON data to TOON format - a compact, human-readable serialization format designed specifically for Large Language Model (LLM) applications. TOON achieves 30-60% token reduction compared to standard JSON while maintaining or improving LLM comprehension.
Key Features
  • Full TOON 2.0 Specification Compliance - Complete implementation of all required features
  • Token Efficiency - 30-60% token reduction on typical LLM payloads
  • Zero Dependencies - Uses only Delphi RTL (System.JSON)
  • Cross-Platform - Windows, macOS, Linux, iOS, Android
  • Comprehensive Test Suite - 300+ unit tests covering all edge cases
  • Clean API - Embarcadero-style static class methods
TOON Format Benefits
TOON is specifically designed for LLM prompts and provides:
  1. Tabular Arrays: Objects with uniform structure encoded as CSV-style rows
    users[3]{id,name,role}:
1,Alice,admin
2,Bob,user
3,Charlie,viewer

  2. Minimal Syntax: Removes redundant punctuation (braces, brackets, quotes)
  3. Explicit Structure: Array lengths and field names declared upfront for validation
  4. Indentation-Based: YAML-like nesting for readability
Quick Start
Installation
// Add to your uses clauseuses
Toon4D,
Toon4D.Types;
Basic Usage
var
JsonString := '{"name":"Alice","age":30,"active":true}';
ToonOutput := TToon.JsonToToon(JsonString);
// Result:// name: Alice// age: 30// active: true
Tabular Arrays
var
JsonString := ''' { "employees": [ {"id": 1, "name": "Alice Johnson", "role": "admin"}, {"id": 2, "name": "Bob Smith", "role": "user"}, {"id": 3, "name": "Charlie Brown", "role": "user"} ] }''';
ToonOutput := TToon.JsonToToon(JsonString);
// Result:// employees[3]{id,name,role}:// 1,Alice Johnson,admin// 2,Bob Smith,user// 3,Charlie Brown,user
Configuration Options
var
Options: TToonOptions := [
TToonOption.Indent4Spaces, // Use 4 spaces instead of 2
TToonOption.DelimiterPipe, // Use pipe delimiter instead of comma
TToonOption.KeyFoldingAggressive, // Aggressive key folding
TToonOption.PreferTabular // Prefer tabular format for arrays
];
ToonOutput := TToon.JsonToToon(JsonString, Options);
Project Structure
Toon4D/
├── Source/
│ ├── Toon4D.pas // Main API (TToon static class)
│ ├── Toon4D.Types.pas // Types, enums, options, exceptions
│ ├── Toon4D.Consts.pas // Constants and resourcestrings
│ └── Toon4D.Utils.pas // Utility functions
├── Tests/
│ ├── Toon4D.Tests.dpr // Test project
│ ├── Toon4D.Tests.Primitives.pas
│ ├── Toon4D.Tests.Arrays.pas
│ ├── Toon4D.Tests.ArrayEdgeCases.pas
│ ├── Toon4D.Tests.RootArrays.pas
│ ├── Toon4D.Tests.Nesting.pas
│ ├── Toon4D.Tests.KeyFolding.pas
│ ├── Toon4D.Tests.KeyEdgeCases.pas
│ ├── Toon4D.Tests.Delimiters.pas
│ ├── Toon4D.Tests.EdgeCases.pas
│ ├── Toon4D.Tests.ObjectEdgeCases.pas
│ ├── Toon4D.Tests.Whitespace.pas
│ ├── Toon4D.Tests.Integration.pas
│ ├── Toon4D.Tests.Conformance.pas
│ ├── Toon4D.Tests.OfficialFixtures.pas
│ └── Toon4D.Tests.Helpers.pas
├── SPEC.md // Detailed technical specification
└── README.md // This file

Configuration Options
TToonOption Enumeration
type
TToonOption = (
// Indentation (mutually exclusive)
Indent2Spaces, // Default: 2 spaces per level
Indent4Spaces, // 4 spaces per level
IndentCustom, // Use CustomIndentSize// Delimiter selection (mutually exclusive)
DelimiterComma, // Default: comma separator
DelimiterTab, // Tab separator
DelimiterPipe, // Pipe separator// Key folding strategy (mutually exclusive)
KeyFoldingNone, // No key folding
KeyFoldingSafe, // Default: fold safe identifier chains
KeyFoldingAggressive, // Aggressive folding// Array format preferences
PreferTabular, // Default: prefer tabular for uniform arrays
PreferList, // Prefer list format
ForceInlineForPrimitives, // Force inline for primitive arrays// Validation strictness
StrictValidation, // Strict TOON validation
LenientValidation, // Lenient validation// Quote minimization
MinimalQuoting, // Default: minimal quotes
AlwaysQuoteStrings, // Always quote string values// Number formatting
NormalizeNumbers, // Default: canonical form
PreserveNumberFormat, // Preserve JSON number format// Whitespace handling
NoTrailingWhitespace, // Remove trailing whitespace
CompactOutput, // Minimize whitespace// Error handling
GracefulDegradation, // Default: convert invalid to valid
StrictConformance // Raise exceptions on errors
);
TToonOptions = setof TToonOption;
API Reference
TToon Class
JsonToToon (TJSONValue overload)
classfunctionJsonToToon(
JsonValue: TJSONValue;
Options: TToonOptions = []
): string;
Encodes a TJSONValue to TOON format.
Parameters:
  • JsonValue: The JSON value to encode (must not be nil)
  • Options: Encoding options (defaults to safe defaults)
Returns: TOON formatted string
Raises:
  • EToonInvalidJsonException - When JsonValue is nil or invalid
  • EToonEncodingException - When encoding fails in strict mode
JsonToToon (String overload)
classfunctionJsonToToon(
const JsonString: string;
Options: TToonOptions = []
): string;
Encodes a JSON string to TOON format.
Parameters:
  • JsonString: Valid JSON string
  • Options: Encoding options
Returns: TOON formatted string
Raises:
  • EToonInvalidJsonException - When JSON string is malformed
  • EToonEncodingException - When encoding fails in strict mode
Validate
classfunctionValidate(
const ToonString: string;
out ErrorMessage: string
): Boolean;
Validates a TOON string against the specification.
Parameters:
  • ToonString: TOON formatted string to validate
  • ErrorMessage: Output parameter with error details
Returns: True if valid, False otherwise
GetLibraryVersion
classfunctionGetLibraryVersion: string;
Returns the library version string (e.g., "1.0.0").
References
Official TOON Resources
  1. TOON Specification v2.0https://github.com/toon-format/spec
  2. TOON Format Repositoryhttps://github.com/toon-format/toon
  3. Official Test Fixtures (340+ tests)
https://github.com/toon-format/spec/tree/main/tests/fixtures
Delphi Resources
  1. System.JSON Documentationhttps://docwiki.embarcadero.com/Libraries/en/System.JSON
  2. DUnitX Testing Frameworkhttps://github.com/VSoftTechnologies/DUnitX
License
MIT License - See LICENSE file for details
Contributing
Contributions welcome! Please open an issue or pull request on GitHub.
Commercial Support
This library is MIT licensed and free to use. For companies that depend on it commercially we offer support and maintenance agreements with guaranteed response times, and sponsored development of features you need. Contact us at gdksoftware.com/contact-us or open an issue to get in touch.
About
Delphi JSON to TOON encoder - 30-60% token reduction for LLM prompts
gdksoftware.com
Topics
delphi
Resources
Readme
MIT license
Activity
Custom properties
Stars
18 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - GDKsoftware/Toon4D: Delphi JSON to TOON encoder - 30-60% token reduction for LLM prompts · GitHub
Skip to content
BranchesTags
Repository files navigation
Toon4D Library - LLM Data Optimization
Token-Oriented Object Notation (TOON) Encoder for Delphi
Overview
Toon4D is a Delphi library that encodes JSON data to TOON format - a compact, human-readable serialization format designed specifically for Large Language Model (LLM) applications. TOON achieves 30-60% token reduction compared to standard JSON while maintaining or improving LLM comprehension.
Key Features
  • Full TOON 2.0 Specification Compliance - Complete implementation of all required features
  • Token Efficiency - 30-60% token reduction on typical LLM payloads
  • Zero Dependencies - Uses only Delphi RTL (System.JSON)
  • Cross-Platform - Windows, macOS, Linux, iOS, Android
  • Comprehensive Test Suite - 300+ unit tests covering all edge cases
  • Clean API - Embarcadero-style static class methods
TOON Format Benefits
TOON is specifically designed for LLM prompts and provides:
  1. Tabular Arrays: Objects with uniform structure encoded as CSV-style rows
    users[3]{id,name,role}:
1,Alice,admin
2,Bob,user
3,Charlie,viewer

  2. Minimal Syntax: Removes redundant punctuation (braces, brackets, quotes)
  3. Explicit Structure: Array lengths and field names declared upfront for validation
  4. Indentation-Based: YAML-like nesting for readability
Quick Start
Installation
// Add to your uses clauseuses
Toon4D,
Toon4D.Types;
Basic Usage
var
JsonString := '{"name":"Alice","age":30,"active":true}';
ToonOutput := TToon.JsonToToon(JsonString);
// Result:// name: Alice// age: 30// active: true
Tabular Arrays
var
JsonString := ''' { "employees": [ {"id": 1, "name": "Alice Johnson", "role": "admin"}, {"id": 2, "name": "Bob Smith", "role": "user"}, {"id": 3, "name": "Charlie Brown", "role": "user"} ] }''';
ToonOutput := TToon.JsonToToon(JsonString);
// Result:// employees[3]{id,name,role}:// 1,Alice Johnson,admin// 2,Bob Smith,user// 3,Charlie Brown,user
Configuration Options
var
Options: TToonOptions := [
TToonOption.Indent4Spaces, // Use 4 spaces instead of 2
TToonOption.DelimiterPipe, // Use pipe delimiter instead of comma
TToonOption.KeyFoldingAggressive, // Aggressive key folding
TToonOption.PreferTabular // Prefer tabular format for arrays
];
ToonOutput := TToon.JsonToToon(JsonString, Options);
Project Structure
Toon4D/
├── Source/
│ ├── Toon4D.pas // Main API (TToon static class)
│ ├── Toon4D.Types.pas // Types, enums, options, exceptions
│ ├── Toon4D.Consts.pas // Constants and resourcestrings
│ └── Toon4D.Utils.pas // Utility functions
├── Tests/
│ ├── Toon4D.Tests.dpr // Test project
│ ├── Toon4D.Tests.Primitives.pas
│ ├── Toon4D.Tests.Arrays.pas
│ ├── Toon4D.Tests.ArrayEdgeCases.pas
│ ├── Toon4D.Tests.RootArrays.pas
│ ├── Toon4D.Tests.Nesting.pas
│ ├── Toon4D.Tests.KeyFolding.pas
│ ├── Toon4D.Tests.KeyEdgeCases.pas
│ ├── Toon4D.Tests.Delimiters.pas
│ ├── Toon4D.Tests.EdgeCases.pas
│ ├── Toon4D.Tests.ObjectEdgeCases.pas
│ ├── Toon4D.Tests.Whitespace.pas
│ ├── Toon4D.Tests.Integration.pas
│ ├── Toon4D.Tests.Conformance.pas
│ ├── Toon4D.Tests.OfficialFixtures.pas
│ └── Toon4D.Tests.Helpers.pas
├── SPEC.md // Detailed technical specification
└── README.md // This file

Configuration Options
TToonOption Enumeration
type
TToonOption = (
// Indentation (mutually exclusive)
Indent2Spaces, // Default: 2 spaces per level
Indent4Spaces, // 4 spaces per level
IndentCustom, // Use CustomIndentSize// Delimiter selection (mutually exclusive)
DelimiterComma, // Default: comma separator
DelimiterTab, // Tab separator
DelimiterPipe, // Pipe separator// Key folding strategy (mutually exclusive)
KeyFoldingNone, // No key folding
KeyFoldingSafe, // Default: fold safe identifier chains
KeyFoldingAggressive, // Aggressive folding// Array format preferences
PreferTabular, // Default: prefer tabular for uniform arrays
PreferList, // Prefer list format
ForceInlineForPrimitives, // Force inline for primitive arrays// Validation strictness
StrictValidation, // Strict TOON validation
LenientValidation, // Lenient validation// Quote minimization
MinimalQuoting, // Default: minimal quotes
AlwaysQuoteStrings, // Always quote string values// Number formatting
NormalizeNumbers, // Default: canonical form
PreserveNumberFormat, // Preserve JSON number format// Whitespace handling
NoTrailingWhitespace, // Remove trailing whitespace
CompactOutput, // Minimize whitespace// Error handling
GracefulDegradation, // Default: convert invalid to valid
StrictConformance // Raise exceptions on errors
);
TToonOptions = setof TToonOption;
API Reference
TToon Class
JsonToToon (TJSONValue overload)
classfunctionJsonToToon(
JsonValue: TJSONValue;
Options: TToonOptions = []
): string;
Encodes a TJSONValue to TOON format.
Parameters:
  • JsonValue: The JSON value to encode (must not be nil)
  • Options: Encoding options (defaults to safe defaults)
Returns: TOON formatted string
Raises:
  • EToonInvalidJsonException - When JsonValue is nil or invalid
  • EToonEncodingException - When encoding fails in strict mode
JsonToToon (String overload)
classfunctionJsonToToon(
const JsonString: string;
Options: TToonOptions = []
): string;
Encodes a JSON string to TOON format.
Parameters:
  • JsonString: Valid JSON string
  • Options: Encoding options
Returns: TOON formatted string
Raises:
  • EToonInvalidJsonException - When JSON string is malformed
  • EToonEncodingException - When encoding fails in strict mode
Validate
classfunctionValidate(
const ToonString: string;
out ErrorMessage: string
): Boolean;
Validates a TOON string against the specification.
Parameters:
  • ToonString: TOON formatted string to validate
  • ErrorMessage: Output parameter with error details
Returns: True if valid, False otherwise
GetLibraryVersion
classfunctionGetLibraryVersion: string;
Returns the library version string (e.g., "1.0.0").
References
Official TOON Resources
  1. TOON Specification v2.0https://github.com/toon-format/spec
  2. TOON Format Repositoryhttps://github.com/toon-format/toon
  3. Official Test Fixtures (340+ tests)
https://github.com/toon-format/spec/tree/main/tests/fixtures
Delphi Resources
  1. System.JSON Documentationhttps://docwiki.embarcadero.com/Libraries/en/System.JSON
  2. DUnitX Testing Frameworkhttps://github.com/VSoftTechnologies/DUnitX
License
MIT License - See LICENSE file for details
Contributing
Contributions welcome! Please open an issue or pull request on GitHub.
Commercial Support
This library is MIT licensed and free to use. For companies that depend on it commercially we offer support and maintenance agreements with guaranteed response times, and sponsored development of features you need. Contact us at gdksoftware.com/contact-us or open an issue to get in touch.
About
Delphi JSON to TOON encoder - 30-60% token reduction for LLM prompts
gdksoftware.com
Topics
delphi
Resources
Readme
MIT license
Activity
Custom properties
Stars
18 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Packages
Contributors
Languages