Hubbry Logo
Chakra (JScript engine)Chakra (JScript engine)Main
Open search
Chakra (JScript engine)
Community hub
Chakra (JScript engine)
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Chakra (JScript engine)
Chakra (JScript engine)
Chakra (JScript engine)
View on Wikipedia
from Wikipedia
Chakra
DeveloperMicrosoft
Initial release2009; 17 years ago (2009)
Written inC++
Operating systemMicrosoft Windows
TypeJScript engine
LicenseProprietary

Chakra is a JScript engine used in the Internet Explorer web browser, both developed by Microsoft as proprietary software.

Microsoft later developed a new JavaScript engine for its Microsoft Edge Legacy browser, which is confusingly also named Chakra. Microsoft Edge changed to V8 (JavaScript engine) in 2020.

Features

[edit]

A distinctive feature of the engine is that it just-in-time (JIT) compiles scripts on a separate central processing unit (CPU) core, parallel to the web browser.[1][2] Though Microsoft has in the past pointed out that other elements, such as rendering and marshalling, are just as important for a browser's overall performance,[3] their improvements to the engine were in response to evolving competing browsers, compared to which IE8 was lagging behind in terms of client-side script processing speed.[4]

History

[edit]

SunSpider tests performed on November 18, 2009 showed the Professional Developers Conference (PDC) version of IE9 executing scripts much faster than IE8, but slower than Firefox 3.6, Chrome 4, and WebKit Nightly.[3] The same test performed on March 15, 2010 showed the first IE9 Platform Preview (using the then-current version of Chakra) to be faster than Firefox (with SpiderMonkey), but slower than Safari (with SquirrelFish Extreme), Chrome (with V8), and Opera (with Carakan).

On March 8, 2011, Microsoft published results showing the 32-bit Internet Explorer 9 to be faster than Safari, Firefox (with TraceMonkey), Chrome, and Opera.[5]

March 2011 performance tests for ZDNET concluded that Internet Explorer 9 (32-bit), Chrome 10, and Firefox 4 release candidate were "pretty evenly matched."[6]

In 2012, subsequent versions of Chakra, such as the version included in Internet Explorer 10, introduced additional performance changes, including JIT compiling on x86-64 and ARM architectures, and optimizations related to floating point math and garbage collection.[7]

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Chakra (JScript engine)

View on Grokipedia
from Grokipedia
Chakra is a high-performance JavaScript engine developed by Microsoft, serving as the runtime for JScript—the company's implementation of ECMAScript—in Internet Explorer and early versions of Microsoft Edge. Introduced with Internet Explorer 9 in 2010, it pioneered just-in-time (JIT) compilation techniques that interpret JavaScript in the foreground while compiling optimized machine code in the background on secondary CPU cores, enabling parallel execution and significant speed improvements over prior JScript engines. This architecture eliminated inefficient layers between script and the Document Object Model (DOM), aligning with ECMAScript 5 standards and delivering top scores on benchmarks like SunSpider. In subsequent releases, Chakra powered via the legacy jscript9.dll for backward compatibility, while utilized the actively developed chakra.dll, supporting advanced features like 6 compliance, rental threading for scalability, script , and resource throttling for memory and CPU limits. Beyond browsers, the Runtime (JSRT) APIs—introduced in —allowed developers to embed Chakra in Windows applications for /CSS/JS-based scripting, including (UWP) integration. open-sourced the core components as ChakraCore in 2016 under the , providing a API for cross-platform embedding on Windows, , and macOS, with broad ES2015 support and plans for further features. This release fostered community contributions, though security updates for ChakraCore ended in March 2021. Chakra's role as the default JavaScript engine in Microsoft Edge ended in 2020, when the browser was rebuilt on the project and adopted the for enhanced compatibility and performance; the announcement came in December 2018, with the first stable Chromium-based Edge launching in January 2020. However, Chakra continues to power Edge's mode for legacy compatibility, with support until at least 2029, though restricted automatic access following a Chakra zero-day exploit in August 2025. Security updates for the browser-integrated Chakra in Edge's IE mode continue, with recent patches addressing vulnerabilities as of October 2025. Despite its deprecation as the primary , a reworked version of Chakra continues to underpin in Windows for Active Scripting hosts, replacing the older JScript 5.8 implementation to bolster security in legacy environments. Overall, Chakra represented a pivotal advancement in browser scripting, influencing modern engine designs through its focus on multicore optimization and embeddability.

Overview

Definition and Purpose

Chakra is a high-performance JavaScript engine developed by , serving as the core component for executing , 's implementation of the scripting language specification. Introduced in , it interprets, compiles, and executes code in parallel, leveraging multiple CPU cores to generate efficient while maintaining foreground interpretation for seamless . The primary purpose of Chakra is to enable dynamic web content rendering, (DOM) manipulation, and client-side scripting within browsers starting from version 9, thereby enhancing the interactivity and responsiveness of web applications. By integrating natively with the browser's DOM, Chakra eliminates intermediate processing layers, allowing to interact directly with web page elements for faster execution of scripts that drive user interfaces and behaviors. This design supports the creation of rich, script-driven experiences in web pages, aligning with the demands of modern web development. Unlike general-purpose engines such as V8 or , Chakra is tailored specifically for compatibility to ensure seamless operation in Microsoft's ecosystem, while progressively incorporating support for contemporary features like those in ES2015 for broader interoperability. Initially developed as under exclusive ownership, Chakra accepted no external contributions until its core components were open-sourced in 2016.

Standards Compliance

Chakra, the JavaScript engine powering Microsoft's implementation, establishes 3 (ES3) as its foundational baseline to ensure compatibility with legacy code from earlier versions. This adherence to ES3 allows Chakra to execute scripts originally written for , which was designed as Microsoft's dialect of the standard, incorporating core language features like object prototypes, functions, and basic control structures without introducing breaking changes. Chakra achieved full ECMAScript 5 (ES5) compliance starting with Internet Explorer 9. It progressively added support for later ECMAScript editions, reaching substantial compliance with ECMAScript 6 (ES2015) in Microsoft Edge. Key ES6 additions include block-scoped variables with let and const, arrow functions for concise syntax, and native Promises for asynchronous programming, enabling more modern patterns while maintaining . For ECMAScript 2016 and beyond, Chakra provided partial or experimental implementations, such as async/await functions, which were introduced in Microsoft Edge previews but not fully available in Internet Explorer 11. The open-sourced ChakraCore provided broad support for 2015 (ES6) and select features from later editions. Beyond standard compliance, Chakra includes Microsoft-specific extensions rooted in 's design, such as direct integration with controls for embedding native Windows components in scripts. These extensions also facilitate interoperability with through the , allowing code to interact with COM objects and shared scripting environments for tasks like and data access. Chakra's conformance to standards has been verified using the official Test262 conformance suite, achieving full ES5 compliance in with only minimal failures across thousands of tests. By the era of , Chakra improved to near-complete ES6 support, passing the majority of Test262 tests for those features and establishing itself as one of the leading engines for modern adherence at the time.

Development History

Origins in Internet Explorer

Development of the Chakra JavaScript engine began in 2008 as a response to the limitations of the existing JScript engine used in Internet Explorer 8 (IE8), which relied on an interpreter-based approach that struggled with the increasing demands of complex web applications requiring faster script execution. By this time, web development had evolved significantly, with dynamic sites and early single-page applications pushing browsers to handle more intensive JavaScript workloads, exposing the performance bottlenecks of legacy engines like JScript. The primary motivations for creating Chakra were to dramatically enhance JavaScript performance through just-in-time (JIT) compilation, enabling the engine to generate machine code from scripts at runtime for greater efficiency compared to interpretation. This shift was essential for Microsoft to regain competitiveness against emerging rivals, such as Google's V8 engine in Chrome and Mozilla's SpiderMonkey in Firefox, which had set new benchmarks for speed in modern browsing scenarios. Chakra was first publicly demonstrated in the Internet Explorer 9 Platform Preview released on March 16, 2010, and made its full debut with the release of on March 14, 2011, representing Microsoft's first implementation of a JIT-compiled JavaScript engine in its flagship browser. The project was spearheaded by the development team at , with a strong emphasis on seamless integration with the Windows operating system to leverage native platform capabilities for optimized rendering and execution. This foundation allowed Chakra to support accelerated hardware features and tighter OS coupling, distinguishing it from more general-purpose engines.

Version Evolution

