hckrnws

ok so I actually like this, but the description and documentation in general are terrible

"rust-powered" meaning it uses rolldown to bundle the javascript, that's fine, but it's a weird thing to highlight, it's confusing for people that aren't super familiar with vite and might think this is a rust framework

from the docs "one of rari's superpowers is seamless NPM package integration" this makes me think the docs are LLM-written... npm package integration, like every other javascript library.

now, the good: there's very few simple frameworks for react (react router and tanstack) and I think the simplicity here on going from an empty project to RSCs is absolutely great, and should be the tagline

I was also happily surprised at how mature the codebase is in comparison to the docs, the vite plugin actually supports a lot of the options I would have expected to see, they're just not documented yet

edit: I realised after digging a bit deeper this actually does have a rust runtime that runs the js, that was not very clear... is this separate from the framework or does the framework only run in the rust runtime? eg can it run on node?

You're right about the messaging being confusing, I've been writing everything solo, so I'm definitely open to PRs that help with the copy. To clarify: "Rust-powered" refers to the server runtime itself, not just the bundler. The actual HTTP server, RSC renderer, and routing are all written in Rust (using an embedded V8 engine to execute your React components). It's not just Rolldown doing the bundling.

On the npm integration point: what I should have said is that rari's Rust runtime handles traditional node_modules resolution (require/import from node_modules), which is actually pretty rare for Rust-based JS runtimes. Deno, for example, uses npm specifiers instead of node_modules.

Great feedback on the tagline too. "Zero to RSC in minutes" is way clearer than what we have now. The codebase is definitely ahead of the docs, I've been focused on getting the runtime solid first, but clearly need to catch the documentation up.

Thanks for taking the time to dig in and give constructive feedback. This is exactly the kind of input that helps make it better.

Yeah I wrote my comment initially thinking it was just rolldown being used, so the "rust-powered" was confusing, I think the tagline is actually ok now that I know this, but really you're doing two things here

1/ an alternative framework for RSCs similar to nextjs, tanstack or react router

2/ a rust runtime for javascript, similar to node, deno or bun (except maybe not as general purpose)

Exactly! Those are the two main layers.

The runtime piece is definitely less general-purpose than Node/Deno/Bun. It's optimized specifically for React Server Components with things like streaming, Suspense boundary handling, and server action execution baked in. You wouldn't use it to run arbitrary JS apps.

V8 is C++, so why isn't it "C++ powered"?

Technically you could say that, but the entire server runtime is written in Rust. V8 is just the embedded JavaScript engine. By that logic, every Node.js or Deno app would be "C++ powered" since they all use V8.

They are using Deno

agree about the messaging, and i think this is actually the make or break problem for any new framework at this point. the react ecosystem has so many options that developers are numb to "another react framework" announcements.

the real pitch buried in the confusing docs is: same react code you already know, but running on a rust server instead of node. that's actually compelling because it's additive, not a rewrite. but it took reading the HN comments to understand that, which is exactly the problem.

fwiw the "zero to RSC in minutes" tagline the author mentioned below would've gotten me to click the docs immediately. most of us just want to ship something without a three day yak shave through webpack/vite/turbopack configuration.

It's like beating a dead horse. React is the literal worst of all the modern JavaScript frameworks and yet that's what everybody insists on using. Vue is light years ahead of it (and will be even further ahead when the new Vapor mode is released in 3.6). Svelte is ahead. Solid is ahead. Heck, even Marko is ahead.

Reacts added some poor abstractions over the last decade. Looking at you hooks and effects.

But its far from the worst.

It was the first framework to put together JSX, a functional way of defining components and simplifying state. This was a monumental improvement. As a result they earned mass adoption.

As a result its the framework that now has a community moat that is not going to crumble until someone else can break ground in the way they did.

Sure, some of these could be considered "better" but they're all better due to incremental improvements for Frontend Engineering.

None of which are substantial enough to unseat the king

> React is the literal worst of all the modern JavaScript frameworks and yet that's what everybody insists on using.

That's rather amusing. "Am I wrong? No it's the rest of the world!"

How are these other frameworks so far ahead? I've used a couple of frameworks and React has been the easiest from the big ones to wrap my head around.

I never "learned" react because the "create react app" would literally never install for me in the early days. There were literally so many dependencies I never got it to build as a novice, I tried svelte everything worked and I got to spend that time building.

I can only speak for Svelte, in Svelte 3/4 it was so dead simple that I built my first basic webapp with 0 javascript, css or html experience in 3 days.

By week 2 I was trying out different UI libraries and css frameworks, that part was super rough though, back then lots of compat issues.

