react-content-loader vs react-loading-skeleton vs react-placeholder
Implementing Skeleton Loading States in React
react-content-loaderreact-loading-skeletonreact-placeholderSimilar Packages:

Implementing Skeleton Loading States in React

react-content-loader, react-loading-skeleton, and react-placeholder are all React libraries designed to create placeholder loading states, often called skeleton screens. These components improve perceived performance by showing a structured layout while data fetches, reducing layout shift and user anxiety. react-content-loader uses SVG to draw custom shapes, offering pixel-perfect control. react-loading-skeleton relies on CSS animations for a simple, box-based approach that is easy to drop in. react-placeholder acts as a wrapper component that swaps between a template and actual content, focusing on structural replacement rather than visual animation details.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
react-content-loader014,001164 kB214 months agoMIT
react-loading-skeleton04,20626.7 kB72 years agoMIT
react-placeholder01,612-235 years agoISC

React Loading Libraries: Content Loader vs Skeleton vs Placeholder

When building modern React applications, showing a loading spinner is no longer enough. Users expect to see the structure of the page immediately, even before data arrives. This technique, known as skeleton screens, reduces perceived wait time and prevents layout shifts. react-content-loader, react-loading-skeleton, and react-placeholder solve this problem in different ways. Let's compare how they handle rendering, customization, and implementation.

🎨 Rendering Engine: SVG vs CSS vs Wrapper

The core difference lies in how these libraries draw the loading state on the screen.

react-content-loader uses SVG elements to draw shapes.

  • You define rectangles, circles, or paths manually.
  • This allows for exact matching of your final UI components.
  • It renders as vector graphics, scaling cleanly on any screen.
// react-content-loader: SVG based
import ContentLoader from "react-content-loader"

const CardLoader = () => (
  <ContentLoader width={300} height={100}>
    <rect x="10" y="10" rx="5" ry="5" width="200" height="20" />
    <rect x="10" y="40" rx="5" ry="5" width="150" height="10" />
  </ContentLoader>
)

react-loading-skeleton uses CSS animations on div elements.

  • It creates gray boxes that pulse using keyframes.
  • The browser handles the rendering as standard HTML blocks.
  • Easier to style with global CSS or utility classes.
// react-loading-skeleton: CSS based
import Skeleton from "react-loading-skeleton"

const CardLoader = () => (
  <div>
    <Skeleton width={200} height={20} />
    <Skeleton width={150} height={10} />
  </div>
)

react-placeholder uses a wrapper component to swap content.

  • It renders a template component when loading is true.
  • The template is usually standard React components, not specialized loaders.
  • Focuses on logic separation rather than visual effects.
// react-placeholder: Wrapper based
import Placeholder from "react-placeholder"

const CardLoader = ({ loading }) => (
  <Placeholder loading={loading} template={<div className="skeleton-box" />}> 
    <ActualCardContent />
  </Placeholder>
)

🛠️ Customization: Drawing Shapes vs Styling Boxes

How much effort do you need to make the loader look like your actual content?

react-content-loader requires you to draw the layout.

  • You must specify x, y, width, and height for every element.
  • Great for unique designs like avatars next to text lines.
  • Harder to maintain if the underlying UI changes frequently.
// react-content-loader: Precise coordinates
<ContentLoader width={400} height={200}>
  <circle cx="30" cy="30" r="30" />
  <rect x="80" y="20" width="200" height="20" />
  <rect x="80" y="60" width="150" height="10" />
</ContentLoader>

react-loading-skeleton relies on box dimensions.

  • You set width and height, but position is handled by layout.
  • Faster to implement for standard lists or grids.
  • Less precise, but often good enough for internal tools.
// react-loading-skeleton: Dimension based
<Skeleton circle={true} height={60} width={60} />
<Skeleton count={3} height={20} />

react-placeholder depends on your template definition.

  • You build a separate React component for the loading state.
  • Full control via standard CSS, but requires duplicate markup.
  • Good if you already have a designed loading component.
// react-placeholder: Template component
const Template = () => <div className="my-custom-loader">Loading...</div>

<Placeholder loading={true} template={<Template />}>
  <Content />
</Placeholder>

