# What XSLT 2.0 and 3.0 can do better than XSLT 1.0

**URL:** <https://the.fmsoup.org/t/what-xslt-2-0-and-3-0-can-do-better-than-xslt-1-0/4856>\
**Category:** MBS Plugins\
**Tags:** scripting, xml, xslt\
**Created:** [May 14, 2025, 5:57am UTC](https://the.fmsoup.org/t/what-xslt-2-0-and-3-0-can-do-better-than-xslt-1-0/4856 "2025-05-14T05:57:11Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![MonkeybreadSoftware](https://yyz2.discourse-cdn.com/flex030/user_avatar/the.fmsoup.org/monkeybreadsoftware/32/361_2.png) [@MonkeybreadSoftware](https://the.fmsoup.org/u/MonkeybreadSoftware)\
**Post date:** [May 14, 2025, 5:57am UTC](https://the.fmsoup.org/t/what-xslt-2-0-and-3-0-can-do-better-than-xslt-1-0/4856/1 "2025-05-14T05:57:11Z")

</div>

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 **FileMaker** with [MBS FileMaker Plugin](https://www.monkeybreadsoftware.com/filemaker/) and our [Saxon](https://www.mbsplugins.eu/component_Saxon.shtml) functions. The built-in XSLT in FileMaker 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.