React vs ReactDOM?

I'm a bit new to react. I see we have to import two things to get started, React and ReactDOM, can anyone explain the difference. I'm reading through the React documentation, but it doesn't say.

React and ReactDOM were only recently split into two different libraries. Prior to v0.14, all ReactDOM functionality was part of React. This may be a source of confusion, since any slightly dated documentation won't mention the React / ReactDOM distinction.

As the name implies, ReactDOM is the glue between React and the DOM. Often, you will only use it for one single thing: mounting with ReactDOM.render(). Another useful feature of ReactDOM is ReactDOM.findDOMNode() which you can use to gain direct access to a DOM element. (Something you should use sparingly in React apps, but it can be necessary.) If your app is "isomorphic", you would also use ReactDOM.renderToString() in your back-end code.

For everything else, there's React. You use React to define and create your elements, for lifecycle hooks, etc. i.e. the guts of a React application.

The reason React and ReactDOM were split into two libraries was due to the arrival of React Native. React contains functionality utilised in web and mobile apps. ReactDOM functionality is utilised only in web apps. [UPDATE: Upon further research, it's clear my ignorance of React Native is showing. Having the React package common to both web and mobile appears to be more of an aspiration than a reality right now. React Native is at present an entirely different package.]

See the blog post announcing the v0.14 release: https://facebook.github.io/react/blog/2015/10/07/react-v0.14.html

From the React v0.14 Beta release announcement.

> As we look at packages like react-native, react-art, react-canvas, and react-three, it's become clear that the beauty and essence of React has nothing to do with browsers or the DOM. > > To make this more clear and to make it easier to build more environments that React can render to, we're splitting the main react package into two: react and react-dom.

Fundamentally, the idea of React has nothing to do with browsers, they just happen to be one of many targets for rendering trees of components into. The ReactDOM package has allowed the developers to remove any non-essential code from the React package and move it into a more appropriate repository.

> The react package contains React.createElement, React.createClass and React.Component, React.PropTypes, React.Children, and the other helpers related to elements and component classes. We think of these as the isomorphic or universal helpers that you need to build components. > > The react-dom package contains ReactDOM.render, ReactDOM.unmountComponentAtNode, and ReactDOM.findDOMNode, and in react-dom/server we have server-side rendering support with ReactDOMServer.renderToString and ReactDOMServer.renderToStaticMarkup.

These two paragraphs explain where the core API methods from v0.13 ended up.

Before v0.14 they were part of main ReactJs file, but as in some cases we may not need both, they separate them and it starts from version 0.14, that way if we need only one of them, our app gonna be smaller due to using only one of those:

var React = require('react'); /* importing react */
var ReactDOM = require('react-dom'); /* importing react-dom */

var MyComponent = React.createClass({
  render: function() {
    return <div>Hello World</div>;
  }
});

ReactDOM.render(<MyComponent />, node);

React package contains: React.createElement, React.createClass, React.Component, React.PropTypes, React.Children

React-dom package contains: ReactDOM.render, ReactDOM.unmountComponentAtNode, ReactDOM.findDOMNode, and react-dom/server that's including: ReactDOMServer.renderToString and ReactDOMServer.renderToStaticMarkup.

It looks like they've separated React into react and react-dom packages, so you don't have to use the DOM-related part for projects where you'd like to use it in non-DOM-specific cases, like in here https://github.com/Flipboard/react-canvas where they import

var React = require('react');
var ReactCanvas = require('react-canvas');

as you can see. Without react-dom.

The ReactDOM module exposes DOM-specific methods, while React has the core tools intended to be shared by React on different platforms (e.g. React Native).

http://facebook.github.io/react/docs/tutorial.html

To be more concise, react is for the components and react-dom is for rendering the components in the DOM. 'react-dom' acts as a glue between components and DOM. You will be using render() method of the react-dom to render components in the DOM and that's all you have to know when you are starting off with it.

React: React is a javascript library, designed for building better user interfaces.

React-DOM: React-DOM is a complimentary library to React which glues React to the browser DOM

We’re using React and whenever we use methods like render() or findDOMNode() we’re using React-DOM.

As we look at packages like react-native, react-art, react-canvas, and react-three, it's become clear that the beauty and essence of React has nothing to do with browsers or the DOM. To make this more clear and to make it easier to build more environments that React can render to, they splitting the main react package into two: react and react-dom.

The react package holds the react source for components, state, props and all the code that is react.

The react-dom package as the name implies is the glue between React and the DOM. Often, you will only use it for one single thing: mounting your application to the index.html file with ReactDOM.render().

The react package holds the react source for components, state, props and all the code that is react.

The react-dom package as the name implies is the glue between React and the DOM. Often, you will only use it for one single thing: mounting your application to the index.html file with ReactDOM.render().

Why separate them?

The reason React and ReactDOM were split into two libraries was due to the arrival of React Native (A react platform for mobile development).

TL;TR the react package is required to create and use components and hooks, react-dom contains react-dom/client and react-dom/server to render you app in the browser's DOM or inside a string (or a stream) on the server. With react-native you can use React to create native apps for Android and iOS.

---

> This question has been asked almost seven years ago and a lot has changed since then. > Most of the answer are no longer correct or contains outdated information. > I'll try to give you a complete but simple answer with the most up to date information available.

React 18

In March 2022 React 18 has been released. It has brought some interesting changes in its public APIs.

Packages

react

As stated in React documentation:

> React is the entry point to the React library. If you load React from a <script> tag, these top-level APIs are available on the React global.

Indeed it exposes most of the common React features to create and use components. Some of these are:

• React.Component and React.PureComponent, used to create class components and function components
• React.createElement(), used convert your JSX code from <Page title="Home page" />to React.createElement(Page, { title: "Home page" }, null)
• React.Fragment, to return multiple elements without creating additional DOM elements (starting with React 16.2 you can also use <></> to create a fragment.
• hooks, to let you use state and other React features without writing a class
• Refs, Suspence and Transitions

Complete list of API exposed by the React object

> react-dom, react-native and the others listed below are React renderers. They manage how a React tree turns into the underlying platform calls.

react-dom

> The react-dom package provides DOM-specific methods that can be used at the top level of your app and as an escape hatch to get outside the React model if you need to.

This package is essentially a container used to expose both the client and server sub-packages from a single one. Indeed it exposes only two function:

• createPortal(), used to create portals and render children outside the DOM hierarchy of the parent component
• flushSync() is something you may not never have heard about and for a reason. Because it can significantly hurt performance.

Starting from React 18 these functions have been flagged as legacy, so they will be deprecated in future releases:

• render()
• hydrate()
• findDOMNode()
• unmountComponentAtNode()

> If you are thinking "OMG they have deprecated the ´ReactDOM.render´ method from React", don't worry and read below.

The reason behind the deprecation is:

> the opportunity to redesign the APIs we expose for rendering on the client and server. These changes allow users to continue using the old APIs in React 17 mode while they upgrade to the new APIs in React 18.

Keep in mind that if you continue to use those legacy APIs, new React 18 features will be disabled.

Complete list of API exposed by the react-dom package

react-dom/client

> The react-dom/client package provides client-specific methods used for initializing an app on the client. Most of your components should not need to use this module.

The React DOM Client module exposes only two methods:

• createRoot() is the new method to create a root where your app will. This the replacement for ReactDOM.render - see the example below
• hydrateRoot() is the replacement for ReactDOM.hydrate, required to hydrate a server rendered application

Now the idiomatic way to render you app is using createRoot and render chained together:

import React from 'react';
import * as ReactDOM from 'react-dom/client';

ReactDOM
  .createRoot(document.getElementById('root'))
  .render(<h1>Hello, world!</h1>);

Or using a constant if you don't like chaining, it's just a matter of style:

import React from 'react';
import * as ReactDOM from 'react-dom/client';

const root = ReactDOM.createRoot(document.getElementById('root'))
root.render(<h1>Hello, world!</h1>);

Complete list of API exposed by the react-dom/client package

react-dom/server

> The ReactDOMServer object enables you to render components to static markup. Typically, it’s used on a Node server

Using ReactDOMServer you can render React components server-side. It offers a wide range of methods to achieve this - there are dedicated functions for every environment:

• renderToPipeableStream(), uses Node.js Streams
• renderToNodeStream() (Deprecated), uses Node.js Streams
• renderToStaticNodeStream(), uses Node.js Streams
• renderToReadableStream(), uses Web Streams available in browsers, Deno, ...

Moreover, there are also render that can be used in the environments that don not support streams:

• renderToString() discouraged from React 18
• renderToStaticMarkup()

> You can use them but they have limited Suspense support.

This is a the minimal working example to try ReactDOMServer on your own:

import React from 'react';
import * as ReactDOMServer from 'react-dom/server';

const html = ReactDOMServer.renderToString(<h1>Hello, world!</h1>);

Complete list of API exposed by the react-dom/server package

react-native

> With React Native, React primitives render to native platform UI, meaning your app uses the same native platform APIs other apps do.

React Native has now a huge ecosystem itself and it is not limited to only render components.

Today is no longer recommended to install the react-native module yourself. Instead, you can use the the expo-cli to take advantage of its automation for the development of your application.

---

Other React renderers

> These are some of the most interesting renderer available today (not dead) for React

react-canvas

react-canvas project is dead, but similar features can be found in react-konva. Using it you can render your React components inside an HTML canvas.

react-three

react-three has been superseded by react-three-fiber. It allows you to build your [tag:three.js] scene declaratively from React.

ink

ink is a React renderer for CLIs. Using it you can build your CLI output using components.

react-figma

react-figma is a React renderer for Figma. You can use React components as a source for your designs.

react-pdf

react-pdf is a React renderer for creating PDF files on the browser and server.

---

FAQ

Where did prop-types go?

With the release of react 15.5 the prop-types library moved outside of React into a dedicated package.