How Bun Makes Building React Apps Simpler & Faster


Bun’s builtin JSX transpiler, hot reloads on the server, JSX prop punning, macro api, automatic package installs, console.log JSX support, 4x faster serverside rendering and more make Bun the best runtime for building React apps

9 min
05 Dec, 2022

AI Generated Video Summary

BUN is a modern all-in-one JavaScript runtime environment that achieves new levels of performance. It includes BUN dev, a fast front-end dev server, BUN install, a speedy package manager, and BUN run, a fast package runner. BUN supports JSX, has optimized React server-side rendering, and offers hot module reloading on the server. The priorities for BUN include stability, node compatibility, documentation improvement, missing features in BUN install, AST plugin API, native Windows support, Bundler and Minifier optimization, and easier deployment to production. BUN's AST plugin API allows for bundle-time JavaScript execution and embedding code, potentially inspiring new frameworks.

1. Introduction to BUN

Short description:

BUN is a modern all-in-one JavaScript runtime environment that starts fast and achieves new levels of performance. It includes BUN dev, a front-end dev server that starts in 4 milliseconds, BUN install, an NPM package manager that installs packages 20 times faster than other clients, and BUN run, an NPM package JSON scripts runner that starts scripts 30 times faster. BUN also supports JSX, has an optimized React server-side render, and offers hot module reloading on the server.

My name's Jared, and I'm going to talk about BUN. BUN is a modern all-in-one JavaScript runtime environment. It's designed to start fast, to achieve new levels of performance, to be a great and complete tool, and to be a drop-in replacement for Node.js.

BUN dev is a front-end dev server that starts in 4 milliseconds. It's a command that's built into BUN. BUN install is an NPM package manager, and it installs NPM packages 20 times faster than any other NPM client that exists today. BUN run is an NPM package JSON scripts runner, and it starts package JSON scripts 30 times faster than NPM.

In BUN v0.3.0, we added automatic NPM package installs to BUN's JavaScript runtime. That means you can just import packages and they install. There's no—you don't have to actually run an install step. This is automatically enabled when you—there is no node modules folder. So it still works with node modules, it just means when you don't have node modules, if you have a quick script that you just want to run and you don't want to have to deal with installing packages, it just works. The other thing that's really interesting about that is you can—you don't—because you don't need a node modules folder, you can just—it saves a lot of disk space and it saves you a lot of time because you don't have to spend this time installing the packages. It uses a shared global cache.

In BUN, JSX is natively supported. There's an automatic JSX slash TypeScript transpiler, JSX is even enabled for .JS files by the way, and you can also have npm packages which use JSX and BUN will just automatically transpile it. You can console.log JSX, you can do JSX prop punting and we have an extremely optimized React server-side render.

This is what it looks like when you console.log a JSX element in BUN. You can see that instead of printing the object representation with the symbols and all that stuff, it actually just pretty prints it like HTML a little bit. You can see it still preserves this is a function, or it highlights the component to be blue instead of green to indicate that it's an element versus a component. And then this is what JSX prop hunting looks like in BOTnets. There's more than one name for this, but the basic idea is that instead of having to type if the property name is the same identifier as the value, you can just emit the value. So that way, it's the equivalent of object destructuring syntax, but for JSX. I don't think there are other tools that support this yet. In the next version of React, they're adding a new bun streaming server render, and that helps make bun three and a half times faster at server-side rendering compared to when using the server.browser build, which is the one that bun currently uses. Overall, this adds up to four times faster server-side rendering in bun compared to node.

This benchmark here is a Hello World benchmark for a very simple React app. If you've used any framework in the past, for building front-end stuff with React, you've probably used hot module reloading. Usually hot module reloading is something that exists on the client, it's run in browsers. But in bun, bun has built-in support for hot module reloading on the server.

2. BUN Hot Reload Demo

Short description:

BUN allows for hot reloading on the server, using render to readable stream and the React API. It supports JSX in JS files and has built-in support for web socket servers. Bunn also provides an API for sending files.

So, here's a quick demo. This is a page that's already loaded. Keep in mind, this is running on the server. It's actually reloading the whole page on the server here. We have it do this hot reload as I type. You can see just how fast this is in the video here. I'm typing and it's immediately reloading. And that's what it looks like, you can see that it's using render to readable stream, the react API to render this react component. You can also see that it's doing JSX but it's a JS file. We have a little web socket here to send over the new styles, which web socket server is also built in support in Bunn. This is an API for sending a file in Bunn. So that's a little bit about Bunn dash dash hot.

3. BUN Priorities and AST Plugin API

Short description:

Today's priorities with Bunn are to make the runtime stable, improve node compatibility, enhance documentation, add missing features to Bunn install, introduce AST plugin API and native Windows support, optimize the Bundler and Minifier, and make it easier to deploy Bunn to production. The AST plugin API allows for executing JavaScript at bundle time and embedding it into the code. BUN's transpiler API enables embedding JavaScript objects into the transpiled result, optimizing code size. Inline data at bundle time is also supported.

Today's priorities with Bunn, Bunn's runtime is not stable yet. And that's really our main focus is getting Bunn to be stable. Our second focus is to improve node compatibility. We're doing both of those at the same time. And the goal there is to make it so you can run virtually every NPM package in Bunn without making changes specific to Bunn.

We also don't have great documentation or examples yet. Our current documentation is one really long readme, it's probably the longest readme you've ever seen. And the good part about that is it means you can do command plus F to search pretty much all of Bunn's docs really quickly, but it means that it's not very easy to browse. So we need to fix that while still preserving the command plus F searching.

We also need to add a few missing features to Bunn install. It's missing a workspace support, it's missing Git support, and those are really important for a lot of projects. What's coming up is we're gonna be adding AST plugin API, we're gonna be adding native Windows support. Currently we support Windows subsystem for Linux, that works great, but it's a better experience to use the actual Windows. Today our Bundler and Minifier is not production optimized. There's no Minifier in fact, but we need to build that. The other thing that we need to help with is make it easier to deploy Bunn to production. So that's sort of the next step.

Here's a little bit about the AST plugin API. The idea here is that you can add bundle time, execute arbitrary JavaScript, and embed it into your code. So here we have Moment running at build time. And as you can see in the strength file output, you can see it returned the exact time without actually rendering any, and that's just in-lined into the code. There was no extra network trip there. Another thing you can do, BUN has a built-in transpiler API, and this is a test in BUN's code base that lets you embed, but BUN's transpiler API lets you embed JavaScript objects into the transpiled result. And it will do some debt code elimination to only include the part that you actually used. So you can see there's a big JSON object we're sending over, and it only actually embedded the URL. It didn't embed the entire JSON object. This means you can inline data at bundle time. So here's another example where we have a bunch of rows of React components. You can see this function. And in the output, it actually just takes all the rows there.

4. BUN Relay Plugin and Wrap-up

Short description:

A relay plugin using Bun's AST API can save a network call. The AST plugin API allows for bundle time JavaScript execution, potentially inspiring new JavaScript frameworks. Thank you for watching the demo, and stay tuned for the next part. Visit our website for more information and to ask questions. Subscribe to our channel for future updates.

This saves a network call. This is what a relay plugin looks like using Bun's AST API. We have the import statement. We inject the import statement into the top of the file. And we have an identifier here that we insert, which is the GraphQL function.

It's still really early for this AST plugin API. We're probably going to make a few more changes to it before we add documentation and start having more examples. But the idea is that you can have bundle time JavaScript execution, and we think it will maybe inspire new JavaScript frameworks.

And that's it. I hope you enjoyed this demo. And we'll see you in the next one. Goodbye. In fact, I'm actually going to have more things on the website right now. So if you want to get to this, you'll have a link to the website in the description. So if you want to add questions or anything to this, you can ask us on the website as well. We'll be getting to the next part of this demo. So we're going to wrap up now. And if you have any questions, feel free to speak to us in the Q and A session. And thank you again for watching. Remember to hit that subscribe button, and I'll see you in the next video.

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

JSNation Live 2021JSNation Live 2021
31 min
Vite: Rethinking Frontend Tooling
Vite is a new build tool that intends to provide a leaner, faster, and more friction-less workflow for building modern web apps. This talk will dive into the project's background, rationale, technical details and design decisions: what problem does it solve, what makes it fast, and how does it fit into the JS tooling landscape.
React Advanced Conference 2022React Advanced Conference 2022
25 min
A Guide to React Rendering Behavior
React is a library for "rendering" UI from components, but many users find themselves confused about how React rendering actually works. What do terms like "rendering", "reconciliation", "Fibers", and "committing" actually mean? When do renders happen? How does Context affect rendering, and how do libraries like Redux cause updates? In this talk, we'll clear up the confusion and provide a solid foundation for understanding when, why, and how React renders. We'll look at: - What "rendering" actually is - How React queues renders and the standard rendering behavior - How keys and component types are used in rendering - Techniques for optimizing render performance - How context usage affects rendering behavior| - How external libraries tie into React rendering
React Summit 2023React Summit 2023
32 min
Speeding Up Your React App With Less JavaScript
Too much JavaScript is getting you down? New frameworks promising no JavaScript look interesting, but you have an existing React application to maintain. What if Qwik React is your answer for faster applications startup and better user experience? Qwik React allows you to easily turn your React application into a collection of islands, which can be SSRed and delayed hydrated, and in some instances, hydration skipped altogether. And all of this in an incremental way without a rewrite.
React Summit 2023React Summit 2023
24 min
React Concurrency, Explained
React 18! Concurrent features! You might’ve already tried the new APIs like useTransition, or you might’ve just heard of them. But do you know how React 18 achieves the performance wins it brings with itself? In this talk, let’s peek under the hood of React 18’s performance features: - How React 18 lowers the time your page stays frozen (aka TBT) - What exactly happens in the main thread when you run useTransition() - What’s the catch with the improvements (there’s no free cake!), and why Vue.js and Preact straight refused to ship anything similar
JSNation 2022JSNation 2022
21 min
The Future of Performance Tooling
Our understanding of performance
user-experience has heavily evolved over the years. Web Developer Tooling needs to similarly evolve to make sure it is user-centric, actionable and contextual where modern experiences are concerned. In this talk, Addy will walk you through Chrome and others have been thinking about this problem and what updates they've been making to performance tools to lower the friction for building great experiences on the web.
GraphQL Galaxy 2021GraphQL Galaxy 2021
32 min
From GraphQL Zero to GraphQL Hero with RedwoodJS
We all love GraphQL, but it can be daunting to get a server up and running and keep your code organized, maintainable, and testable over the long term. No more! Come watch as I go from an empty directory to a fully fledged GraphQL API in minutes flat. Plus, see how easy it is to use and create directives to clean up your code even more. You're gonna love GraphQL even more once you make things Redwood Easy!

Workshops on related topic

React Summit 2023React Summit 2023
171 min
React Performance Debugging Masterclass
Workshop Free
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 🤐)
JSNation 2023JSNation 2023
170 min
Building WebApps That Light Up the Internet with QwikCity
Workshop Free
Building instant-on web applications at scale have been elusive. Real-world sites need tracking, analytics, and complex user interfaces and interactions. We always start with the best intentions but end up with a less-than-ideal site.
QwikCity is a new meta-framework that allows you to build large-scale applications with constant startup-up performance. We will look at how to build a QwikCity application and what makes it unique. The workshop will show you how to set up a QwikCitp project. How routing works with layout. The demo application will fetch data and present it to the user in an editable form. And finally, how one can use authentication. All of the basic parts for any large-scale applications.
Along the way, we will also look at what makes Qwik unique, and how resumability enables constant startup performance no matter the application complexity.
React Day Berlin 2022React Day Berlin 2022
53 min
Next.js 13: Data Fetching Strategies
Workshop Free
- Introduction
- Prerequisites for the workshop
- Fetching strategies: fundamentals
- Fetching strategies – hands-on: fetch API, cache (static VS dynamic), revalidate, suspense (parallel data fetching)
- Test your build and serve it on Vercel
- Future: Server components VS Client components
- Workshop easter egg (unrelated to the topic, calling out accessibility)
- Wrapping up
React Day Berlin 2022React Day Berlin 2022
86 min
Using CodeMirror to Build a JavaScript Editor with Linting and AutoComplete
Workshop Free
Using a library might seem easy at first glance, but how do you choose the right library? How do you upgrade an existing one? And how do you wade through the documentation to find what you want?
In this workshop, we’ll discuss all these finer points while going through a general example of building a code editor using CodeMirror in React. All while sharing some of the nuances our team learned about using this library and some problems we encountered.
Vue.js London 2023Vue.js London 2023
49 min
Maximize App Performance by Optimizing Web Fonts
Workshop Free
You've just landed on a web page and you try to click a certain element, but just before you do, an ad loads on top of it and you end up clicking that thing instead.
That…that’s a layout shift. Everyone, developers and users alike, know that layout shifts are bad. And the later they happen, the more disruptive they are to users. In this workshop we're going to look into how web fonts cause layout shifts and explore a few strategies of loading web fonts without causing big layout shifts.
Table of Contents:
What’s CLS and how it’s calculated?
How fonts can cause CLS?
Font loading strategies for minimizing CLS
Recap and conclusion
React Summit 2022React Summit 2022
50 min
High-performance Next.js
Next.js is a compelling framework that makes many tasks effortless by providing many out-of-the-box solutions. But as soon as our app needs to scale, it is essential to maintain high performance without compromising maintenance and server costs. In this workshop, we will see how to analyze Next.js performances, resources usage, how to scale it, and how to make the right decisions while writing the application architecture.