diff --git a/fixtures/unstable-async/time-slicing/src/index.js b/fixtures/unstable-async/time-slicing/src/index.js
index 6e23aba0cab2f..dc8890617229f 100644
--- a/fixtures/unstable-async/time-slicing/src/index.js
+++ b/fixtures/unstable-async/time-slicing/src/index.js
@@ -1,6 +1,6 @@
 import React, {PureComponent} from 'react';
-import {flushSync, render} from 'react-dom';
-import {unstable_scheduleCallback} from 'scheduler';
+import {flushSync, unstable_createRoot} from 'react-dom';
+import Scheduler from 'scheduler';
 import _ from 'lodash';
 import Charts from './Charts';
 import Clock from './Clock';
@@ -67,7 +67,7 @@ class App extends PureComponent {
     }
     this._ignoreClick = true;
 
-    unstable_scheduleCallback(() => {
+    Scheduler.unstable_next(() => {
       this.setState({showDemo: true}, () => {
         this._ignoreClick = false;
       });
@@ -146,9 +146,5 @@ class App extends PureComponent {
 }
 
 const container = document.getElementById('root');
-render(
-  <React.unstable_ConcurrentMode>
-    <App />
-  </React.unstable_ConcurrentMode>,
-  container
-);
+const root = ReactDOM.unstable_createRoot(container);
+root.render(<App />, container);
diff --git a/packages/react-dom/src/__tests__/ReactDOMFiberAsync-test.internal.js b/packages/react-dom/src/__tests__/ReactDOMFiberAsync-test.internal.js
index 760ed6d445de3..5d85217921328 100644
--- a/packages/react-dom/src/__tests__/ReactDOMFiberAsync-test.internal.js
+++ b/packages/react-dom/src/__tests__/ReactDOMFiberAsync-test.internal.js
@@ -16,8 +16,6 @@ let ReactFeatureFlags = require('shared/ReactFeatureFlags');
 let ReactDOM;
 let Scheduler;
 
-const ConcurrentMode = React.unstable_ConcurrentMode;
-
 const setUntrackedInputValue = Object.getOwnPropertyDescriptor(
   HTMLInputElement.prototype,
   'value',
@@ -86,12 +84,9 @@ describe('ReactDOMFiberAsync', () => {
         );
       }
     }
-    ReactDOM.render(
-      <ConcurrentMode>
-        <Counter />
-      </ConcurrentMode>,
-      container,
-    );
+    const root = ReactDOM.unstable_createRoot(container);
+    root.render(<Counter />);
+    Scheduler.flushAll();
     expect(asyncValueRef.current.textContent).toBe('');
     expect(syncValueRef.current.textContent).toBe('');
 
@@ -108,34 +103,7 @@ describe('ReactDOMFiberAsync', () => {
     expect(syncValueRef.current.textContent).toBe('hello');
   });
 
-  describe('with feature flag disabled', () => {
-    beforeEach(() => {
-      jest.resetModules();
-      ReactFeatureFlags = require('shared/ReactFeatureFlags');
-      ReactDOM = require('react-dom');
-      Scheduler = require('scheduler');
-    });
-
-    it('renders synchronously', () => {
-      ReactDOM.render(
-        <ConcurrentMode>
-          <div>Hi</div>
-        </ConcurrentMode>,
-        container,
-      );
-      expect(container.textContent).toEqual('Hi');
-
-      ReactDOM.render(
-        <ConcurrentMode>
-          <div>Bye</div>
-        </ConcurrentMode>,
-        container,
-      );
-      expect(container.textContent).toEqual('Bye');
-    });
-  });
-
-  describe('with feature flag enabled', () => {
+  describe('concurrent mode', () => {
     beforeEach(() => {
       jest.resetModules();
       ReactFeatureFlags = require('shared/ReactFeatureFlags');
@@ -144,7 +112,7 @@ describe('ReactDOMFiberAsync', () => {
       Scheduler = require('scheduler');
     });
 
-    it('createRoot makes the entire tree async', () => {
+    it('top-level updates are concurrent', () => {
       const root = ReactDOM.unstable_createRoot(container);
       root.render(<div>Hi</div>);
       expect(container.textContent).toEqual('');
@@ -157,7 +125,7 @@ describe('ReactDOMFiberAsync', () => {
       expect(container.textContent).toEqual('Bye');
     });
 
-    it('updates inside an async tree are async by default', () => {
+    it('deep updates (setState) are oncurrent', () => {
       let instance;
       class Component extends React.Component {
         state = {step: 0};
@@ -179,56 +147,6 @@ describe('ReactDOMFiberAsync', () => {
       expect(container.textContent).toEqual('1');
     });
 
-    it('ConcurrentMode creates an async subtree', () => {
-      let instance;
-      class Component extends React.Component {
-        state = {step: 0};
-        render() {
-          instance = this;
-          return <div>{this.state.step}</div>;
-        }
-      }
-
-      ReactDOM.render(
-        <ConcurrentMode>
-          <Component />
-        </ConcurrentMode>,
-        container,
-      );
-      Scheduler.flushAll();
-
-      instance.setState({step: 1});
-      expect(container.textContent).toEqual('0');
-      Scheduler.flushAll();
-      expect(container.textContent).toEqual('1');
-    });
-
-    it('updates inside an async subtree are async by default', () => {
-      let instance;
-      class Child extends React.Component {
-        state = {step: 0};
-        render() {
-          instance = this;
-          return <div>{this.state.step}</div>;
-        }
-      }
-
-      ReactDOM.render(
-        <div>
-          <ConcurrentMode>
-            <Child />
-          </ConcurrentMode>
-        </div>,
-        container,
-      );
-      Scheduler.flushAll();
-
-      instance.setState({step: 1});
-      expect(container.textContent).toEqual('0');
-      Scheduler.flushAll();
-      expect(container.textContent).toEqual('1');
-    });
-
     it('flushSync batches sync updates and flushes them at the end of the batch', () => {
       let ops = [];
       let instance;
@@ -345,12 +263,8 @@ describe('ReactDOMFiberAsync', () => {
         }
       }
 
-      ReactDOM.render(
-        <ConcurrentMode>
-          <Component />
-        </ConcurrentMode>,
-        container,
-      );
+      const root = ReactDOM.unstable_createRoot(container);
+      root.render(<Component />);
       Scheduler.flushAll();
 
       // Updates are async by default
@@ -390,12 +304,9 @@ describe('ReactDOMFiberAsync', () => {
           return this.state.counter;
         }
       }
-      ReactDOM.render(
-        <ConcurrentMode>
-          <Counter />
-        </ConcurrentMode>,
-        container,
-      );
+      const root = ReactDOM.unstable_createRoot(container);
+      root.render(<Counter />);
+      Scheduler.flushAll();
       expect(container.textContent).toEqual('0');
 
       // Test that a normal update is async
diff --git a/packages/react-dom/src/__tests__/ReactDOMHooks-test.js b/packages/react-dom/src/__tests__/ReactDOMHooks-test.js
index 360cfa9f9a392..bc85d18b108ce 100644
--- a/packages/react-dom/src/__tests__/ReactDOMHooks-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMHooks-test.js
@@ -141,7 +141,7 @@ describe('ReactDOMHooks', () => {
     expect(labelRef.current.innerHTML).toBe('abc');
   });
 
-  it('should not bail out when an update is scheduled from within an event handler in ConcurrentMode', () => {
+  it('should not bail out when an update is scheduled from within an event handler in Concurrent Mode', () => {
     const {createRef, useCallback, useState} = React;
 
     const Example = ({inputRef, labelRef}) => {
@@ -162,11 +162,7 @@ describe('ReactDOMHooks', () => {
     const labelRef = createRef();
 
     const root = ReactDOM.unstable_createRoot(container);
-    root.render(
-      <React.unstable_ConcurrentMode>
-        <Example inputRef={inputRef} labelRef={labelRef} />
-      </React.unstable_ConcurrentMode>,
-    );
+    root.render(<Example inputRef={inputRef} labelRef={labelRef} />);
 
     Scheduler.flushAll();
 
diff --git a/packages/react-dom/src/__tests__/ReactDOMRoot-test.js b/packages/react-dom/src/__tests__/ReactDOMRoot-test.js
index 670f45e28bb8a..095f44f554c4b 100644
--- a/packages/react-dom/src/__tests__/ReactDOMRoot-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMRoot-test.js
@@ -13,7 +13,6 @@ let React = require('react');
 let ReactDOM = require('react-dom');
 let ReactDOMServer = require('react-dom/server');
 let Scheduler = require('scheduler');
-let ConcurrentMode = React.unstable_ConcurrentMode;
 
 describe('ReactDOMRoot', () => {
   let container;
@@ -25,7 +24,6 @@ describe('ReactDOMRoot', () => {
     ReactDOM = require('react-dom');
     ReactDOMServer = require('react-dom/server');
     Scheduler = require('scheduler');
-    ConcurrentMode = React.unstable_ConcurrentMode;
   });
 
   it('renders children', () => {
@@ -47,7 +45,7 @@ describe('ReactDOMRoot', () => {
 
   it('`root.render` returns a thenable work object', () => {
     const root = ReactDOM.unstable_createRoot(container);
-    const work = root.render(<ConcurrentMode>Hi</ConcurrentMode>);
+    const work = root.render('Hi');
     let ops = [];
     work.then(() => {
       ops.push('inside callback: ' + container.textContent);
@@ -65,7 +63,7 @@ describe('ReactDOMRoot', () => {
 
   it('resolves `work.then` callback synchronously if the work already committed', () => {
     const root = ReactDOM.unstable_createRoot(container);
-    const work = root.render(<ConcurrentMode>Hi</ConcurrentMode>);
+    const work = root.render('Hi');
     Scheduler.flushAll();
     let ops = [];
     work.then(() => {
@@ -157,11 +155,7 @@ describe('ReactDOMRoot', () => {
 
     const root = ReactDOM.unstable_createRoot(container);
     const batch = root.createBatch();
-    batch.render(
-      <ConcurrentMode>
-        <App />
-      </ConcurrentMode>,
-    );
+    batch.render(<App />);
 
     Scheduler.flushAll();
 
@@ -208,7 +202,7 @@ describe('ReactDOMRoot', () => {
   it('can wait for a batch to finish', () => {
     const root = ReactDOM.unstable_createRoot(container);
     const batch = root.createBatch();
-    batch.render(<ConcurrentMode>Foo</ConcurrentMode>);
+    batch.render('Foo');
 
     Scheduler.flushAll();
 
@@ -248,7 +242,7 @@ describe('ReactDOMRoot', () => {
 
   it('can commit an empty batch', () => {
     const root = ReactDOM.unstable_createRoot(container);
-    root.render(<ConcurrentMode>1</ConcurrentMode>);
+    root.render(1);
 
     Scheduler.advanceTime(2000);
     // This batch has a later expiration time than the earlier update.
diff --git a/packages/react-dom/src/__tests__/ReactDOMServerIntegrationModes-test.js b/packages/react-dom/src/__tests__/ReactDOMServerIntegrationModes-test.js
index 3a4abc6abb249..b9f8a5c48c8a1 100644
--- a/packages/react-dom/src/__tests__/ReactDOMServerIntegrationModes-test.js
+++ b/packages/react-dom/src/__tests__/ReactDOMServerIntegrationModes-test.js
@@ -103,72 +103,4 @@ describe('ReactDOMServerIntegration', () => {
       expect(await render(<React.StrictMode />)).toBe(null);
     });
   });
-
-  describe('React.unstable_ConcurrentMode', () => {
-    itRenders('an concurrent mode with one child', async render => {
-      let e = await render(
-        <React.unstable_ConcurrentMode>
-          <div>text1</div>
-        </React.unstable_ConcurrentMode>,
-      );
-      let parent = e.parentNode;
-      expect(parent.childNodes[0].tagName).toBe('DIV');
-    });
-
-    itRenders('an concurrent mode with several children', async render => {
-      let Header = props => {
-        return <p>header</p>;
-      };
-      let Footer = props => {
-        return (
-          <React.unstable_ConcurrentMode>
-            <h2>footer</h2>
-            <h3>about</h3>
-          </React.unstable_ConcurrentMode>
-        );
-      };
-      let e = await render(
-        <React.unstable_ConcurrentMode>
-          <div>text1</div>
-          <span>text2</span>
-          <Header />
-          <Footer />
-        </React.unstable_ConcurrentMode>,
-      );
-      let parent = e.parentNode;
-      expect(parent.childNodes[0].tagName).toBe('DIV');
-      expect(parent.childNodes[1].tagName).toBe('SPAN');
-      expect(parent.childNodes[2].tagName).toBe('P');
-      expect(parent.childNodes[3].tagName).toBe('H2');
-      expect(parent.childNodes[4].tagName).toBe('H3');
-    });
-
-    itRenders('a nested concurrent mode', async render => {
-      let e = await render(
-        <React.unstable_ConcurrentMode>
-          <React.unstable_ConcurrentMode>
-            <div>text1</div>
-          </React.unstable_ConcurrentMode>
-          <span>text2</span>
-          <React.unstable_ConcurrentMode>
-            <React.unstable_ConcurrentMode>
-              <React.unstable_ConcurrentMode>
-                {null}
-                <p />
-              </React.unstable_ConcurrentMode>
-              {false}
-            </React.unstable_ConcurrentMode>
-          </React.unstable_ConcurrentMode>
-        </React.unstable_ConcurrentMode>,
-      );
-      let parent = e.parentNode;
-      expect(parent.childNodes[0].tagName).toBe('DIV');
-      expect(parent.childNodes[1].tagName).toBe('SPAN');
-      expect(parent.childNodes[2].tagName).toBe('P');
-    });
-
-    itRenders('an empty concurrent mode', async render => {
-      expect(await render(<React.unstable_ConcurrentMode />)).toBe(null);
-    });
-  });
 });
diff --git a/packages/react-dom/src/events/__tests__/SimpleEventPlugin-test.internal.js b/packages/react-dom/src/events/__tests__/SimpleEventPlugin-test.internal.js
index 32f66e8e0c956..bce3242e77384 100644
--- a/packages/react-dom/src/events/__tests__/SimpleEventPlugin-test.internal.js
+++ b/packages/react-dom/src/events/__tests__/SimpleEventPlugin-test.internal.js
@@ -374,7 +374,7 @@ describe('SimpleEventPlugin', function() {
       expect(button.textContent).toEqual('Count: 7');
     });
 
-    it('flushes lowest pending interactive priority', () => {
+    it('flushes discrete updates in order', () => {
       container = document.createElement('div');
       document.body.appendChild(container);
 
@@ -382,15 +382,21 @@ describe('SimpleEventPlugin', function() {
       class Button extends React.Component {
         state = {lowPriCount: 0};
         render() {
+          const text = `High-pri count: ${
+            this.props.highPriCount
+          }, Low-pri count: ${this.state.lowPriCount}`;
+          Scheduler.yieldValue(text);
           return (
             <button
               ref={el => (button = el)}
-              onClick={
-                // Intentionally not using the updater form here
-                () => this.setState({lowPriCount: this.state.lowPriCount + 1})
-              }>
-              High-pri count: {this.props.highPriCount}, Low-pri count:{' '}
-              {this.state.lowPriCount}
+              onClick={() => {
+                Scheduler.unstable_next(() => {
+                  this.setState(state => ({
+                    lowPriCount: state.lowPriCount + 1,
+                  }));
+                });
+              }}>
+              {text}
             </button>
           );
         }
@@ -402,19 +408,24 @@ describe('SimpleEventPlugin', function() {
           return (
             <div
               onClick={
-                // Intentionally not using the updater form here
-                () => this.setState({highPriCount: this.state.highPriCount + 1})
+                // Intentionally not using the updater form here, to test
+                // that updates are serially processed.
+                () => {
+                  this.setState({highPriCount: this.state.highPriCount + 1});
+                }
               }>
-              <React.unstable_ConcurrentMode>
-                <Button highPriCount={this.state.highPriCount} />
-              </React.unstable_ConcurrentMode>
+              <Button highPriCount={this.state.highPriCount} />
             </div>
           );
         }
       }
 
       // Initial mount
-      ReactDOM.render(<Wrapper />, container);
+      const root = ReactDOM.unstable_createRoot(container);
+      root.render(<Wrapper />);
+      expect(Scheduler).toFlushAndYield([
+        'High-pri count: 0, Low-pri count: 0',
+      ]);
       expect(button.textContent).toEqual('High-pri count: 0, Low-pri count: 0');
 
       function click() {
@@ -425,8 +436,12 @@ describe('SimpleEventPlugin', function() {
 
       // Click the button a single time
       click();
-      // The high-pri counter should flush synchronously, but not the
-      // low-pri counter
+      // Nothing should flush on the first click.
+      expect(Scheduler).toHaveYielded([]);
+      // Click again. This will force the previous discrete update to flush. But
+      // only the high-pri count will increase.
+      click();
+      expect(Scheduler).toHaveYielded(['High-pri count: 1, Low-pri count: 0']);
       expect(button.textContent).toEqual('High-pri count: 1, Low-pri count: 0');
 
       // Click the button many more times
@@ -437,10 +452,22 @@ describe('SimpleEventPlugin', function() {
       click();
       click();
 
-      // Flush the remaining work
-      Scheduler.flushAll();
-      // Both counters should equal the total number of clicks
-      expect(button.textContent).toEqual('High-pri count: 7, Low-pri count: 7');
+      // Flush the remaining work.
+      expect(Scheduler).toHaveYielded([
+        'High-pri count: 2, Low-pri count: 0',
+        'High-pri count: 3, Low-pri count: 0',
+        'High-pri count: 4, Low-pri count: 0',
+        'High-pri count: 5, Low-pri count: 0',
+        'High-pri count: 6, Low-pri count: 0',
+        'High-pri count: 7, Low-pri count: 0',
+      ]);
+
+      // At the end, both counters should equal the total number of clicks
+      expect(Scheduler).toFlushAndYield([
+        'High-pri count: 8, Low-pri count: 0',
+        'High-pri count: 8, Low-pri count: 8',
+      ]);
+      expect(button.textContent).toEqual('High-pri count: 8, Low-pri count: 8');
     });
   });
 
diff --git a/packages/react-is/README.md b/packages/react-is/README.md
index f01acef953511..9adeee1d9aad1 100644
--- a/packages/react-is/README.md
+++ b/packages/react-is/README.md
@@ -45,16 +45,6 @@ ReactIs.isValidElementType(React.createFactory("div")); // true
 
 ### Determining an Element's Type
 
-#### ConcurrentMode
-
-```js
-import React from "react";
-import * as ReactIs from 'react-is';
-
-ReactIs.isConcurrentMode(<React.unstable_ConcurrentMode />); // true
-ReactIs.typeOf(<React.unstable_ConcurrentMode />) === ReactIs.ConcurrentMode; // true
-```
-
 #### Context
 
 ```js
diff --git a/packages/react-is/src/__tests__/ReactIs-test.js b/packages/react-is/src/__tests__/ReactIs-test.js
index 4889d0f74f313..1c47fd551bb58 100644
--- a/packages/react-is/src/__tests__/ReactIs-test.js
+++ b/packages/react-is/src/__tests__/ReactIs-test.js
@@ -58,9 +58,6 @@ describe('ReactIs', () => {
       true,
     );
     expect(ReactIs.isValidElementType(React.Fragment)).toEqual(true);
-    expect(ReactIs.isValidElementType(React.unstable_ConcurrentMode)).toEqual(
-      true,
-    );
     expect(ReactIs.isValidElementType(React.StrictMode)).toEqual(true);
     expect(ReactIs.isValidElementType(React.Suspense)).toEqual(true);
 
@@ -72,20 +69,6 @@ describe('ReactIs', () => {
     expect(ReactIs.isValidElementType({type: 'div', props: {}})).toEqual(false);
   });
 
-  it('should identify concurrent mode', () => {
-    expect(ReactIs.typeOf(<React.unstable_ConcurrentMode />)).toBe(
-      ReactIs.ConcurrentMode,
-    );
-    expect(ReactIs.isConcurrentMode(<React.unstable_ConcurrentMode />)).toBe(
-      true,
-    );
-    expect(ReactIs.isConcurrentMode({type: ReactIs.ConcurrentMode})).toBe(
-      false,
-    );
-    expect(ReactIs.isConcurrentMode(<React.StrictMode />)).toBe(false);
-    expect(ReactIs.isConcurrentMode(<div />)).toBe(false);
-  });
-
   it('should identify context consumers', () => {
     const Context = React.createContext(false);
     expect(ReactIs.typeOf(<Context.Consumer />)).toBe(ReactIs.ContextConsumer);
@@ -117,7 +100,6 @@ describe('ReactIs', () => {
     expect(ReactIs.isElement(<Context.Provider />)).toBe(true);
     expect(ReactIs.isElement(<Context.Consumer />)).toBe(true);
     expect(ReactIs.isElement(<React.Fragment />)).toBe(true);
-    expect(ReactIs.isElement(<React.unstable_ConcurrentMode />)).toBe(true);
     expect(ReactIs.isElement(<React.StrictMode />)).toBe(true);
     expect(ReactIs.isElement(<React.Suspense />)).toBe(true);
   });
@@ -127,7 +109,6 @@ describe('ReactIs', () => {
     expect(ReactIs.typeOf(<RefForwardingComponent />)).toBe(ReactIs.ForwardRef);
     expect(ReactIs.isForwardRef(<RefForwardingComponent />)).toBe(true);
     expect(ReactIs.isForwardRef({type: ReactIs.StrictMode})).toBe(false);
-    expect(ReactIs.isForwardRef(<React.unstable_ConcurrentMode />)).toBe(false);
     expect(ReactIs.isForwardRef(<div />)).toBe(false);
   });
 
@@ -168,7 +149,6 @@ describe('ReactIs', () => {
     expect(ReactIs.typeOf(<React.StrictMode />)).toBe(ReactIs.StrictMode);
     expect(ReactIs.isStrictMode(<React.StrictMode />)).toBe(true);
     expect(ReactIs.isStrictMode({type: ReactIs.StrictMode})).toBe(false);
-    expect(ReactIs.isStrictMode(<React.unstable_ConcurrentMode />)).toBe(false);
     expect(ReactIs.isStrictMode(<div />)).toBe(false);
   });
 
@@ -188,7 +168,6 @@ describe('ReactIs', () => {
       ReactIs.isProfiler(<React.Profiler id="foo" onRender={jest.fn()} />),
     ).toBe(true);
     expect(ReactIs.isProfiler({type: ReactIs.Profiler})).toBe(false);
-    expect(ReactIs.isProfiler(<React.unstable_ConcurrentMode />)).toBe(false);
     expect(ReactIs.isProfiler(<div />)).toBe(false);
   });
 });
diff --git a/packages/react-reconciler/src/__tests__/ReactIncrementalPerf-test.internal.js b/packages/react-reconciler/src/__tests__/ReactIncrementalPerf-test.internal.js
index 2080cbc17a23b..282ab0a0787fd 100644
--- a/packages/react-reconciler/src/__tests__/ReactIncrementalPerf-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactIncrementalPerf-test.internal.js
@@ -189,14 +189,12 @@ describe('ReactDebugFiberPerf', () => {
     expect(getFlameChart()).toMatchSnapshot();
   });
 
-  it('does not include ConcurrentMode, StrictMode, or Profiler components in measurements', () => {
+  it('does not include StrictMode or Profiler components in measurements', () => {
     ReactNoop.render(
       <React.Profiler id="test" onRender={jest.fn()}>
         <React.StrictMode>
           <Parent>
-            <React.unstable_ConcurrentMode>
-              <Child />
-            </React.unstable_ConcurrentMode>
+            <Child />
           </Parent>
         </React.StrictMode>
       </React.Profiler>,
diff --git a/packages/react-reconciler/src/__tests__/ReactSuspenseWithNoopRenderer-test.internal.js b/packages/react-reconciler/src/__tests__/ReactSuspenseWithNoopRenderer-test.internal.js
index ee45396a4d173..b74488faeaf0d 100644
--- a/packages/react-reconciler/src/__tests__/ReactSuspenseWithNoopRenderer-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactSuspenseWithNoopRenderer-test.internal.js
@@ -5,8 +5,6 @@ let ReactNoop;
 let Scheduler;
 let ReactCache;
 let Suspense;
-let StrictMode;
-let ConcurrentMode;
 
 let TextResource;
 let textResourceShouldFail;
@@ -26,8 +24,6 @@ describe('ReactSuspenseWithNoopRenderer', () => {
     Scheduler = require('scheduler');
     ReactCache = require('react-cache');
     Suspense = React.Suspense;
-    StrictMode = React.StrictMode;
-    ConcurrentMode = React.unstable_ConcurrentMode;
 
     TextResource = ReactCache.unstable_createResource(([text, ms = 0]) => {
       return new Promise((resolve, reject) =>
@@ -896,7 +892,7 @@ describe('ReactSuspenseWithNoopRenderer', () => {
       expect(ReactNoop.getChildren()).toEqual([span('Result')]);
     });
 
-    it('times out immediately when Suspense is in loose mode, even if the suspender is async', async () => {
+    it('times out immediately when Suspense is in legacy mode', async () => {
       class UpdatingText extends React.Component {
         state = {step: 1};
         render() {
@@ -918,15 +914,13 @@ describe('ReactSuspenseWithNoopRenderer', () => {
       function App() {
         return (
           <Suspense fallback={<Spinner />}>
-            <ConcurrentMode>
-              <UpdatingText ref={text} />
-              <Text text="Sibling" />
-            </ConcurrentMode>
+            <UpdatingText ref={text} />
+            <Text text="Sibling" />
           </Suspense>
         );
       }
 
-      // Initial mount. This is synchronous, because the root is sync.
+      // Initial mount.
       ReactNoop.renderLegacySyncRoot(<App />);
       await advanceTimers(100);
       expect(Scheduler).toHaveYielded([
@@ -945,14 +939,13 @@ describe('ReactSuspenseWithNoopRenderer', () => {
         </React.Fragment>,
       );
 
-      // Update. This starts out asynchronously.
+      // Update.
       text.current.setState({step: 2}, () =>
         Scheduler.yieldValue('Update did commit'),
       );
 
-      // Suspend during an async render.
-      expect(ReactNoop.flushNextYield()).toEqual(['Suspend! [Step: 2]']);
-      expect(Scheduler).toFlushAndYield([
+      expect(ReactNoop.flushNextYield()).toEqual([
+        'Suspend! [Step: 2]',
         'Loading (1)',
         'Loading (2)',
         'Loading (3)',
@@ -979,269 +972,6 @@ describe('ReactSuspenseWithNoopRenderer', () => {
       );
     });
 
-    it(
-      'continues rendering asynchronously even if a promise is captured by ' +
-        'a sync boundary (legacy mode)',
-      async () => {
-        class UpdatingText extends React.Component {
-          state = {text: this.props.initialText};
-          render() {
-            return this.props.children(this.state.text);
-          }
-        }
-
-        const text1 = React.createRef(null);
-        const text2 = React.createRef(null);
-        function App() {
-          return (
-            <Fragment>
-              <Suspense fallback={<Text text="Loading..." />}>
-                <ConcurrentMode>
-                  <UpdatingText ref={text1} initialText="Async: 1">
-                    {text => (
-                      <Fragment>
-                        <Text text="Before" />
-                        <AsyncText text={text} />
-                        <Text text="After" />
-                      </Fragment>
-                    )}
-                  </UpdatingText>
-                </ConcurrentMode>
-              </Suspense>
-              <ConcurrentMode>
-                <UpdatingText ref={text2} initialText="Sync: 1">
-                  {text => (
-                    <Fragment>
-                      <Text text="Before" />
-                      <Text text={text} />
-                      <Text text="After" />
-                    </Fragment>
-                  )}
-                </UpdatingText>
-              </ConcurrentMode>
-            </Fragment>
-          );
-        }
-
-        // Initial mount
-        ReactNoop.renderLegacySyncRoot(<App />, () =>
-          Scheduler.yieldValue('Did mount'),
-        );
-        await advanceTimers(100);
-
-        expect(Scheduler).toHaveYielded([
-          'Before',
-          'Suspend! [Async: 1]',
-          'After',
-          'Loading...',
-          'Before',
-          'Sync: 1',
-          'After',
-          'Did mount',
-          'Promise resolved [Async: 1]',
-        ]);
-        expect(Scheduler).toFlushExpired(['Async: 1']);
-        expect(ReactNoop).toMatchRenderedOutput(
-          <React.Fragment>
-            <span prop="Before" />
-            <span prop="Async: 1" />
-            <span prop="After" />
-
-            <span prop="Before" />
-            <span prop="Sync: 1" />
-            <span prop="After" />
-          </React.Fragment>,
-        );
-
-        // Update. This starts out asynchronously.
-        text1.current.setState({text: 'Async: 2'}, () =>
-          Scheduler.yieldValue('Update 1 did commit'),
-        );
-        text2.current.setState({text: 'Sync: 2'}, () =>
-          Scheduler.yieldValue('Update 2 did commit'),
-        );
-
-        // Start rendering asynchronously
-        expect(Scheduler).toFlushAndYieldThrough(['Before']);
-
-        // Now render the next child, which suspends
-        expect(ReactNoop.flushNextYield()).toEqual([
-          // This child suspends
-          'Suspend! [Async: 2]',
-        ]);
-        expect(Scheduler).toFlushAndYield([
-          'After',
-          'Loading...',
-          'Before',
-          'Sync: 2',
-          'After',
-          'Update 1 did commit',
-          'Update 2 did commit',
-        ]);
-        expect(ReactNoop).toMatchRenderedOutput(
-          <React.Fragment>
-            <span hidden={true} prop="Before" />
-            <span hidden={true} prop="Async: 1" />
-            <span hidden={true} prop="After" />
-            <span prop="Loading..." />
-
-            <span prop="Before" />
-            <span prop="Sync: 2" />
-            <span prop="After" />
-          </React.Fragment>,
-        );
-
-        // When the placeholder is pinged, the boundary must be re-rendered
-        // synchronously.
-        await advanceTimers(100);
-
-        expect(Scheduler).toHaveYielded(['Promise resolved [Async: 2]']);
-        expect(Scheduler).toFlushExpired(['Async: 2']);
-        expect(ReactNoop).toMatchRenderedOutput(
-          <React.Fragment>
-            <span prop="Before" />
-            <span prop="Async: 2" />
-            <span prop="After" />
-
-            <span prop="Before" />
-            <span prop="Sync: 2" />
-            <span prop="After" />
-          </React.Fragment>,
-        );
-      },
-    );
-
-    it(
-      'continues rendering asynchronously even if a promise is captured by ' +
-        'a sync boundary (strict, legacy)',
-      async () => {
-        class UpdatingText extends React.Component {
-          state = {text: this.props.initialText};
-          render() {
-            return this.props.children(this.state.text);
-          }
-        }
-
-        const text1 = React.createRef(null);
-        const text2 = React.createRef(null);
-        function App() {
-          return (
-            <StrictMode>
-              <Suspense fallback={<Text text="Loading..." />}>
-                <ConcurrentMode>
-                  <UpdatingText ref={text1} initialText="Async: 1">
-                    {text => (
-                      <Fragment>
-                        <Text text="Before" />
-                        <AsyncText text={text} />
-                        <Text text="After" />
-                      </Fragment>
-                    )}
-                  </UpdatingText>
-                </ConcurrentMode>
-              </Suspense>
-              <ConcurrentMode>
-                <UpdatingText ref={text2} initialText="Sync: 1">
-                  {text => (
-                    <Fragment>
-                      <Text text="Before" />
-                      <Text text={text} />
-                      <Text text="After" />
-                    </Fragment>
-                  )}
-                </UpdatingText>
-              </ConcurrentMode>
-            </StrictMode>
-          );
-        }
-
-        // Initial mount
-        ReactNoop.renderLegacySyncRoot(<App />, () =>
-          Scheduler.yieldValue('Did mount'),
-        );
-        await advanceTimers(100);
-        expect(Scheduler).toHaveYielded([
-          'Before',
-          'Suspend! [Async: 1]',
-          'After',
-          'Loading...',
-          'Before',
-          'Sync: 1',
-          'After',
-          'Did mount',
-          'Promise resolved [Async: 1]',
-        ]);
-        expect(Scheduler).toFlushExpired(['Async: 1']);
-        expect(ReactNoop).toMatchRenderedOutput(
-          <React.Fragment>
-            <span prop="Before" />
-            <span prop="Async: 1" />
-            <span prop="After" />
-
-            <span prop="Before" />
-            <span prop="Sync: 1" />
-            <span prop="After" />
-          </React.Fragment>,
-        );
-
-        // Update. This starts out asynchronously.
-        text1.current.setState({text: 'Async: 2'}, () =>
-          Scheduler.yieldValue('Update 1 did commit'),
-        );
-        text2.current.setState({text: 'Sync: 2'}, () =>
-          Scheduler.yieldValue('Update 2 did commit'),
-        );
-
-        // Start rendering asynchronously
-        expect(Scheduler).toFlushAndYieldThrough(['Before']);
-
-        // Now render the next child, which suspends
-        expect(ReactNoop.flushNextYield()).toEqual([
-          // This child suspends
-          'Suspend! [Async: 2]',
-        ]);
-        expect(Scheduler).toFlushAndYield([
-          'After',
-          'Loading...',
-          'Before',
-          'Sync: 2',
-          'After',
-          'Update 1 did commit',
-          'Update 2 did commit',
-        ]);
-        expect(ReactNoop).toMatchRenderedOutput(
-          <React.Fragment>
-            <span hidden={true} prop="Before" />
-            <span hidden={true} prop="Async: 1" />
-            <span hidden={true} prop="After" />
-            <span prop="Loading..." />
-
-            <span prop="Before" />
-            <span prop="Sync: 2" />
-            <span prop="After" />
-          </React.Fragment>,
-        );
-
-        // When the placeholder is pinged, the boundary must be re-rendered
-        // synchronously.
-        await advanceTimers(100);
-
-        expect(Scheduler).toHaveYielded(['Promise resolved [Async: 2]']);
-        expect(Scheduler).toFlushExpired(['Async: 2']);
-        expect(ReactNoop).toMatchRenderedOutput(
-          <React.Fragment>
-            <span prop="Before" />
-            <span prop="Async: 2" />
-            <span prop="After" />
-
-            <span prop="Before" />
-            <span prop="Sync: 2" />
-            <span prop="After" />
-          </React.Fragment>,
-        );
-      },
-    );
-
     it('does not re-render siblings in loose mode', async () => {
       class TextWithLifecycle extends React.Component {
         componentDidMount() {
diff --git a/packages/react-reconciler/src/__tests__/__snapshots__/ReactIncrementalPerf-test.internal.js.snap b/packages/react-reconciler/src/__tests__/__snapshots__/ReactIncrementalPerf-test.internal.js.snap
index b9845de602cb7..4372eb2baca1f 100644
--- a/packages/react-reconciler/src/__tests__/__snapshots__/ReactIncrementalPerf-test.internal.js.snap
+++ b/packages/react-reconciler/src/__tests__/__snapshots__/ReactIncrementalPerf-test.internal.js.snap
@@ -91,7 +91,7 @@ exports[`ReactDebugFiberPerf deduplicates lifecycle names during commit to reduc
 "
 `;
 
-exports[`ReactDebugFiberPerf does not include ConcurrentMode, StrictMode, or Profiler components in measurements 1`] = `
+exports[`ReactDebugFiberPerf does not include StrictMode or Profiler components in measurements 1`] = `
 "⚛ (Waiting for async callback...)
 
 // Mount
diff --git a/packages/react/src/React.js b/packages/react/src/React.js
index a5a0411fd0364..8c7ee01d45d9d 100644
--- a/packages/react/src/React.js
+++ b/packages/react/src/React.js
@@ -7,7 +7,6 @@
 
 import ReactVersion from 'shared/ReactVersion';
 import {
-  REACT_CONCURRENT_MODE_TYPE,
   REACT_FRAGMENT_TYPE,
   REACT_PROFILER_TYPE,
   REACT_STRICT_MODE_TYPE,
@@ -51,12 +50,7 @@ import {
 } from './ReactElementValidator';
 import ReactSharedInternals from './ReactSharedInternals';
 import {error, warn} from './withComponentStack';
-import {
-  enableEventAPI,
-  enableStableConcurrentModeAPIs,
-  enableJSXTransformAPI,
-} from 'shared/ReactFeatureFlags';
-
+import {enableEventAPI, enableJSXTransformAPI} from 'shared/ReactFeatureFlags';
 const React = {
   Children: {
     map,
@@ -101,8 +95,6 @@ const React = {
 
   version: ReactVersion,
 
-  unstable_ConcurrentMode: REACT_CONCURRENT_MODE_TYPE,
-
   __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: ReactSharedInternals,
 };
 
@@ -115,11 +107,6 @@ if (enableEventAPI) {
   React.unstable_createEventComponent = createEventComponent;
 }
 
-if (enableStableConcurrentModeAPIs) {
-  React.ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
-  React.unstable_ConcurrentMode = undefined;
-}
-
 if (enableJSXTransformAPI) {
   if (__DEV__) {
     React.jsxDEV = jsxWithValidation;
diff --git a/packages/react/src/__tests__/ReactStrictMode-test.internal.js b/packages/react/src/__tests__/ReactStrictMode-test.internal.js
index 14b33ce991805..c674a5b03e18e 100644
--- a/packages/react/src/__tests__/ReactStrictMode-test.internal.js
+++ b/packages/react/src/__tests__/ReactStrictMode-test.internal.js
@@ -10,6 +10,7 @@
 'use strict';
 
 let React;
+let Scheduler;
 let ReactFeatureFlags;
 let ReactTestRenderer;
 let PropTypes;
@@ -21,6 +22,7 @@ describe('ReactStrictMode', () => {
       ReactFeatureFlags = require('shared/ReactFeatureFlags');
       ReactFeatureFlags.debugRenderPhaseSideEffects = true;
       React = require('react');
+      Scheduler = require('scheduler');
       ReactTestRenderer = require('react-test-renderer');
     });
 
@@ -153,6 +155,7 @@ describe('ReactStrictMode', () => {
         ReactFeatureFlags = require('shared/ReactFeatureFlags');
         ReactFeatureFlags.debugRenderPhaseSideEffectsForStrictMode = debugRenderPhaseSideEffectsForStrictMode;
         React = require('react');
+        Scheduler = require('scheduler');
         ReactTestRenderer = require('react-test-renderer');
       });
 
@@ -298,27 +301,16 @@ describe('ReactStrictMode', () => {
     });
   });
 
-  describe('async subtree', () => {
+  describe('Concurrent Mode', () => {
     beforeEach(() => {
       jest.resetModules();
 
       React = require('react');
+      Scheduler = require('scheduler');
       ReactTestRenderer = require('react-test-renderer');
     });
 
-    it('should warn about unsafe legacy lifecycle methods within the tree', () => {
-      class SyncRoot extends React.Component {
-        UNSAFE_componentWillMount() {}
-        UNSAFE_componentWillUpdate() {}
-        UNSAFE_componentWillReceiveProps() {}
-        render() {
-          return (
-            <React.unstable_ConcurrentMode>
-              <AsyncRoot />
-            </React.unstable_ConcurrentMode>
-          );
-        }
-      }
+    it('should warn about unsafe legacy lifecycle methods anywhere in the tree', () => {
       class AsyncRoot extends React.Component {
         UNSAFE_componentWillMount() {}
         UNSAFE_componentWillUpdate() {}
@@ -352,13 +344,12 @@ describe('ReactStrictMode', () => {
         }
       }
 
-      let rendered;
-      expect(() => {
-        rendered = ReactTestRenderer.create(<SyncRoot />);
-      }).toWarnDev(
+      const root = ReactTestRenderer.create(null, {
+        unstable_isConcurrent: true,
+      });
+      root.update(<AsyncRoot />);
+      expect(() => Scheduler.flushAll()).toWarnDev(
         'Unsafe lifecycle methods were found within a strict-mode tree:' +
-          '\n    in ConcurrentMode (at **)' +
-          '\n    in SyncRoot (at **)' +
           '\n\ncomponentWillMount: Please update the following components ' +
           'to use componentDidMount instead: AsyncRoot' +
           '\n\ncomponentWillReceiveProps: Please update the following components ' +
@@ -367,26 +358,15 @@ describe('ReactStrictMode', () => {
           'to use componentDidUpdate instead: AsyncRoot' +
           '\n\nLearn more about this warning here:' +
           '\nhttps://fb.me/react-strict-mode-warnings',
+        {withoutStack: true},
       );
 
       // Dedupe
-      rendered = ReactTestRenderer.create(<SyncRoot />);
-      rendered.update(<SyncRoot />);
+      root.update(<AsyncRoot />);
+      Scheduler.flushAll();
     });
 
     it('should coalesce warnings by lifecycle name', () => {
-      class SyncRoot extends React.Component {
-        UNSAFE_componentWillMount() {}
-        UNSAFE_componentWillUpdate() {}
-        UNSAFE_componentWillReceiveProps() {}
-        render() {
-          return (
-            <React.unstable_ConcurrentMode>
-              <AsyncRoot />
-            </React.unstable_ConcurrentMode>
-          );
-        }
-      }
       class AsyncRoot extends React.Component {
         UNSAFE_componentWillMount() {}
         UNSAFE_componentWillUpdate() {}
@@ -409,15 +389,14 @@ describe('ReactStrictMode', () => {
         }
       }
 
-      let rendered;
+      const root = ReactTestRenderer.create(null, {
+        unstable_isConcurrent: true,
+      });
+      root.update(<AsyncRoot />);
 
       expect(() => {
-        expect(
-          () => (rendered = ReactTestRenderer.create(<SyncRoot />)),
-        ).toWarnDev(
+        expect(() => Scheduler.flushAll()).toWarnDev(
           'Unsafe lifecycle methods were found within a strict-mode tree:' +
-            '\n    in ConcurrentMode (at **)' +
-            '\n    in SyncRoot (at **)' +
             '\n\ncomponentWillMount: Please update the following components ' +
             'to use componentDidMount instead: AsyncRoot, Parent' +
             '\n\ncomponentWillReceiveProps: Please update the following components ' +
@@ -426,6 +405,7 @@ describe('ReactStrictMode', () => {
             'to use componentDidUpdate instead: AsyncRoot, Parent' +
             '\n\nLearn more about this warning here:' +
             '\nhttps://fb.me/react-strict-mode-warnings',
+          {withoutStack: true},
         );
       }).toLowPriorityWarnDev(
         [
@@ -437,103 +417,14 @@ describe('ReactStrictMode', () => {
       );
 
       // Dedupe
-      rendered = ReactTestRenderer.create(<SyncRoot />);
-      rendered.update(<SyncRoot />);
-    });
-
-    it('should group warnings by async root', () => {
-      class SyncRoot extends React.Component {
-        UNSAFE_componentWillMount() {}
-        UNSAFE_componentWillUpdate() {}
-        UNSAFE_componentWillReceiveProps() {}
-        render() {
-          return (
-            <div>
-              <AsyncRootOne />
-              <AsyncRootTwo />
-            </div>
-          );
-        }
-      }
-      class AsyncRootOne extends React.Component {
-        render() {
-          return (
-            <React.unstable_ConcurrentMode>
-              <Foo>
-                <Bar />
-              </Foo>
-            </React.unstable_ConcurrentMode>
-          );
-        }
-      }
-      class AsyncRootTwo extends React.Component {
-        render() {
-          return (
-            <React.unstable_ConcurrentMode>
-              <Foo>
-                <Baz />
-              </Foo>
-            </React.unstable_ConcurrentMode>
-          );
-        }
-      }
-      class Foo extends React.Component {
-        componentWillMount() {}
-        render() {
-          return this.props.children;
-        }
-      }
-      class Bar extends React.Component {
-        componentWillMount() {}
-        render() {
-          return null;
-        }
-      }
-      class Baz extends React.Component {
-        componentWillMount() {}
-        render() {
-          return null;
-        }
-      }
-
-      let rendered;
-
-      expect(() => {
-        expect(
-          () => (rendered = ReactTestRenderer.create(<SyncRoot />)),
-        ).toWarnDev([
-          'Unsafe lifecycle methods were found within a strict-mode tree:' +
-            '\n    in ConcurrentMode (at **)' +
-            '\n    in AsyncRootOne (at **)' +
-            '\n    in div (at **)' +
-            '\n    in SyncRoot (at **)' +
-            '\n\ncomponentWillMount: Please update the following components ' +
-            'to use componentDidMount instead: Bar, Foo',
-          'Unsafe lifecycle methods were found within a strict-mode tree:' +
-            '\n    in ConcurrentMode (at **)' +
-            '\n    in AsyncRootTwo (at **)' +
-            '\n    in div (at **)' +
-            '\n    in SyncRoot (at **)' +
-            '\n\ncomponentWillMount: Please update the following components ' +
-            'to use componentDidMount instead: Baz',
-        ]);
-      }).toLowPriorityWarnDev(['componentWillMount is deprecated'], {
-        withoutStack: true,
-      });
-
-      // Dedupe
-      rendered = ReactTestRenderer.create(<SyncRoot />);
-      rendered.update(<SyncRoot />);
+      root.update(<AsyncRoot />);
+      Scheduler.flushAll();
     });
 
     it('should warn about components not present during the initial render', () => {
       class AsyncRoot extends React.Component {
         render() {
-          return (
-            <React.unstable_ConcurrentMode>
-              {this.props.foo ? <Foo /> : <Bar />}
-            </React.unstable_ConcurrentMode>
-          );
+          return this.props.foo ? <Foo /> : <Bar />;
         }
       }
       class Foo extends React.Component {
@@ -549,32 +440,34 @@ describe('ReactStrictMode', () => {
         }
       }
 
-      let rendered;
-      expect(() => {
-        rendered = ReactTestRenderer.create(<AsyncRoot foo={true} />);
-      }).toWarnDev(
+      const root = ReactTestRenderer.create(null, {
+        unstable_isConcurrent: true,
+      });
+      root.update(<AsyncRoot foo={true} />);
+      expect(() => Scheduler.flushAll()).toWarnDev(
         'Unsafe lifecycle methods were found within a strict-mode tree:' +
-          '\n    in ConcurrentMode (at **)' +
-          '\n    in AsyncRoot (at **)' +
           '\n\ncomponentWillMount: Please update the following components ' +
           'to use componentDidMount instead: Foo' +
           '\n\nLearn more about this warning here:' +
           '\nhttps://fb.me/react-strict-mode-warnings',
+        {withoutStack: true},
       );
 
-      expect(() => rendered.update(<AsyncRoot foo={false} />)).toWarnDev(
+      root.update(<AsyncRoot foo={false} />);
+      expect(() => Scheduler.flushAll()).toWarnDev(
         'Unsafe lifecycle methods were found within a strict-mode tree:' +
-          '\n    in ConcurrentMode (at **)' +
-          '\n    in AsyncRoot (at **)' +
           '\n\ncomponentWillMount: Please update the following components ' +
           'to use componentDidMount instead: Bar' +
           '\n\nLearn more about this warning here:' +
           '\nhttps://fb.me/react-strict-mode-warnings',
+        {withoutStack: true},
       );
 
       // Dedupe
-      rendered.update(<AsyncRoot foo={true} />);
-      rendered.update(<AsyncRoot foo={false} />);
+      root.update(<AsyncRoot foo={true} />);
+      Scheduler.flushAll();
+      root.update(<AsyncRoot foo={false} />);
+      Scheduler.flushAll();
     });
 
     it('should also warn inside of "strict" mode trees', () => {
diff --git a/packages/shared/ReactSymbols.js b/packages/shared/ReactSymbols.js
index cde9f89c5b463..cecaaaf7d019e 100644
--- a/packages/shared/ReactSymbols.js
+++ b/packages/shared/ReactSymbols.js
@@ -32,6 +32,8 @@ export const REACT_PROVIDER_TYPE = hasSymbol
 export const REACT_CONTEXT_TYPE = hasSymbol
   ? Symbol.for('react.context')
   : 0xeace;
+// TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
+// (unstable) APIs that have been removed. Can we remove the symbols?
 export const REACT_ASYNC_MODE_TYPE = hasSymbol
   ? Symbol.for('react.async_mode')
   : 0xeacf;
diff --git a/packages/shared/getComponentName.js b/packages/shared/getComponentName.js
index 32f174e2b4e6b..6e7c021227730 100644
--- a/packages/shared/getComponentName.js
+++ b/packages/shared/getComponentName.js
@@ -11,7 +11,6 @@ import type {LazyComponent} from 'shared/ReactLazyComponent';
 
 import warningWithoutStack from 'shared/warningWithoutStack';
 import {
-  REACT_CONCURRENT_MODE_TYPE,
   REACT_CONTEXT_TYPE,
   REACT_FORWARD_REF_TYPE,
   REACT_FRAGMENT_TYPE,
@@ -64,8 +63,6 @@ function getComponentName(type: mixed): string | null {
     return type;
   }
   switch (type) {
-    case REACT_CONCURRENT_MODE_TYPE:
-      return 'ConcurrentMode';
     case REACT_FRAGMENT_TYPE:
       return 'Fragment';
     case REACT_PORTAL_TYPE: