Skip to content

Should the web platform adopt XSLT 3.0? #11578

Open

Description

@tony-sull

What is the issue with the HTML Standard?

Background

This is a follow-up to #11523. That issue raises concerns regarding security issues, code maintainability, and the complexity of aging browser code currently used for rendering XML with XSLT stylesheets. I highly recommend reading through that issue first as it includes a good background of XSLT on the web as well as the specific concerns that may lead to deprecating XSLT as the most prudent option for browser vendors.

As a reminder, please read the whatwg Code of Conduct. This issue is intended to be a discussion of alternatives to deprecations and how the concerns raised in #11523 may be handled to mitigate the risks for both browser maintainers and users. Please stay on topic here by discussing the pros and cons of XSLT v3.0 support, alternatives, etc. Discussions related to assumed motivations, specific browser vendors, etc. aren't relevant here and will likely just result in the issue being locked, preventing us from having the important discussion in public here.

What is the issue with the HTML Standard?

The XSLT 1.0 specification was originally standardized in 1999. Though the W3C has subsequently defined 2.0 and 3.0 specifications for XSLT, most browsers today never added support beyond v1.0. In addition, cross-browser functionality for XSLT is incomplete with certain features like <xsl:text disable-output-escaping="yes"> having open issues dating back over two decades with no fix in sight. I raise longstanding issues in general as a challenge related to the concerns of maintainability and relatively little use of XSLT 1.0 today, not as a concern over prioritization or resource allocation by browser vendors.

The question of use of XSLT today, raised in #11523, raises an interesting question. Is the low usage statistics of XSLT today an indication of the usefulness of the specification in today's web, or an indication of the challenges of dealing with v1.0 limitations and bugs? Deprecating XSLT entirely assumes that the issue related to use relies only on XSLT itself and that use would go effectively unchanged if the improvements from v2.0 and v3.0 were available in browsers. Anecdotally I can say that I have run into blocking issues with v1.0 itself; I built a blogging CMS as a hobby project that was designed to lean entirely on XSLT to render CMS users' RSS feeds to complete, customizable websites. Between vendor-specific XSLT bugs and the limitations of a now 25 year old spec, I found that I would only be able to build the CMS with a more recent version of the XSLT specification.

Alternatives to deprecation

I don't intend to prescribe a solution here! Instead, these open questions (and others I missed) are important when weighing the relative merits with regards to deprecating XSLT entirely.

  • Are there external libraries that browsers could adopt in order to gain v3.0 support without building and maintaining the specification in house?
  • Are there security concerns relevant to v3.0, or are the concerns limited to the v1.0 specification and current implementations?
  • Is there an approach that would allow browser vendors to use a single implementation for XSLT, combining efforts to reduce cost on each vendor?

Activity

  1. ndriscoll commented on Aug 19, 2025

    @ndriscoll

    One consideration that unfortunately no one can add to the other thread:

    Or perform the XSLT transformation on the server side, and serve the resulting HTML to the client. The more long-term solution would be to migrate to a more modern JS/JSON-based framework.

    The more "modern" solutions proposed all greatly raise the barrier to entry on the web. The cool thing about XSLT is that it provides a fully static way to add templates to a website (a need everyone immediately comes across once they have more than 2-3 web pages) that you can work your way into piecemeal as you discover your needs without needing build steps or API servers or anything like that. I'm guessing people that program professionally forget that dealing with things like npm, webpack, etc. are way more difficult than wrapping your text in some markup, adding some styles, realizing that you want to extract those out into a stylesheet so you can use them on multiple pages, and eventually coming to understand that you really want to template the whole thing. The old web standards provide a very natural onramp and let you go only as far as you need at any given time. Getting onto the programming language treadmill also pushes security maintenance burden onto authors (who now need to keep on top of regularly updating their frameworks, following the treadmill of paradigm shifts, etc. when they just wanted to make a web site).

    The suggestion that someone who wants to make a website should go learn a programming language & frameworks or how to set up a server processing pipeline seems to me to hammer home to idea that individuals are simply no longer relevant to "the web platform". I suppose the writing was on the wall when we gave up on the idea of WYSIWYG editors (remember when Seamonkey had that built right in?) and started normalizing the idea that even simple, completely static web pages like blogs require programming/are not something for the common person to be able to make, but it's still sad.

  2. Chailotl commented on Aug 19, 2025

    @Chailotl

    Is the low usage statistics of XSLT today an indication of the usefulness of the specification in today's web, or an indication of the challenges of dealing with v1.0 limitations and bugs?

    Another factor to consider is whether people are aware of this technology in the first place, and what it is capable of. Personally, when I learned that I can style my RSS feeds to make it user-friendly and include a helpful message at the top explaining what a feed is and how the user can subscribe to it, I immediately applied it to my RSS feed.

    As of this issue receiving a lot of attention, I've started informing my fellow developers about XSLT and encouraging them to apply it to their own RSS feeds.

  3. Lexicality commented on Aug 19, 2025

    @Lexicality

    I do agree that something needs to change at least. I set up an XSLT stylesheet for my sitemap last year and it was spectacularly frustrating that there was no clear information anywhere on what features were actually supported by the browsers and the complete lack of feedback when I used an unsupported feature. Sometimes it just hung my entire Firefox process which was unsettling to say the least.
    I'm sure at least some of the lack of adoption is caused by developers assuming the entire technology is broken and giving up.

    If browser vendors do not have enough resources independently to maintain their XSLT implementations, perhaps resources could be pooled into a single pdf.js style project that could be adopted by all browsers, providing a uniform and consistent experience? Being written in JS would presumably make it easier to provide active feedback to the developer when they make mistakes too. 🙂

  4. emmacharp commented on Aug 20, 2025

    @emmacharp

    I know XSLT has fallen out of favor over the past 20 years, and most developers don’t really care about it anymore. But when it’s used with purpose and skill, it’s incredibly powerful. I’ve been working with XSLT since I first discovered it about ten years ago, and it has become my language of choice for building content-driven websites. I’m sure I’m not entirely alone in this, but sometimes it feels like there are, like, maybe three of us who use XSLT as consistently as I do. And that’s a shame.

    XSLT could replace many of the technologies that have been bolted onto the Web platform over the years. With proper browser support for XSLT 3.0 and just a little push in public awareness, it could be a game changer.

    There are so many advantages to using XSLT on the Web, but the developer community simply doesn’t know about them. If they did, we might already have full XSLT 3.0 support in browsers. Let’s try to make that happen, then!

  5. tony-sull commented on Aug 20, 2025

    @tony-sull
    Author

    One concern I have with an alternative approach leveraging either a polyfill or a browser extension is that either approach lose some of the core features of XSLT. With XSLT built into browsers, developers have access to a client-side templating engine that is "closer to the metal" and will work when JS is disabled or unavailable in the browser. Unless I'm mistaken, polyfills and extensions wouldn't work in that scenario and there would be a noticeable performance hit compared to XSLT rendering.


    I'm interested to hear more from engineers with deeper experience in the existing XSLT implementations.

    Given the age and general state of the current v1.0 implementations, is it reasonable to assume a v3.0 implementation would be a complete rewrite?

    Ignoring resource availability and current priorities, what would a realistic estimate be for the effort it would take to implement and is there an avenue in which one implementation could be used across multiple browsers to spread the effort?


    One concern with removing XSLT from the web platform entirely is that it means it that not only will the v1.0 implementations be removed, we will likely never see them replaced with the modern specifications. We do want WHATWG to realistically reflect what browser vendors have implemented or are expecting to implement, if there truly is no interest in supporting XSLT in the future then so be it I suppose. That is a different conversation compared to security and maintainability of the current implementation, but browser vendors only have so much bandwidth and that's totally reasonable and WHATWG should reflect that if there's vendor consensus.

    One area where I think the lack of XSLT support may be more glaring in the future is with the continued growth of LLMs. If the MCP spec isn't broadly adopted, or if it runs into challenges during adoption, web developers may need a different solution for providing proper REST APIs to LLMs. XML has gone out of favor, but it is a great fit for that scenario. I could see a future where we end up developing one semantic REST API providing web page/app state as XML; LLMs interact directly with that gaining what they need from semantic markup and browsers render the exact same state via XSLT stylesheets. One XML API can serve both use cases, and it does seem like the LLM use case will only grow to a larger piece of the pie in the near future.

  6. zcorpan commented on Aug 20, 2025

    @zcorpan
    Member

    cc @mfreed7

    On disable-output-escaping="yes", this is problematic to support because it requires serialization and parsing of the transformed content. For efficiency in a client-side setting, you want a DOM-to-DOM transformation, which is what Gecko does. Possibly, adopting a third-party library that supports XSLT 3.0 would mean switching to a serialize-parse model (and thus theoretically regress performance).

    Are there security concerns relevant to v3.0, or are the concerns limited to the v1.0 specification and current implementations?

    I think there's inherent XSS risk with supporting XSLT regardless of version, because the transformed content can execute script and the expectation may be that e.g. RSS is safe.

    I think there are also non-security arguments against client-side XSLT, e.g. lack of incremental rendering.

  7. mfreed7 commented on Aug 20, 2025

    @mfreed7
    Contributor

    As a reminder, please read the whatwg Code of Conduct. This issue is intended to be a discussion of alternatives to deprecations and how the concerns raised in #11523 may be handled to mitigate the risks for both browser maintainers and users. Please stay on topic here by discussing the pros and cons of XSLT v3.0 support, alternatives, etc. Discussions related to assumed motivations, specific browser vendors, etc. aren't relevant here and will likely just result in the issue being locked, preventing us from having the important discussion in public here.

    I don't have a more detailed comment on this issue right now, but I wanted to explicitly say thank you for this portion of your comment, and for the general tone you've created here. It is appreciated.

  8. bahrus commented on Aug 20, 2025

    @bahrus

    My reasons for mourning the loss of XSLT:

    1. Many design web component libraries use markup that is modeled after built-in elements, like the table, ul/li, etc. These web components are beautiful, but the problem is that it's really difficult to make the light DOM children look the same while waiting for the component to download. With XSLT and just a few lines of very clear instructions, one can let the server be "design library neutral" and ship native table elements, which, with a little styling, can look close to what the design library provides, without the bells and whistles. Then, when the library has downloaded, apply the XSLT and replace the table with the web components. Obviously having to download a monstrous polyfill would defeat the purpose.
    2. There are scenarios where xslt 3's streaming support would shine, like dynamically building a table of contents as the actual content streams in dynamically.
    3. If it could be used in the service worker layer, it could allow bringing in content from third party web sites, and filter out content in an elegant way. I have another proposal that could do this, but it's just been sitting there gathering dust.

    Why don't the browser vendors do this: Say how much it would cost to incorporate a library, initially and per year, and see if kickstarter can raise the funds? I think that would be a much better look, even if sufficient funds aren't raised.

  9. tony-sull commented on Aug 21, 2025

    @tony-sull
    Author

    @zcorpan and @mfreed7 thank you both for jumping in here!

    Possibly, adopting a third-party library that supports XSLT 3.0 would mean switching to a serialize-parse model (and thus theoretically regress performance).

    Alternatives to in-browser XSLT support would rely on polyfills or browser extensions. Though adopting third-party libraries would likely mean a performance regression compared to what we have today, would it likely still outperform a polyfill or extension approach?

    I think there's inherent XSS risk with supporting XSLT regardless of version, because the transformed content can execute script and the expectation may be that e.g. RSS is safe.

    This concern is particularly interesting to me. I've viewed the XSS risk similar to that of using innerHTML DOM APIs or dangerouslySetInnerHTML in react. Are there situations where XSLT actually poses a more fundamental risk than using innerHTML and related wrappers over that API (apologies if I missed examples already given elsewhere in ongoing discussions)? If so, that seems like a very important example for why deprecating XSLT is more important than updating to the latest specs.

  10. zb3 commented on Aug 21, 2025

    @zb3

    The new Polish e-Invoice will also use the XML format (many government documents do), and with XSLT we can have one community-or-government-made template which everyone could integrate regardless of used technology. It'd also be great if the web browser was able to display just the XML file without any need for additional UI frameworks, it'd reduce the friction to basically zero.

    I've learned about XSLT relatively recently, precisely because of this invoice change.. seeing this I was wondering why wasn't it more popular and why so few people were talking about it, but while trying to modify these templates I quickly noticed the limitations of XSLT 1.0 which doesn't even support user functions.
    But many don't even know about XSLT at all, especially new developers who might feel overwhelmed by today's complicated web technologies.. the article "XSLT – Native, zero-config build system for the Web" got popular only recently, perhaps because many just didn't know that even existed and was already supported by web browsers?

    So I think there's a good opportunity to reduce the barrier to entry for the web by improving XSLT, I genuinely believe this technology has more potential, we just need to give it a proper try!

    I think there's inherent XSS risk with supporting XSLT regardless of version, because the transformed content can execute script and the expectation may be that e.g. RSS is safe.

    Oh, it definitely shouldn't be able to execute any JS code..

    Regarding implementation details, builtin support via JS/WASM should alleviate security concerns. But for extensions, it should at least be possible to install it with one click instead of being redirected to web store with spammy third-party extensions..

  11. marypcbuk commented on Aug 21, 2025

    @marypcbuk

    "closer to the metal" and will work when JS is disabled or unavailable in the browser. Unless I'm mistaken, polyfills and extensions wouldn't work in that scenario and there would be a noticeable performance hit compared to XSLT rendering.

    I'm very curious about the impact of polyfills and extensions when the data is XML coming from an embedded device and being transformed by XSLT for a web based control interface or reporting dashboard (which can do things like localisation, text translation for the interface, data visualisations), or to integrate with other systems (like the XML-based APIs used in network devices or medical monitoring systems that get transformed with XSLT into more user friendly formats like HTML or JSON for the systems they integrate with); my understanding is a polyfill isn't going to fit well there and it can't be done serverside when the server is a microcontroller running a web server. Moving to XSLT 3 could unlock a lot more richness for how the data from embedded systems could be used and even a small perf hit from that would presumably be better than the whole data handling having to be reimplented in Java? And like enterprise usage, that also wouldn't show in web stats...

  12. zb3 commented on Aug 21, 2025

    @zb3

    I'm very curious about the impact of polyfills and extensions when the data is XML coming from an embedded device and being transformed by XSLT for a web based control interface or reporting dashboard

    If you can change the Content-Type header and serve that as text/html, you might be able to use a trick inserting this below the xml-stylesheet directive:

    <?js-stylesheet /><script src="https://example.com/style.js"></script><!--?><!-- -->
    

    and then that style.js could generate the page with high flexibility, while the XML file remains valid and can still contain a normal XSLT stylesheet..

    But I believe we should go the opposite way - instead of legitimizing the use of JS for such simple cases, we should discourage it by supporting powerful, more user-friendly alternatives such as XSLT 3.0.
    JS can do too much and it's difficult for the user to inspect it to ensure only code that serves their interest is allowed to execute, plus it can even interfere with such measures.

  13. zcorpan commented on Aug 22, 2025

    @zcorpan
    Member

    Though adopting third-party libraries would likely mean a performance regression compared to what we have today, would it likely still outperform a polyfill or extension approach?

    I think the biggest difference in performance is DOM-to-DOM vs. serialize-transform-parse strategy. The former is better for performance, but the latter is possible to sandbox and therefore likely better for security.

    For XSS specifically, it's maybe about the same as innerHTML, however there are other classes of security bugs reported for XSLT that don't apply to innerHTML, e.g.: reading local files, various UAF bugs, bypassing CSP, etc.

    Since XSLT 3.0 has more features than 1.0, in theory it means more attack surface. Some classes of bugs could be addressed by using an implementation written in a memory-safe language + sandboxing, though.

  14. hsivonen commented on Aug 22, 2025

    @hsivonen
    Member

    The phenomenon of XSLT implementations getting stuck at XSLT 1.0 is broader than just browsers:

    Xalan is at XSLT 1.0. According to Wikipedia, "Microsoft provides two XSLT processors (both XSLT 1.0 only)."

    Adding XSLT 3.0 support either in the context of libxslt (WebKit and Chromium) or Transformiix (Gecko) doesn't make sense from the point of view of the current technical state of libxslt or Transformiix or as a matter of the amount of effort needed vs. the benefit and considering the opportunity cost of what else could be accomplished in Web browser development with that amount of effort.

    Which makes the question

    Are there external libraries that browsers could adopt in order to gain v3.0 support without building and maintaining the specification in house?

    relevant.

    Setting aside for the moment the question of whether the benefit would be worth the integration effort, let's look at the other requirements:

    First there's the question of level of integration vs. performance. Gecko currently has much deeper integration of the XSLT engine with the browser internals: The XSLT engine operates on the browser DOM implementation. WebKit and Chromium integrate with libxslt in a way that's inherently bad for performance: The XSLT engine doesn't operate on the browser DOM but the XSLT engine and the rest of the browser communicate via XML as serialized as text. The Gecko approach gives rise to opportunities for security bugs (due to both XSLT and JS having access to the same DOM) that the inherently-bad-for-performance XSLT integration architecture that WebKit and Chromium use protects from.

    So perhaps worse is better and we don't even need to constrain the search for an external library to one that could operate on an externally-provided XML tree (i.e. the browser DOM)!

    But there are still real constraints left (list possibly not exhaustive!):

    1. The external library needs to be under an Open Source license (and likely one that doesn't have provisions that would make the exact manner of integration a license matter in addition to being a technical matter) and the preferred form for making modifications needs to actually be available.
    2. The external library needs to implement enough XSLT 1.0 and EXSLT compatibility that existing Web content written for libxslt and Tranformiix keeps working.
    3. The external library needs to use a programming language that fits the memory-safety requirements and engineering practices of Web browsers. (That is, even implementation in a safe language isn't OK if browsers don't otherwise contain code in that particular safe language and adding the capability to use code in that language would be involve high up front and ongoing cost.)

    I'm not aware of any existing XSLT 3.0 implementation that satisfies those three rather basic constraints.

    (Typically Xee is suggested as the solution. At this time, it fails the second constraint. I can't speak for Safari, but it might also fail the third constraint for Safari.)

  15. lukewarlow commented on Aug 22, 2025

    @lukewarlow
    Member

    The phenomenon of XSLT
    implementations getting stuck at XSLT 1.0 is broader than just browsers:

    To expand on this a bit if you look at any runtime with XSLT built-in: e.g. Java, PHP, .net they're all limited to XSLT 1.0 (happy to be corrected)

    PHP for example is using libxslt the same library as chromium and WebKit.

    Other third-party libraries that are used for other languages like python's lxml also don't support more than libxslt 1.0 (they're also based on libxslt).

    If there was an obvious convergence on a specific V2 or V3 implementation then it might make more sense but if nothing else has made the move to integrate a newer version it probably presents more work for browsers if they were to be the first (and possibly only) to do that.

  16. 68 remaining items

  17. Alhadis commented on Nov 9, 2026

    @Alhadis

    Which means the platform groups( XML or MathML ) should provide the stable and supported software capable to be integrated into browser.

    Why? Did the W3C ever provide such a library for HTML or CSS?

    If such libraries existed, there'd be no need for detailed specifications written to guide implementors in the correct fashion.

  18. wendellpiez commented on Nov 9, 2026

    @wendellpiez

    If such libraries existed, there'd be no need for detailed specifications written to guide implementors in the correct fashion.

    The specifications would play a different role, but it does not follow that they would play no role.

    As used to be said way back in SGML days, the core question is "who owns the parse?" When producers and publishers seek to own their data in the sense of take responsibility for it over the long term (to say nothing of governments and other "serious people"), it poses difficulties for them to be locked into proprietary stacks, even when nominally 'standard' in some fashion.

    XML was designed for the web but it is also useful off the web. One reason is because XML is XML, and tool vendors are not in a position to say otherwise (notwithstanding the fact that some have tried). One reason XML is XML (and not what some tool vendor says it is), is because of that system of interlocking specifications.

    XSLT 1.0 came with an unofficial reference implementation (XT by James Clark), in which the very useful <xsl:key> instruction was disabled, in order to give room for other implementations to offer value.

  19. sashafirsov commented on Nov 9, 2026

    @sashafirsov

    @Alhadis ,

    platform groups( XML or MathML ) should provide the stable and supported software capable to be integrated into browser.

    Why? Did the W3C ever provide such a library for HTML or CSS?

    No. And that is a problem. Having no reference implementation set the high barrier for adoption, resulting in resistance from browser vendors side. Also the quality which kinf of been supported from w3c like html validator is bellow the meaningful threshould. Simply unuseful.

    Many other standard groups like DVD, USB, etc. always covered as the standard as ready-to-consume reference implementations.

    The implementation would matter also. If XSLT transfromation would consume the browser UI thread, would not give ability to restrict resources consumed(CPU, RAM, call stack depth, etc.) it also would not be useful as unsafe to integrate. The insecure implementation is worse than not having one.

    As I mentioned, such solution does exist - CEM at the moment is only such. But with given effort I do not see the problem to create w3c owned one.

  20. sashafirsov commented on Nov 9, 2026

    @sashafirsov

    @wendellpiez

    "who owns the parse?"

    The schema. If the language syntax is well defined by schema, the unified parser would serve any input, html, xslt, or custom.

    The trouble that schema definition protocols as of now are not flexible enough. That is why I had to re-invent the schema definition. And w3c need a decent enough too. At least to cover current web lingual stack.

    See CEM implementation with 2 dozens formats supported. From programming language like Rust to HTML, XSLT, and SCSS.

    While it sounds self- advertizement, actual goal of linking is to proof that such kind of problems are solvable.

  21. liamquin commented on Nov 9, 2026

    @liamquin

    No. And that is a problem. Having no reference implementation set the high barrier for adoption,

    W3C required (and still requires) at least two independent implementations that have been tested to show they implement the whole spec, before a spec can become a Recommendation.

    This is MUCH better than a reference implementation and the bar is MUCH higher.

    It means that people implement to the spec, not just based on what the reference implementation does.

    Few digital specs have achieved the level of interoperability that XML did, and the uptake was HUGE.

    Please, let’s not get off topic about what might or might not have happened (but let’s also not share incorrect histories)..

    The ways forward are

    • browsers drop XSLT support, and maybe also XPath, and XHTML 5;
    • browsers use a JavaScript of wasm polyfill for XSLT 1 and keep XPath; this seems the current approach, but end users may need to install a browser extension, which is less than ideal;
    • browsers incorporate a new XSLT implementation, which is compatible with XSLT 1 (or the browser extension or polyfill); if new, this could implement XSLT 4, and in that case XSLT 4 could be changed if needed, e.g. to permit the “wilful violation” of XPath but maybe to go further, perhaps exploring what Saxonica has done to integrate more closely with the Web platform.

    Reference implementations have been used in the past to force vendors to pay significant amounts of money to access them and to have their software tested. It’s a way of controlling, not liberating. And when there is a difference between the formal reference implementation and the spec, by definition the spec is wrong, even if it’s a bug, and even if it’s undocumented.

    A sample implementation is another matter, and can help speed adoption without the weight of authority. But we have sample implementations of XSLT for sure; we are not at that stage any more.

  22. michaelhkay commented on Nov 9, 2026

    @michaelhkay

    e.g. to permit the “wilful violation” of XPath

    It's not really possible to do that without at the same time restricting XPath to accessing a single document. Plus, it means the semantics of the expression depend on what kind of document is being processed, which makes it very difficult to precompile the expression for repeated use. It's a feature that works well only when XPath is restricted to very simple use cases.

  23. liamquin commented on Nov 10, 2026

    @liamquin

    @michaelhkay XHTML5 says of it,

    If the QName has no prefix and the principal node type of the axis is element, then the default element namespace is used. Otherwise, if the QName has no prefix, the namespace URI is null. The default element namespace is a member of the context for the XPath expression. The value of the default element namespace when executing an XPath expression through the DOM3 XPath API is determined in the following way:

    If the context node is from an HTML DOM, the default element namespace is "http://www.w3.org/1999/xhtml".
    
    Otherwise, the default element namespace URI is null.This is equivalent to adding the default element namespace feature of XPath 2.0 to XPath 1.0, and using the HTML namespace as the default element namespace for HTML documents. It is motivated by the desire to have implementations be compatible with legacy HTML content while still supporting the changes that this specification introduces to HTML regarding the namespace used for HTML elements, and by the desire to use XPath 1.0 rather than XPath 2.0.
    

    So i don’t see a problem in explicitly allowing an implementation to do this, nor in configuring a default for XPath 2 or later in browsers. Any API in a browser allowing XPath 2 3 or 4 would need a mechanism for saying which XPath version is to be used, and perhaps for passing in a map of default options.

  24. michaelhkay commented on Nov 10, 2026

    @michaelhkay

    The problems with the statement "If the context node is from an HTML DOM, the default element namespace is http://www.w3.org/1999/xhtml. are that (a) you need to extend the data model to recognize there are two kinds of nodes, XML nodes and HTML nodes, and (b) you need to change the default element namespace to be a dynamic concept rather than a static one (because it depends on runtime data). But more fundamentally, you need to explain what "the context node" means here: is it the context node for an XPath expression as a whole, or the context node for an individual axis step? Either way, it gets very confusing when you do joins across multiple documents (something, of course, that XPath 1.0 can't really handle).

    The assertion that "This is equivalent to adding the default element namespace feature of XPath 2.0 to XPath 1.0" is just plain ignorant.

    Since a mapping is needed from the HTML DOM to XDM anyway, the whole thing could have been handled much more easily (and conformantly) by mapping HTML elements to no-namespace XDM elements.

  25. liamquin commented on Nov 10, 2026

    @liamquin

    The problems
    100% agree with you here, there would be some spec work to be done and the approach adopted was not ideal. I mentioned it as an example of somewhere alignment could possibly be improved. But it sounds like it’s more complex than i’d realised. Like many things, alas!

  26. Alhadis commented on Nov 11, 2026

    @Alhadis

    BTW, if anybody wants a high-profile example of XSLT usage, the IANA uses it on the XML versions of their registration pages (e.g., media-types.xml). There is an HTML rendering of that page (alongside a plain-text rendering), but reading the source-code of the XML version shows a mostly data-driven document that's transformed via an XSL stylesheet that's quite terse, thanks to an <xsl:import href="../_support/iana-registry.xsl" /> tag that loads reusable XSL functions.

    In other words, if anybody wants a practical, Real World™ example of XSLT being used on a high-visibility website… well, there you go. Just felt impelled to bring this up to remind those in favour of XSLT's removal that it isn't just unindexed web-pages and hobbyists who use this language.

  27. michaelhkay commented on Nov 11, 2026

    @michaelhkay

    @Alhadis Rather sad that we have to make the point by showing them a web page that they are likely to be using themselves in their own tech bubble, since they're unlikely to be influenced by equally important web pages used in the real world outside tech.

    We have now spent a week converting our own site to cut out client-side XSLT (replacing it in some cases with SaxonJS). We've had to drop some historic content that it isn't cost-effective to convert.

  28. Alhadis commented on Nov 11, 2026

    @Alhadis

    @michaelhkay I don't envy you having to make the cut. But at least you managed to do so before the XSLT removal was shipped to users worldwide. Because I predict there's gonna be a fair amount of confusion, rendering errors and broken webapps (or worse, webapps that change their behaviour in subtle, pernicious ways that're difficult to notice, let alone debug) amongst hapless users on sites with load-bearing XSLT files.

    Honestly, the removal of XSLT has broken my confidence in Web technologies as a future-proof, backwards compatible programming platform. If Google can decide to drop XSLT support at the drop of a hat, what else is on the chopping block? They already tried axing window.alert(), prompt() and confirm() some time ago, and was met with fierce pushback. Are they gonna remove document.write() next? (Which is almost guaranteed to make browsing old sites on Archive.org useless, but hey, think of all that crusty KHTML-era code they can get rid of!)

    I've spent the past 20+ years being a staunch advocate of Web standards, and have maintained my faith in the platform's philosophy… until now. And the amount of control that one company's decisions has on the Web should be concerning to every developer, irrespective of their feelings on XSLT's removal—Google announce their intent to remove something, and the two (‼) remaining browser vendors (Mozilla and WebKit) fall in line.

    Gone is the Web Platform, replaced by the Web Pedestal. And there's only room on it for three companies.

    </pessimistic-diatribe>

  29. michaelhkay commented on Nov 11, 2026

    @michaelhkay

    If it makes you feel better, read my rant at https://blog.saxonica.com/mike/2010/11/tpac-the-morning-after.html

  30. marypcbuk commented on Nov 11, 2026

    @marypcbuk

    If Google can decide to drop XSLT support at the drop of a hat

    I don't know if it's helpful to point out that it was Mozilla who suggested dropping XSLT rather than Google, but it's probably best to be accurate. Certainly the browser vendors have outsize influence but the API Owners group did sign off on it. (I'm also disappointed, just wanted to note the facts)

  31. Oblomov commented on Nov 11, 2026

    @Oblomov

    I don't know if it's helpful to point out that it was Mozilla who suggested dropping XSLT rather than Google, but it's probably best to be accurate. Certainly the browser vendors have outsize influence but the API Owners group did sign off on it. (I'm also disappointed, just wanted to note the facts)

    Google has been pressuring to remove XSLT since at least 2013. I had a long writeup on Google's war on XML and open standards up on my website, which is currently offline for unrelated reason but you can still read it on archive.org https://web.archive.org/web/20260509230446/https://wok.oblomov.eu/tecnologia/google-killing-open-web/ (sorry for the typos, can't fix them at the momen).

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    addition/proposalNew features or enhancementsneeds implementer interestMoving the issue forward requires implementers to express interest

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions