return to table of content

HonoJS: Small, simple, and ultrafast web framework for the Edges

jacobn
10 replies
2d13h

I've been mulling over this weird idea that we should all be using an Edge (Web) Framework that manages the layouts + static site content, then pulls in either JSON or pre-rendered HTML templates from the more dynamic db-driven backends (which can then be in any language, and mapped to any path, and can be a majestic monolith or many microservices, whichever).

It would free things up so much - the backend team can focus on JSON/HTML templates, the designers can work directly with the website without necessarily going through dev (for better or worse ;), marketing can add all their little trackers, easy to outsource parts, and you could build up an entire cross-language ecosystem of plugins that manage anything from user accounts, billing, wikis, blogs, knowledge base, admin CRUD systems, ... yet it's all on the same site from the end user's perspective.

I think there are multiple enterprises that have (also re-)invented this architecture, but I haven't seen any serious open source offering that focuses on this type of use.

axelthegerman
2 replies
2d9h

Maybe I'm missing something but what is the role of the edge web framework?

If the actual backend renders HTML and JSON and we have a CDN for static assets I'm not sure what's missing.

Sure bringing stuff onto the edge is great but if the edge needs to always forward requests upstream there is limited gain here.

datascienced
1 replies
2d8h

Edge can win if data (as in realtime app data not just static stuff) is replicated there at least or possibly even better can allow writes using CRDTs so the edge is also a distributed DB node.

zarzavat
0 replies
2d10h

Conway’s law comes to mind: the architecture of a system reflects the structure of the organization that created it.

syhol
0 replies
2d9h

Sounds like the Backends For Frontends pattern. Sam Newman has a nice write-up on this.

metalrain
0 replies
2d7h

Marketing scripts often are invasive, wanting to run before all other scripts or overriding event/clickhandlers.

For me it kind of feels you need some runtime and DSL to enable all requirements in web. And Google Tag Manager isn't it.

I'm not saying we should go back to XML and XSLT but some separation of concerns would help: data, display, events, animation.

crabmusket
0 replies
2d8h

This sounds almost like a "backend for frontend" pattern.

blackoil
0 replies
2d11h

A backend + NextJS is somewhat what you are suggesting. Backend serves json/graphQL. Frontend server is responsible for rendering, caching, templates etc. Prerendered HTML in backend will overlap the roles, so not sure if that is used.

angra_mainyu
0 replies
2d11h

Isn't this basically astro?

soulchild77
7 replies
2d8h

I created a pet project (REST API) with Hono and I'm seriously considering using it for future projects instead of what has been my go-to stack for years (Express, lately with Zodios).

Hono's middlewares, especially zod-openapi[1] and @scalar/hono-api-reference[2], make it really easy to define your REST endpoints once and get full typesafe routes with request/response validation, an automatic OpenAPI spec, a beautiful OpenAPI browser and you can even reuse the typings in your frontend with Hono's RPC[3] middleware, essentially giving you end-to-end type-safety without any code-generation.

Its maintainer yusukebe is a really nice guy who is always being helpful and very active. I want Hono to become the modern successor of Express. :)

[1] https://hono.dev/snippets/zod-openapi

[2] https://www.npmjs.com/package/@scalar/hono-api-reference

[3] https://hono.dev/guides/rpc

franciscop
2 replies
2d5h

I'm very curious, I'm learning from both HonoJS and ElysiaJS about how to build a great next-generation library, and the thing that strikes me from Hono is that it seems it has integration for a lot of things, BUT you have to write a lot of manual code for those instead of "extending the base Hono" so to speak. For the `zod-openapi` example you gave, I'm looking at the docs and it seems there's no import in common from hono to hono/zod-openapi project:

    import { z } from '@hono/zod-openapi'
    import { createRoute } from '@hono/zod-openapi'
    import { OpenAPIHono } from '@hono/zod-openapi'
I would have expected/hoped things to be more integrated, e.g. you still do `import { Hono } from 'hono'` and then somehow you connect to this OpenAPI middleware. Any thoughts on this? Do you feel like moving from "base Hono" to use hono/zod-openapi you have to change how you do things? Another place I've seen this pattern is with the different edges, you have different import/exports, which I understand to certain degree but I still think a bit more could be done at the base library.

soulchild77
1 replies
2d3h

That's actually something I find a bit awkward, too. Especially, there was no way to re-use the global Hono error handler for all OpenAPI routes. I created an issue[1] with my suggested workaround and was told that that's the way to go. Maybe things are that way because `zod-openapi` was introduced later on. But I believe in the end it doesn't really matter that much as the code is clean and readable. :)

[1] https://github.com/honojs/middleware/issues/323#issuecomment...

franciscop
0 replies
7h36m

"in the end it doesn't really matter that much as the code is clean and readable"

The thing I'm worried about is the behaviour differences of having 2 different ways of importing things, exactly as it seems you found. That's valuable feedback, thanks!

sqwxl
1 replies
1d22h

We are using a similar stack. I assume your client is located in the same repo as your server? That's a no-go for us, so we're planning on using the OpenAPI spec to generate a type-safe frontend client. I kind of wish it was as easy as using the RPC middleware, though.

soulchild77
0 replies
1d12h

In cases where the client needs to stay separate, we have had a good experience with Orval[1] to generate a fully-typed @tanstack/query client from our OpenAPI spec.

[1] https://orval.dev/

lioeters
0 replies
2d

request/response validation

beautiful OpenAPI browser

end-to-end type-safety without any code-generation

That's a great sales pitch - I'd looked at Hono before but now I've opened all the links you mentioned and will try it out.

groothe1drr
0 replies
2d3h

Was looking to do this the same with Hono. Need a basic REST API. Possible for you to share your code?

rrr_oh_man
6 replies
2d12h

> Batteries Included - Hono has built-in middleware, custom middleware, and third-party middleware. Batteries included

What does this mean?

pavlov
2 replies
2d10h

It’s a slogan popularized by Python.

Python with its seven circles of infinite package hell also demonstrates the limits of this approach. It’s not very useful that the language gives you two AA batteries when your application needs a megawatt of power (metaphorically).

datascienced
1 replies
2d8h

Batteries included really means large sections of the factory included!

pavlov
0 replies
2d7h

Always the wrong sections in my experience...

tobyhinloopen
0 replies
2d12h

If it includes third party middleware, is it still third party?

austin-cheney
0 replies
2d9h

When it comes to frameworks (any framework) any jargon not explicitly pointing to numbers always eventually reduces down to some interpretation of easy.

aerhardt
0 replies
2d12h

It means instead of the philosophy prevalent in the JS world of bringing everything in as a dependency by yourself, the library attempts to provide sensible default solutions for you.

I don’t know what that might cover, but it might be things as basic as parsers for headers and cookies. Which I applaud, because me personally, that’s shit I’ve never wanted to think about.

mansarip
4 replies
2d13h

Recently, I've been looking for a suitable stack for another pet project. Personally my go-to stack is Remix.

But I want to use a server other than the default provided by Remix, i.e minimal Express. So, I found Hono. It looks interesting because it can run on many runtimes, and this time I want to try using Bun.

After researching Hono, it turns out it can render JSX directly from the server, which piqued my interest. Then I tried to make the JSX interactive, and finally, I used htmx. Lol.

And just yesterday, after spending hours I found a way to use PDFKit with Hono (Bun runtime), so I created a gist for reference:

https://gist.github.com/mansarip/eb11b66e7dc65cee988155275a1...

Anyway I'm still cautious about putting this Hono + htmx stack into production use.

throwitaway1123
1 replies
2d13h

After researching Hono, it turns out it can render JSX directly from the server, which piqued my interest. Then I tried to make the JSX interactive, and finally, I used htmx. Lol.

HTMX is fine if you want to avoid writing client side JS, but Hono did add support for client components in version 4 [1]. There's even an esbuild middleware that can transpile TS/TSX files on the fly (the Deno framework Fresh uses a similar technique) [2].

[1] https://hono.dev/guides/jsx-dom

[2] https://github.com/honojs/middleware/tree/main/packages/esbu...

mb2100
0 replies
1d5h

Hono client components are interesting. But I couldn't find any docs on how it's implemented and how that implementation compares to React/Preact/Solid etc.

willsmith72
0 replies
1d19h

hono and remix are a dream combo

dhucerbin
0 replies
1d22h

May I interest you in hwy.dev?

vaylian
3 replies
2d12h

It works on any JavaScript runtime: Cloudflare Workers, Fastly Compute, Deno, Bun, Vercel, AWS Lambda, Lambda@Edge, and Node.js.

Does it work in the browser as well?

rafter
1 replies
2d11h

Yes it works in the browser also. I've been using it for routing and templating etc client side (main thread, and service worker), as well as in a cloudflare worker.

vmfunction
0 replies
2d10h

this is kinda lib we need! Not something specifically coded for a runtime, rather adhered to the Web Standard.

vijaybritto
0 replies
2d11h

Yes I think so. You can use it in a service worker too

strogonoff
3 replies
2d7h

At first glance, Hono seems like the most standards-compatible framework.

It works on any JavaScript runtime: Cloudflare Workers, Fastly Compute, Deno, Bun, Vercel, AWS Lambda, Lambda@Edge, and Node.js.

Not sure it counts as “any JS runtime” if it does not work in browser (e.g., worker context), but judging by the rest of the docs it might work there, too.

