Lessons Learnt While Creating a New Framework on Top of React

This ad is not shown to multipass and full ticket holders
JSNation US
JSNation US 2025
November 17 - 20, 2025
New York, US & Online
See JS stars in the US biggest planetarium
Learn More
In partnership with Focus Reactive
Upcoming event
JSNation US 2025
JSNation US 2025
November 17 - 20, 2025. New York, US & Online
Learn more
Bookmark
Slides
Rate this content

React is so powerful that it can be used for more than frontend development. E.g. creating UI programmatically in the backend using a rule-based system or machine learning is another use case where React can serve as the best fit. Similarly, documentation earlier used to have only .md files but now it also includes .mdx file that contains React code. To fulfill such use cases, developers need to understand the internals of React and the tooling around it. Some great sources are popular codebases such as create-react-app, Next.js, etc. In this talk, I will share the lessons we learnt while creating a framework that achieves more than web development using React. Firstly, I will cover how create-react-app codebase is the best codebase to understand how webpack, babel, eslint, typescript etc. can be used alongside React. Secondly, I will share how Next.js teaches us to create a js framework where we can write backend and frontend in the same file and still be able to separate the two during calls. Thirdly, I will share how our framework supports plugins, i.e. the React code resides in multiple repositories but all of this code can share a single React runtime inside the browser. This is a very advanced use of React that cannot be achieved by code splitting using React.lazy. This talk will enable developers to use React for more than frontend development.

This talk has been presented at React Advanced 2022, check out the latest edition of this React Conference.

FAQ

JSX is primarily used in React to generate HTML. Beyond web development, it serves similar functions to SSG and SSR, and it has been incorporated into programming languages like Go and Python to enhance their syntax.

Apart from traditional UI development, React has been used for tasks like synthesizing music and creating content by combining markdown files with React code, as seen in frameworks like DocuSource.

The framework manages various JavaScript and TypeScript syntaxes using compilers, transpilers, formatters, and linters, ensuring smooth import and usage of different file types like images and SVGs as React components.

Webpack is crucial in Shyam's framework for managing resources, offering features like the 'resource query' to enhance developer tools like intellisense and build-time checks.

Choosing the right bundler and build tools involves considering the specific requirements of the framework, such as whether the tooling needs to support code mods, which might lead one to prefer Babel over ESBuild due to its AST manipulation capabilities.

Shyam's framework supports server-side rendering by accommodating React in both browsers and Node.js environments, which is essential for most modern web frameworks.

Shyam Swaroop is the co-founder and CTO of Atrilabs, responsible for creating a new full stack framework that enables developers to build frontends using React.

Shyam was motivated by React's design philosophy to create a framework that enhances developer productivity. The foundational tools for his framework included bundlers and transpilers.

Shyam Swaroop
Shyam Swaroop
20 min
24 Oct, 2022

Comments

Sign in or register to post your comment.
Video Summary and Transcription
React is a versatile tool that goes beyond front-end development and can be used for synthesizing music. Creating a specialized framework with React requires understanding the tooling ecosystem and React's design philosophy. Examining good codebases like createreactapp can accelerate development. Handling side effects and module replacement can be achieved through techniques like dead code elimination and hot module replacement. Maintaining component state and implementing hot module replacement are important considerations for a React application.

1. Introduction to React and Its Applications

Short description:

Hello everyone, I'm thankful to React Advanced London team for inviting me to share what I have learned while creating a new full stack framework. A bit about me, my name is Shyam Swaroop and I am the co-founder and CTO of Atrilabs. I have been using React for now more than a year, and it has become one of the go-to choices for generating HTML. React goes beyond just front-end development. We are mixing plain content in markdown files with react code for writing content. React Native was used to create native mobile apps for Androids and iOS. React Reconciler can be adapted for rendering UI on any device. I recently came across a very interesting use case that does not involve rendering UI, but rather synthesizing music by writing React code.

Hello everyone, I'm thankful to React Advanced London team for inviting me to share what I have learned while creating a new full stack framework that allows developers to write React code to build frontends.

A bit about me, my name is Shyam Swaroop and I am the co-founder and CTO of Atrilabs, a company that is building an exciting new full stack framework. I was pursuing Masters from Columbia University, then I dropped out and started working on my own startup.

I have been using React for now more than a year, I was more of an Angular person before that. We can find the use of JSX beyond just web development. It has become one of the go-to choices for generating HTML, a use case very similar to SSG, SSR, or you can say a replacement for template engines. Some projects have extended grammar of languages like Go and Python to include JSX.

React goes beyond just front-end development. We are mixing plain content in markdown files with react code for writing content. This has given rise to frameworks that specialize in specific tasks like documentation. A popular example would be DocuSource. React Native was used to create native mobile apps for Androids and iOS. There are few frameworks that can be used to create native Windows or MacOS apps using React. React Reconciler can be adapted for rendering UI on any device. I recently came across a very interesting use case that does not involve rendering UI, but rather synthesizing music by writing React code. I remember the power I felt when I learned React or Bison, where you just write a context-free grammar and it generates the parser. Since I knew how to create parsers easily, I was able to innovate fast in many scenarios.

2. Creating a Specialized Framework with React

Short description:

Now that I know React and the tools to handle a React code base, I can easily create a specialized framework to enhance developer productivity. Understanding the tooling ecosystem and React's design philosophy were crucial in defining the framework's philosophies. Tools like compilers, transpilers, bundlers, and linters enable handling different JavaScript syntax and importing non-JavaScript typescript files. Supporting React in both browsers and Node.js requires realizing the difference between module types. Choosing the right bundler and build tools depends on your requirements, such as code mods. We use Webpack and Babel together, leveraging Webpack's resource query feature for better intellisense and build time checks.

This is how I feel now with web development, because now that I know the React and tools to handle a React code base, I can easily create a very specialized framework that can enhance the developer productivity of a web developer team.

We have seen quite a few frameworks on top of React and all of these innovate and differentiate in their offerings for developers. It wasn't easy to reach this comfort level. When I decided to create a full stack framework, it took me more than a month to just understand the tooling ecosystem around React or JavaScript type script in general. This was even harder because I had to dive a bit into the history of JavaScript type script and how they came to be. I landed upon React's design philosophy which motivated me to write down philosophies for the framework.

It has really helped me in deciding two major categories of tools that our framework should use. Those are bundler and transpiler. More on this later. Once we had pinned these down, then only we can move to development of the framework. When we think of a framework, we quickly start to think that they provide abstraction, helper functions, components, server side rendering, server side generation, etc. We take many other things for granted. For example, how are we handling different JavaScript syntax and type script all in one code base? How are we able to import non-JavaScript typescript files in JavaScript typescript files? For example, we import image files as string URLs, and VG as React components, etc. These have become the de facto standards for a good developer experience in any framework.

This is made possible by tools like compilers, transpilers, bundlers, formatters, and linters. Rendering on the server side is a common requirement for most of the frameworks, if not all. Hence, our framework has to support React in both browsers and Node.js. In other words, it becomes crucial to realize the difference between different module types, especially ECMAScript and common.js. When we think about what bundler and build tools to use, we mostly think in terms of how fast they run. But as a framework creator, you might have to think more about your requirements. For example, if the developer's experience entails code mods, then you might prefer something like Babel over ESBuild because Babel exposes AST to load as plugins, while ESBuild doesn't. We're using Webpack and Babel together at a 3 framework.

A 3 framework allows developers to write plugins etc. where JavaScript modules are treated as different resources. We needed a way so that one resource can point to another resource. One way could have been that you write the path to a module you want to point as in the first statement you see here. It has several drawbacks. While the developer is writing or typing the code, the developer won't get any intellisense and no checks at build time. To circumvent these, we are using a feature from Webpack called resource query that we can add at the end of the import path as you can see in the second example. In the second example we are able to offer good intellisense and build time checks.

3. Understanding the Create React App Codebase

Short description:

Going through good codebases or frameworks sped up our development. The createreactapp repository and NextGIS repository were helpful starting points. Classifying the packages in createreactapp into three categories: building a CRE application, configuring tools, and generating initial scaffolding. Configuring multiple tools to insert non-JavaScript modules like CSS, SVG, PNG. Handling imports in the bundler, webpack. Understanding the webpack.config.js file and the loaders used by create-react-app. The importance of adding a loader to handle import statements in CSS, such as Sass loader.

Once we have some idea about tools and the ecosystem, going through a few good codebases or frameworks helped us a lot. It speeded up our development where we are able to focus more on our unique offerings than the mundane ones. The best starting point was going through the createreactapp repository, and that's what we are going to look at in detail next. Looking at NextGIS repository is also a good idea.

Before we look into the code of createreactapp, I would like to classify the packages in createreactapp into three categories. Packages that are used to build a CRE application. These are the most important packages to go through. There are a few packages to configure the tools such as transpilers, for example, Babel and the linter such as ESLint. Finally, the packages to generate the initial scaffolding when we run something like NPX Create React App.

An important question is how are we able to insert non JavaScript modules like CSS, SVG, PNG, etc? We need to configure multiple tools to actually be able to achieve this in our We need to add types for non JavaScript files and we need to add types for Node.js namespace. We can do this by creating a TypeScript type declaration file and including it in our tsconfig.json file. Here we see that we are declaring model types for reports sourced and matching different globe patterns. Let's look at the highlighted part. This informs tools like eslint in our code editors that whenever the source string ends with svg, treat the source module as exporting a default string value that will contain the asset url and a React component named export which will be of type react.functional component. We also need to handle these imports in our bundler in our case webpack. More on how to configure webpack to achieve this in a later section.

As mentioned before we use the resource query feature from webpack.export to point to a module. Hence we had to add one more module definition here. Whenever an import source path ends with a question mark id. It will be treated as a module that default exports a string. The entry point to understanding the corrupts of everything that happens when you actually do a build during development or production is the webpack.config.js file. It can be found in React scripts package in create-react-app code base. The create-react-app uses many loaders that run one after the other to process CSS, as we can see here. The webpack will start from a post CSS loader that provides support for mixins, transpile upcoming CSS syntax, and inline images. It has some plugins that help insert vendor prefixes in your CSS. Webpack can handle JavaScript imports by default, but it cannot handle import statements in CSS. For example, when we use import directive in CSS or the URL function in CSS, it uses the CSS loader to resolve them. If you decide to use Sass or CSS, you might have to add a loader to preprocess it. The create react app uses Sass loader. See, we can see that over here, we go into Sass loader.

4. Handling Side Effects and Module Replacement

Short description:

Cid apps handle SVGs using a third-party library called SVGR. Dead code elimination or pre-shaking eliminates unused functions from across the world by starting at the entry point and only including functions that may be executed. To prevent Webpack from traversing further in the dependencies, let it know that no module in this package has any side effects by setting side effects field in package.json as false. Hot module replacement or HMR allows replacing the module containing the dialog box component during runtime and React's Fast Refresh plugin handles reapplying the state of the app once the module has reloaded.

Cid apps handle SVGs using a third-party library called SVGR. This is different than handling other assets which are directly handled by webpack like this. Here we can see side effects. What does this mean? How does it affect the final bundle? This brings us to the next topic dead code elimination or pre-shaking. The bundle optimization techniques such as dead code elimination and mangling are activated by default in production mode. If we are not in production mode but we still want to have any of these optimization benefits, then we will have to import optimization plugins on our own.

Pre-shaking eliminates unused functions from across the world by starting at the entry point and only including functions that may be executed. React's higher order components make it harder for Tercer to pre-shake dead code. For pre-shaking to work, we have to use ES 2015 or ES6 module syntax that is import and export. We have to ensure that no compilers or loaders or plugins transform our ES6 and above syntax code into CommonJS module. Just as a precaution, if you are using Babel and you use Babel's Preset env, you might have to configure it so that it does not convert the ES6 modules to CommonJS which is its default behavior.

