Hubbry Logo
Trident (software)Trident (software)Main
Open search
Trident (software)
Community hub
Trident (software)
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Trident (software)
Trident (software)
Trident (software)
View on Wikipedia
from Wikipedia
Trident
Other namesMSHTML[1][2][3]
DeveloperMicrosoft
Initial releaseAugust 1997; 28 years ago (1997-08)
Final release
8.0
Written inC++[4]
Operating systemMicrosoft Windows
SuccessorEdgeHTML
TypeBrowser engine
LicenseProprietary
Websitedocs.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa741317(v=vs.85) Edit this at Wikidata

Trident[1][2][3] (also known as MSHTML[1][2][5]) is a proprietary browser engine for the Microsoft Windows version of Internet Explorer, developed by Microsoft.

MSHTML debuted with the release of Internet Explorer 4 in 1997. For versions 7 and 8 of Internet Explorer, Microsoft made significant changes to MSHTML's layout capabilities to improve compliance with Web standards and add support for new technologies.[6][7][8]

MSHTML will continue to receive security updates[9] for the IE mode of Microsoft Edge until at least 2029. However, support for new Web standards will not be added.

Use in software development

[edit]

MSHTML was designed as a software component to allow software developers to easily add web browsing functionality to their own applications. It presents a COM interface for accessing and editing web pages in any COM-supported environment, like C++ and .NET. For instance, a web browser control can be added to a C++ program and MSHTML can then be used to access the page currently displayed in the web browser and retrieve element values. Events from the web browser control can also be captured. MSHTML functionality becomes available by linking the file mshtml.dll to the software project.

Release history

[edit]
MSHTML version MSHTML.dll version Internet Explorer version Internet Explorer Mobile version Notes
No version[10] 4.0.x 4.0 — Initial version.
5.0.x 5.0 — Improved CSS 1 support and had sweeping changes in CSS 2 rendering.
5.5.x 5.5 — Corrected issues with CSS handling.
6.0.x 6.0 — Corrected the box model and added quirks mode with DTD switching.
7.0.x 7.0 — Fixed many CSS rendering issues and added partial PNG alpha support.
— — 6.0 IEMobile 6 combines many features of IE 6, 7, and 8.[11]
3.1[12][13] 7.0 — 7.0 Second port on a mobile system of MSHTML. IE Mobile version for Windows Phone 7.
4.0[14] 8.0.x 8.0 — First version to pass the Acid 2 test.[4] Added full support for CSS 2.1.[15]
5.0[10] 9.0.x 9.0 9.0 Added support for SVG, XHTML, HTML5, and CSS 3. Added a new hardware-accelerated JScript engine named Chakra. Scores 100/100 on the Acid3 test. Included with IE 9 Mobile in Windows Phone 7.5 "Mango".
6.0[16] 10.0.x 10.0 10.0[17] More support for CSS 3, HTML5 and ES5. Included in Windows Phone 8. Support for linear gradient CSS transitions.[18]
7.0 11.0.x 11.0 11.0 Support for WebGL and SPDY. Improved support for HTML5.[19] Speed improvement.[20] Included in Windows Phone 8.1.

Use cases

[edit]

All versions of Internet Explorer for Windows from 4.0 onwards use MSHTML, and it is also used by various other web browsers and software components (see Internet Explorer shells). In Windows 98, Windows Me, and Windows 2000, it is also used for the Windows file manager/shell, Windows Explorer.[21] The Add/Remove Programs tool in Windows 2000 uses MSHTML to render the list of installed programs,[22] and in Windows XP it is also used for the User Accounts Control Panel, which is an HTML Application.[23] MSHTML, however, was not used by Internet Explorer for Mac (which used Tasman starting with version 5.0), nor by the early versions of Internet Explorer Mobile.

Some other MSHTML-based applications include:

Standards compliance

[edit]