I am a react developer. For past few months I am working in vue and I Just dont see any benefits

Thou art living under a rock.

Totally agree.

It can be made better if you write it using non standard patterns - but the community is so dogmatic you'll get laughed out of the room.

All of my personal react projects use the MVC/MVVM architecture and are so much easier to work with

    export class AppViewModel {
      @rx accessor message = new TextField()
    }

    export function App() {
      const vm = useViewModel(AppViewModel)

      return <div>
        <p>{vm.message.value}</p>
        <input 
          onChange={vm.message.fromEvent} 
          value={vm.message.value} />
      <div>
    }

Hi do you have some examples or repos you'd be comfortable with sharing? This looks interesting.

How is a viewmodel better? It's way more skipping around in the codebase to find the parts you actually care about

- Allows you to use async/await and generators (useful for pagination/infinite scroll)

- You can test the view model independently of the rendering logic

- Dramatically reduces the code that lives directly in the component (it's only TSX)

- Allows for better abstractions and state management (services)

- Clear path to leveraging threads in front end applications

- Simple "visual" components (like <Input />, <Button />) don't need view models, just orchestrating components.

In practice, when writing traditional React, I focus too much on rendering cycles and the nuances of managing component state while spending much less time on making the application look good and feel performant/nice to use.

Having a component be pretty much exclusively TSX gives me a clear separation of "view" and "what the view needs" - so I just think of the html structure and css. I tend to create much better looking and nicer applications this way.

> It's way more skipping around in the codebase to find the parts you actually care about

Not really. You cnt+click to an implementation. Say you have "await someApi.getItems()" - you just click and go directly there. Traditional React apps need to thunk with redux or have a bunch of custom hooks that quickly become a source of confusion.

As a Svelte developer working with React at $DAYJOB I must say it is the most horrific kludge of terrible abstractions I’ve ever had to suffer through in my life. The sheer number of hoops you have to jump through to do literally anything is comically absurd, and even the nicest way of doing things is a dumpster fire of bad programming patterns. The worst part is, React devs are blind to just how much of their day is spent solving problems that are created solely by React itself, unrelated to any business logic or actual value.

One day my dream is to delete 75% of the code, sprinkle some svelte into the business logic, and be left with a strictly superior, more performant version of the platform.

I hear you my brother. Days i had to write react were the worst i had to endure

[dead]

I've dreamed of someone taking React and making it somehow embeddable to any back-end programming language without a performance hit, so you can blend it with .NET, Go, Django, etc and it would run either natively or alongside said platform. This is impressive.

For those looking for an actual Rust web framework, check out Leptos:

- https://leptos.dev/

- https://news.ycombinator.com/item?id=36461660

- https://youtu.be/cp3tnlTZ9IU?si=5H4cAVS8g6CFGwab

Thanks for sharing Leptos! I'm actually a fan of it too, it's a great framework for those who want to build full-stack apps in Rust.

That said, rari takes a different approach. It's not a pure Rust framework. It's a React Server Components framework that happens to be powered by a Rust runtime. The goal is to abstract away Rust's complexity entirely so JavaScript/TypeScript developers can build high-performance React apps without needing to learn Rust.

If anyone’s exploring Rust + React, I’ve been building something similar on the rendering side.

react-vello [1] exposes Vello (a Rust GPU renderer) as a React renderer via WASM + WebGPU, so you can draw shapes and text declaratively while Rust handles the rendering in the browser.

[1] https://github.com/mblode/react-vello

Very nice, I think a Rust server using a WebSocket to send MorphDOM diffs to the browser would be very well received.

> React Server Components framework powered by a Rust runtime.

If anybody is wondering.

Thank you, came to comments to find out what it is. Now I can go back to site and see what it is about.

Thanks again.

I understand nothing of frontend, and never even saw what React looks like, what is this supposed to be? Is it compiler--written in Rust--of React whatever to actual Javacript with DOM calls?

"Rust-Powered Performance

Native speed with Rust compilation for blazing-fast builds and runtime"

It seems only Rust itself compiles slow while helping others brag about it :).

"I guide others to a treasure I cannot possess"

Is this like ReasonML and its React-Reason framework?

I don't really understand how it works, what part is Rust powered, is it reimplementing the JS engine in Rust?

Not like ReasonML, you still write normal React/TypeScript.

The Rust part is the server runtime. Instead of Node.js running your React Server Components, rari uses a Rust server with an embedded V8 engine. Same React code, different server underneath.

You write React → Rust server executes it → better performance than Node-based alternatives.

