The State of React

Hi, everybody. Welcome to today's presentation about the latest results from the State of React survey. Now, the latest survey ran in October of 2024, and the results were published in early 2025. And by the way, one thing I want to mention is this is a community survey. It's unofficial, so it's not affiliated with the React team or Meta or Vercel or anybody. But hopefully, it's still interesting. And another thing is that to sign up for the next survey, you can go to stateofreact.com. The next survey will take place in September 2025. And if you want to follow along with the data I'm going to present today, you can go to 2024.stateofreact.com.

Now, before I talk about the State of React survey, I want to give you a little bit of context because one question that I get a lot when I talk about these surveys is how I got started, how I decided to start doing developer surveys. We have three main surveys, so stateofjs, CSS, HTML, which get between 5,000 up to 10,000 or sometimes even 20,000 respondents, depending on the year. And it all started back in 2016, which was the beginning of our current modern JavaScript era. At the time, React and Vue were still fairly new. And we had a lot of options.

But at the same time, there weren't really any clear leaders, there weren't any default options to choose from. So people were really struggling with JavaScript fatigue and choice paralysis. And of course, we had data about things like NPM downloads or GitHub stars. But that was kind of a bit rough. We didn't have very detailed insights into those trends because after all, even if React is downloaded a lot and Vue is downloaded a lot less, that doesn't necessarily mean that people are enjoying using React. And on the other hand, maybe the few people who are using Vue, I absolutely love it and things might change eventually. So of course, I'm just using React and Vue as two examples here. But that was really the key insight that pushed me to do the first survey, measuring not just raw data, how many people were using each item, but also what they thought about them, whether they would want to use it again, and even things like which frameworks or libraries people were most interested in learning in the future, with the idea being of capturing those upcoming trends as well. So like I said, it started in 2016, almost 10 years ago now with the state of JS, then came the state of CSS. 2023, I did the first edition of the state of React survey. And then this year, 2025, I added two new surveys, the state of web dev AI and the state of devs.

So let's now move on to the state of React results themselves. And 7,870 respondents to the survey, which is quite a decent sample size. As one might expect, a lot of the respondents came from the US, but also European countries and overall a nice spread of respondents throughout the world.

One thing that's interesting, I think, is looking at years of experience. If you group those first two buckets, you actually see that 59% of respondents have less than 10 years of experience. In other words, they never knew a world where React didn't exist, in terms of them being web developers.

And so maybe for a lot of people taking the survey or even watching this, while React might seem like a very default way of doing things, very obvious. But if you have been around for longer than that, then you remember that when React was first introduced, it was actually quite innovative. Things like JSX, the virtual DOM, and even later on hooks, every time React did things a bit differently from everybody else.

We can also look at job titles. We have a good split between software engineer, developer, front-end developer. But it becomes really interesting when you switch to job titles versus income. Because here, you can see that engineer job titles, senior engineer, front-end engineer, are all at the top, whereas developers, front-end, full stack are at the bottom, with a pretty sizable gap in income between them.

And so, I don't know if this is correlation or causation, but just to be safe, if you're able to, I would recommend updating your resume if you are currently labeling yourself as a developer of some kind, and just replace that with engineer. Who knows, you might get a nice raise for your next position. Moving on to features.

So, let me explain how to read this chart, because I know it can be a lot to take in at first. For example, if we look at create portal here, you'll see that each row is split into three colored bars. The first one, dark blue, corresponds to users who have actually used a feature. Light blue is for users who have heard of a feature but not used it. And finally, gray is for users who haven't even heard of the feature. And then within those bars, you further have a subdivision according to positive sentiment in green and negative sentiment in red.

And then, in the middle, it's just people who didn't submit a sentiment, so who remained neutral. Now, what's cool about this system is you can change the grouping from experience to sentiment, and then you can also sort by, for example, positive sentiment. At the top here, we have things like fragment, create context, use states. In other words, APIs that are fairly straightforward to use, that are well understood, and those are the ones with very little negative sentiment.

But of course, you're probably curious to sort by negative sentiment and see which APIs are the most hated. And no surprise here, but forward ref is first by far.

But of course, you're probably curious to sort by negative sentiment and see which APIs are the most hated. And no surprise here, but forward ref is first by far. And forward ref is actually deprecated going forward in React 19. And so it's nice to see that the React team has already addressed this issue and the fact that forward ref has always been a bit cumbersome to use. Number two is use effect. We actually let respondents submit comments on every feature, and one word that comes back a lot is footgun, as in it's very easy to shoot yourself in the foot with use effect. And so that explains why it's the number two feature with the most negative sentiment. But I do want to point out that even though it has 15% negative sentiment, it has more than double that amount in positive sentiment. And that holds true for all the other features here. So in other words, looked at it collectively, the set of React APIs are actually very well loved by React developers, even though we like to complain. But at the end of the day, if you look at the raw data, I think it points to a very healthy relationship between the developers and React team that are able to listen to our concerns and create APIs that address them.