With the release of in 2012, Chakra introduced stricter compliance with 5 (ES5), including full support for strict mode, alongside initial optimizations leveraging to enhance rendering and execution speed. , launched in 2013, marked a significant advancement with complete ES5 support and support for certain ES6 features like typed arrays, while incorporating a tiered just-in-time () compilation approach to reduce startup times through efficient interpretation and progressive optimization. In 2015, Chakra transitioned to power the new Microsoft Edge browser, built on the EdgeHTML rendering engine rather than Trident, enabling adaptations for modern web standards and continued proprietary enhancements until Edge's shift away from EdgeHTML in 2019. Key milestones in Chakra's evolution included cumulative performance improvements reaching up to 2x over the JScript engine in Internet Explorer 8, as demonstrated in benchmarks like SunSpider and Kraken, which highlighted gains in JavaScript execution efficiency across versions. Internally, Chakra's versioning aligned closely with Internet Explorer and Edge builds, starting with version 1.0 in Internet Explorer 9 and progressing through iterative cores integrated into EdgeHTML platforms. The evolved core was later open-sourced as ChakraCore in 2016.

Open-Sourcing as ChakraCore

In December 2015, during a presentation at JSConf US, Microsoft announced its intention to open-source the core components of the Chakra JavaScript engine, rebranded as ChakraCore. The initial release occurred on January 13, 2016, when the source code was published on GitHub under the permissive MIT license. This version focused on the engine's foundational elements, deliberately excluding browser-specific integrations such as DOM and UI bindings tailored for Internet Explorer or Microsoft Edge, which allowed ChakraCore to function as a lightweight, embeddable JavaScript runtime suitable for server-side environments, desktop applications, or Node.js-compatible setups. Microsoft's motivations for this open-sourcing effort centered on building a collaborative development model to accelerate and broaden the engine's applicability beyond browser contexts. By releasing ChakraCore, the company aimed to invite global community input for enhancements, ensure greater alignment with evolving open web standards like specifications, and reinforce its commitment to the open-source ecosystem amid a broader cultural shift toward transparency in . This approach was intended to leverage external expertise for ongoing improvements while positioning ChakraCore for cross-platform uses, including potential integrations in cloud services and applications. Following its launch, ChakraCore quickly gained traction among external developers, who contributed pull requests addressing bug fixes, performance tweaks, and expanded support for 2017 features such as async/await and . Notable early adoption included the Node-ChakraCore project, an experimental fork of powered by ChakraCore instead of V8, which demonstrated its viability in server-side execution and attracted further community experimentation. The repository saw sustained development activity through 2020, with regular releases incorporating community-submitted enhancements; however, following the transition of to the engine, active development ceased, with the final release (v1.11.24) in December 2020 and security updates provided until March 2021.

Technical Architecture

Parsing and Execution Model

Chakra processes source code through a multi-stage pipeline designed for efficiency and on-demand execution. Upon receiving input, the engine performs an initial quick parse to detect syntax errors without full analysis, ensuring rapid feedback during development or loading. If no errors are found, full occurs lazily when a function is first invoked, transforming the source into an (AST) that represents the code's structure in a platform-independent manner. This AST is then lowered into platform-agnostic , a compact optimized for subsequent interpretation, which supports features like dynamic typing and scope resolution. generation enables caching via APIs such as JsSerializeScript, allowing applications to store and reload parsed scripts for faster startup in repeated executions. The interpreter phase handles initial code execution to prioritize quick startup times, directly running the generated in a fast, non-optimizing manner. This interpreter manages core behaviors, including dynamic type handling—where variables and operations adapt at runtime—and scope resolution, which determines variable accessibility across function contexts and closures. By executing interpretively, Chakra achieves low-latency launches for short scripts or cold starts, while gathering runtime profiles like type information to inform later optimizations, though the core interpretation remains focused on straightforward, unoptimized traversal. This phase transitions seamlessly to compiled code for frequently invoked functions, enhancing overall performance without interrupting execution flow. Chakra's runtime environment employs a generational mark-and-sweep garbage collector for automatic , dividing objects into young and old generations to efficiently reclaim unused space and minimize pauses. The collector operates concurrently in the background, performing partial collections that include marking reachable objects, rescanning for accuracy, and sweeping freed memory, which supports scalable handling of large object graphs in production workloads. In 64-bit configurations, this system accommodates substantial heap sizes, enabling robust memory usage for memory-intensive applications while triggering out-of-memory errors when limits are exceeded. Error handling integrates diagnostics throughout the pipeline, with the initial parse flagging syntax immediately and the interpreter capturing runtime exceptions during execution. For thrown , particularly those deriving from the Error prototype, Chakra generates stack traces that map back to original source lines, providing developers with precise information for . The threading model adheres to JavaScript's single-threaded execution paradigm, where all script code runs on a primary thread to avoid concurrency issues in shared state. Asynchronous operations integrate via an mechanism, queuing callbacks and promises for non-blocking handling without multi-threading the core runtime, though background threads may assist ancillary tasks like garbage collection. This design ensures deterministic behavior for synchronous code while supporting scalable async patterns through host environment integrations.