wait so it actually has a rust runtime? that's not documented in the site so I had assumed the rust part was simply rolldown

it would be interesting to see a performance comparison to node and bun

I can only found this benchmarks

https://github.com/rari-build/benchmarks

interesting, but would certainly be good to see an apples to apples benchmark of rari vs node/deno/bun for the same app, I would imagine the goals of the runtime are not to be a general runtime like those others, but it would still be good to see if it performs better

How is this different than running that same React code in deno whose HTTP server is also written in Rust?

The main difference is that Deno doesn't have React Server Components support. You'd need to build the entire RSC runtime yourself (streaming, Suspense boundaries, server actions, etc.), whereas rari has this built in and optimized. rari also uses Axum for the HTTP layer with opinionated defaults for RSC workloads: streaming responses, proper cache headers, and optimized middleware are all configured out of the box.

While we use Deno's excellent crates (deno_core for V8 bindings, we're big fans of the project!), you're not locked into the Deno ecosystem. rari uses standard node_modules resolution, so your existing Node/npm workflows just work. Think of it like this: Deno gives you a runtime to build on, while rari gives you the full stack with integrated bundler, router, HMR, and dev server all configured to work together for RSC apps.

I forgot all about Reason…

I once (2022 I think) took a short ReasonML course with hands-on and while it was only superficial, I remember how much it increased the appeal of pattern matching and immutability for me... without being a true FP head or anything.

Author here! Should be all good now, turns out the rate limiter was a bit overzealous

Nice project, thank you for working on it. I was trying to figure out the architecture, and I understand that it runs a Deno VM to execute JS on the backend?

I was working on something similar, but for JVM backends [1]. And it seems there are a lot to learn from your project. For example, I'm using GraalVM that executes JS on the server. But I have to compile JS to WebAssembly because otherwise it produces a lot integration issues on the backend. Do you do the same?

[1] https://github.com/emeraldpay/double-view

Thanks for checking it out! rari uses V8 (via deno_core bindings) embedded directly in the Rust runtime, not a full Deno VM. We execute JavaScript directly on V8 without compiling to WebAssembly.

The key is that deno_core provides clean Rust bindings to V8's C++ API, which lets us run JS/TypeScript with minimal overhead. We handle module resolution, imports, and the React rendering pipeline all in Rust, then execute the actual component code in V8. No WASM compilation step needed.

Your JVM project looks cool! The GraalVM → WASM approach makes sense for JVM integration. We avoid those integration issues by keeping everything in the Rust/V8 ecosystem. The tradeoff is we're tied to V8, but we get native performance and direct access to V8's features.

That may sound strange, but it turns out I don't use WASM as well. Last time I touched this part was ~8 month ago, and WASM was just one of the experiments, and I forgot about this. Just remember it was hard to find a right approach initially, on how to execute JS without NodeJS environment. But with a right set of polyfills it works now.

Anyway, I see we have a bit different approaches on how to handle JS part, and I could get some ideas from that.

this looks neat and reminds me of "Ferrari" for fast and combines "react" so it's a great name. Was there a specific use case for this that inspired you? I would imagine some massive existing heavy thing that you plugged in to fix to save it? I just put my open source thing out so it's nice to see some traction on yours, rooting for you.

Thank you, that's very kind! The name actually comes from "Runtime Accelerated Rendering Infrastructure" (RARI), but I love the Ferrari connection, it definitely fits the performance theme.

The inspiration was pretty straightforward: I wanted to build something for myself that was as performant as I could make it. I'd been using Rust a lot more in my day-to-day work and wanted to see if I could bring those performance benefits to React development without forcing JS devs to write Rust. The goal was to abstract away the complexity of Rust but still deliver the same benefits.

Congrats on shipping your project! What did you build?

ah gotcha... i was picturing like this massive web page that was dog slow that you just like made mad fast... but that's cool though. I'll run it.

I built autonomo on github, it's this mcp you plugin to your whatever ai editor and it drives the app/web/desktop whatever thing and validates it actually runs and works... keep building homie!

Would be more interesting to compare this to Bun or Deno + NextJs or Tanstack Start or React Router performance wise.

Website has been hugged

Thats not good advertising for raris Performance claims.

Fair point! To be clear: rari handled the traffic perfectly fine - the issue was an overly defensive rate limiter I had configured (and it was grouping proxy traffic incorrectly). The framework itself was cruising, I just had the safety rails set too tight. Adjusted now and it's handling the load as expected!

Get started but not working

Naming so lit

Thanks twin!

[dead]

[flagged]