We can also look at how things have evolved over time. One metric that is kind of interesting is appreciation. What appreciation is is the gap between how many positive sentiment there is among respondents who have only heard of a feature and those who have actually used it. And the reason the chart looks a bit broken here is because we actually have negative values for all the way at the bottom, forward ref. So in other words, people who have never used forward ref may have a bad opinion of it, but people who have actually used it think even less of it and have an even higher proportion of negative sentiment. The other ones that have low appreciation are act, memo, profiler, and it doesn't mean that necessarily there are more negative opinions than positive. All it means is that maybe people initially were interested enough to try the feature, but once they actually tried it, they ran into some edge cases or confusing parts and their overall positivity went down a bit. And I think that can easily happen, especially with new features that aren't maybe that well documented or where it's harder to find examples in the wild. And what's going to be really interesting is seeing how this ratio evolves next year and the year after that. And that's the whole value of doing a recurring survey like that is seeing how the React team is able to address community feedback and evolve the library, which I have to say it's done a pretty good job, I think, up to now.

We can also look at usage for new APIs. So React server components are gaining ground on suspense as well. And if we look at satisfaction, which is positive sentiment among respondents having used a feature, it's actually pretty high for almost every new API. So the only one that's a bit low is the Taint API, maybe because of the name, I don't know. And then server actions, maybe because they are still very new and not that well documented, necessarily. But overall, I would say that all the new APIs recently introduced have been hits with the community, even though, of course, they have their own challenges, which we can see in the pain points. So again, a lot of pain points around forward draft, like we said, memo and act as well, which makes sense. These are new and you need time to assimilate how to use them. And then new APIs against React server components, which I think shows that when you introduce a new API, especially a new paradigm like React server components, of course, it's going to create pain.

But just because you have pain doesn't mean that the community is going to reject the feature. It's just part of evolving alongside with the framework. Moving on to libraries. Now, one thing you'll notice here is that the first two items are not actually libraries, useState and fetch. The reason they're included here is just as a point of comparison, for example, with useState state management libraries and for fetch data loading libraries. But we can go ahead and look at positive sentiment. Number one is useState. Number two, in other words, the first actual library is 10-stack query. That didn't really surprise me because 10-stack products in general seem to be pretty beloved by the community and 10-stack query is actually establishing itself, I think, as one of the main ways of handling data loading in your app. Zeus 10, which is great for state management, and then Next.js. Now, Next.js still has a very high positivity to negativity ratio, even though people love to complain about it. So what's going on here? I think it's natural when you have something as complex as Next.js and also as widely used that on social media, on forums, on Reddit, on YouTube, wherever, people will vent. They will air their complaints. They will share feedback, which can give this appearance of negativity around any project. But I think it's interesting and useful to look at data like this to remind ourselves that there's a big community of just developers quietly using Next.js and sure, we run into issues now and then, but it doesn't mean we don't like the framework and so this is what's shown here, I think. We can also see this confirmed in this quadrant chart. On the bottom axis here, we have user count, and on the left we have retention or satisfaction. Again, the only React library with both high usage and satisfaction is Next.js. The other ones here are not really libraries or something that's not React specific, again, included as a point of comparison. A 10-stack query, though, is very close to crossing over into that over 50% usage quadrant, but for now, at least, it's in the top left quadrant, along with things like Astro, GISTAN, 10-stack start, which is all those things that have very high satisfaction. People love them, but they're not widely used yet. So if you are a more prudent developer, you can wait for things to cross over and become really mainstream before using them. If you're more of an early adopter, you can also experiment with those items here.

Moving on, we can look more specifically at component libraries. Let's go straight to positivity, or let's do satisfaction. Now, I'll switch to the rank view to have a bit clearer picture. Number one is Redux, then we had ShedCNUI, React-Aria, Headless-UI, and Mantine. What's interesting is, with maybe the exception of Mantine, all the other ones are not really traditional component libraries. ShedCNUI lets you copy-paste code snippets. There's no npm package.

And then the other ones are Headless-UI libraries, which means that they give you components that are unstyled. You only have the behavior part of the component. And I think there's a couple of factors for the popularity of these Headless-UI libraries. One, Tailwind actually does a good job of handling styling for you, and making styling more accessible for developers who might struggle with CSS. And the other thing is, if you have built-in styles with something like Material-UI or Bootstrap, overriding those styles and customizing them can be quite tough. It's almost more work to customize those styles compared to simply just writing your own sometimes. So it makes sense that these would be popular, I'm using Redix myself. I think these toggles are Redix, probably.

Now, what else can we look at? Maybe pain points. And again, styling and customization is a big issue, which goes back to the idea of it's good when you are able to customize things to your own needs without struggling too much. Which, again, Headless-UI libraries are great at. Moving on to state management. Now, useState is number one and Zeus10 is number two. If we look at the values, they're very close but useState is at 97% satisfaction and Zeus10, 95%. I think that's very cool that the default option, useState, is actually number one. Like, it's not only competitive with dedicated libraries, but beating them in terms of satisfaction. And it's not always the case with other ecosystems. A lot of the time, the default weight is too limited or frustrating to use, so you have to resort to third-party libraries. But for React, at least, useState, although limited, does provide a good developer experience for most people.

And then, of course, if you do need more power, you can move on to things like Zeus10 or Jotai. But it's nice to see that the defaults do work. We can also look at pain points. Excessive complexity is a big one, which I think is not a surprise for state management. Next up is data loading. Now, like I said, 10-Stack Query is scoring very high. And after that, fetch is the next one. So this is a case, unlike with useState, where although the native browser API also scores high, it doesn't score as high as 10-Stack Query. But again, both are doing fine. Axios is also doing pretty well, and TRPC is also a good choice. If we look at pain points, state management, caching, error handling are the top three, which also all happen to be things that 10-Stack Query helps with, which goes to explain the popularity of that library, I think.

Finally, for libraries, backend and infrastructure, and more specifically, meta frameworks, things like Astro, Next, and so on. Now, number one is Astro in terms of satisfaction. After that, we have, which one is it, 10-Stack Start, which is very new but has very high satisfaction, Remix, DocuZeros, Remix, DocuZeros, and then Next.js, still with high satisfaction. Now, in terms of usage, Create React app might be number one, but Next.js is clear number two. And after that, there's a big gap before Gatsby and Remix and the other ones. One note about Gatsby, it has very low satisfaction because, as far as I know, it's not being very actively developed anymore, and it has its share of issues. But ironically enough, the site that we're looking at right now is a Gatsby site. So, I am using Gatsby, and I think it's still pretty good, it's still pretty powerful. But of course, as the ecosystem evolves, there is a turnover, and now Gatsby seems to be on the way out, while Astro is doing great.

If we look at pain points, interesting to see that end-to-end type safety or the lack thereof is the number one pain point. The reason it's interesting is because this is something that's Next.js, that the leader in this category doesn't really address natively, out of the box, I would say. Whereas other frameworks like TempStack, Start, are built around that concept, or tRPC as well. If this is really such a big pain point, this might prove to be a way that these new entrants can disrupt Next.js. So, we'll see what happens with that next year.

Finally, let's look at how people are actually using React. For example, application patterns, as you can see, the biggest one by far is single-page applications, followed by server-side rendering and static-side generations. All three of those are fairly traditional patterns, I would say. They've been around for a long time. Whereas the other ones, the fancier, more esoteric application architectural patterns, have much lower usage. But, of course, if you go to a conference such as React Summit or if you look at React videos on YouTube, people will often talk about these fancier, more complex patterns, because there's not that much left to say about SPAs or static-sides. On the other hand, you can say a lot about incremental static generation, partial hydration, and so on. But then I think this creates a false impression that the community has already moved on and is now adopting all these new patterns. Whereas the truth is, most developers, including myself, are always lagging a couple of years behind. So, if that's your case, I think there's nothing wrong with that. And I just want to caution against feeling too much FOMO, fear of missing out, just because you are not implementing, whether it's React components or partial hydration or this or that. Actually, I do think even being a couple of years late to the party can be a more productive way to be a developer, because you let others figure out all the edge cases and handle all this complexity. That being said, it doesn't mean you can't still be excited about new features, such as React Compiler, React Server Components, Use Hook. Server Actions score fairly low, even though I think they will be a pretty game-changing feature, or server functions. So, I'm very curious to see how this in particular changes next year. So, there you go.

I think that's a pretty good overview of the state of React, at least in October of last year. Of course, things changed so fast, so we'll take this with a grain of salt. But I just want to leave you with, I guess, two messages. One, as I already mentioned, if you feel like you're behind, don't panic. I think the majority of the community always lags behind a little bit. That's normal. And then also, take a second to appreciate things like JSX, the virtual DOM, useState, all the things that we take for granted. They are actually quite well thought out, I think. And we do have a very good library on our hands.

And then, a third thing maybe, use social media to keep up. But if you see a lot of negativity around something, whether it's a library or a feature, remember that there's kind of a bias here where people will only tweet or go on BlueSky or whatever to only do that when they are actually angry, when they need to vent. So, that's always going to be biased towards negativity. But if you look at actual data, you'll see that things aren't that bad.

So, there you go. Thanks a lot for tuning in today. And I definitely hope you will join us for the next State of React in September 2025. Thank you.