Just-In-Time Compilation

Chakra's just-in-time (JIT) compilation mechanism employs a tiered approach to balance startup latency and peak performance, consisting of three execution tiers: an initial interpreter for rapid bytecode execution, a simple JIT compiler that generates quick but less optimized machine code for warming up hot functions, and a full optimizing JIT compiler that produces highly tuned code incorporating advanced transformations like inlining and loop unrolling. This tiered strategy allows the engine to progressively optimize code based on runtime behavior, with compilation occurring on background threads to avoid blocking the main execution thread. Hot code identification begins during interpretation, where the collects profile data on invocation counts, type information, and execution paths for functions and loops. When a function reaches predefined thresholds—such as 25 invocations for promotion to the simple tier and 20,000 for the full tier—the relevant code is queued for compilation, enabling dynamic to frequently executed paths while minimizing unnecessary compilations. The JIT compilers apply several key optimization techniques to enhance efficiency. Type specialization leverages profiled type information to assume stable types for variables and objects, allowing the generation of faster, type-specific operations instead of generic handling. removes instructions that do not affect program outcomes, while optimizes the use of CPU registers to reduce memory accesses and improve instruction throughput. These optimizations are guided by the interpreter's profile data to infer common usage patterns. Chakra supports JIT backends for x86, x64, and architectures, ensuring compatibility across diverse hardware platforms. Later versions incorporate SIMD instructions to accelerate vector mathematics operations, enabling efficient handling of and numerical computations in . To maintain correctness, the includes deoptimization mechanisms, where execution bails out to the interpreter if runtime conditions violate compilation assumptions, such as unexpected type changes or overflows. Upon , the engine invalidates the optimized code, reverts to interpretation for re-profiling, and may trigger recompilation with updated assumptions; repeated bailouts can lead to disabling optimizations for the affected code path.

Key Features

Language Extensions and Support

Chakra, as the JavaScript engine powering in and later, included support for several JScript-specific APIs designed for integration with the Windows ecosystem. The window.external object enabled interactions with Internet Explorer-specific features, such as accessing external application services or browser extensions. Similarly, the ActiveXObject constructor facilitated COM automation, allowing scripts to instantiate and manipulate controls for tasks like file access or database connectivity in legacy web applications. These APIs were retained in Chakra for to maintain compatibility with existing enterprise and sites reliant on Windows-specific scripting. In terms of 6 (ES6) and later features, Chakra provided progressive support across its implementations. Internet Explorer 11's Chakra offered partial ES6 compatibility, including features such as let and const declarations, default parameters, and rest parameters, but lacked support for classes, modules, generators, and many other ES6 features. By contrast, the Chakra engine in delivered comprehensive ES6+ implementation, encompassing modules for modular code organization, enhanced classes with inheritance, and generators for asynchronous-like without requiring full async/await. This evolution aligned Chakra with modern web standards while building on its ES5 baseline. Chakra incorporated debugging aids to enhance developer productivity, particularly through integration with browser tools. Source maps were supported to map minified or transpiled code back to original sources, enabling accurate breakpoint setting and inspection in the F12 developer tools. Enhancements to the console , such as improved formatting for objects and arrays, along with support for console.table() and console.group(), facilitated more effective logging and workflows in both and Edge environments. Security features in Chakra emphasized safe script execution, including compliance with Content Security Policy (CSP) to restrict script sources and mitigate cross-site scripting risks. Sandboxing mechanisms allowed for isolated execution of untrusted scripts, using runtime constraints in the JavaScript Runtime (JSRT) APIs to limit access to host resources and prevent unauthorized operations. For backward compatibility, Chakra supported a legacy JScript 5.6 mode to accommodate older Internet Explorer sites developed for earlier versions like IE5.5, where scripts could opt into modern parsing via directives while emulating classic behaviors such as variable scoping and error handling. This mode, activated through document compatibility directives or Active Scripting host configurations, ensured seamless operation of legacy code without breaking existing deployments.

Performance Optimizations

