Is the output guaranteed to be valid TOML?

Yes, the tool builds a plain JavaScript object tree and hands it to the smol-toml package's stringify function, the same library this site's TOML formatter tool uses, rather than assembling TOML text by hand.

Why doesn't the output ever contain null values?

TOML has no null type at all (unlike JSON or YAML), so any null scalar produced by the underlying random tree is dropped from the document before serialization rather than being coerced into some other type that would misrepresent the data.

How are nested objects and arrays represented?

Nested objects become TOML tables (`[table]` headers), arrays of scalars become inline arrays, and arrays of objects become array-of-tables (`[[table]]`) sections — all handled automatically by the smol-toml serializer.

What TOML version does this target?

TOML 1.0.0, which is what the smol-toml library implements, including its relaxed rule allowing mixed-type arrays.

Random TOML Generator - Sample Tables & Key/Value Data

Overview

Introduction

TOML is the configuration format behind tools like Cargo, Poetry, and countless static site generators, and it's often useful to have a random sample document to feed into a TOML parser or formatter you're testing.

This generator builds a random nested tree, the same kind used by the JSON/XML/YAML generators in this category, and serializes it as tables and key/value pairs.

What Is Random TOML Generator?

A random data generator whose output format is TOML rather than the more common JSON.

Serialization goes through the smol-toml npm package rather than hand-built string concatenation, so table headers, array-of-tables sections, and value quoting all follow the real TOML 1.0 spec.

How Random TOML Generator Works

The generator builds a random object tree with configurable depth, keys-per-object, and array length, exactly as the JSON generator does, then strips out any null-valued fields since TOML has no null type to represent them.

The sanitized tree is passed to smol-toml's stringify function, which automatically chooses between inline key/value pairs, `[table]` sections for nested objects, and `[[table]]` array-of-tables sections for arrays of objects.

When To Use Random TOML Generator

Use it to generate sample input for a TOML parser, linter, or config-loading library you're building or testing.

It's also useful for seeing how a TOML formatter or TOML-to-JSON/YAML converter handles a mix of tables, arrays, and array-of-tables.

Often used alongside Random YAML Generator, Random JSON Generator and Random XML Generator.

Features

Advantages

Always produces valid TOML, since serialization is delegated to a real, spec-compliant library rather than string templates.
Shares the same depth/breadth options as the JSON/XML/YAML generators for direct format comparison.
Correctly handles the null-value gap in TOML by removing null fields rather than silently producing invalid output.

Limitations

Because null fields are dropped, a TOML document generated from the exact same random tree as a JSON/YAML sibling may end up with slightly fewer fields.
Generated keys and string values are placeholder words, not realistic configuration keys like `name` or `version` you'd see in a real Cargo.toml.

Examples

A flat table

Input

(no input; generated from settings)

Output

id_0 = "nova"
name_1 = 482

A nested table

Input

(no input; generated from settings)

Output

[tags_0]
value_0 = "onyx"

Best Practices & Notes

Best Practices

Keep max depth around 2-3; deeper trees produce many nested `[table]` sections that get hard to scan.
Validate the output against your target TOML parser's exact version, since TOML 0.5 and 1.0 differ on a few edge cases (like mixed-type arrays).

Developer Notes

The same random tree structure feeds all four structured-format generators in this category (JSON, XML, YAML, TOML); TOML is the one exception that needs a sanitization pass first, since it's the only one of the four with no null type at all.

Random TOML Generator Use Cases

Generating sample input for a TOML parser or linter under test
Producing a fixture file that mimics the shape of a real Cargo.toml or pyproject.toml
Comparing how the same random data looks serialized as TOML vs. YAML vs. JSON

Common Mistakes

Expecting null values to appear in the output the way they do in the JSON/YAML siblings — TOML simply has no way to represent them, so they're omitted.
Assuming the generated table names map to a real schema; they're generic placeholder words.

Tips

Regenerate a few times at the same settings to see a range of table/array-of-tables shapes before picking one to keep.
Use the YAML generator alongside this one if you need a format that can represent null values too.

Random TOML Generator