On this article, we’ll current a complete set of suggestions and methods designed to empower builders in optimizing their React Native purposes, elevating them to peak efficiency, and delivering an unparalleled consumer expertise.

Maximizing the efficiency of React Native purposes is essential for guaranteeing a seamless and environment friendly consumer expertise. Sadly, many builders overlook the importance of efficiency optimization, usually prioritizing the performance of their code with out contemplating its influence on pace and responsiveness.

What units distinctive builders aside is their skill to method coding with a aware consideration of efficiency implications.

Desk of Contents

Stability Animations between the JS Thread and the Major Thread

In any software, animation is a demanding activity, and this holds true for React Native as nicely.

React Native operates with two foremost threads: the JS thread for executing JavaScript code, and the principle thread, which is primarily answerable for rendering the consumer interface and responding to consumer enter.

Animations usually run on the principle thread by default. Nevertheless, a heavy animation workload on the principle thread can result in efficiency points, resembling dropped frames.

Let’s contemplate a situation the place you’ve got a React Native software displaying a draggable aspect on the display screen (resembling a draggable ball). The consumer can drag this aspect across the display screen utilizing contact gestures, and also you goal to animate its motion easily.

Within the above situation, once you drag the ball across the display screen, the principle thread might be busy gathering consumer touches. If we execute animations on the principle thread, it’ll burden it additional. The outcome will seemingly be dropped frames and efficiency points. In such situations, we will shift the animation activity on the JS thread through the use of the options mentioned under.

Answer 1: Attempt utilizing useNativeDriver

useNativeDriver is a React Native animation property that you should use when animating components in your React Native software.

When the consumer units this property’s worth to true, the React Native software will render the animation on the principle thread. Nevertheless, if the principle thread is anticipated to be busy with another activity, you’ll be able to shift the animation to the JS thread by setting useNativeDriver: false.


Animated.timing(this.state.animatedValue, {
  toValue: 1,
  period: 500,
  useNativeDriver: false, 

Within the code above, React Native will examine the useNativeDriver worth and it’ll shift the animation to the JS thread.

You may be taught extra about animation here.

Answer 2: Use InteractionManager

There might be situations the place each the JS thread and the principle thread might be busy. For instance, the appliance could also be fetching API information, performing some logic, and rendering it on the UI.

On this state of affairs, the JS thread is occupied with fetching the information and performing logic, whereas the principle thread is busy displaying the UI. When each threads are engaged, trying to run animations can lead to dropped frames and efficiency points.

In such instances, InteractionManager might be utilized. You provoke the animation first. As soon as the animation is accomplished, React Native will name InteractionManager.runAfterInteractions to execute JS code. The JS code will then name the API and show information on the UI.

This method helps keep away from overloading the JS thread with simultaneous execution of JS code and animations.


InteractionManager.runAfterInteractions(() => {

Keep away from Pointless Re-rendering

Avoiding pointless re-renderings in React Native is essential for sustaining optimum efficiency. Each time the app re-renders, the JS thread creates a JS bundle file and passes it by way of the React Native bridge, which then fingers it over to the principle thread.

The extra the appliance re-renders, the extra passes happen between the JS thread and the principle thread, which may degrade the appliance’s efficiency.

Answer 1: Memoize the part

React.memo is a higher-order part supplied by React that’s used for optimizing practical elements by stopping pointless re-renders.

While you wrap a practical part with React.memo, React will memoize the part, that means it’ll solely re-render the part if its props have modified. If the props stay the identical between renders, React will reuse the beforehand rendered outcome, thus avoiding the price of rendering the part once more.


const MyComponent = React.memo((props) => {

Answer 2: Study to make use of useCallback operate correctly

When a mother or father part units a callback operate for its baby part, every time the mother or father part re-renders, the callback operate can also be recreated, leading to a brand new operate reference being returned.

Consequently, the kid part perceives this as a change within the callback operate’s worth, prompting it to re-render, even when React.memo is utilized. Subsequently, the kid part will certainly re-render.

To mitigate this, make the most of useCallback to forestall the recreation of the operate reference on each re-render of the mother or father part.

If you wish to use a callback operate with new state values, the operate must be recreated. To recreate the operate with up to date state values, you’ll be able to make the most of the dependency part in useCallback.

By including state values to the dependency array, as demonstrated within the instance code under, useCallback will recreate the operate solely when the state worth modifications. Consequently, you’ll get hold of a brand new operate reference and up to date values because of this.


const memoizedCallback = useCallback(() => {
}, [dependency]);

Answer 3: Attempt to keep away from updating the native state with Redux state

Updating the state with Redux information can lead to the part rendering twice: first when the Redux information is up to date, and once more when the native state is up to date with Redux state.

By following this method, we will keep away from pointless re-rendering of the part. Subsequently, attempt to chorus from updating the native state with Redux-updated retailer information.

As an alternative, make the most of Redux retailer values instantly within the UI. If calculations are obligatory earlier than displaying any Redux information initially, then solely use the part state with the Redux state.

Answer 4: Memoize the operate outcome

Memoize the operate outcome with useMemo. This can execute the operate and retailer the worth in reminiscence.

When the app calls the operate once more, it retrieves the information from the memoized storage as an alternative of executing the whole operate repeatedly. You may add dependencies to re-execute the operate and retailer a brand new outcome.


const handleClick = useMemo(() => {
}, [dependency]);

Answer 5: Keep away from inline capabilities

Keep away from utilizing inline capabilities. As an alternative, use arrow capabilities with useCallback and useMemo to forestall pointless re-rendering.

When a mother or father part re-renders, capabilities are additionally recreated with new references. If we move any operate as a prop to a baby part, the kid part will even re-render.

To beat this drawback, we will use the useCallback operate to forestall operate recreation.

Moreover, through the use of useMemo, we will keep away from re-rendering the kid part.

Additionally, through the use of named capabilities as an alternative of inline capabilities, your code turns into extra readable and maintainable.


<Textual content onPress={() => pressed()}>Press Me</Textual content> 
<Textual content onPress={pressed}>Press Me</Textual content> 

The really useful instance above will instantly name the operate as an alternative of making yet another operate.

Optimizing Photographs

Optimizing pictures can enhance app efficiency. We are able to make the most of the react-native-compressor npm package deal to scale back the picture measurement for importing and viewing. Moreover, we will use SVG pictures to show icons and different pictures.

Answer 1: Use SVG icons and pictures

SVG information comprise XML code describing picture/icon paths and features. SVG pictures are resolution-independent, permitting them to be scaled to any measurement with out dropping readability.

Since SVG pictures are rendered utilizing vector paths somewhat than pixel information, they sometimes eat much less reminiscence when rendered within the software. This will result in improved picture load efficiency, particularly on units with restricted reminiscence assets.

SVG information are likely to have smaller file sizes than raster picture codecs like PNG or JPEG, particularly for easy or geometric graphics. This ends in quicker obtain occasions and reduces the general reminiscence footprint of the appliance.

Answer 2: Use WebP picture for lossless picture high quality

WebP is a contemporary picture format developed by Google that effectively reduces picture measurement with out compromising high quality. WebP pictures are smaller in measurement but preserve good high quality, enabling quicker show on screens.

Answer 3: Cache pictures to render quicker

Make the most of caching mechanisms to retailer beforehand loaded pictures, lowering the necessity to fetch pictures from the community repeatedly. You may cache URL pictures utilizing the react-native-fast-image npm package deal. This library will show cached pictures instantly on the display screen.

Use Secure NPM Packages

Go for smaller-sized and extra secure npm packages. These packages not solely cut back the dimensions of your React Native software but in addition guarantee effectivity as a result of their secure codebase.

In an effort to determine the appropriate package deal in your performance, contemplate the next factors from the npm web site:

  1. Examine various kinds of npm packages with the identical performance.
  2. Verify the weekly downloads of the npm package deal. A package deal with extra weekly downloads is preferable.
  3. Verify the npm package deal measurement. A package deal with a smaller measurement will occupy much less area within the mission, thus lowering the mission measurement.
  4. Verify the variety of releases. A better variety of releases signifies lively upkeep by builders.
  5. Verify the final replace. This helps decide whether or not the package deal remains to be being maintained by somebody.

Following these factors will help in deciding on the appropriate npm package deal.

Use Stylesheet to the Part

Using the StyleSheet module to model elements provides the benefit of making an object solely in the course of the preliminary name. Subsequent calls will reuse the already created model object reference. This method helps cut back the creation of fashion objects for each re-rendering.

Use Flatlist for Efficiency

Use FlatList to render arrays of things as an alternative of utilizing ScrollView with the map operate. FlatList solely renders the objects which might be at present seen on the display screen, which helps optimize the code by rendering solely the mandatory objects.

Keep away from Reminiscence Leaking

A reminiscence leak is a state of affairs the place this system doesn’t launch reminiscence (RAM) that it has allotted however is not utilizing.

Over time, if reminiscence leaks aren’t addressed, they will result in this system consuming an increasing number of reminiscence, ultimately inflicting it to decelerate and even crash as a result of operating out of obtainable reminiscence.

We are able to use profiling instruments in Android Studio and iOS Xcode to detect reminiscence leaks. These instruments assist determine areas the place reminiscence consumption is rising, though pinpointing the precise causes might be difficult. Detecting reminiscence leaks in an app might be tough, so it’s finest to maintain the above factors in thoughts to forestall reminiscence leak points.

After we register any timers, listeners, or subscriptions, it’s vital to unregister them throughout part unmount. In any other case, these timers, listeners, or subscriptions will proceed to name occasions even when we’re not on these elements, resulting in elevated unused reminiscence.


useEffect(() => {
  const handleAppStateChange = (nextAppState: AppStateStatus) => {
    console.log("App state modified to:", nextAppState);
  AppState.addEventListener("change", handleAppStateChange);
  return () => {
    AppState.removeEventListener("change", handleAppStateChange);
}, []);

Answer 2: Keep away from utilizing international variables unnecessarily

International variables persist so long as the app is operating, as a result of they’re accessible from anyplace within the app’s scope. In consequence, the rubbish collector interprets them as nonetheless in use and doesn’t deallocate them.

Answer 3: Round object references

Creating object references the place two objects are pointing to one another will stop rubbish assortment, as a result of the rubbish collector assumes the objects are nonetheless in use.


const person1 = {
  identify: "Alice",
  buddy: person2,

const person2 = {
  identify: "Bob",
  buddy: person1,

Debugging itself is primarily centered on figuring out and resolving points inside an software’s codebase somewhat than instantly bettering efficiency. Nevertheless, by way of the method of debugging, builders could determine and tackle performance-related points resembling inefficient algorithms, extreme re-renders, or reminiscence leaks, which may in the end result in efficiency enhancements.

Debugging and efficiency monitoring are essential points of growing React Native purposes to make sure easy and environment friendly consumer experiences. Beneath, I’ll point out some instruments for debugging and efficiency monitoring.

1. Profiling instruments

Use profiling instruments supplied by platforms like Android Studio Profiler for Android and Xcode Devices for iOS. These instruments supply insights into CPU utilization, reminiscence allocation, community requests, and different efficiency metrics. You may observe the under steps to open the profiler in each Android Studio and Xcode.

Notice: figuring out reminiscence leaks just isn’t all the time simple, however these instruments might help analyze potential points within the code.

Android Studio

Open Android Studio > View > Instrument Home windows > Profiler.

The Profiler window will show CPU and Reminiscence utilization. Attempt accessing completely different screens within the app and observe the Profiler window to determine which display screen makes use of excessive CPU and reminiscence assets. Then you’ll be able to examine the code and logs to repair any points.


Open Xcode > Xcode menu > Developer Instrument > Devices.

As soon as Devices is chosen, a brand new popup window will seem, providing a number of choices resembling Exercise Monitor, CPU Profiler, Leaks, and so forth. If you wish to examine for reminiscence leaks, click on on the Leaks possibility. Right here you’ll discover an exercise graph together with logs.

2. Chrome’s DevTools

Chrome’s DevTools is a generally used software for debugging React Native purposes. Though primarily designed for debugging internet apps, its JavaScript capabilities enable for debugging React Native purposes as nicely. It lets you examine community exercise, reminiscence utilization, and JavaScript efficiency.

To apply it to Home windows, press CTRL + M, and on macOS, press Command + R. In the event you’re utilizing a Bodily gadget, then you’ll be able to shake the cell gadget to open the window in your cellphone.

Notice: if you happen to’re utilizing React Native 0.73 or later, you’ll be able to’t use it as a result of it’s deprecated.

If you wish to be taught extra about Chrome’s DevTools, try our browser DevTools secrets article.

3. React DevTools

React DevTools lets you examine the props and state of particular person elements in your React Native software. By monitoring modifications in props and state, you’ll be able to determine potential efficiency bottlenecks.

React DevTools offers insights into part re-renders, permitting you to determine elements which might be re-rendering unnecessarily and optimizing them for higher efficiency.

Whereas React DevTools doesn’t supply built-in efficiency profiling particularly tailor-made for React Native, you’ll be able to nonetheless use it together with different profiling instruments like Chrome DevTools or Xcode Devices to observe efficiency metrics resembling rendering occasions, CPU utilization, and reminiscence allocation.

You may run the npx react-devtools command to open React DevTools.

Yow will discover out much more about React DevTools here.

4. Flipper

Flipper is a strong debugging software developed by Fb that helps React Native. It provides numerous plugins for inspecting community requests, database queries, and UI rendering efficiency.

The Format Inspector plugin in Flipper lets you visualize and examine the hierarchy of React Native elements.

5. React Native Efficiency Monitor

It is a built-in efficiency monitoring software supplied by React Native itself. It lets you monitor numerous efficiency metrics resembling FPS (frames per second), CPU utilization, reminiscence utilization, and community requests instantly inside your app.

To apply it to Home windows, press CTRL + M, and on macOS, press Command + R. You’re going to get the present per monitor possibility.

If you wish to know extra, you’ll be able to go to the React Native Official website.

Take away Console Logs

Console logs can decelerate app efficiency by printing logs to the console. Subsequently, it’s advisable to keep away from utilizing console logs in manufacturing.

Answer 1: Use _DEV_ international variable

Use the next code in a utility file and reuse it in all places. This code will execute console.log solely in growth mode with the assistance of _DEV_, however keep away from it in manufacturing mode.


const logger ={
    log: __DEV__ ? console.log : ()=>{},
    error:__DEV__ ? console.error : ()=>{}
logger.log(“show values†,information);

On this code snippet, logger.log and logger.error will respectively use console.log and console.error provided that _DEV_ evaluates to true, indicating that the appliance is operating in growth mode. In any other case, they are going to be set to empty capabilities, guaranteeing that they haven’t any impact in manufacturing mode.

Use babel-plugin-transform-remove-console

The babel-plugin-transform-remove-console plugin removes console.log within the manufacturing construct. This ends in higher efficiency in your software in manufacturing mode.

There are numerous instruments accessible within the React Native ecosystem for debugging and efficiency monitoring, together with Reactotron, Firebase Performance Monitoring, and extra. Explaining all these instruments intimately would make the article longer. Subsequently, you’ll be able to deal with utilizing any one of many above instruments to determine and tackle points.


In conclusion, optimizing React Native app efficiency is essential for a seamless consumer expertise. By balancing animations, minimizing re-rendering, optimizing pictures, and utilizing secure npm packages, builders can improve app pace and responsiveness.

Moreover, leveraging environment friendly debugging instruments and eradicating pointless console logs additional improves efficiency.

Prioritizing these optimization strategies ensures peak efficiency and superior consumer satisfaction in as we speak’s aggressive app market.