XSLT (Extensible Stylesheet Language Transformations) has been a core technology for XML data transformation since the early 2000s. While XSLT 1.0 laid the groundwork, subsequent versions — 2.0 and 3.0 — significantly expanded the language’s capabilities, power, and usability.
You can use XSLT 3.0 in Xojo with MBS Xojo Plugins and our Saxon classes. Please check the MBS Xojo XML Plugin. The built-in XSLT in Xojo itself is only doing XSLT 1.0.
Here’s a breakdown of what you can do in XSLT 2.0 and 3.0 that you simply can’t do in 1.0.
1. Data Types Beyond Strings
XSLT 1.0 is essentially string-based. Everything is treated as a string or node-set, which limits complex operations.
XSLT 2.0+ introduced a full suite of data types from XML Schema: numbers, booleans, dates, times, durations, QNames, and more. You can now perform real arithmetic, date calculations, and type validation directly in your transformations.
2. Grouping with for-each-group
In 1.0, grouping data (e.g., grouping items by category) requires convoluted workarounds using keys and Muenchian methods.
XSLT 2.0 introduces the for-each-group instruction, making grouping declarative, readable, and much more powerful — with options like group-by, group-adjacent, and group-starting-with.
3. Regular Expressions
XSLT 1.0 has no regex support at all.
XSLT 2.0+ adds functions like matches(), replace(), and tokenize() using XPath 2.0’s regular expression capabilities, allowing sophisticated string manipulation tasks directly in the stylesheet.
4. Multiple Output Documents
XSLT 1.0 can only produce a single output result.
XSLT 2.0+ allows you to generate multiple output files from a single transformation using xsl:result-document. This is huge for batch processing or generating reports, indexes, or web pages in one go.
5. User-Defined Functions
In 1.0, there’s no way to define reusable functions — just templates and recursion.
XSLT 2.0+ introduces xsl:function, enabling clean, modular programming practices. You can now write pure functions with parameters, helping structure complex transformations more cleanly.
6. Sequence Handling
XSLT 2.0 and 3.0 support sequences — ordered collections of items (nodes, strings, numbers, etc.) — and provide operators to filter, map, and manipulate them. This is a paradigm shift from 1.0’s node-set limitations and opens up a functional programming style.
7. Try/Catch Error Handling (3.0)
Only in XSLT 3.0, you get xsl:try and xsl:catch, allowing robust error handling within stylesheets. This is critical for building reliable, fail-safe transformations.
8. Streaming Support (3.0)
When dealing with massive XML files, XSLT 3.0 introduces streaming, enabling transformation of data as it’s read without loading the full document into memory. This is a game-changer for performance and scalability.
9. Higher-Order Functions (3.0)
XSLT 3.0 supports higher-order functions — meaning functions can be passed as arguments, returned from other functions, and stored in variables. This unlocks truly functional programming patterns, like fold-left, filter, and map.
10. Packages and Modularity (3.0)
With XSLT 3.0, you can organize your code into packages — making it easier to build large-scale applications with reusable components and better namespace isolation.
Conclusion
While XSLT 1.0 still powers many legacy systems, modern XSLT versions bring a major leap in functionality, performance, and developer ergonomics. XSLT 2.0 introduced rich typing, better grouping, user functions, and multiple outputs. XSLT 3.0 went even further, enabling streaming, modular code, and robust error handling.
If you’re still working with XSLT 1.0, it might be time to explore what the newer versions have to offer — especially if you’re facing performance bottlenecks, code complexity, or evolving data processing needs.