Published: October 22, 2025
Chrome is deprecating the live editing of JavaScript sources feature. It will be moved behind an experiment flag in Chrome 142 and we plan to completely remove it in Chrome 145 (February 2026). We are not removing other powerful features related to source files like Local Overrides, Workspaces, or Snippets, which will continue to be fully supported.
The Chrome DevTools team is constantly working to provide developers with powerful and reliable tools. As part of this effort, we sometimes need to retire features that are no longer pulling their weight. This decision has not been made lightly and is based on the feature's disproportionately high maintenance cost, low usage, and the existence of superior modern alternatives. We know that changes to any workflow can be disruptive, and this post aims to explain our reasoning clearly.
What was live editing?
Live editing let you replace the content of a script file at runtime, on the fly. This even worked when the script was paused at a breakpoint. You could modify JavaScript code in the Sources panel and apply the change by saving the file (Command+S / Ctrl+S). The debugger would then patch functions that were already defined at runtime. If the modified function was on the call stack, it would also be restarted.
The goal was to provide a way to test small changes without a full page reload, which would otherwise clear the application's state. In this way, its objective was similar to what Hot Module Replacement (HMR) achieves in modern development stacks.
Why are we removing it?
The user experience for live editing has always been challenging. The related shortcut (Command+S / Ctrl+S) is usually associated with saving a file, but not with further side effects, which may be surprising. When it fails, the feedback can be unclear: DevTools may display a warning message like "LiveEdit failed: Functions that are on the stack (currently being executed) can not be edited", which can be overlooked, leaving the developer unsure if their change was applied.
It gets even worse when live editing interacts with other DevTools features related to source files. For example, live editing the content of a DevTools Snippet may confuse DevTools with reference to identity of the snippet source, resulting in the new version shown as a read-only file. When the Workspaces feature is enabled, DevTools may observe source changes in the file system and seamlessly apply these changes to the live page. This behavior might be expected or surprising depending on the user's environment and their toolchain setup.
The original problem that live editing tried to solve–making changes without losing application state–is now solved more effectively by Hot Module Replacement (HMR). HMR is a standard feature in modern Web development frameworks like React, Angular, or Vue. It achieves the same effect in userspace and at a higher level of abstraction. Live editing in DevTools may interfere with it, resulting in unexpected and faulty behavior.
These issues contribute to a difficult user experience. Also, confirmed by our usage statistics, the feature has not become a core part of most developers' workflows. The number of users engaging with this feature is very low, with a downward trend.
High maintenance cost and technical complexity
Replacing code on a live page is not straightforward in terms of defining reasonable semantics, but also in its implementation. It imposes a significant engineering cost on the V8 JavaScript engine and on Chrome DevTools, requiring careful consideration across many parts of V8. Unless great care is taken, live editing can result in hard-to-reproduce and difficult-to-debug crashes. For example, if the new version of a function contains a different number of regular expression, object, or function literals than the earlier version, the data structure that keeps track of these literals needs to be carefully reconciled.
This maintenance burden slows down the implementation of new JavaScript features and draws resources away from improving more widely used DevTools features.
This complexity also led to many unsupported scenarios, including:
- Editing a function that is on the call stack but not the top-most frame.
- Editing async functions or generators.
- Editing the top-level code of an ES module.
Alternatives
As previously mentioned, Hot Module Replacement (HMR) is a more popular alternative, and superior to live editing in a few key aspects:
- Live editing replaces parts of the live page's older version on a source code level. On the other hand, HMR swaps out the older version at the abstraction level intended by the Web framework, increasing the chance to correctly migrate the component and application state during a live update.
- HMR works on your authored source code. You edit your original files (for example, TypeScript, JSX) in your editor, and the build tool handles the update in the browser, whereas live editing only affects deployed source files, which in many cases are the build output generated by the toolchain.
- It is robust and well-integrated. HMR is a core part of the modern development toolchain, providing a reliable experience with clear feedback when updates succeed or fail.
The removal of live editing does not affect two other powerful features in Chrome DevTools:
- Local Overrides lets you intercept a network request and serve a local file instead. It's ideal for prototyping changes on a live production site where you don't have access to the source code. The changes persist across page reloads.
- Workspaces turns DevTools into a more powerful editor by creating a two-way binding between the Sources panel and your local project files. When you save a change in DevTools, it saves directly to your file system. This then may trigger your development server's HMR or live reload process.
Conclusion
We are removing live editing because its high maintenance cost and low usage make it unsustainable. The modern web development ecosystem has provided a far superior solution in Hot Module Replacement.
By retiring this feature, we can focus our engineering efforts on more impactful parts of Chrome DevTools. The timeline for removal is as follows:
- Near future: The feature will be moved behind an experiment in Chrome 142, available as a Chrome flag (chrome://flags/#devtools-live-edit).
- Chrome 145 (February 2026): The feature and the corresponding Chrome flag will be completely removed.
We welcome your feedback on this change. Add your comments on the feedback issue.