TOML to XML Converter

Understanding TOML and XML

TOML (Tom's Obvious, Minimal Language) is a modern configuration format that prioritizes human readability. It uses tables (denoted by square brackets), key-value pairs with explicit types, and arrays of tables to structure data. TOML is the native configuration format for Rust's Cargo, Python's Poetry and pip (pyproject.toml), and the Hugo static site generator. For a comprehensive overview of TOML syntax, data types, and conventions, visit our TOML guide.

XML (eXtensible Markup Language) is a mature, self-describing markup language designed for both human and machine readability. It uses a hierarchical tree of elements with opening and closing tags, attributes, and text content. XML powers enterprise systems (SOAP web services, Java configuration), document formats (XHTML, SVG, RSS/Atom), and data exchange standards across industries including healthcare (HL7), finance (FIX), and publishing (DocBook). To learn more about XML structure, namespaces, and validation, see our XML guide.

Converting TOML to XML bridges a modern, minimal configuration language with the verbose, universally supported markup standard. This is especially useful when configuration data authored in TOML must be consumed by XML-based toolchains, build systems, or enterprise middleware.

Why Convert TOML to XML?

Although TOML and XML serve different ecosystems, there are several practical scenarios where converting between them is necessary:

• Feeding TOML configuration into XML-based build systems. Tools like Maven, Ant, and MSBuild expect XML configuration files. If your canonical configuration is maintained in TOML for readability, converting to XML lets you integrate with these build pipelines without maintaining two separate files.
• Generating XML data feeds from TOML-defined datasets. Content managed in TOML (such as product catalogs, metadata records, or structured documentation) can be converted to XML for publishing via RSS/Atom feeds, SOAP APIs, or XML-based CMS imports.
• Integrating with enterprise middleware and ESBs. Enterprise Service Buses and legacy integration platforms often require XML message formats. Converting TOML configuration or data payloads to XML enables communication with these systems.
• Creating XML configuration for Java/Spring applications. Spring Framework and many Java libraries still rely on XML configuration files. Converting TOML-authored settings to Spring-compatible XML avoids manual transcription.

How the Conversion Works

TOML-to-XML is a cross-format conversion that passes through JSON as an intermediate representation. Here is the step-by-step process:

1. Parse the TOML input using the smol-toml parser, which validates syntax and enforces the TOML specification including type correctness and table uniqueness.
2. Convert to JSON intermediate. TOML tables become JSON objects, arrays of tables become JSON arrays of objects, and scalar values (strings, integers, floats, booleans, dates) are mapped to their JSON equivalents.
3. Transform JSON to XML. Each JSON key becomes an XML element name. Objects produce nested elements, arrays produce repeating sibling elements, and scalar values become text content within their parent elements.
4. Wrap in a root element to ensure the output is a well-formed XML document with a single root node.
5. Escape special characters (&, <, >, ") to produce valid XML output.

The table below shows how common TOML constructs map to XML elements:

Before and After Example

Below is a practical example showing a TOML application configuration and its XML equivalent after conversion.

[application]
name = "WebService"
version = "2.1.0"
debug = false

[application.server]
host = "0.0.0.0"
port = 8080

[application.database]
driver = "postgresql"
host = "db.example.com"
port = 5432
name = "production"

[[application.routes]]
path = "/api/users"
method = "GET"

[[application.routes]]
path = "/api/orders"
method = "POST"

<?xml version="1.0" encoding="UTF-8"?>
<root>
  <application>
    <name>WebService</name>
    <version>2.1.0</version>
    <debug>false</debug>
    <server>
      <host>0.0.0.0</host>
      <port>8080</port>
    </server>
    <database>
      <driver>postgresql</driver>
      <host>db.example.com</host>
      <port>5432</port>
      <name>production</name>
    </database>
    <routes>
      <path>/api/users</path>
      <method>GET</method>
    </routes>
    <routes>
      <path>/api/orders</path>
      <method>POST</method>
    </routes>
  </application>
</root>

Notice how TOML tables map directly to nested XML elements, preserving the full hierarchy. The [[application.routes]] array of tables becomes repeating <routes> elements, each containing the same child structure. The result is a well-formed XML document ready for consumption by any XML-aware tool.

Tips and Best Practices

Related Tools

Explore other converters and resources that complement TOML-to-XML conversion: