Skip to main content

​
Supported Browsers

Lexical is designed to work across all modern browsers. This page outlines the minimum supported versions and important compatibility notes.

​
Browser Support Matrix

Lexical does not support Internet Explorer or legacy versions of Microsoft Edge (pre-Chromium).

​
Desktop Browsers

BrowserMinimum VersionNotes
Chrome86+Full support including all features
Edge86+Chromium-based Edge only
Firefox115+Full support including all features
Safari15+macOS Big Sur (11.3) or later
Opera72+Chromium-based versions

​
Mobile Browsers

BrowserMinimum VersionNotes
Chrome Android86+Full mobile editing support
Safari iOS15+iOS 15.0 or later
Safari iPadOS15+iPadOS 15.0 or later

​
Why These Versions?

Lexical relies on modern web platform features that are only available in recent browser versions:
Lexical uses advanced contentEditable features and Selection APIs that require modern browser implementations for reliability and consistency.
The framework uses modern JavaScript features like:
  • Optional chaining (?.)
  • Nullish coalescing (??)
  • Private class fields
  • Dynamic imports
Lexical depends on modern DOM APIs and event handling features:
  • MutationObserver improvements
  • beforeinput event
  • CompositionEvent handling
  • InputEvent data transfer
Proper support for Input Method Editors (IME) used for typing in Chinese, Japanese, Korean, and other languages requires modern browser implementations.

​
Feature Support by Browser

​
Full Feature Parity

All supported browsers have feature parity for core Lexical functionality:
  • ✅ Text editing and formatting
  • ✅ Rich text nodes (headings, quotes, lists)
  • ✅ Tables with cell merging
  • ✅ Drag and drop
  • ✅ Copy/paste with formatting
  • ✅ Undo/redo
  • ✅ IME composition
  • ✅ Accessibility features
  • ✅ Real-time collaboration

​
Browser-Specific Behaviors

Some subtle differences exist between browsers, which Lexical handles automatically:
Strengths:
  • Best DevTools integration with Lexical DevTools extension
  • Most performant for large documents
  • Excellent clipboard handling
Known Issues:
  • None currently

​
Mobile Considerations

​
Touch Input

Lexical fully supports touch-based editing on mobile browsers:
  • Touch selection and cursor positioning
  • Virtual keyboard integration
  • Touch-friendly toolbar interactions
  • Swipe gestures where appropriate

​
iOS Safari Specifics

On iOS Safari 15.0-15.3, there are some known issues with selection handling that are resolved in iOS 15.4+. We recommend iOS 15.4 or later for the best experience.
iOS Safari requires special handling for:
  • Virtual keyboard appearance
  • Selection popover positioning
  • Scroll behavior when keyboard appears
Lexical handles these cases automatically, but be aware that the behavior may differ slightly from desktop.

​
Android Chrome

Android Chrome 86+ works well with Lexical, with full support for:
  • Gboard and other virtual keyboards
  • Voice input
  • Auto-correct and suggestions
  • Multi-language input

​
Testing Browser Compatibility

Before deploying your Lexical-based editor, test across your target browsers:
1

Identify target browsers

Determine which browsers and versions your users are using based on your analytics.
2

Test core functionality

Verify that basic editing, formatting, and your custom features work correctly:
  • Type and delete text
  • Apply formatting (bold, italic, etc.)
  • Use copy/paste
  • Test undo/redo
  • Try IME input if applicable
3

Test edge cases

Check browser-specific edge cases:
  • Long documents (10,000+ words)
  • Rapid input
  • Simultaneous users (if using collaboration)
  • Mobile virtual keyboards
4

Use automated testing

Leverage Lexical’s E2E testing setup with Playwright:
# Test across browsers
npm run test-e2e-chromium
npm run test-e2e-firefox
npm run test-e2e-webkit

​
Polyfills and Fallbacks

Lexical does not require polyfills for supported browsers. However, if you need to support older browsers, you would need:
Supporting browsers older than the minimum versions listed above is not recommended and not officially supported. The complexity and edge cases make it impractical.
If you absolutely must support older browsers:
  1. Use a transpiler like Babel for JavaScript features
  2. Add polyfills for missing DOM APIs
  3. Expect degraded performance and potential bugs
  4. Test extensively

​
Developer Tools

The Lexical Developer Tools browser extension is available for: This extension helps debug Lexical editors by:
  • Visualizing the editor state tree
  • Inspecting node properties
  • Monitoring state updates
  • Tracking performance

​
Checking Browser Support Programmatically

You can check if the current browser is supported: 
function isBrowserSupported(): boolean {
  // Check for required APIs
  const hasSelection = typeof window.getSelection === 'function';
  const hasContentEditable = 'contentEditable' in document.createElement('div');
  const hasMutationObserver = typeof MutationObserver !== 'undefined';
  
  // Check for minimum browser versions (simplified)
  const ua = navigator.userAgent;
  const isModernChrome = /Chrome\/(\d+)/.test(ua) && parseInt(RegExp.$1) >= 86;
  const isModernFirefox = /Firefox\/(\d+)/.test(ua) && parseInt(RegExp.$1) >= 115;
  const isModernSafari = /Version\/(\d+).*Safari/.test(ua) && parseInt(RegExp.$1) >= 15;
  const isModernEdge = /Edg\/(\d+)/.test(ua) && parseInt(RegExp.$1) >= 86;
  
  return (
    hasSelection &&
    hasContentEditable &&
    hasMutationObserver &&
    (isModernChrome || isModernFirefox || isModernSafari || isModernEdge)
  );
}

if (!isBrowserSupported()) {
  console.warn('Your browser may not be fully supported by Lexical');
}
This is a simplified check. Lexical will generally work or fail gracefully, so browser detection is often unnecessary.

​
Reporting Browser Issues

If you encounter browser-specific issues:
  1. Verify browser version - Ensure you’re using a supported version
  2. Check existing issues - Search GitHub Issues
  3. Create minimal reproduction - Isolate the issue in a minimal example
  4. Report with details:
    • Browser name and exact version
    • Operating system
    • Steps to reproduce
    • Expected vs actual behavior
    • Screenshots or screen recordings

​
Next Steps

Installation

Install Lexical with your preferred package manager

Quickstart

Build your first Lexical editor

Core Concepts

Understand Lexical’s architecture

Testing Guide

Learn how to test your editor across browsers

Build docs developers (and LLMs) love

Get started for freeTalk to us