🧩 Implementation Patterns: Standalone vs Wrapper

Where does the loader sit in your component tree?

react-content-loader is typically a standalone component.

  • You create a specific loader for each complex component.
  • You conditionally render the loader or the data component.
  • Keeps loading logic separate from data logic.
// react-content-loader: Conditional render
{isLoading ? <CardLoader /> : <CardData />}

react-loading-skeleton can be inline or standalone.

  • You can wrap text directly or use it as a block.
  • Often used inside a map function for lists.
  • Very flexible for mixed content areas.
// react-loading-skeleton: Inline usage
<div>
  {isLoading ? <Skeleton /> : <h1>{title}</h1>}
</div>

react-placeholder is strictly a wrapper.

  • It wraps the actual content and handles the toggle.
  • Reduces conditional logic in your render method.
  • Can lead to deeper component nesting.
// react-placeholder: Wrapper pattern
<Placeholder loading={isLoading} template={<Loader />}>
  <CardData />
</Placeholder>

🌱 Maintenance and Ecosystem

Long-term support matters when choosing a dependency.

react-content-loader is highly active and widely adopted.

  • Regular updates and strong community support.
  • Many examples and third-party presets available.
  • Safe choice for long-term projects.

react-loading-skeleton is also actively maintained.

  • Focuses on simplicity and zero config.
  • Good documentation and clear API.
  • Growing popularity in the React community.

react-placeholder has lower recent activity.

  • Stable API but fewer updates compared to others.
  • Smaller community and fewer examples online.
  • Consider if it fits existing architecture, but evaluate alternatives for new builds.

📊 Summary Table

Featurereact-content-loaderreact-loading-skeletonreact-placeholder
Rendering🎨 SVG Shapes🟦 CSS Boxes🔄 Component Wrapper
Customization🔧 High (Coordinates)⚙️ Medium (Dimensions)🧩 High (Templates)
Setup Effort🕒 Higher⚡ Low⚙️ Medium
Visual Fidelity✅ Exact Match⚠️ Approximate✅ Depends on Template
Maintenance🟢 Active🟢 Active🟡 Less Active

💡 Final Recommendation

For most modern React applications, react-loading-skeleton is the best starting point. It offers the best balance between effort and result — you get a polished loading state with minimal code. Use it for dashboards, admin panels, and standard content feeds.

Choose react-content-loader when design precision is a requirement. If your marketing site or public-facing app needs the loading state to match the final UI exactly, the SVG approach is worth the extra setup time.

Use react-placeholder primarily if you are maintaining an existing codebase that already relies on it. For new projects, the other two options offer better long-term support and more flexible integration patterns.

Final Thought: All three libraries solve the same user experience problem — preventing blank screens during data fetches. The right choice depends on how much control you need over the visual details versus how quickly you need to ship.

How to Choose: react-content-loader vs react-loading-skeleton vs react-placeholder

  • react-content-loader:

    Choose react-content-loader if you need precise visual control over the loading state. It is ideal for matching complex UI layouts where standard boxes look out of place. Use this when design fidelity is critical and you have the time to draw custom SVG shapes.

  • react-loading-skeleton:

    Choose react-loading-skeleton for most standard applications where speed and simplicity matter. It works well for lists, cards, and text blocks where a generic rectangular pulse is acceptable. This is the best choice for teams that want a dependency with minimal configuration.

  • react-placeholder:

    Choose react-placeholder if you prefer a wrapper pattern that toggles between a template and children. It suits legacy projects or specific architectures where you define a full component template for the loading state. However, evaluate newer alternatives for modern projects due to lower maintenance activity.

README for react-content-loader

react-content-loader

Example's react-content-loader