Coming back to where we left in the code, the Tercive will detect CSS imports as unused, hence it will try to remove them. To prevent it we need to set side effects field in Webpack as true. Let's look at how Tree Seeking works in Webpack with an example. In this example, the index file imports wrap-button, but does not use it. Webpack's Tercer plugin, tries to figure out if it can drop some code from this file. But it might not be able to figure it out if button-wrapper function call has some side effects or not. A side effect might be something like changing a value on window object or any other global variable. The highlighted code will be eliminated once we have added a comment like this, which says Pure. But there are still questions with the imports which need to be included or evaluated because they could contain side effects. In other words Webpack will traverse the dependencies in this module and figure out if imported modules have any side effects. This will hurt bundle time and bundle size. One way to prevent this is by letting Webpack know that no module in this package has any side effects by setting side effects field in package.json as false.

Imagine we are developing a dialog box that opens up after we click through a few buttons. We have to change the app's state to finally open that dialog box. It becomes time-consuming and annoying for frontend developers to open the dialog box after every change they make to that dialog box component. The solution is to somehow replace the module containing the dialog box component during runtime and this is commonly referred to as hot module replacement or HMR. In React's context, a question arises. How do we maintain the state of the component after the module containing this component has been replaced? React's Fast Refresh plugin handles reapplying the state of the app once the module has reloaded.

5. Maintaining Component State and Implementing HMR

Short description:

React's Fast Refresh plugin handles reapplying the state of the app once the module has reloaded. We use the React Refresh Babel plugin to handle this. To decide whether to hot replace the module or full-page reload, we can implement checks such as requiring all imports from the module to be a React component. Implementing HMR for React is easy with bundlers like Webpack. Adding a Babel loader and including the React refresh Webpack plugin are the steps to enable HMR. HMR for CSS files can be achieved by replacing them with JavaScript modules using a plugin like tile loader in webpack.

How do we maintain the state of the component after the module containing this component has been replaced? React's Fast Refresh plugin handles reapplying the state of the app once the module has reloaded. It needs to inject some code into each module to accomplish this. We use the React Refresh Babel plugin to actually handle this for us.

How do we decide whether the changes made in the module should trigger a full-page reload or a hot module replacement? To decide whether to hot replace the module or full-page reload, we can implement some checks on the module such as all the imports from the module must be a React component for the module to be eligible for HMR. Thankfully implementing HR for React is quite easy with bundlers like Webpack. Module bundlers like Webpack and Ruler have exposed HMR API that can be implemented on a module. Let's look into the code.

Here we are adding a Babel loader that will run for all JavaScript and TypeScript modules outside Node modules. And the second and the final step is to include the React refresh Webpack plugin in the Webpack config. How do we do HMR for CSS and other similar files? During development, a plugin can replace CSS files with JavaScript modules. This makes it possible to hot reload the JavaScript modules in order to emulate HMR for the CSS files. In webpack, we can use tile loader to achieve this. If you are interested in creating a full-stack framework, you can check out our open source repo here. You can find me on social with this handle.

Check out more articles and videos

We constantly think of articles and videos that might spark Git people interest / skill us up or help building a stellar career

A Guide to React Rendering Behavior
React Advanced 2022React Advanced 2022
25 min
A Guide to React Rendering Behavior
Top Content
This transcription provides a brief guide to React rendering behavior. It explains the process of rendering, comparing new and old elements, and the importance of pure rendering without side effects. It also covers topics such as batching and double rendering, optimizing rendering and using context and Redux in React. Overall, it offers valuable insights for developers looking to understand and optimize React rendering.
Building Better Websites with Remix
React Summit Remote Edition 2021React Summit Remote Edition 2021
33 min
Building Better Websites with Remix
Top Content
Remix is a web framework built on React Router that focuses on web fundamentals, accessibility, performance, and flexibility. It delivers real HTML and SEO benefits, and allows for automatic updating of meta tags and styles. It provides features like login functionality, session management, and error handling. Remix is a server-rendered framework that can enhance sites with JavaScript but doesn't require it for basic functionality. It aims to create quality HTML-driven documents and is flexible for use with different web technologies and stacks.
React Compiler - Understanding Idiomatic React (React Forget)
React Advanced 2023React Advanced 2023
33 min
React Compiler - Understanding Idiomatic React (React Forget)
Top Content
Watch video: React Compiler - Understanding Idiomatic React (React Forget)
Joe Savona
Mofei Zhang
2 authors
The Talk discusses React Forget, a compiler built at Meta that aims to optimize client-side React development. It explores the use of memoization to improve performance and the vision of Forget to automatically determine dependencies at build time. Forget is named with an F-word pun and has the potential to optimize server builds and enable dead code elimination. The team plans to make Forget open-source and is focused on ensuring its quality before release.
Using useEffect Effectively
React Advanced 2022React Advanced 2022
30 min
Using useEffect Effectively
Top Content
Today's Talk explores the use of the useEffect hook in React development, covering topics such as fetching data, handling race conditions and cleanup, and optimizing performance. It also discusses the correct use of useEffect in React 18, the distinction between Activity Effects and Action Effects, and the potential misuse of useEffect. The Talk highlights the benefits of using useQuery or SWR for data fetching, the problems with using useEffect for initializing global singletons, and the use of state machines for handling effects. The speaker also recommends exploring the beta React docs and using tools like the stately.ai editor for visualizing state machines.
Speeding Up Your React App With Less JavaScript
React Summit 2023React Summit 2023
32 min
Speeding Up Your React App With Less JavaScript
Top Content
Watch video: Speeding Up Your React App With Less JavaScript
Mishko, the creator of Angular and AngularJS, discusses the challenges of website performance and JavaScript hydration. He explains the differences between client-side and server-side rendering and introduces Quik as a solution for efficient component hydration. Mishko demonstrates examples of state management and intercommunication using Quik. He highlights the performance benefits of using Quik with React and emphasizes the importance of reducing JavaScript size for better performance. Finally, he mentions the use of QUIC in both MPA and SPA applications for improved startup performance.
Full Stack Documentation
JSNation 2022JSNation 2022
28 min
Full Stack Documentation
Top Content
The Talk discusses the shift to full-stack frameworks and the challenges of full-stack documentation. It highlights the power of interactive tutorials and the importance of user testing in software development. The Talk also introduces learn.svelte.dev, a platform for learning full-stack tools, and discusses the roadmap for SvelteKit and its documentation.

Workshops on related topic

React Performance Debugging Masterclass
React Summit 2023React Summit 2023
170 min
React Performance Debugging Masterclass
Top Content
Featured Workshop
Ivan Akulov
Ivan Akulov
Ivan’s first attempts at performance debugging were chaotic. He would see a slow interaction, try a random optimization, see that it didn't help, and keep trying other optimizations until he found the right one (or gave up).
Back then, Ivan didn’t know how to use performance devtools well. He would do a recording in Chrome DevTools or React Profiler, poke around it, try clicking random things, and then close it in frustration a few minutes later. Now, Ivan knows exactly where and what to look for. And in this workshop, Ivan will teach you that too.
Here’s how this is going to work. We’ll take a slow app → debug it (using tools like Chrome DevTools, React Profiler, and why-did-you-render) → pinpoint the bottleneck → and then repeat, several times more. We won’t talk about the solutions (in 90% of the cases, it’s just the ol’ regular useMemo() or memo()). But we’ll talk about everything that comes before – and learn how to analyze any React performance problem, step by step.
(Note: This workshop is best suited for engineers who are already familiar with how useMemo() and memo() work – but want to get better at using the performance tools around React. Also, we’ll be covering interaction performance, not load speed, so you won’t hear a word about Lighthouse 🤐)
Next.js for React.js Developers
React Day Berlin 2023React Day Berlin 2023
157 min
Next.js for React.js Developers
Top Content
Featured WorkshopFree
Adrian Hajdin
Adrian Hajdin
In this advanced Next.js workshop, we will delve into key concepts and techniques that empower React.js developers to harness the full potential of Next.js. We will explore advanced topics and hands-on practices, equipping you with the skills needed to build high-performance web applications and make informed architectural decisions.
By the end of this workshop, you will be able to:1. Understand the benefits of React Server Components and their role in building interactive, server-rendered React applications.2. Differentiate between Edge and Node.js runtime in Next.js and know when to use each based on your project's requirements.3. Explore advanced Server-Side Rendering (SSR) techniques, including streaming, parallel vs. sequential fetching, and data synchronization.4. Implement caching strategies for enhanced performance and reduced server load in Next.js applications.5. Utilize React Actions to handle complex server mutation.6. Optimize your Next.js applications for SEO, social sharing, and overall performance to improve discoverability and user engagement.
Concurrent Rendering Adventures in React 18
React Advanced 2021React Advanced 2021
132 min
Concurrent Rendering Adventures in React 18
Top Content
Featured Workshop
Maurice de Beijer
Maurice de Beijer
With the release of React 18 we finally get the long awaited concurrent rendering. But how is that going to affect your application? What are the benefits of concurrent rendering in React? What do you need to do to switch to concurrent rendering when you upgrade to React 18? And what if you don’t want or can’t use concurrent rendering yet?

There are some behavior changes you need to be aware of! In this workshop we will cover all of those subjects and more.

Join me with your laptop in this interactive workshop. You will see how easy it is to switch to concurrent rendering in your React application. You will learn all about concurrent rendering, SuspenseList, the startTransition API and more.
React Hooks Tips Only the Pros Know
React Summit Remote Edition 2021React Summit Remote Edition 2021
177 min
React Hooks Tips Only the Pros Know
Top Content
Featured Workshop
Maurice de Beijer
Maurice de Beijer
The addition of the hooks API to React was quite a major change. Before hooks most components had to be class based. Now, with hooks, these are often much simpler functional components. Hooks can be really simple to use. Almost deceptively simple. Because there are still plenty of ways you can mess up with hooks. And it often turns out there are many ways where you can improve your components a better understanding of how each React hook can be used.You will learn all about the pros and cons of the various hooks. You will learn when to use useState() versus useReducer(). We will look at using useContext() efficiently. You will see when to use useLayoutEffect() and when useEffect() is better.
Introducing FlashList: Let's build a performant React Native list all together
React Advanced 2022React Advanced 2022
81 min
Introducing FlashList: Let's build a performant React Native list all together
Top Content
Featured Workshop
David Cortés Fulla
Marek Fořt
Talha Naqvi
3 authors
In this workshop you’ll learn why we created FlashList at Shopify and how you can use it in your code today. We will show you how to take a list that is not performant in FlatList and make it performant using FlashList with minimum effort. We will use tools like Flipper, our own benchmarking code, and teach you how the FlashList API can cover more complex use cases and still keep a top-notch performance.You will know:- Quick presentation about what FlashList, why we built, etc.- Migrating from FlatList to FlashList- Teaching how to write a performant list- Utilizing the tools provided by FlashList library (mainly the useBenchmark hook)- Using the Flipper plugins (flame graph, our lists profiler, UI & JS FPS profiler, etc.)- Optimizing performance of FlashList by using more advanced props like `getType`- 5-6 sample tasks where we’ll uncover and fix issues together- Q&A with Shopify team
React, TypeScript, and TDD
React Advanced 2021React Advanced 2021
174 min
React, TypeScript, and TDD
Top Content
Featured Workshop
Paul Everitt
Paul Everitt
ReactJS is wildly popular and thus wildly supported. TypeScript is increasingly popular, and thus increasingly supported.

The two together? Not as much. Given that they both change quickly, it's hard to find accurate learning materials.

React+TypeScript, with JetBrains IDEs? That three-part combination is the topic of this series. We'll show a little about a lot. Meaning, the key steps to getting productive, in the IDE, for React projects using TypeScript. Along the way we'll show test-driven development and emphasize tips-and-tricks in the IDE.