Make Hono work on Node.js

Hi. I'm very excited to speak at Node Congress today. The title is Make Hono Work on Node.js. Let's go ahead. My name is Yusuke. I love building web frameworks. I'm working at Cloudflare as a developer advocate. I'm a creator of Hono.

Today I'd like to talk about how we made Hono work on Node.js. Here's today's agenda. First, I talk about Hono. Next, I'll share how Hono started. Then, I'll explain how we made Hono work on Node.js and performance improvements. First, I talk about what is Hono. Hono is the backend of web frameworks for JavaScript. We can call Hono the next generation of express. It uses only web standard APIs and it works on Cloudflare, Castino, and Node.js, et cetera. Here's Hello World web application using Hono. Only one, two, three, four lines, and this API is super simple.

Hono has five key features. First, it's very fast, and second, the bundle size is small and it works across multiple runtime, and you can add many features easily by using middleware. Last, Hono supports TypeScript as first class and providing a great developer experience. I'll talk about the beginning of Hono. Let me share how I started building Hono. We are creating Hono, I wanted to build an application for Cloudflare workers, but at that time, I couldn't find a great framework for me. This IttyRooter is so simple. It doesn't have enough features for me and this worktop and Thunder are good frameworks, but I don't prefer the API that's similar to express. So, I decided to make my own framework. That's how Hono was born. The initial commit of Hono was December 15th, 2021, then Hono was started.

It's over three years ago. At that time, Hono was built with WebStandard API and it was only for Cloudflare workers. So, we couldn't really say it's multiple runtime yet. I'll talk about how Hono supports multiple runtimes.

We released version 2 of Hono on June 16th, 2022. Version 2, Hono started to support Dno and BAN. We didn't say Hono supports Dno and BAN before version 2, but it was easy to support them because both Dno and BAN use WebStandard APIs.

To support Dno, we need to do two things. In Dno, to import module, we had to add an extension like .ts or .ds, the module name. And second, Dno imports modules using URLs. So, we made a Hono package that can be downloaded from Dno.runx. Supporting BAN was very easy. After BAN was made public, someone created this issue and is there any plan for BAN.js support? But we don't have to do anything. Hono just works on BAN without any changes.

Here is something interesting. The same code can run on Cloudflare and BAN. This example is just a hello world application and you can learn it. Language dev commands for Cloudflare workers and BAN command for BAN. So, the completely same for hello world application started as Cloudflare workers and BAN. So, we can say Hono is a multi-runtime framework.

Becoming multi-runtime had some great benefits. When Hono started supporting multi-runtime, more people began to use it. This meant we got more feedback, issues and use cases. By addressing this, we improved Hono's quality. So, learning Hono on multi-runtime has led to very good results for us. Next, I explain the Node.js adapter. After supporting DNO and BAN in version 2, our next big challenge was making Hono work on Node.js. Because many people use Node.js, so if it succeeds, Hono would reach much larger users. But Hono application can't run on Node.js as it is. Node.js has web standard APIs like fetch and request response URL and et cetera.

But if you build a web server, you need Node.js specified APIs. Here's an example of Hono application for Node.js. As you can see, this object is HTTP incoming message and HTTP server response. This Node.js API, they are different from web standard API. So, you have to use these objects instead of web standard API for Node.js application.

To solve this, we created Node.js adapter. This is published as npm package named at .machono. This converts Node.js API into web standard API. It transforms Node.js HTTP incoming message to web standard request object and it passes it to Hono application. And then Hono application returns the response object and converts it to Node.js HTTP server response. This area is Hono application, Hono Node.js adapter. This adapter you can run your Hono application in Node.js. This is an internal implementation of the adapter. This fallback means Hono application. It receives request object and return response object. The adapter converts Node.js incoming message object to a request object and it passes to Hono's application. Then Hono application returns response object and it sets the status code and header values and body for Node.js server response.

Here's how you use Node.js adapter. This is very basic Hono application and this app is Hono's instance. If you want to run it Node.js, first import a sub method from Hono adapter, Node.js adapter, and pass the application to the sub method. It's so simple and you can execute this code by Node command. Creating Node.js adapter works very well and the download count is increasing. However, there's some performance overhead. It converts between Node.js adapter, Node.js APIs and WebStandard APIs. This overhead introduces performance degradation. So we've done benchmark to measure performance. We'll follow the method described at this URL and there are three scenarios. One is simply receive GET request and return hello world response. Second, it returns a GET request and captures the pass parameter and query parameter and returns these values and add custom header. Last one is passing JSON body from POST request and returns serialized JSON body.

Here's a Hono application that handles three scenarios. Here's the benchmark results compared to some Node.js frameworks. And BAN and DINO. These BAN and DINO are faster than Node.js application because it doesn't have overheads. But among Node.js frameworks, Hono is faster than Express. But that is slower on the core. And there is a big difference from Fastify. So we cannot say Hono is fast on Node.js.

However, still Node.js has many users, so our Node.js adapter ended up being used by a lot of users. After the Node.js adapter was released, after a while, we made a significant improvement to boost performance. In November 2023, this pull request titled reduce object generation and optimize performance was created. This pull request applies fundamental performance tuning principle. Don't do things until they are necessary. We realized that creating requests and response object using new request and new response are very slow. To solve this, we introduced lightweight request and lightweight response object. Normally, these lightweight objects are used if it doesn't need to read the body. For example, accessing property like request, sorry, status object and status property and method property. But if you want to accessing the body like leak JSON, leak text and leak alibha, then it creates request object.

This means that some simple use case like Hello World application, Hono can extremely fast and one great thing about this optimization is that lightweight request and response object don't change the API. Here's simple code to implement lightweight request in Node.js adapter. This constructor, it doesn't create request object immediately. Instead, it caches this incoming message. When accessing property like method or status, it doesn't create request object either. However, calling JSON or text alibha, which require reading the body, it creates the request object for the first time and read the body from it and it caches request object. Then, it caches object for future. So, next time, it is useful from this cached request object. We learned benchmark again using the same scenarios. There wasn't much difference in JSON body passing benchmark, but we saw large improvement in ping and query test. Each of them about 50% faster than before. Let's compare it with other frameworks.

Previously, Hono was slower in the core, but now it has become faster. And it is always getting, also getting closer to fastify in performance. With this, our performance tuning is complete. The performance of Hono on Node.js is pretty good. Of course, learning on Cloud-Havercast and Deno is faster because there is no conversion overhead. But Node.js is still enough to fast for real-world use case.

So, now, you can use Node.js adapter in production. Now, let's wrap up today's talk. We love new runtime like Cloud-Havercast and Deno and BAN, however, Node.js still has widely used by many developers. So, with the Node.js adapter, it converts web standard APIs to Node.js APIs. By using lightweight request and lightweight response object, we successfully improved performance. One of the best things about Hono is support for multiple runtime. So, this helps Hono reach more users and improve the quality of Hono. Adding Node.js support was definitely a good decision.

So, this was the story of making Hono work on Node.js. This is the end. Thank you very much.