Current versions of MSHTML, as of Internet Explorer 9, have introduced support for CSS 3, HTML5, and SVG, as well as other modern web standards. Web standards compliance was gradually improved with the evolution of MSHTML. Although each version of IE has improved standards support, including the introduction of a "standards-compliant mode" in version 6, the core standards that are used to build web pages (HTML and CSS) were sometimes implemented in an incomplete fashion. For example, there was no support for the <abbr> element which is part of the HTML 4.01 standard prior to IE 8. There were also some CSS attributes missing from MSHTML, like min-height, etc. as of Internet Explorer 6. As of Internet Explorer 8 CSS 2.1 is fully supported as well as some CSS 3.0 attributes.[15] This lack of standards compliance has been known to cause rendering bugs and lack of support for modern web technologies, which often increases development time for web pages.[25] Still, HTML rendering differences between standards-compliant browsers are not yet completely resolved.

Microsoft alternatives

[edit]

Apart from MSHTML, Microsoft also has and uses several other layout engines. One of them, known as Tasman, was used in Internet Explorer 5 for Mac. Development of Internet Explorer for Mac was halted in roughly 2003, but development of Tasman continued to a limited extent, and was later included in Office 2004 for Mac. Office for Mac 2011 uses the open source WebKit engine. Microsoft's now defunct web design product, Expression Web, as well as Visual Studio 2008 and later, do not use Internet Explorer's MSHTML engine, but rather a different engine.[26]

In 2014, MSHTML was forked to create the engine EdgeHTML for Microsoft Edge [Legacy] on Windows 10. The new engine is "designed for interoperability with the modern web" and deprecates or removes a number of legacy components and behaviors, including document modes, ensuring that pure, standards-compliant HTML will render properly in browsers without the need for special considerations by web developers.[27][28] This resulted in a completely new browser called Microsoft Edge (later referred to as "Microsoft Edge Legacy",[29] with a flat blue "e" icon) which replaced Internet Explorer as Windows' stock browser and became the base of Microsoft's web related services, until its replacement with a Blink / Chromium[30][31]-based browser, also called Microsoft Edge[32][33] (with a brand new wave-like icon) in late 2020.

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Trident (software)

View on Grokipedia
from Grokipedia
Trident, also known as MSHTML, is a proprietary web rendering engine developed by to power the layout and display of in the browser and related applications. Introduced in 1997 with the release of 4.0, it handles the parsing and rendering of , CSS, scripting, and other web technologies, serving as a component-based engine that could be embedded in software via the mshtml.dll file. Developed initially to compete in the of the late 1990s, Trident underwent significant updates across versions, with major layout overhauls in IE7 and IE8 to improve standards compliance, including better support for CSS 2.1 and the introduction of features like the Acid2 test pass in IE8. It powered IE from version 4 through 11, becoming integral to Windows ecosystems, and was also used in embedded contexts such as the WebBrowser control for desktop applications and add-ins on older systems. Despite criticisms for slow adoption of modern web standards like and CSS3 in early iterations, later versions in IE9–11 added accelerated rendering via GPU hardware and partial support for emerging APIs, though it lagged behind competitors like and in full compliance. Although retired the user interface in June 2022, the MSHTML engine remains available for legacy compatibility through mode in , where it renders sites requiring IE-specific behaviors using the IE11 version of the engine, with support extended until at least 2029. In 2015, forked to create the EdgeHTML engine for the new Edge browser, aiming for improved performance and standards adherence, before transitioning to the open-source engine in 2020. 's legacy endures in enterprise environments and embedded scenarios, underscoring its historical role in shaping 's web technology stack.

Overview

Development Background

In the mid-1990s, Microsoft faced intense competition from Netscape Communications during the escalating browser wars, prompting the company to develop a proprietary rendering engine to secure its dominance in the operating system market and integrate web technologies deeply into Windows. Bill Gates emphasized the Internet as a "tidal wave" threatening Microsoft's core products like Windows and Office, especially as Netscape's Navigator browser captured over 70% market share and aimed to commoditize OS platforms through cross-platform extensions. This rivalry accelerated Microsoft's shift from licensing external technology to building native capabilities, with a focus on creating a Windows-centric web ecosystem to counter Netscape's multi-platform approach. Development of the rendering engine began following the release of 3.0 in 1996, as part of the effort for 4.0, marking Microsoft's first major proprietary in-house rendering engine and replacing the Spyglass-licensed derivative used in IE 3.0 and earlier versions. First released with IE 4.0 in October 1997. Under the leadership of Brad Silverberg, who headed the Internet Platform and Tools division starting in early 1996, the IE team expanded significantly for subsequent versions including IE 4.0, reflecting Microsoft's commitment to outpacing competitors through substantial internal investment. Silverberg, previously overseeing Windows development, unified scattered IE initiatives into a cohesive strategy that prioritized Windows-native performance. Trident's design principles centered on tight integration with Windows APIs, particularly (COM) and controls, to enable seamless multimedia and dynamic content support within applications. This componentized architecture allowed Trident to function as a reusable module, facilitating web content embedding in non-browser software like email clients and enhancing overall system interactivity.