syrusakbary
0 replies
2d5h

It also even works in Wasmer Edge (template here: https://wasmer.io/templates/hono-starter )... I'm incredibly impressed with how much effort they have been putting on the framework, I bet they will win big time!

rafter
0 replies
2d6h

Yeah, it works in the browser also.

prakashn27
0 replies
16h18m

Technically if it works in Cloudflare it also should work on browser as both are run in same runtime

pier25
3 replies
2d12h

It’s good but it’s not much of a framework.

To me a backend framework is more like Rails or ASP.NET. Hono is more like an http router.

dreadnip
0 replies
2d9h

It's similar to the PHP micro-frameworks back in the day, like Silex and Lumen. Those often didn't contain more than a router, middleware, request/response objects, some type utils and a validator.

diordiderot
0 replies
2d7h

I thought those were 'batteries included' framework. I can't think of any generally recognized boundaries though

cies
0 replies
2d7h

This is also called a framework:

https://github.com/cloudflare/pingora

Pingora is actually fast and small (it does not require a JS engine). Way faster and smaller than Hono.

If you want something to be really fast: do not use RegExes.

k__
3 replies
2d

How does Hono compare to Elysia?

I often heared both mentioned together with Bun.

ntry01
2 replies
1d10h

Performance-wise, both are nearly identical - fast.

Both frameworks support route groups, middleware, context, and mounting apps from other frameworks.

Both are WinterCG compliant - deployment to platforms other than your own server or Docker, such as Cloudflare or Vercel Edge, should not be an issue.

Hono appears to be very focused on serverless and edge runtimes like Fastly Compute, Lambda@Edge, Supabase Functions, etc.

Both offer their own RPC implementations:

- Hono: RPC in Hono: https://hono.dev/concepts/stacks#rpc

- Elysia has Eden—its own end-to-end type safety RPC: https://elysiajs.com/eden/overview.html

So, it's a matter of preference, I would say.

I'm personally using ElysiaJS in production and have zero complaints.

qsq151
0 replies
1d8h

That's very helpful. I'm also using Elysia in several small projects. Considering that the official stable 1.0 release was in March, it might be mature enough for production use.

k__
0 replies
1d8h

Nice, thank you!

_spl
3 replies
2d10h

I've been using Hono + Bun + SQLite for all my personal projects, and I really like it. Essentially, I've replaced Express and Node with it. What I appreciate the most is how quickly I can set up a project with Bun, have native SQLite connector, and how minimal the Hono base app is. Additionally, I can use JSX without any setup hassle.

machiaweliczny
1 replies
2d8h

Do you have some example?

Liquix
0 replies
1d23h

not that guy, but here is a small video streaming example using Bun/Hono/SQLite/Drizzle/SolidJS: https://codeberg.org/vlfldr/ucourse

blackhaj7
0 replies
2d3h

Where do you deploy these projects?

sandGorgon
2 replies
2d10h

we decided to base our GenAI framework - Edgechains on Hono. Primarily because of winterjs compatibility. We build a WASM compiler to compile our prompts and chains into webassembly. Honojs was a critical part of it.

https://github.com/arakoodev/EdgeChains/

sandGorgon
0 replies
2d8h

yup. there are two differences - we model prompts AND chains (the looping logic) as a config management problem. So we model it in jsonnet and then compile it to wasm as a deployment step. The rest of everything we do is javascript and api-centric. In that way, we are solving a DX (or a developer UX problem) if you will.

AICI takes a more abstract approach here - first everything not related to prompt or token compilation is out of scope. So your api is not wasm-ed. Second, the job of creating the wasm prompts is your responsibility - use what you will. While we fundamentally try to answer the question "how can prompts and chains be expressed in a WASM friendly way without locking urself to the language and having it as a config"

bnjemian
2 replies
2d11h

Been using Hono for a few months and have really enjoyed it. For me, it's been the perfect minimal HTTP/router functionality needed to structure an API that lives within a single edge function that's deployed to Supabase and interacts with the Postgres DB therein. Great project – simple, intuitive, fast, lightweight.

4star3star
1 replies
2d4h

Hi, new to Hono, Supabase, and never used Deno - do you have to use Deno with Supabase or can you substitute Hono?

bnjemian
0 replies
2d1h

In the documentation and Supabase CLI, edge functions on Supabase are demonstrated and scaffolded, respectively, with a Deno runtime. I don't think it's required though. And if you've used Node.js, Deno will feel very familiar.

samsquire
1 replies
2d9h

I'm curious what makes it so fast?

The README.md says RegExpRouter uses no loops and just regular expressions, presumably it maps a route to a hashmap matched entry?

Related but slightly different:

I am curious because NFAs, deterministic automata are interesting to me. I remember one person on HN talked to me about using regular expressions to match event sequences. (That is: don't match against strings but match against tokens)

I am not a Rust developer, but the pattern of using Rust sum types and pattern matching or OCaml dispatch based on types are similar to me intuitively.

What are your thoughts on this style of programming?

I feel so much of modern business programming is dispatch logic!

If you think of Redux and state machines and event sequences in GUIs for behaviour, I feel there is a lot of untapped potential ideaspace here.

wrsh07
0 replies
2d3h

The regexprouter compiles all of the routes into a single matcher, so you're not doing a linear search of all of your routes (lots of routers are essentially doing an if else on all of the routes).

They also have a similar trie router, but my understanding is that it's not as fast.

axhl
1 replies
2d12h

Please could a fellow HNer who has experience using this explain in simple terms what Hono on a Cloudflare Worker enables that one cannot already do with a vanilla worker?

The docs[0] are not instructive on this point.

[0] https://hono.dev

yawnxyz
0 replies
2d12h

it's just really nice abstractions that makes everything nicer. But it doesn't offer anything new that you couldn't build yourself

Ajnasz
1 replies
2d7h

How often developers encounter performance issues coming from the slow framework, so they need to switch to a fast one? Which one is the slow?

JodieBenitez
0 replies
2d

In my case, the number of times the bare request->router->response cycle has been the bottleneck is exactly 0.

spxneo
0 replies
2d1h

Supabase already offers a full REST API when i upload my db. How does this differ?

rozenmd
0 replies
2d12h

I use this both on Cloudflare Workers and classic Node servers, it's fast and reliable.

renke1
0 replies
2d9h

Looks interesting. Does anyone have a good example that uses Client Components?

prakashn27
0 replies
16h17m

This is my go to stack too.

Hono, Cloudflare workers solves most of my server problems at affordable price

orph
0 replies
2d5h

Hono still doesn’t support request cancellation well.

So if you’re streaming tokens from an LLM and you cancel the request from the client you’ll be wasting money.

orliesaurus
0 replies
2d2h

OT: I met the author of Hono at a Cloudflare meetup, he was really cool and we chatted about how things are so different in Japan, his country of origin. Honestly that's why in-person is so much better for.

nobleach
0 replies
2d5h

I've built POC apps with both this and Elysia recently. Elysia is really cool, it has a bit of its own ecosystem. Eden Treaty for example, is the way it handles backend to frontend type-safety. Hono on the other hand, seems like such a nice ExpressJS replacement. I wouldn't hesitate to ship either one.

jpahd
0 replies
2d9h

Looks like a js version of mojolicious :D

iansinnott
0 replies
2d15h

Have used this a bit on personal projects. Being runtime agnostic was the selling point for me. Wanted to try Bun as the runtime but not use APIs that are Bun specific, in case I ran into issues and had to move to Node.

gunta
0 replies
1d7h

Using it in production

dandigangi
0 replies
2d2h

Did something change w/ Hono or it just someone reposting about it?

bastawhiz
0 replies
1d16h

The benchmark that's provided says nothing, actually. Being able to serve half a million requests per second isn't a useful measurement for two reasons:

1. In a serverless environment, _the whole point_ is that the requests are essentially all concurrent. If you get 1000 requests at T+0, you get 1000 concurrent invocations of your function. The overhead of the worker doesn't stack unless you hit a concurrency limit, which most folks won't.

2. The overhead of the framework is a rounding error. The slowest framework benchmarked clocks in at over 200K QPS. That's ones of microseconds of overhead from the framework per request. HonoJS is still ones of microseconds per request. If your application code takes one millisecond to return meaningful output, that's _hundreds of times slower_ than the overhead, and the framework's performance is already moot.

Choose a framework that is nice to use and gives you all of the features you want. Shaving off a handful of kilobytes of source code _on the server_ is premature optimization. Shaving off a few microseconds from the request time is premature optimization. Even "heavy" frameworks like Koa and Express will give you good-enough performance that you probably wouldn't ever even notice. What matters is the tool you choose that helps you build useful stuff faster.

amsterdorn
0 replies
2d8h

Hono is great! I used it to build a dev blog w/ Cloudflare workers, source is here if anyone's curious: https://github.com/brycedorn/blog

__jonas
0 replies
1d20h

This is interesting:

https://hono.dev/concepts/routers

I was just thinking about implementing a trie based router for fun in a different language, I would have never guessed that this big RegEx method is the winner in terms of performance here.

SpaghettiX
0 replies
2d9h

Has anyone also used an interesting alternative, Elysia, and understand the differences? Both are quite modern, ergonomic frameworks.

4star3star
0 replies
2d4h

Having proper routing for cloudflare workers will be nice, and it looks like Hono covers all the bases.

0xedd
0 replies
1d21h

Enough with all the web frameworks.