Chakra employs runtime profiling techniques within its process to guide optimizations, particularly for inline caching on accesses. Inline caches store information about object shapes and offsets, enabling faster lookups by avoiding repeated dictionary searches during execution. This approach reduces the overhead of dynamic resolution, which is common in due to its prototype-based and mutable objects. In Chakra, polymorphic inline caches extend this to bracket notation accesses like object['property'], further minimizing expensive runtime checks. Memory efficiency in Chakra is enhanced through compact object representations and a generational garbage collector. Objects are structured with a shared "type" descriptor that defines layout and inline slots for properties, allowing multiple instances to reuse the same type for reduced compared to per-object metadata. The generational mark-and-sweep collector divides the heap into young and old generations, performing concurrent and partial collections to reclaim memory with minimal interruption to execution. This design supports low-latency operation by focusing collections on recently allocated objects, which account for the majority of allocations in typical workloads. Benchmark results highlight Chakra's competitive performance, particularly in 11. In the JetStream suite, IE11 achieved scores demonstrating solid throughput for real-world web applications, while later iterations in showed over 1.6 times improvement over IE11. Similarly, on 2.0, Chakra in IE11 delivered strong results in computational tasks, remaining competitive with engines like V8 through 2017 before broader ecosystem shifts. These outcomes reflect optimizations in code generation and execution speed for dynamic language constructs. Startup time optimizations in Chakra include lazy parsing, where the engine performs a lightweight syntax check at load time but defers full generation until functions are invoked. This reduces initial parsing overhead, allowing quicker execution of entry-point code in web pages. Additionally, for modules, Chakra delays parsing and JIT compilation of functions until runtime call sites, avoiding upfront costs for unused code paths. Hardware utilization in Chakra leverages vectorization for math-intensive operations via SIMD.js support, enabling single-instruction multiple-data processing on SIMD registers for tasks like matrix multiplications and vector arithmetic. This accelerates numerical computations in applications such as and simulations. For multi-core scaling, Chakra integrates with Web Workers, allowing parallel execution of across threads to distribute workloads and improve responsiveness on multi-processor systems.

Deployments and Usage

Browser Integrations

Chakra served as the core engine in through 11, both on desktop and mobile platforms, enabling enhanced execution of modern web applications by compiling JavaScript code just-in-time and leveraging multiple CPU cores for parallel processing. Introduced in IE9 in 2011, it replaced the legacy engine, delivering significant speed gains that allowed IE9 to achieve a score of 95/100 on the standards compliance test, a marked improvement over IE8's 21/100 and facilitating support for and features essential for contemporary . This integration extended to 7.5 with IE9 Mobile, where Chakra powered accelerated rendering and scripting for mobile web experiences. In Microsoft Edge from its 2015 launch through 2019, Chakra was paired with the proprietary EdgeHTML rendering engine, providing robust JavaScript execution that supported advanced web standards including Progressive Web Apps (PWAs) and service workers. 's implementation of Chakra enabled service workers by default starting in late 2017, allowing developers to build offline-capable, installable web applications with background synchronization and push notifications, thereby bridging native app functionality within the browser environment. To maintain with legacy websites from the 1990s and early 2000s, versions 9-11 employed document modes, where handled standards-compliant rendering and scripting in IE9+ mode, while quirks mode or compatibility view used configured to emulate IE5.5 or IE7 behaviors. This emulation approach, activated via the Compatibility View button or meta tags, ensured that outdated sites relying on non-standard features continued to function without disruption, preserving access to enterprise intranets and archival content. Chakra's integration with the F12 developer tools in both and Edge provided developers with specialized profiling capabilities, including a built-in profiler that captured execution timelines, memory usage, and call stacks to optimize script performance. In IE9 and later, the tools allowed real-time inspection of Chakra-compiled , while Edge's enhanced F12 interface extended this to include DOM interaction tracing and performance metrics tailored to Chakra's process. During 2011-2018, Chakra's advancements contributed to and Edge achieving performance parity with competitors like Chrome's V8 and Firefox's , as evidenced by competitive scores in benchmarks such as Octane 2.0 and JetStream, where Edge occasionally outperformed rivals in real-world web scenarios. This parity helped sustain IE's dominant market position in enterprise environments and bolstered Edge's initial , with IE holding over 50% global share in 2011 and Edge reaching 5-10% by 2018, driven by reliable execution of complex scripts in business-critical applications.

Applications Beyond Web Browsing

Following its open-sourcing as ChakraCore under the , the engine found applications in various non-browser environments, enabling developers to embed execution without relying on web rendering components. Official security updates ended in March 2021, and release downloads became unavailable after May 31, 2024, though the project remains archived for community use. ChakraCore's standalone capabilities were particularly valuable in Windows applications built on the Universal Windows Platform (UWP), where it powered and -based user interfaces in hybrid apps combining C# and JavaScript. For instance, developers used ChakraCore via libraries like ChakraBridge to integrate JavaScript frameworks seamlessly into C#/UWP projects, allowing scripting and dynamic interfaces in desktop and mobile apps without a WebView dependency. In server-side contexts, experimental integrations like chakra-node allowed to optionally run on ChakraCore instead of the dominant , providing an alternative for Windows-centric deployments. This effort included a V8 API shim layered over ChakraCore's hosting , submitted as a pull request to the repository, though adoption remained limited due to V8's established ecosystem and performance parity in most scenarios. For embedded systems, ChakraCore's lightweight design supported deployments in resource-constrained environments such as IoT devices on IoT Core, where it enabled scripting for tasks. Additionally, it underpinned -based applications on , leveraging WinJS for interactive experiences in console apps running on the EdgeHTML Chakra engine. Third-party projects further demonstrated ChakraCore's versatility, with developers building custom scripting engines and mobile runtimes, such as Janea Systems' implementation for and Android that utilized ChakraCore's interpreter mode to comply with platform restrictions. These efforts highlighted the engine's C API for embedding in C/C++ projects, fostering innovations like hybrid mobile apps. The MIT license of ChakraCore permitted broad commercial uses without Microsoft-specific dependencies, allowing redistribution in proprietary software while requiring only the inclusion of the license notice. This permissive structure encouraged adoption in diverse stacks, from enterprise tools to consumer applications.

Legacy and Transition

End of Active Development

In January 2020, Microsoft released the stable version of its Chromium-based Edge browser, confirming the full transition away from the Chakra JavaScript engine to Google's V8 engine. This marked the effective end of Chakra's role in Microsoft's primary web browser, as the company shifted resources to the Chromium ecosystem. The decision stemmed from Microsoft's strategic pivot toward the Chromium project to accelerate feature delivery, enhance web compatibility, and ensure greater cross-platform consistency across Windows, macOS, and other operating systems. By adopting V8 and the broader rendering , Microsoft aimed to reduce development overhead and align more closely with industry standards, allowing faster integration of web innovations without maintaining a . Following the Edge transition, provided minor security patches for the open-source ChakraCore project until March 9, 2021, after which active support ceased. 's announcement encouraged community ownership of ChakraCore for niche applications, but no large-scale community takeover emerged. As of 2025, the project has seen limited activity and is largely inactive, with pre-built releases discontinued after May 31, 2024. Concurrently, support for , which relied on Chakra, was extended for enterprise users until June 15, 2022, to accommodate legacy applications on Windows 10. The shift impacted Edge users through automatic updates via , compelling a migration to the new Chromium-based version and phasing out the legacy Edge runtime. For legacy Windows environments dependent on IE11, the runtime persisted until the 2022 cutoff, providing a temporary bridge for compatibility. However, continues to be used in Microsoft Edge's (IE) Mode for legacy compatibility. In August 2025, threat actors exploited zero-day vulnerabilities in the engine via IE Mode to achieve remote code execution, prompting Microsoft to restrict IE Mode access in October 2025 to mitigate risks.

Successors and Influence

Following the transition of Microsoft Edge to a Chromium-based architecture in January 2020, the V8 JavaScript engine became the direct successor to Chakra in the browser, replacing its role in rendering and executing dynamic web content. While V8 introduces distinct optimizations such as its Ignition interpreter and TurboFan compiler, it upholds Chakra's foundational philosophy of tiered just-in-time (JIT) compilation to balance startup speed with peak performance, ensuring continued efficient JavaScript handling in Edge. This shift allowed Microsoft to leverage the broader Chromium ecosystem while maintaining high compatibility for Windows users. Chakra's early adoption of 2015 (ES6) features, including modules, classes, and arrow functions, provided one of the most comprehensive implementations among major engines at the time, influencing TC39 committee discussions and accelerating the standardization and real-world testing of these proposals. The 2016 open-sourcing of Chakra's core as ChakraCore further promoted transparency in JavaScript engine design, inviting community scrutiny and contributions that inspired similar openness in other proprietary engines and fostered collaborative advancements in the ecosystem. On a broader scale, Chakra's development and open-sourcing exemplified Microsoft's evolving embrace of open-source practices, building on initiatives like and contributing to the runtime ecosystem. Forks of ChakraCore persist in legacy embedded systems, such as certain Windows applications and compatibility modes like IE Mode, while the engine serves as a key in academic and developer resources exploring techniques, garbage collection, and . Throughout the 2010s, Chakra democratized high-performance within the Windows ecosystem by powering not only browsers but also native applications via the , delivering benchmark-competitive speeds that rivaled V8 and and enabling seamless integration of web technologies into desktop software. This contributed to widespread adoption of for cross-platform development on Windows, reducing barriers for developers targeting the platform's vast user base. A reworked version of Chakra continues to underpin in Windows for Active Scripting hosts, replacing the older JScript 5.8 implementation.

References

  1. https://download.microsoft.com/download/9/2/1/921F91D0-B01A-40B0-BA65-88C7F6E33316/InternetExplorer9BetaProductGuide.pdf
  2. https://www.microsoft.com/en-us/research/video/chakra-script-optimized-code/
  3. https://blogs.windows.com/msedgedev/2015/05/18/using-chakra-for-scripting-applications-across-windows-10/
  4. https://opensource.microsoft.com/blog/2016/01/13/microsoft-open-source-edge-chakra-javascript
  5. https://github.com/chakra-core/ChakraCore
  6. https://blogs.windows.com/windowsexperience/2018/12/06/microsoft-edge-making-the-web-better-through-more-open-source-collaboration/
  7. https://learn.microsoft.com/en-us/lifecycle/products/internet-explorer-11
  8. https://www.bleepingcomputer.com/news/security/microsoft-restricts-ie-mode-access-in-edge-after-zero-day-attacks/
  9. https://learn.microsoft.com/en-us/answers/questions/1071647/windows-11-22h2-has-a-different-way-of-using-the-j
  10. https://learn.microsoft.com/en-us/style-guide/a-z-word-list-term-collections/j/java-jscript-javascript
  11. https://learn.microsoft.com/en-us/windows/win32/com/translating-to-jscript
  12. https://www.wirfs-brock.com/allen/jshopl.pdf
  13. https://blogs.windows.com/msedgedev/2015/05/12/javascript-moves-forward-in-microsoft-edge-with-ecmascript-6-and-beyond/
  14. https://blogs.windows.com/msedgedev/2015/09/30/asynchronous-code-gets-easier-with-es2016-async-function-support-in-chakra-and-microsoft-edge/
  15. https://blogs.windows.com/msedgedev/2015/12/05/open-source-chakra-core/
  16. https://news.microsoft.com/source/1996/07/18/microsoft-announces-activex-scripting/
  17. https://learn.microsoft.com/en-us/windows/win32/com/using-com-objects-in-windows-script-host
  18. https://www.infoq.com/news/2015/12/microsoft-chakra-open-source/
  19. https://thehackernews.com/2015/12/microsoft-javascript-engine.html
  20. https://technologizer.com/2010/03/16/ie9-platform-preview/index.html
  21. https://arstechnica.com/information-technology/2009/11/javascript-graphics-performance-improvements-on-tap-for-ie9/
  22. https://www.cnet.com/culture/google-tunes-up-chromes-javascript-engine/
  23. http://www.staroceans.org/wiki/A/Chakra_%28JScript_engine%29
  24. https://www.wired.com/2011/03/internet-explorer-9-to-arrive-march-14/
  25. https://redmondmag.com/articles/2010/03/16/ie-9-platform-preview-at-mix10.aspx
  26. https://www.pcworld.com/article/508337/internet_explorer_9_next_stop_public_beta.html
  27. https://www.itprotoday.com/windows-7/internet-explorer-10-for-windows-7-preview
  28. https://mspoweruser.com/microsoft-details-improvements-in-chakra-javascript-engine-delivered-as-part-of-internet-explorer-in-windows-10-preview/
  29. https://learn.microsoft.com/en-us/shows/webplatformsummit-2015/chakra-javascript-engine-that-powers-microsoft-edge
  30. https://news.softpedia.com/news/IE9-RC-Performance-Superior-to-IE9-Beta-to-All-Rival-Browsers-183736.shtml
  31. https://blogs.windows.com/msedgedev/2015/05/20/delivering-fast-javascript-performance-in-microsoft-edge/
  32. https://blogs.windows.com/msedgedev/2016/01/13/chakracore-now-open/
  33. https://arstechnica.com/information-technology/2015/12/microsoft-to-open-source-chakra-the-javascript-heart-of-its-edge-browser/
  34. https://www.zdnet.com/article/microsoft-to-open-source-key-pieces-of-its-chakra-javascript-engine/
  35. https://blogs.windows.com/msedgedev/2017/10/04/node-chakracore-update-node-js-interactive-2017/
  36. https://github.com/chakra-core/ChakraCore/wiki/Architecture-Overview
  37. https://github.com/chakra-core/ChakraCore/wiki/JavaScript-Runtime-%28JSRT%29-Overview
  38. https://www.webappers.com/2013/02/22/how-to-diagnose-javascript-errors-faster-with-error-stack/
  39. https://www.usenix.org/system/files/usenixsecurity23-wang-junjie.pdf
  40. https://blogs.windows.com/msedgedev/2015/05/21/intel-and-microsoft-partnering-for-an-improved-web-experience/
  41. https://mathiasbynens.be/notes/shapes-ics
  42. https://blogs.windows.com/msedgedev/2017/10/31/optimizations-webassembly-sharedarraybuffer-atomics-edgehtml-16/
  43. https://www.sstic.org/media/SSTIC2019/SSTIC-actes/Pwning_Browsers/SSTIC2019-Slides-Pwning_Browsers-keith.pdf
  44. https://ariya.io/2012/07/lazy-parsing-in-javascript-engines
  45. https://blogs.windows.com/msedgedev/2017/04/20/improved-javascript-performance-webassembly-shared-memory/
  46. https://www.itwriting.com/blog/2958-internet-explorer-9-preview-gets-to-95-on-acid-3.html
  47. https://blogs.windows.com/latam/2011/06/14/ie9-para-windows-phone-mango-en-la-mira/
  48. https://blogs.windows.com/msedgedev/2017/12/19/service-workers-going-beyond-page/
  49. https://news.microsoft.com/download/archived/presskits/internetexplorer/docs/IE9RCFS.docx
  50. https://blogs.windows.com/msedgedev/2015/01/27/updates-for-the-f12-developer-tools-in-the-windows-10-january-technical-preview/
  51. https://blogs.windows.com/msedgedev/2016/06/22/javascript-performance-updates-anniversary-update/
  52. https://adtmag.com/blogs/dev-watch/2016/06/javascript-wars.aspx
  53. https://github.com/chakra-core/ChakraCore/issues/6991
  54. https://devblogs.microsoft.com/ise/hybrid-apps-using-c-and-javascript-with-chakracore/
  55. https://www.codeproject.com/Articles/1060634/Using-JavaScript-frameworks-from-your-Csharp-UWP-a
  56. https://github.com/nodejs/node-chakracore
  57. https://github.com/microsoft/node-v0.12
  58. https://blogs.windows.com/msedgedev/2016/01/19/nodejs-chakracore-mainline/
  59. https://visualstudiomagazine.com/articles/2017/08/02/node-chakracore-update.aspx
  60. https://www.ctrl.blog/entry/xbox-edge-user-agent.html
  61. https://www.janeasystems.com/blog/announcing-node-js-mobile-apps-true-node-js-runtime-android-ios
  62. https://blogs.windows.com/windowsexperience/2020/01/15/new-year-new-browser-the-new-microsoft-edge-is-out-of-preview-and-now-available-for-download/
  63. https://www.browserstack.com/blog/chromium-based-edge/
  64. https://www.zdnet.com/article/microsofts-edge-to-morph-into-a-chromium-based-cross-platform-browser/
  65. https://github.com/microsoft/ChakraCore/issues/6384
  66. https://learn.microsoft.com/en-us/lifecycle/announcements/internet-explorer-11-end-of-support
  67. https://thehackernews.com/2025/10/microsoft-locks-down-ie-mode-after.html
  68. https://blogs.windows.com/msedgedev/2016/05/17/es6-modules-and-beyond/
  69. https://radar.offseq.com/threat/microsoft-limits-ie-mode-in-edge-after-chakra-zero-7c1f8e3c
  70. https://deno.com/blog/history-of-javascript
Add your contribution
Related Hubs
User Avatar
No comments yet.