Core Functionality

Trident, also known as MSHTML, serves as the proprietary layout and rendering engine developed by for processing and displaying content on Windows platforms. It primarily handles the of markup, application of CSS styles, and execution of scripting languages to construct visual layouts, enabling the rendering of web pages and embedded elements within applications. This end-to-end process transforms into a structured, interactive document that can be viewed and manipulated by users. At the heart of Trident's operations is the MSHTML dynamic-link library (DLL), which provides the core infrastructure for document object model (DOM) manipulation. The MSHTML component exposes a comprehensive set of interfaces, such as IHTMLDocument and IHTMLElement, allowing developers and applications to dynamically access, modify, and query the DOM tree derived from parsed . This facilitates programmatic control over page elements, events, and properties, making it integral for building interactive web experiences and integrating HTML rendering into non-browser software. Trident manages layout through an implementation of the , which organizes content into rectangular boxes with properties for margins, borders, padding, and sizing, aligned with early CSS standards like CSS1 and partial CSS2 support. This model calculates positioning and flow for block and inline elements, ensuring consistent rendering of structured documents. Additionally, Trident incorporates proprietary extensions such as (VML), an XML-based format for defining scalable 2D , which allows for the embedding of shapes, paths, and fills directly within without requiring external image files. VML support enhances rendering of diagrammatic and illustrative content, particularly in legacy applications. For scripting integration, Trident employs , Microsoft's implementation of the standard, to enable dynamic behavior and interactivity within rendered documents. JScript executes client-side code embedded via

History

Initial Creation and Early Versions

Trident, Microsoft's proprietary web rendering engine, also known as MSHTML, was developed in the mid-1990s as part of efforts to create a more competitive and integrated browser during the . Building on experience from earlier versions that licensed code from Spyglass , development of began around 1994–1996 under the Internet Platform and Tools division, led by a team of nearly 100 engineers headed by Brad Silverberg. It debuted with 4.0 (IE 4.0), released on September 30, 1997, marking a shift to a componentized for embedding web technologies in Windows applications via mshtml.dll. Trident 4.0 provided full support for CSS Level 1, enabling sophisticated styling and layout control, while expanding ActiveX integration for richer multimedia and scripting. IE 4.0 introduced Dynamic HTML (DHTML), combining HTML, CSS, and scripting for client-side dynamic content manipulation without server round-trips, enhancing web responsiveness. Developed amid competition with Netscape Navigator, these features were refined in betas released in April and July 1997. Early challenges included stability issues and security vulnerabilities addressed in post-release patches, highlighting the complexities of the new standards-oriented design.

Evolution Through Internet Explorer Releases

Trident's evolution continued with 5.0 in 1999, where version 5.0 introduced support for XML through data islands and XSL transformations, enabling dynamic . It also achieved partial compliance with CSS Level 2, supporting properties like floating elements and relative positioning, though with proprietary extensions. These built on DHTML foundations for better structured data and styling. In 2001, Trident 6.0 powered Internet Explorer 6.0, adding incremental rendering for progressive content display during download, improving performance on slower connections. It supported the CSS position: fixed property in quirks mode, with full standards-mode support added later, expanding layout options. Trident advanced in Internet Explorer 7 through 9 from 2006 to 2011, with versions 7.0, 8.0, and 9.0 focusing on standards and interactivity. IE 7 introduced native XMLHttpRequest for AJAX. IE 8 passed the Acid2 test for better CSS and DOM rendering. IE 9 added partial HTML5 support, including canvas and video, hardware-accelerated GPU rendering, and improved Acid3 scores. Trident 10.0 debuted in in 2012, optimized for touch-enabled devices on , integrating snap and touch gestures for fluid interactions on tablets and touchscreens. This version emphasized responsive layouts and modern standards compliance. The final major update to Trident, version 11.0, arrived with in 2013, adding for 3D graphics acceleration and JavaScript performance improvements via the engine with .