SVG-Powered component to easily create placeholder loadings (like Facebook's cards loading).

Features

  • :gear: Customizable: Feel free to change the colors, speed, sizes, and even RTL;
  • :ok_hand: Plug and play: with many presets to use, see the examples;
  • :pencil2: DIY: use the create-content-loader to create your own custom loaders easily;
  • 📱 React Native support: same API, as same powerful features;
  • ⚛️ Really lightweight: less than 2kB and 0 dependencies for web version;

Index

Getting Started

npm i react-content-loader --save
yarn add react-content-loader

For React Native

npm i react-content-loader react-native-svg --save
yarn add react-content-loader react-native-svg

CDN from JSDELIVR

Usage

There are two ways to use it:

1. Presets, see the examples:

import ContentLoader, { Facebook } from 'react-content-loader'

const MyLoader = () => <ContentLoader />
const MyFacebookLoader = () => <Facebook />

2. Custom mode, see the online tool

const MyLoader = () => (
  <ContentLoader viewBox="0 0 380 70">
    {/* Only SVG shapes */}    
    <rect x="0" y="0" rx="5" ry="5" width="70" height="70" />
    <rect x="80" y="17" rx="4" ry="4" width="300" height="13" />
    <rect x="80" y="40" rx="3" ry="3" width="250" height="10" />
  </ContentLoader>
)

Still not clear? Take a look at this working example at codesandbox.io Or try the components editable demo hands-on and install it from bit.dev

Native

react-content-loader can be used with React Native in the same way as web version with the same import:

1. Presets, see the examples:

import ContentLoader, { Facebook } from 'react-content-loader/native'

const MyLoader = () => <ContentLoader />
const MyFacebookLoader = () => <Facebook />

2. Custom mode

To create custom loaders there is an important difference: as React Native doesn't have any native module for SVG components, it's necessary to import the shapes from react-native-svg or use the named export Rect and Circle from react-content-loader import:

import ContentLoader, { Rect, Circle } from 'react-content-loader/native'

const MyLoader = () => (
  <ContentLoader viewBox="0 0 380 70">
    <Circle cx="30" cy="30" r="30" />
    <Rect x="80" y="17" rx="4" ry="4" width="300" height="13" />
    <Rect x="80" y="40" rx="3" ry="3" width="250" height="10" />
  </ContentLoader>
)

Options

Prop name and type
EnvironmentDescription
animate?: boolean
Defaults to true
React DOM
React Native
Opt-out of animations with false
title?: string
Defaults to Loading...
React DOM onlyIt's used to describe what element it is. 
Use '' (empty string) to remove.
baseUrl?: string
Defaults to an empty string
React DOM onlyRequired if you're using <base url="/" /> document <head/>
This prop is common used as: 
<ContentLoader baseUrl={window.location.pathname} /> which will fill the SVG attribute with the relative path. Related #93.
speed?: number
Defaults to 1.2
React DOM
React Native
Animation speed in seconds.
viewBox?: string
Defaults to undefined
React DOM
React Native
Use viewBox props to set a custom viewBox value,
for more information about how to use it,
read the article How to Scale SVG.
gradientRatio?: number
Defaults to 1.2
React DOM onlyWidth of the animated gradient as a fraction of the view box width.
rtl?: boolean
Defaults to false
React DOM
React Native
Content right-to-left.
backgroundColor?: string
Defaults to #f5f6f7
React DOM
React Native
Used as background of animation.
foregroundColor?: string
Defaults to #eee
React DOM
React Native
Used as the foreground of animation.
backgroundOpacity?: number
Defaults to 1
React DOM
React Native
Background opacity (0 = transparent, 1 = opaque)
used to solve an issue in Safari
foregroundOpacity?: number
Defaults to 1
React DOM
React Native
Animation opacity (0 = transparent, 1 = opaque)
used to solve an issue in Safari
style?: React.CSSProperties
Defaults to {}
React DOM only
uniqueKey?: string
Defaults to random unique id
React DOM onlyUse the same value of prop key, 
that will solve inconsistency on the SSR, see more here.
beforeMask?: JSX.Element
Defaults to null
React DOM
React Native
Define custom shapes before content, 
see more here.

See all options live

Examples

Facebook Style
import { Facebook } from 'react-content-loader'

const MyFacebookLoader = () => <Facebook />
Facebook Style
Instagram Style
import { Instagram } from 'react-content-loader'

const MyInstagramLoader = () => <Instagram />
Instagram Style
Code Style
import { Code } from 'react-content-loader'

const MyCodeLoader = () => <Code />
Code Style
List Style
import { List } from 'react-content-loader'

const MyListLoader = () => <List />
List Style
Bullet list Style
import { BulletList } from 'react-content-loader'

const MyBulletListLoader = () => <BulletList />
Bullet list Style

Custom Style

For the custom mode, use the online tool.

const MyLoader = () => (
  <ContentLoader
    height={140}
    speed={1}
    backgroundColor={'#333'}
    foregroundColor={'#999'}
    viewBox="0 0 380 70"
  >
    {/* Only SVG shapes */}
    <rect x="0" y="0" rx="5" ry="5" width="70" height="70" />
    <rect x="80" y="17" rx="4" ry="4" width="300" height="13" />
    <rect x="80" y="40" rx="3" ry="3" width="250" height="10" />
  </ContentLoader>
)

Custom

Troubleshooting

Responsive - Mobile version

In order to avoid unexpected behavior, the package doesn't have opinioned settings. So if it needs to be responsive, have in mind that the output of the package is a regular SVG, so it just needs the same attributes to become a regular SVG responsive, which means:

import { Code } from 'react-content-loader'

const MyCodeLoader = () => (
  <Code
    width={100}
    height={100}
    viewBox="0 0 100 100"
    style={{ width: '100%' }}
  />
)

Server-side rendering (SSR) - Match snapshot

As the main component generates random values to match the id of the SVG element with background style, it can encounter unexpected errors and unmatching warning on render, once the random value of id will be generated twice, in case of SSR: server and client; or in case of snapshot test: on the first match and re-running the test.

To fix it, set the prop uniqueKey, then the id will not be random anymore:

import { Facebook } from 'react-content-loader'

const MyFacebookLoader = () => <Facebook uniqueKey="my-random-value" />

Alpha is not working: Safari / iOS

When using rgba as a backgroundColor or foregroundColor value, Safari does not respect the alpha channel, meaning that the color will be opaque. To prevent this, instead of using a rgba value for backgroundColor/foregroundColor, use the rgb equivalent and move the alpha channel value to the backgroundOpacity/foregroundOpacity props.

{/* Opaque color in Safari and iOS */}
<ContentLoader
  backgroundColor="rgba(0,0,0,0.06)"
  foregroundColor="rgba(0,0,0,0.12)">


{/_ Semi-transparent color in Safari and iOS _/}
<ContentLoader
    backgroundColor="rgb(0,0,0)"
    foregroundColor="rgb(0,0,0)"
    backgroundOpacity={0.06}
    foregroundOpacity={0.12}>


Black box in Safari / iOS (again)

Using the base tag on a page that contains SVG elements fails to render and it looks like a black box. Just remove the base-href tag from the <head /> and the issue has been solved.

black box

See: #93 / 109

Browser supports SVG-Animate

Old browsers don't support animation in SVG (compatibility list), and if your project must support IE, for examples, here's a couple of ways to make sure that browser supports SVG Animate:

  • window.SVGAnimateElement
  • document.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#SVG-Animation", "1.1")
  • Or even use https://modernizr.com/

Similar packages


Development

Fork the repo and then clone it

$ git clone git@github.com:YourUsername/react-content-loader.git && cd react-content-loader

$ npm i: Install the dependencies;

$ npm run build: Build to production;

$ npm run dev: Run the Storybook to see your changes;

$ npm run test: Run all tests: type checking, unit tests on web and native;

$ npm run test:watch: Watch unit tests;

React Native

As React Native doesn't support symbolic links (to link the dependency to another folder) and as there is no playground to check your contributions (like storybook), this is recommended strategy to run the project locally:

  1. Create a new React Native from scratch, either Metro or create-react-native-app;
  2. Install the dependency to your root project: yarn add react-content-loader react-native-svg
  3. Open the project just created and clone this repository there;
  4. Create your loading component and point the react-content-loader to the project just cloned, like: import ContentLoader, { Rect, Circle } from './react-content-loader/native'

Commit messages

Commit messages should follow the commit message convention so, changelogs could be generated automatically by that. Commit messages are validated automatically upon commit. If you aren't familiar with the commit message convention, you can use yarn commit (or npm run commit) instead of git commit, which provides an interactive CLI for generating proper commit messages.

License

MIT