diff --git a/packages/react-dom/src/__tests__/ReactCompositeComponent-test.js b/packages/react-dom/src/__tests__/ReactCompositeComponent-test.js
index 7006f51b77f5..1c02667d7bc9 100644
--- a/packages/react-dom/src/__tests__/ReactCompositeComponent-test.js
+++ b/packages/react-dom/src/__tests__/ReactCompositeComponent-test.js
@@ -13,7 +13,6 @@ let ChildUpdates;
 let MorphingComponent;
 let React;
 let ReactDOM;
-let ReactDOMServer;
 let ReactCurrentOwner;
 let ReactTestUtils;
 let PropTypes;
@@ -65,7 +64,6 @@ describe('ReactCompositeComponent', () => {
     jest.resetModules();
     React = require('react');
     ReactDOM = require('react-dom');
-    ReactDOMServer = require('react-dom/server');
     ReactCurrentOwner = require('react')
       .__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner;
     ReactTestUtils = require('react-dom/test-utils');
@@ -170,43 +168,6 @@ describe('ReactCompositeComponent', () => {
     expect(el.tagName).toBe('A');
   });
 
-  it('should not thrash a server rendered layout with client side one', () => {
-    class Child extends React.Component {
-      render() {
-        return null;
-      }
-    }
-
-    class Parent extends React.Component {
-      render() {
-        return (
-          <div>
-            <Child />
-          </div>
-        );
-      }
-    }
-
-    const markup = ReactDOMServer.renderToString(<Parent />);
-
-    // Old API based on heuristic
-    let container = document.createElement('div');
-    container.innerHTML = markup;
-    expect(() =>
-      ReactDOM.render(<Parent />, container),
-    ).toWarnDev(
-      'render(): Calling ReactDOM.render() to hydrate server-rendered markup ' +
-        'will stop working in React v18. Replace the ReactDOM.render() call ' +
-        'with ReactDOM.hydrate() if you want React to attach to the server HTML.',
-      {withoutStack: true},
-    );
-
-    // New explicit API
-    container = document.createElement('div');
-    container.innerHTML = markup;
-    ReactDOM.hydrate(<Parent />, container);
-  });
-
   it('should react to state changes from callbacks', () => {
     const container = document.createElement('div');
     document.body.appendChild(container);
diff --git a/packages/react-dom/src/__tests__/ReactLegacyContextDisabled-test.internal.js b/packages/react-dom/src/__tests__/ReactLegacyContextDisabled-test.internal.js
index c6a2d1fbb5aa..f04a4d0ea216 100644
--- a/packages/react-dom/src/__tests__/ReactLegacyContextDisabled-test.internal.js
+++ b/packages/react-dom/src/__tests__/ReactLegacyContextDisabled-test.internal.js
@@ -139,9 +139,7 @@ describe('ReactLegacyContextDisabled', () => {
       'LegacyFnConsumer uses the legacy contextTypes API which is no longer supported. ' +
         'Use React.createContext() with React.useContext() instead.',
     ]);
-    expect(text).toBe(
-      '<span data-reactroot="">{}<!-- -->undefined<!-- -->undefined</span>',
-    );
+    expect(text).toBe('<span>{}<!-- -->undefined<!-- -->undefined</span>');
     expect(lifecycleContextLog).toEqual([{}, {}, {}]);
   });
 
diff --git a/packages/react-dom/src/__tests__/ReactRenderDocument-test.js b/packages/react-dom/src/__tests__/ReactRenderDocument-test.js
index def1c35bc64e..8003ee06cb8a 100644
--- a/packages/react-dom/src/__tests__/ReactRenderDocument-test.js
+++ b/packages/react-dom/src/__tests__/ReactRenderDocument-test.js
@@ -33,225 +33,6 @@ describe('rendering React components at document', () => {
     ReactDOMServer = require('react-dom/server');
   });
 
-  describe('with old implicit hydration API', () => {
-    function expectDeprecationWarningWithFiber(callback) {
-      expect(
-        callback,
-      ).toWarnDev(
-        'render(): Calling ReactDOM.render() to hydrate server-rendered markup ' +
-          'will stop working in React v18. Replace the ReactDOM.render() call ' +
-          'with ReactDOM.hydrate() if you want React to attach to the server HTML.',
-        {withoutStack: true},
-      );
-    }
-
-    it('should be able to adopt server markup', () => {
-      class Root extends React.Component {
-        render() {
-          return (
-            <html>
-              <head>
-                <title>Hello World</title>
-              </head>
-              <body>{'Hello ' + this.props.hello}</body>
-            </html>
-          );
-        }
-      }
-
-      const markup = ReactDOMServer.renderToString(<Root hello="world" />);
-      const testDocument = getTestDocument(markup);
-      const body = testDocument.body;
-
-      expectDeprecationWarningWithFiber(() =>
-        ReactDOM.render(<Root hello="world" />, testDocument),
-      );
-      expect(testDocument.body.innerHTML).toBe('Hello world');
-
-      ReactDOM.render(<Root hello="moon" />, testDocument);
-      expect(testDocument.body.innerHTML).toBe('Hello moon');
-
-      expect(body === testDocument.body).toBe(true);
-    });
-
-    it('should not be able to unmount component from document node', () => {
-      class Root extends React.Component {
-        render() {
-          return (
-            <html>
-              <head>
-                <title>Hello World</title>
-              </head>
-              <body>Hello world</body>
-            </html>
-          );
-        }
-      }
-
-      const markup = ReactDOMServer.renderToString(<Root />);
-      const testDocument = getTestDocument(markup);
-      expectDeprecationWarningWithFiber(() =>
-        ReactDOM.render(<Root />, testDocument),
-      );
-      expect(testDocument.body.innerHTML).toBe('Hello world');
-
-      // In Fiber this actually works. It might not be a good idea though.
-      ReactDOM.unmountComponentAtNode(testDocument);
-      expect(testDocument.firstChild).toBe(null);
-    });
-
-    it('should not be able to switch root constructors', () => {
-      class Component extends React.Component {
-        render() {
-          return (
-            <html>
-              <head>
-                <title>Hello World</title>
-              </head>
-              <body>Hello world</body>
-            </html>
-          );
-        }
-      }
-
-      class Component2 extends React.Component {
-        render() {
-          return (
-            <html>
-              <head>
-                <title>Hello World</title>
-              </head>
-              <body>Goodbye world</body>
-            </html>
-          );
-        }
-      }
-
-      const markup = ReactDOMServer.renderToString(<Component />);
-      const testDocument = getTestDocument(markup);
-
-      expectDeprecationWarningWithFiber(() =>
-        ReactDOM.render(<Component />, testDocument),
-      );
-      expect(testDocument.body.innerHTML).toBe('Hello world');
-
-      // This works but is probably a bad idea.
-      ReactDOM.render(<Component2 />, testDocument);
-
-      expect(testDocument.body.innerHTML).toBe('Goodbye world');
-    });
-
-    it('should be able to mount into document', () => {
-      class Component extends React.Component {
-        render() {
-          return (
-            <html>
-              <head>
-                <title>Hello World</title>
-              </head>
-              <body>{this.props.text}</body>
-            </html>
-          );
-        }
-      }
-
-      const markup = ReactDOMServer.renderToString(
-        <Component text="Hello world" />,
-      );
-      const testDocument = getTestDocument(markup);
-
-      expectDeprecationWarningWithFiber(() =>
-        ReactDOM.render(<Component text="Hello world" />, testDocument),
-      );
-
-      expect(testDocument.body.innerHTML).toBe('Hello world');
-    });
-
-    it('renders over an existing text child without throwing', () => {
-      const container = document.createElement('div');
-      container.textContent = 'potato';
-      ReactDOM.render(<div>parsnip</div>, container);
-      expect(container.textContent).toBe('parsnip');
-      // We don't expect a warning about new hydration API here because
-      // we aren't sure if the user meant to hydrate or replace a stub node.
-      // We would see a warning if the container had React-rendered HTML in it.
-    });
-
-    it('should give helpful errors on state desync', () => {
-      class Component extends React.Component {
-        render() {
-          return (
-            <html>
-              <head>
-                <title>Hello World</title>
-              </head>
-              <body>{this.props.text}</body>
-            </html>
-          );
-        }
-      }
-
-      const markup = ReactDOMServer.renderToString(
-        <Component text="Goodbye world" />,
-      );
-      const testDocument = getTestDocument(markup);
-
-      expect(() => {
-        expect(() =>
-          ReactDOM.render(<Component text="Hello world" />, testDocument),
-        ).toWarnDev(
-          'render(): Calling ReactDOM.render() to hydrate server-rendered markup ' +
-            'will stop working in React v18. Replace the ReactDOM.render() call ' +
-            'with ReactDOM.hydrate() if you want React to attach to the server HTML.',
-          {withoutStack: true},
-        );
-      }).toErrorDev('Warning: Text content did not match.');
-    });
-
-    it('should throw on full document render w/ no markup', () => {
-      const testDocument = getTestDocument();
-
-      class Component extends React.Component {
-        render() {
-          return (
-            <html>
-              <head>
-                <title>Hello World</title>
-              </head>
-              <body>{this.props.text}</body>
-            </html>
-          );
-        }
-      }
-
-      ReactDOM.render(<Component text="Hello world" />, testDocument);
-      expect(testDocument.body.innerHTML).toBe('Hello world');
-      // We don't expect a warning about new hydration API here because
-      // we aren't sure if the user meant to hydrate or replace the document.
-      // We would see a warning if the document had React-rendered HTML in it.
-    });
-
-    it('supports findDOMNode on full-page components', () => {
-      const tree = (
-        <html>
-          <head>
-            <title>Hello World</title>
-          </head>
-          <body>Hello world</body>
-        </html>
-      );
-
-      const markup = ReactDOMServer.renderToString(tree);
-      const testDocument = getTestDocument(markup);
-      let component;
-      expectDeprecationWarningWithFiber(() => {
-        component = ReactDOM.render(tree, testDocument);
-      });
-      expect(testDocument.body.innerHTML).toBe('Hello world');
-      expect(ReactDOM.findDOMNode(component).tagName).toBe('HTML');
-    });
-  });
-
   describe('with new explicit hydration API', () => {
     it('should be able to adopt server markup', () => {
       class Root extends React.Component {
diff --git a/packages/react-dom/src/__tests__/ReactServerRendering-test.js b/packages/react-dom/src/__tests__/ReactServerRendering-test.js
index e84ae1d2ede4..b39d7c8ff517 100644
--- a/packages/react-dom/src/__tests__/ReactServerRendering-test.js
+++ b/packages/react-dom/src/__tests__/ReactServerRendering-test.js
@@ -31,14 +31,12 @@ describe('ReactDOMServer', () => {
   describe('renderToString', () => {
     it('should generate simple markup', () => {
       const response = ReactDOMServer.renderToString(<span>hello world</span>);
-      expect(response).toMatch(
-        new RegExp('<span data-reactroot=""' + '>hello world</span>'),
-      );
+      expect(response).toMatch(new RegExp('<span' + '>hello world</span>'));
     });
 
     it('should generate simple markup for self-closing tags', () => {
       const response = ReactDOMServer.renderToString(<img />);
-      expect(response).toMatch(new RegExp('<img data-reactroot=""' + '/>'));
+      expect(response).toMatch(new RegExp('<img' + '/>'));
     });
 
     it('should generate comment markup for component returns null', () => {
@@ -74,10 +72,7 @@ describe('ReactDOMServer', () => {
       const response = ReactDOMServer.renderToString(<Parent />);
       expect(response).toMatch(
         new RegExp(
-          '<div ' +
-            'data-reactroot' +
-            '=""' +
-            '>' +
+          '<div>' +
             '<span' +
             '>' +
             'My name is <!-- -->child' +
@@ -136,12 +131,7 @@ describe('ReactDOMServer', () => {
 
         expect(response).toMatch(
           new RegExp(
-            '<span ' +
-              'data-reactroot' +
-              '=""' +
-              '>' +
-              'Component name: <!-- -->TestComponent' +
-              '</span>',
+            '<span>' + 'Component name: <!-- -->TestComponent' + '</span>',
           ),
         );
         expect(lifecycle).toEqual([
@@ -580,9 +570,7 @@ describe('ReactDOMServer', () => {
     it('should generate simple markup', () => {
       const SuccessfulElement = React.createElement(() => <img />);
       const response = ReactDOMServer.renderToNodeStream(SuccessfulElement);
-      expect(response.read().toString()).toMatch(
-        new RegExp('<img data-reactroot=""' + '/>'),
-      );
+      expect(response.read().toString()).toMatch(new RegExp('<img' + '/>'));
     });
 
     it('should handle errors correctly', () => {
diff --git a/packages/react-dom/src/__tests__/ReactServerRenderingHydration-test.js b/packages/react-dom/src/__tests__/ReactServerRenderingHydration-test.js
index 29d2ce6c2214..12fc6987cf59 100644
--- a/packages/react-dom/src/__tests__/ReactServerRenderingHydration-test.js
+++ b/packages/react-dom/src/__tests__/ReactServerRenderingHydration-test.js
@@ -25,99 +25,6 @@ describe('ReactDOMServerHydration', () => {
     Scheduler = require('scheduler');
   });
 
-  it('should have the correct mounting behavior (old hydrate API)', () => {
-    let mountCount = 0;
-    let numClicks = 0;
-
-    class TestComponent extends React.Component {
-      componentDidMount() {
-        mountCount++;
-      }
-
-      click = () => {
-        numClicks++;
-      };
-
-      render() {
-        return (
-          <span ref="span" onClick={this.click}>
-            Name: {this.props.name}
-          </span>
-        );
-      }
-    }
-
-    const element = document.createElement('div');
-    document.body.appendChild(element);
-    try {
-      ReactDOM.render(<TestComponent />, element);
-
-      let lastMarkup = element.innerHTML;
-
-      // Exercise the update path. Markup should not change,
-      // but some lifecycle methods should be run again.
-      ReactDOM.render(<TestComponent name="x" />, element);
-      expect(mountCount).toEqual(1);
-
-      // Unmount and remount. We should get another mount event and
-      // we should get different markup, as the IDs are unique each time.
-      ReactDOM.unmountComponentAtNode(element);
-      expect(element.innerHTML).toEqual('');
-      ReactDOM.render(<TestComponent name="x" />, element);
-      expect(mountCount).toEqual(2);
-      expect(element.innerHTML).not.toEqual(lastMarkup);
-
-      // Now kill the node and render it on top of server-rendered markup, as if
-      // we used server rendering. We should mount again, but the markup should
-      // be unchanged. We will append a sentinel at the end of innerHTML to be
-      // sure that innerHTML was not changed.
-      ReactDOM.unmountComponentAtNode(element);
-      expect(element.innerHTML).toEqual('');
-
-      lastMarkup = ReactDOMServer.renderToString(<TestComponent name="x" />);
-      element.innerHTML = lastMarkup;
-
-      let instance;
-
-      expect(() => {
-        instance = ReactDOM.render(<TestComponent name="x" />, element);
-      }).toWarnDev(
-        'render(): Calling ReactDOM.render() to hydrate server-rendered markup ' +
-          'will stop working in React v18. Replace the ReactDOM.render() call ' +
-          'with ReactDOM.hydrate() if you want React to attach to the server HTML.',
-        {withoutStack: true},
-      );
-      expect(mountCount).toEqual(3);
-      expect(element.innerHTML).toBe(lastMarkup);
-
-      // Ensure the events system works after mount into server markup
-      expect(numClicks).toEqual(0);
-
-      instance.refs.span.click();
-      expect(numClicks).toEqual(1);
-
-      ReactDOM.unmountComponentAtNode(element);
-      expect(element.innerHTML).toEqual('');
-
-      // Now simulate a situation where the app is not idempotent. React should
-      // warn but do the right thing.
-      element.innerHTML = lastMarkup;
-      expect(() => {
-        instance = ReactDOM.render(<TestComponent name="y" />, element);
-      }).toErrorDev('Text content did not match. Server: "x" Client: "y"');
-      expect(mountCount).toEqual(4);
-      expect(element.innerHTML.length > 0).toBe(true);
-      expect(element.innerHTML).not.toEqual(lastMarkup);
-
-      // Ensure the events system works after markup mismatch.
-      expect(numClicks).toEqual(1);
-      instance.refs.span.click();
-      expect(numClicks).toEqual(2);
-    } finally {
-      document.body.removeChild(element);
-    }
-  });
-
   it('should have the correct mounting behavior (new hydrate API)', () => {
     let mountCount = 0;
     let numClicks = 0;
@@ -289,7 +196,7 @@ describe('ReactDOMServerHydration', () => {
       // Simulate IE normalizing the style attribute. IE makes it equal to
       // what's available under `node.style.cssText`.
       element.innerHTML =
-        '<div style="height: 10px; color: black; text-decoration: none;" data-reactroot=""></div>';
+        '<div style="height: 10px; color: black; text-decoration: none;"></div>';
 
       // We don't expect to see false positive warnings.
       // https://github.com/facebook/react/issues/11807
@@ -308,7 +215,7 @@ describe('ReactDOMServerHydration', () => {
     const element = document.createElement('div');
 
     element.innerHTML =
-      '<div style="text-decoration: none; color: black; height: 10px;" data-reactroot=""></div>';
+      '<div style="text-decoration: none; color: black; height: 10px;"></div>';
 
     expect(() =>
       ReactDOM.hydrate(
diff --git a/packages/react-dom/src/__tests__/escapeTextForBrowser-test.js b/packages/react-dom/src/__tests__/escapeTextForBrowser-test.js
index 08d324daae3c..73565983da74 100644
--- a/packages/react-dom/src/__tests__/escapeTextForBrowser-test.js
+++ b/packages/react-dom/src/__tests__/escapeTextForBrowser-test.js
@@ -21,37 +21,37 @@ describe('escapeTextForBrowser', () => {
 
   it('ampersand is escaped when passed as text content', () => {
     const response = ReactDOMServer.renderToString(<span>{'&'}</span>);
-    expect(response).toMatch('<span data-reactroot="">&amp;</span>');
+    expect(response).toMatch('<span>&amp;</span>');
   });
 
   it('double quote is escaped when passed as text content', () => {
     const response = ReactDOMServer.renderToString(<span>{'"'}</span>);
-    expect(response).toMatch('<span data-reactroot="">&quot;</span>');
+    expect(response).toMatch('<span>&quot;</span>');
   });
 
   it('single quote is escaped when passed as text content', () => {
     const response = ReactDOMServer.renderToString(<span>{"'"}</span>);
-    expect(response).toMatch('<span data-reactroot="">&#x27;</span>');
+    expect(response).toMatch('<span>&#x27;</span>');
   });
 
   it('greater than entity is escaped when passed as text content', () => {
     const response = ReactDOMServer.renderToString(<span>{'>'}</span>);
-    expect(response).toMatch('<span data-reactroot="">&gt;</span>');
+    expect(response).toMatch('<span>&gt;</span>');
   });
 
   it('lower than entity is escaped when passed as text content', () => {
     const response = ReactDOMServer.renderToString(<span>{'<'}</span>);
-    expect(response).toMatch('<span data-reactroot="">&lt;</span>');
+    expect(response).toMatch('<span>&lt;</span>');
   });
 
   it('number is correctly passed as text content', () => {
     const response = ReactDOMServer.renderToString(<span>{42}</span>);
-    expect(response).toMatch('<span data-reactroot="">42</span>');
+    expect(response).toMatch('<span>42</span>');
   });
 
   it('number is escaped to string when passed as text content', () => {
     const response = ReactDOMServer.renderToString(<img data-attr={42} />);
-    expect(response).toMatch('<img data-attr="42" data-reactroot=""/>');
+    expect(response).toMatch('<img data-attr="42"/>');
   });
 
   it('escape text content representing a script tag', () => {
@@ -59,7 +59,7 @@ describe('escapeTextForBrowser', () => {
       <span>{'<script type=\'\' src=""></script>'}</span>,
     );
     expect(response).toMatch(
-      '<span data-reactroot="">&lt;script type=&#x27;&#x27; ' +
+      '<span>&lt;script type=&#x27;&#x27; ' +
         'src=&quot;&quot;&gt;&lt;/script&gt;</span>',
     );
   });
diff --git a/packages/react-dom/src/__tests__/quoteAttributeValueForBrowser-test.js b/packages/react-dom/src/__tests__/quoteAttributeValueForBrowser-test.js
index fc2a711149fe..e8f181477577 100644
--- a/packages/react-dom/src/__tests__/quoteAttributeValueForBrowser-test.js
+++ b/packages/react-dom/src/__tests__/quoteAttributeValueForBrowser-test.js
@@ -21,32 +21,32 @@ describe('quoteAttributeValueForBrowser', () => {
 
   it('ampersand is escaped inside attributes', () => {
     const response = ReactDOMServer.renderToString(<img data-attr="&" />);
-    expect(response).toMatch('<img data-attr="&amp;" data-reactroot=""/>');
+    expect(response).toMatch('<img data-attr="&amp;"/>');
   });
 
   it('double quote is escaped inside attributes', () => {
     const response = ReactDOMServer.renderToString(<img data-attr={'"'} />);
-    expect(response).toMatch('<img data-attr="&quot;" data-reactroot=""/>');
+    expect(response).toMatch('<img data-attr="&quot;"/>');
   });
 
   it('single quote is escaped inside attributes', () => {
     const response = ReactDOMServer.renderToString(<img data-attr="'" />);
-    expect(response).toMatch('<img data-attr="&#x27;" data-reactroot=""/>');
+    expect(response).toMatch('<img data-attr="&#x27;"/>');
   });
 
   it('greater than entity is escaped inside attributes', () => {
     const response = ReactDOMServer.renderToString(<img data-attr=">" />);
-    expect(response).toMatch('<img data-attr="&gt;" data-reactroot=""/>');
+    expect(response).toMatch('<img data-attr="&gt;"/>');
   });
 
   it('lower than entity is escaped inside attributes', () => {
     const response = ReactDOMServer.renderToString(<img data-attr="<" />);
-    expect(response).toMatch('<img data-attr="&lt;" data-reactroot=""/>');
+    expect(response).toMatch('<img data-attr="&lt;"/>');
   });
 
   it('number is escaped to string inside attributes', () => {
     const response = ReactDOMServer.renderToString(<img data-attr={42} />);
-    expect(response).toMatch('<img data-attr="42" data-reactroot=""/>');
+    expect(response).toMatch('<img data-attr="42"/>');
   });
 
   it('object is passed to a string inside attributes', () => {
@@ -59,7 +59,7 @@ describe('quoteAttributeValueForBrowser', () => {
     const response = ReactDOMServer.renderToString(
       <img data-attr={sampleObject} />,
     );
-    expect(response).toMatch('<img data-attr="ponys" data-reactroot=""/>');
+    expect(response).toMatch('<img data-attr="ponys"/>');
   });
 
   it('script tag is escaped inside attributes', () => {
@@ -68,8 +68,7 @@ describe('quoteAttributeValueForBrowser', () => {
     );
     expect(response).toMatch(
       '<img data-attr="&lt;script type=&#x27;&#x27; ' +
-        'src=&quot;&quot;&gt;&lt;/script&gt;" ' +
-        'data-reactroot=""/>',
+        'src=&quot;&quot;&gt;&lt;/script&gt;"/>',
     );
   });
 });
diff --git a/packages/react-dom/src/__tests__/utils/ReactDOMServerIntegrationTestUtils.js b/packages/react-dom/src/__tests__/utils/ReactDOMServerIntegrationTestUtils.js
index b81a74983780..eec6cd855064 100644
--- a/packages/react-dom/src/__tests__/utils/ReactDOMServerIntegrationTestUtils.js
+++ b/packages/react-dom/src/__tests__/utils/ReactDOMServerIntegrationTestUtils.js
@@ -211,7 +211,7 @@ module.exports = function(initModules) {
       element,
       shouldUseDocument(element)
         ? '<html><body><div id="badIdWhichWillCauseMismatch" /></body></html>'
-        : '<div id="badIdWhichWillCauseMismatch" data-reactroot="" data-reactid="1"></div>',
+        : '<div id="badIdWhichWillCauseMismatch"></div>',
     );
 
     await renderIntoDom(element, container, true, errorCount + 1);
diff --git a/packages/react-dom/src/client/ReactDOMComponent.js b/packages/react-dom/src/client/ReactDOMComponent.js
index 635c67f5d770..782097895710 100644
--- a/packages/react-dom/src/client/ReactDOMComponent.js
+++ b/packages/react-dom/src/client/ReactDOMComponent.js
@@ -941,9 +941,6 @@ export function diffHydratedProperties(
     for (let i = 0; i < attributes.length; i++) {
       const name = attributes[i].name.toLowerCase();
       switch (name) {
-        // Built-in SSR attribute is allowed
-        case 'data-reactroot':
-          break;
         // Controlled attributes are not validated
         // TODO: Only ignore them on controlled tags.
         case 'value':
diff --git a/packages/react-dom/src/client/ReactDOMLegacy.js b/packages/react-dom/src/client/ReactDOMLegacy.js
index 589ddfedcda3..f1ee572ee6ef 100644
--- a/packages/react-dom/src/client/ReactDOMLegacy.js
+++ b/packages/react-dom/src/client/ReactDOMLegacy.js
@@ -18,7 +18,6 @@ import {
   unmarkContainerAsRoot,
 } from './ReactDOMComponentTree';
 import {createLegacyRoot, isValidContainer} from './ReactDOMRoot';
-import {ROOT_ATTRIBUTE_NAME} from '../shared/DOMProperty';
 import {
   DOCUMENT_NODE,
   ELEMENT_NODE,
@@ -41,7 +40,6 @@ import {has as hasInstance} from 'shared/ReactInstanceMap';
 const ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
 
 let topLevelUpdateWarnings;
-let warnedAboutHydrateAPI = false;
 
 if (__DEV__) {
   topLevelUpdateWarnings = (container: Container) => {
@@ -102,57 +100,21 @@ function getReactRootElementInContainer(container: any) {
   }
 }
 
-function shouldHydrateDueToLegacyHeuristic(container) {
-  const rootElement = getReactRootElementInContainer(container);
-  return !!(
-    rootElement &&
-    rootElement.nodeType === ELEMENT_NODE &&
-    rootElement.hasAttribute(ROOT_ATTRIBUTE_NAME)
-  );
-}
-
 function legacyCreateRootFromDOMContainer(
   container: Container,
   forceHydrate: boolean,
 ): RootType {
-  const shouldHydrate =
-    forceHydrate || shouldHydrateDueToLegacyHeuristic(container);
   // First clear any existing content.
-  if (!shouldHydrate) {
-    let warned = false;
+  if (!forceHydrate) {
     let rootSibling;
     while ((rootSibling = container.lastChild)) {
-      if (__DEV__) {
-        if (
-          !warned &&
-          rootSibling.nodeType === ELEMENT_NODE &&
-          (rootSibling: any).hasAttribute(ROOT_ATTRIBUTE_NAME)
-        ) {
-          warned = true;
-          console.error(
-            'render(): Target node has markup rendered by React, but there ' +
-              'are unrelated nodes as well. This is most commonly caused by ' +
-              'white-space inserted around server-rendered markup.',
-          );
-        }
-      }
       container.removeChild(rootSibling);
     }
   }
-  if (__DEV__) {
-    if (shouldHydrate && !forceHydrate && !warnedAboutHydrateAPI) {
-      warnedAboutHydrateAPI = true;
-      console.warn(
-        'render(): Calling ReactDOM.render() to hydrate server-rendered markup ' +
-          'will stop working in React v18. Replace the ReactDOM.render() call ' +
-          'with ReactDOM.hydrate() if you want React to attach to the server HTML.',
-      );
-    }
-  }
 
   return createLegacyRoot(
     container,
-    shouldHydrate
+    forceHydrate
       ? {
           hydrate: true,
         }
diff --git a/packages/react-dom/src/events/__tests__/DOMPluginEventSystem-test.internal.js b/packages/react-dom/src/events/__tests__/DOMPluginEventSystem-test.internal.js
index 9b913f50728c..81ce4ecc1940 100644
--- a/packages/react-dom/src/events/__tests__/DOMPluginEventSystem-test.internal.js
+++ b/packages/react-dom/src/events/__tests__/DOMPluginEventSystem-test.internal.js
@@ -1272,7 +1272,7 @@ describe('DOMPluginEventSystem', () => {
               return <div ref={divRef}>Hello world</div>;
             }
             const output = ReactDOMServer.renderToString(<Test />);
-            expect(output).toBe(`<div data-reactroot="">Hello world</div>`);
+            expect(output).toBe(`<div>Hello world</div>`);
           });
 
           // @gate experimental
@@ -1293,9 +1293,7 @@ describe('DOMPluginEventSystem', () => {
               );
             }
             const output = ReactDOMServer.renderToString(<Test />);
-            expect(output).toBe(
-              `<div data-reactroot=""><span>Hello world</span></div>`,
-            );
+            expect(output).toBe(`<div><span>Hello world</span></div>`);
             container.innerHTML = output;
             ReactDOM.hydrate(<Test />, container);
             Scheduler.unstable_flushAll();
diff --git a/packages/react-dom/src/server/DOMMarkupOperations.js b/packages/react-dom/src/server/DOMMarkupOperations.js
index 3cddbb493e07..014e63553192 100644
--- a/packages/react-dom/src/server/DOMMarkupOperations.js
+++ b/packages/react-dom/src/server/DOMMarkupOperations.js
@@ -8,7 +8,6 @@
  */
 
 import {
-  ROOT_ATTRIBUTE_NAME,
   BOOLEAN,
   OVERLOADED_BOOLEAN,
   getPropertyInfo,
@@ -23,10 +22,6 @@ import quoteAttributeValueForBrowser from './quoteAttributeValueForBrowser';
  * Operations for dealing with DOM properties.
  */
 
-export function createMarkupForRoot(): string {
-  return ROOT_ATTRIBUTE_NAME + '=""';
-}
-
 /**
  * Creates markup for a property.
  *
diff --git a/packages/react-dom/src/server/ReactPartialRenderer.js b/packages/react-dom/src/server/ReactPartialRenderer.js
index dd568c16363e..c8ccbfc245a1 100644
--- a/packages/react-dom/src/server/ReactPartialRenderer.js
+++ b/packages/react-dom/src/server/ReactPartialRenderer.js
@@ -52,7 +52,6 @@ import {allocThreadID, freeThreadID} from './ReactThreadIDAllocator';
 import {
   createMarkupForCustomAttribute,
   createMarkupForProperty,
-  createMarkupForRoot,
 } from './DOMMarkupOperations';
 import escapeTextForBrowser from './escapeTextForBrowser';
 import {
@@ -388,15 +387,6 @@ function createOpenTagMarkup(
     }
   }
 
-  // For static pages, no need to put React ID and checksum. Saves lots of
-  // bytes.
-  if (makeStaticMarkup) {
-    return ret;
-  }
-
-  if (isRootElement) {
-    ret += ' ' + createMarkupForRoot();
-  }
   return ret;
 }
 
diff --git a/packages/react-dom/src/shared/DOMProperty.js b/packages/react-dom/src/shared/DOMProperty.js
index 92adf041d196..83b48555ebd8 100644
--- a/packages/react-dom/src/shared/DOMProperty.js
+++ b/packages/react-dom/src/shared/DOMProperty.js
@@ -63,7 +63,6 @@ export const ATTRIBUTE_NAME_START_CHAR =
 export const ATTRIBUTE_NAME_CHAR =
   ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
 
-export const ROOT_ATTRIBUTE_NAME = 'data-reactroot';
 export const VALID_ATTRIBUTE_NAME_REGEX = new RegExp(
   '^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$',
 );
diff --git a/packages/react-reconciler/src/__tests__/ReactScope-test.internal.js b/packages/react-reconciler/src/__tests__/ReactScope-test.internal.js
index 2eeba5236285..10cdadfc66db 100644
--- a/packages/react-reconciler/src/__tests__/ReactScope-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactScope-test.internal.js
@@ -228,7 +228,7 @@ describe('ReactScope', () => {
       }
       const html = ReactDOMServer.renderToString(<Test />);
       expect(html).toBe(
-        '<div data-reactroot=""><div>DIV</div><span>SPAN</span><a>A</a><div>Outside content!</div></div>',
+        '<div><div>DIV</div><span>SPAN</span><a>A</a><div>Outside content!</div></div>',
       );
       container.innerHTML = html;
       ReactDOM.hydrate(<Test />, container);
diff --git a/packages/react-reconciler/src/__tests__/__snapshots__/ReactHooks-test.internal.js.snap b/packages/react-reconciler/src/__tests__/__snapshots__/ReactHooks-test.internal.js.snap
index 87633a047a8f..6d0f97a7b993 100644
--- a/packages/react-reconciler/src/__tests__/__snapshots__/ReactHooks-test.internal.js.snap
+++ b/packages/react-reconciler/src/__tests__/__snapshots__/ReactHooks-test.internal.js.snap
@@ -1,3 +1,3 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`ReactHooks works with ReactDOMServer calls inside a component 1`] = `"<p data-reactroot=\\"\\">hello</p>0<p>bye</p>"`;
+exports[`ReactHooks works with ReactDOMServer calls inside a component 1`] = `"<p>hello</p>0<p>bye</p>"`;