Technical Architecture

Rendering Engine Components

The core of the Trident rendering engine is encapsulated in the MSHTML.dll , which serves as the central component responsible for HTML documents and constructing the corresponding (DOM) tree. During the process, MSHTML employs internal classes such as CHtmPre for initial pre-parsing of the input stream and CHtmPost alongside CHtml5Parse for post-parsing to handle tag and attribute resolution. Tree construction occurs in the post-parsing phase through the execution of CHtmPost::Exec(), which generates DOM objects from the processed tag streams, enabling the representation of the document structure for subsequent rendering stages. Trident's layout engine implements a proprietary flow layout algorithm, designed to position elements sequentially in a block-based manner while accommodating inline and floating content. This algorithm includes specialized handling for complex structures like tables, utilizing algorithms to compute cell dimensions, borders, and alignments based on HTML table specifications, and , which enable the division of the viewport into independent rendering regions with their own scrollable content areas. Markup and style processing is managed through internal parsers that integrate CSS rules with the DOM tree to determine element positioning and visual properties prior to final layout computation. The scripting subsystem in Trident was initially powered by the engine, Microsoft's implementation of , which acts as the host for executing client-side scripts embedded in or referenced by documents. Starting with , it transitioned to the engine, which provided for enhanced performance. JScript and Chakra integrate tightly with the DOM to allow scripts to query, modify, and respond to document elements dynamically, including through methods like getElementById and innerHTML for manipulation. Event handling is facilitated via the DOM's event model, where scripts register listeners for user interactions and browser events, propagating them through the object hierarchy to trigger bound callbacks, ensuring responsive behavior in web applications. In later iterations of Trident, starting with , the graphics rendering layer incorporates technologies for hardware-accelerated compositing, shifting computationally intensive tasks like drawing and layered content blending to the GPU. This leverages for 2D graphics acceleration, enabling smoother rendering of elements such as and , while DirectWrite handles text layout and rendering for improved performance and subpixel accuracy. These optimizations allow for offloading of compositing operations, where multiple layers (e.g., backgrounds, foregrounds, and effects) are combined efficiently using GPU resources, particularly beneficial for animations and transitions.

Integration with Windows

Trident, also known as MSHTML, relies heavily on the Windows (COM) for its extensibility, allowing it to be hosted in various applications and enabling the integration of controls as plugins. This COM-based architecture permits developers to embed the rendering engine into custom hosts by implementing key interfaces such as IOleDocumentSite and IWebBrowser2, which facilitate scripting, event handling, and dynamic content loading. controls, themselves COM objects, extend Trident's functionality for rich interactions like multimedia playback and form processing, making it a foundational component for Windows-native web experiences. The engine provides native support for Windows system themes, fonts, and UI elements, ensuring seamless visual consistency with the operating system's interface. For instance, Trident adopts default system fonts such as Segoe UI for rendering web content, configurable through Internet Explorer's options that draw from the Windows font library to handle accessibility and localization needs. This integration extends to UI elements like the , where file dialogs and other native controls align with the active theme, such as Aero in and later, enhancing user familiarity without requiring additional bridging code. Trident's security model is intrinsically linked to Windows features, including Internet Explorer security zones and , to enforce granular content restrictions. Security zones categorize websites into levels like , Local , and Trusted Sites, applying policies via Feature Control Keys (FCKs) that MSHTML respects, such as locking down local machine access or protocol-specific behaviors. , introduced in on , runs the browser process at Medium Integrity Level, isolating it from the user's full privileges and preventing exploits from escalating; however, independent MSHTML hosting outside this mode lacks such protections, underscoring Trident's dependence on the OS's integrity mechanisms. Performance optimizations in Trident leverage Windows-specific , transitioning from GDI+ in earlier versions to in and beyond. GDI+ provided software-based and for smoother rendering, but it was CPU-intensive; , built on , offloads 2D graphics operations to the GPU for hardware-accelerated , text, and effects, significantly improving page load times and interactivity on compatible Windows hardware. This shift enabled features like accelerated while maintaining compatibility with Windows graphics pipelines.

Usage and Applications

Role in Web Browsers

Trident, also known as MSHTML, functioned as the proprietary rendering engine exclusively powering versions 4 through 11 on Windows desktop and server platforms. Introduced with in 1997, it handled the parsing, layout, and rendering of web content, including , CSS, and scripting, making it integral to the browser's operation across these releases. This exclusive deployment ensured that 's performance and compatibility were directly tied to 's capabilities, influencing its dominance in enterprise environments where Windows integration was paramount. As of 2025, the IE11 version of remains available via mode in for rendering legacy sites, with support extended until at least 2029. In 2015, forked to create EdgeHTML, a more modular engine that powered the initial release of Microsoft Edge as the successor to , from 2015 until the browser's transition to a Chromium-based in 2020. While EdgeHTML diverged from over time to support modern web standards, it retained core elements of the MSHTML/Trident codebase, particularly for in rendering legacy content. This fork extended 's influence into the post- era, allowing Edge to leverage improved performance while maintaining support for sites optimized for older behaviors until the full switch to . A key enterprise feature enabled by Trident was Compatibility View, which permitted users and administrators to render websites using emulated document modes from earlier Trident versions, such as those in or 8, to ensure functionality for legacy applications. This mechanism addressed compatibility issues arising from Trident's historical deviations from web standards, allowing organizations to maintain access to intranet sites and enterprise tools without immediate redevelopment. During its peak in the early 2000s, , driven by , commanded over 95% of the global browser market share by 2003, profoundly shaping practices. Developers often resorted to IE-specific hacks, such as conditional comments and CSS selectors targeting Trident's unique parsing quirks, to work around inconsistencies in standards support and ensure cross-browser compatibility. These adaptations, while enabling broader site accessibility, fragmented the web ecosystem and delayed the adoption of uniform standards until competing browsers gained traction.

Adoption in Non-Browser Software

Trident, also known as MSHTML, has been integrated into various Microsoft applications outside of web browsers to handle HTML rendering tasks. One prominent example is its use in Microsoft Outlook for rendering HTML-formatted emails. Office 2000 to 2003 versions relied on the Trident engine to display email content, leveraging the same rendering capabilities as Internet Explorer to interpret HTML and CSS in messages. Beyond email clients, Trident powers HTML rendering in core Windows utilities. Compiled HTML Help (CHM) files, a standard format for Windows application documentation, utilize the HTML Help viewer (hh.exe), which embeds the MSHTML component to render the contained pages, indexes, and navigation elements. Similarly, incorporates Trident through its HTMLView feature in the Now Playing interface, allowing the display of web-based content alongside media playback in versions 9 and 10. Third-party developers have also adopted Trident for embedding web-like interfaces in their software. This integration extends to custom Windows widgets and controls, facilitated by the WebBrowser ActiveX control, which developers embed in Win32 or .NET applications to incorporate rich HTML views, such as dynamic dashboards or embedded web previews, directly into desktop software. MSHTML could be embedded in Win32 applications via the WebBrowser ActiveX control for creating HTML-rendered user interfaces, such as forms or informational panels. This availability promoted widespread use in enterprise and productivity tools, where Trident provided a consistent rendering environment tied to the Windows ecosystem.

Standards and Compatibility

Support for Web Standards

Trident's adherence to web standards developed incrementally through its integration with successive versions of , focusing on W3C recommendations for core technologies like , CSS, and scripting languages. Early implementations prioritized foundational standards, with enhancements in later versions addressing modern web requirements while maintaining . Support for HTML 4.01 was fully achieved by , providing conformance to the W3C specification with documented variations for rendering and parsing. With the release of , Trident introduced partial support for , including key features such as the <canvas> element for 2D graphics and the <video> element for media playback, though full compliance remained incomplete across the specification. CSS support began with full implementation of Level 1 in initial Trident versions, enabling basic styling rules like fonts, colors, and margins. Level 2 support was partial in early releases, with notable gaps such as limited application of the :hover pseudo-class, which was restricted to anchor elements until extended it to all elements for improved . CSS Level 3 adoption was limited overall, with selective features like advanced selectors and animations appearing in and later, but without support for layout modules such as flexbox until partial implementation in and 11. The scripting engine in Trident complied with 3 (ECMA-262 Third Edition) starting from 5.5, supporting core language features like objects, functions, and error handling for dynamic . Partial support for 5 arrived with , incorporating enhancements such as strict mode and methods, though not all features were fully realized until subsequent versions. Trident natively handled XML and documents, with and later providing built-in parsing and rendering compliant with 1.0, leveraging the library for earlier versions. This included support for transformations to convert XML into other formats like , enabling structured data presentation in web applications.

Compatibility Challenges

Trident's implementation of quirks mode and standards mode introduced significant compatibility challenges, as the engine would switch behaviors based on the document's DOCTYPE declaration, often resulting in inconsistent rendering across websites. In quirks mode, activated by an absent or malformed DOCTYPE, Trident emulated the layout behaviors of early browsers like to maintain with legacy content, but this led to deviations from modern CSS specifications, such as altered box model calculations and margin handling. Conversely, standards mode, triggered by a valid DOCTYPE like <!DOCTYPE html>, enforced stricter adherence to web standards, which could break older sites designed under assumptions of quirks-mode leniency, forcing developers to include conditional comments or browser-specific hacks to target Trident explicitly. Notable rendering bugs further exacerbated interoperability issues in early Trident versions. For instance, in Internet Explorer 6 powered by Trident 4.0, the double-margin float bug caused elements floated left or right with a corresponding directional margin to render with twice the intended spacing, disrupting layouts like multi-column designs and requiring workarounds such as setting display: inline on the affected elements to override the erroneous calculation. Similarly, Trident versions in Internet Explorer 4 through 6 failed to support alpha transparency in PNG images, rendering transparent areas as solid colors (often gray or black) instead of blending with the background, which compelled developers to use cumbersome filters like AlphaImageLoader or convert images to GIF format, complicating cross-browser development until native support was added in Internet Explorer 7 with Trident 5.0. The proprietary nature of Trident fostered through support for non-standard and elements, embedding Microsoft-specific code into web applications that hindered portability to other engines. Features like the <marquee> element, which animated scrolling text, and deprecated attributes such as align="center" on were widely used in legacy sites targeting , as they provided behaviors not standardized in or CSS at the time, leading to breakage or incomplete functionality in competing browsers like or Chrome. This reliance on Trident-exclusive syntax persisted in enterprise environments, where developers optimized for 's market dominance, resulting in codebases resistant to migration. Cross-browser compatibility was starkly illustrated by Trident's poor performance on the test, a benchmark evaluating adherence to , CSS, and standards released in 2008. Internet Explorer 7, using Trident 5.0, achieved a score of only 12 out of 100, failing most tests related to DOM manipulation, SVG rendering, and execution, while Internet Explorer 8 with an updated Trident scored 20 out of 100, still lagging far behind contemporaries like 3 (70/100) and highlighting systemic gaps in standards compliance that prolonged the need for IE-specific testing and polyfills.

Legacy and Transition

Deprecation Timeline

In February 2015, Microsoft announced the development of a new rendering engine, EdgeHTML, as a fork of the Trident-based MSHTML engine, aimed at improving standards compliance and performance by removing legacy code and adding modern web capabilities. This divergence marked the beginning of Trident's phase-out in Microsoft's primary browser efforts, with EdgeHTML powering the initial version of Microsoft Edge released alongside Windows 10 in July 2015. On December 6, 2018, Microsoft revealed plans to rebuild Edge on the open-source Chromium engine, effectively deprecating EdgeHTML and severing the direct lineage from Trident for the browser's core rendering. The Chromium-based Edge reached stable release as version 79 on January 15, 2020, completing the transition and ending active development of Trident-derived engines in the new Edge. Trident continued to be retained in Internet Explorer 11 for backward compatibility with legacy web applications, but Microsoft ended support for the IE 11 desktop application on June 15, 2022, for most Windows 10 versions, redirecting users to the modern Edge browser. As of November 2025, Trident (via the MSHTML engine) persists in limited use through Internet Explorer mode in the Chromium-based Microsoft Edge, which emulates IE 11 rendering for enterprise and legacy Windows applications requiring it, with support extended at least until 2029.

Successor Technologies

Microsoft developed EdgeHTML as a direct successor to Trident, introducing it in 2015 as the rendering engine for the new Microsoft Edge browser in Windows 10. EdgeHTML began as a of Trident's core MSHTML.dll but rapidly diverged to eliminate legacy compatibility modes accumulated over two decades, focusing instead on modern web standards . This addressed Trident's longstanding shortcomings in CSS3 and support by implementing over 40 new web platform features and resolving more than 3,000 bugs related to cross-browser compatibility. As a result, EdgeHTML enabled faster rendering and broader adherence to contemporary web specifications, marking a significant evolution from Trident's document modes and proprietary extensions. Despite these advancements, announced in December 2018 a pivot from EdgeHTML to the open-source project's Blink rendering engine for future versions of Edge, with the transition beginning in early 2019. This shift aimed to further mitigate and EdgeHTML's compatibility issues by aligning Edge more closely with the dominant web ecosystem, reducing developer fragmentation, and enhancing site rendering consistency across browsers. To support legacy applications reliant on , the Chromium-based Edge incorporated (IE) mode, which emulates the MSHTML engine from IE11 for specified sites, allowing seamless handling of older web content without disrupting modern browsing. Post-deprecation, has maintained security updates for MSHTML to sustain embedded and legacy uses, with IE binaries—including —receiving patches through at least 2029 to protect against vulnerabilities in enterprise environments. For developers transitioning from Trident-based WebViews, introduced WebView2 as a Chromium-powered alternative, which embeds modern web content in native applications. For legacy Trident-dependent scenarios, the MSHTML-based WebBrowser control remains supported through at least 2029, though migration to WebView2 is recommended where possible. This runtime ensures evergreen updates and improved performance, effectively replacing Trident's role in non-browser software without requiring full rewrites.

References

  1. https://learn.microsoft.com/en-us/deployedge/edge-ie-mode
  2. https://developer.mozilla.org/en-US/docs/Glossary/Trident
  3. https://learn.microsoft.com/en-us/security-updates/securitybulletins/1998/ms98-013
  4. https://blogs.windows.com/msedgedev/2015/02/26/a-break-from-the-past-the-birth-of-microsofts-new-web-rendering-engine/
  5. https://learn.microsoft.com/en-us/office/dev/add-ins/testing/ie-11-testing
  6. https://learn.microsoft.com/en-us/office/dev/add-ins/concepts/browsers-used-by-office-web-add-ins
  7. https://www.wired.com/2010/05/0526bill-gates-internet-memo/
  8. https://www.infoworld.com/article/2253054/up-down-out-20-years-microsoft-internet-explorer-3.html
  9. https://www.internethistorypodcast.com/2015/11/how-microsoft-went-online-with-brad-silverberg/
  10. https://arstechnica.com/gadgets/2022/06/remembering-internet-explorer-the-now-dead-browser-that-once-powered-the-internet/
  11. https://learn.microsoft.com/en-us/windows/win32/devnotes/mshtml2
  12. https://learn.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/hh801968(v=vs.85)
  13. https://learn.microsoft.com/en-us/windows/win32/vml/web-workshop---specs---standards----introduction-to-vector-markup-language--vml-
  14. https://www.microsoft.com/en-us/msrc/blog/2009/04/the-mshtml-host-security-faq-part-ii-of-ii
  15. https://learn.microsoft.com/en-us/windows/win32/com/translating-to-jscript
  16. https://www.webdesignmuseum.org/software/internet-explorer-4-0-in-1997
  17. https://learn.microsoft.com/en-us/previous-versions/iis/6.0-sdk/ms525542%28v=vs.90%29
  18. https://www.xml.com/pub/2000/05/03/msie/index.html
  19. https://www.cnet.com/reviews/microsoft-internet-explorer-6-0-review/
  20. https://betanews.com/2001/08/03/internet-explorer-6-in-final-stretches/
  21. https://www.smashingmagazine.com/2009/10/css-differences-in-internet-explorer-6-7-and-8/
  22. https://www.blackhat.com/docs/us-15/materials/us-15-Yason-Understanding-The-Attack-Surface-And-Attack-Resilience-Of-Project-Spartans-New-EdgeHTML-Rendering-Engine-wp.pdf
  23. https://www.microsoft.com/en-us/msrc/blog/2009/04/the-mshtml-host-security-faq-part-i-of-ii
  24. https://blogs.msdn.microsoft.com/ie/2010/03/16/internet-explorer-9-platform-preview-3-available-for-download/
  25. https://news.microsoft.com/source/2010/03/16/microsoft-announces-hardware-accelerated-html5-pushes-boundaries-on-web-and-cloud-development/
  26. https://download.microsoft.com/download/9/2/1/921F91D0-B01A-40B0-BA65-88C7F6E33316/InternetExplorer9BetaProductGuide.pdf
  27. https://learn.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa741317(v=vs.85)
  28. https://support.microsoft.com/en-us/windows/internet-explorer-ease-of-access-options-037270c1-db10-7ca8-ccba-ebd83ea6ace9
  29. https://learn.microsoft.com/en-us/windows/compatibility/direct2d-does-not-support-rendering-to-rich-metafiles
  30. https://learn.microsoft.com/en-us/previous-versions/troubleshoot/browsers/core-features/gpu-hardware-acceleration
  31. https://learn.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-it-pro/internet-explorer-11/ie11-deploy-guide/tips-and-tricks-to-manage-ie-compatibility
  32. https://learn.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-it-pro/internet-explorer-11/ie11-deploy-guide/missing-the-compatibility-view-button
  33. https://www.bbc.com/news/10095730
  34. https://paulirish.com/2009/browser-specific-css-hacks/
  35. https://annevankesteren.nl/2008/01/ie-lock-in
  36. https://www.litmus.com/blog/a-guide-to-rendering-differences-in-microsoft-outlook-clients
  37. https://learn.microsoft.com/en-us/dotnet/desktop/winforms/controls/webbrowser-control-overview
  38. https://learn.microsoft.com/en-us/openspecs/ie_standards/ms-html401/1c56f14c-603d-4028-8031-6a6f2600e808
  39. https://learn.microsoft.com/en-us/openspecs/ie_standards/ms-html5/4257eddd-d92e-4ef0-88d5-b7accc73e094
  40. https://learn.microsoft.com/en-us/openspecs/ie_standards/ms-css21/dbb3fd1b-4d0c-4899-9e87-587d4f232a9e
  41. https://download.microsoft.com/download/2/8/e/28e60dcc-123c-4b27-b397-1f6b2b6cb420/part2_mm.pdf
  42. https://learn.microsoft.com/en-us/openspecs/ie_standards/ms-es3/940eb5a7-43a3-44dc-82c7-44188eb8ef9e
  43. https://learn.microsoft.com/en-us/openspecs/ie_standards/ms-es5/25dfd6ed-f540-4b9e-9e83-2157286dc892
  44. https://learn.microsoft.com/en-us/openspecs/ie_standards/ms-xhtml/6ac9708c-2273-452f-a99f-7b35517adba5
  45. https://learn.microsoft.com/en-us/openspecs/ie_standards/ms-xslt/edf5c768-02cf-4dfd-9322-0516470216fa
  46. https://developer.mozilla.org/en-US/docs/Web/HTML/Guides/Quirks_mode_and_standards_mode
  47. https://www.dave-woods.co.uk/ie6-css-bugs-and-fixes-explained/
  48. https://www.howtocreate.co.uk/wrongWithIE/?chapter=PNG+Transparency
  49. https://www.webstandards.org/2008/02/05/acid3-nearing-completion/index.html
  50. https://macdailynews.com/2009/03/21/microsoft_internet_explorer_8s_epic_fail_scores_20_100_on_acid3/
  51. https://blogs.windows.com/msedgedev/2016/01/21/microsoft-edge-2015-in-review/
  52. https://blogs.windows.com/msedgedev/2020/01/15/upgrading-new-microsoft-edge-79-chromium/
  53. https://learn.microsoft.com/en-us/lifecycle/announcements/internet-explorer-11-end-of-support
  54. https://blogs.windows.com/windowsexperience/2018/12/06/microsoft-edge-making-the-web-better-through-more-open-source-collaboration/
  55. https://techcommunity.microsoft.com/blog/windows-itpro-blog/internet-explorer-11-desktop-app-retirement-faq/2366549
Add your contribution
Related Hubs
User Avatar
No comments yet.