HN Reader

I'm not hopefully Nue would revolutionize this since there are plethora of Web SaaS companies just wanting to use "common" frameworks... but I can at least root for them.

It's an untyped view layer kind of along the lines of early angular 2.0.

The model files are plain javascript.

So no typings anywhere. Which is fine, I guess this is targeting the vuejs crowd. Maybe their marketing should pivot a little bit in that direction, most react people now use TypeScript because first class types in your view layer are super useful

[0] https://mpa.nuejs.org/app/

Just need a simple interaction free site? Use Astro.

Need some interaction? Use Svelte. Larger project? SvelteKit.

Need a more established solution? Use Vue.

Working in a huge team and need a highly opinionated framework with strict conventions? Use Angular.

More than 99% of websites would be sufficient with Astro though. And when just some interactivity is needed it is always possible to add Svelte / Vue / Solid / Alpine / HTMX on top of Astro.

Nit: while I fully support making the web more efficient and hope that Nue is successful in promoting that, I'm skeptical of the "crashing" JS claim here. You can do amazingly efficient things with TypedArrays, the forgotten middle child between JavaScript and WASM.

Having said that, this requires building a few clever data structures on top (I've gotten a lot of mileage out of "typed" dequeues, and (sparse) bitmaps myself), often emulating structs in a language unable to express them properly. So the resulting code is not exactly idiomatic JavaScript — which I presume is what they implied here. Plus in this case it probably still wouldn't be as fast as a well-written WASM implementation, since almost all of the work is likely spent searching with only a little bit of DOM manipulation at the end.

So I'm both agreeing and feeling like it slightly overgeneralizes. I guess my point is: yes, let's be critical of bloated web frameworks, but let's not equate React with JavaScript either.

But if you wanted web standards + web component, Lit already fills that space. If you want untyped JS or little/no JS at all, there's HTMX. Or if you're just tired of React, and want something faster + simpler, there's Svelte/Solid.

I'm not sure what problem Nue is uniquely solving.

Anyways, here are my initial observations on NueJS

1. In the age of AI we need to support it for broader adoption. One of the reasons people choose NextJs and Tailwind over other frameworks is that LLMs understand them well. We need some minified doc to pass onto LLM to make it understand the framework.

2. What do you think about the unstyled components like Radix UI? Accessibility issue are important for components like Model.

3. What do you think about server components? I like them personality as we don't need to pay for separate NodeJS server as a small team.

4. How much Rust is required to use it properly? It's not an easy language to learn as far I heard.

5. How do it compared to AlpineJS who also focuses on performance?

Comparing a JavaScript app to anything wasm is false equivalence because wasm can’t do the DOM.

Please add a button or something to disable that effect.

And SVG icons should use svg `<use>` tag and shouldn't be counted in code size.

So the "cloud" part is where the enshittification will begin. Been there, done that, switched away from next.js :|

And I discovered that:

  - React is not that hard if you understand the hooks.

  - React is lightweight too. For my use case at least.

  - React is boring technology at this point which is good.

  - The ecosystem is huge. You cannot have React Query like library and that's just one example.

Even React Native supports React compiler and I don't see this support going away rather getting better.

PS Edit: React compiler leaves not much for runes in Svelte or its compiled nature. I don't like Svelte much after runes because it feels like you're not writing Javascript rather a notation that looks like Javascript. Post React compiler, much of the hooks hell is not needed in complex scenarios.

Also I didn't understand the phrase about JS "overflowing stack" with 150 000 objects. I created a list of 150 000 objects with the following code:

    var list = [];
    for (var i = 0; i < 150000; i++) { list.push({ id: i, name: `Name ${i}`, weight: i * 100 });  }

JS is not that slow. And if you do numeric computations (i.e. multiplication of numbers in large arrays) the code gets compiled and runs pretty fast.

  - Why is the demo impressive https://mpa.nuejs.org/app/ I believe someone can do the same web-app in React with the same performance.
  - I'd like to quickly see some code samples on the home page. I had to dig the documentation to find some code samples (https://nuejs.org/docs/view.html#clean-html-templating), is it inspired from Svelte ?
  - How is new faster and lighter compared to other tech? Specifically, compared to raw HTML/js.

  1. Is simpler than HTML+JS (or at least simpler than react): like https://alpinejs.dev/
  2. Is easy to understand: maybe the markup and logic are close to HTML or something else I already know
  3. Has a better DX with good build time and HMR: you nailed this one
  4. The tech is better: low overhead? highly based on WASM? virtual DOM? Server islands? 
  5. Show me metrics: https://esbuild.github.io/ nailed this one

Please post again 10 years from now after you have added all the bloat your users request and handled all the edge cases you don't yet understand.

If you are still lighter than a react button...that will be news worthy.

How light or heavy an app feels, in my experience, has very little to do with initial bundle size, and far more to do with how adeptly the developers have solved the distributed systems problems of their app.

Are images compressed and cached on a CDN? Is linked content pre-fetched? Does the app avoid unnecessary roundtrips to the server?

These are the questions that truly matter, IMHO. They’re also things that junior devs are likely to get wrong.

All that said, I agree that you tend to see far more sluggish websites written in React than in any other framework. But personally, I think that’s a consequence of React being popular, and attracting a larger proportion of devs who miss important details.

I share this opinion of Electron, BTW.

This is misleading to people and the promise is so shallow that it almost feels insulting.

Damn should I update my resume again? I’ve used webmaster, web developer, full stack developer in the past. Can I use "internet creationist" to leap directly to the next call phrase?

More seriously, I’m lost when using a search bar in a job listing. Now I just type "JavaScript" but that miss the posts only mentioning the higher stack and/or typescript.

Seeing the .dhtml extension certainly brings back memories... One thing I dislike is that the HTML is still parsed and converted into JS, which is then evaluated at runtime, correct? I realize that this is required to support templating and a nicer syntax for binding and such, but my ideal "framework" would support plain HTML files that are not converted to JS, but used very lightweight syntax (essentially custom data attributes, and `<template>` elements) to make the page dynamic. In fact, I'm experimenting with such a library right now[1]. This approach is likely more difficult to manage when building large web apps, but for simple UIs as used in browser extensions, it's fairly sufficient.

Frontend web development has been stuck in a pit of complexity for well over a decade now, and it's about time we go back to basics. There are new generations of frontend developers who only know this way of working, which is a shame. They're not really _web_ developers, but React, Vue, or whatever the popular framework is, developers. Web standards are far along now that there is very little additional glue and sugar needed to build modern web applications. React ushered in a new way of building UIs, but it also spawned dozens of copycats and frameworks that are downright developer-hostile beyond their shiny exterior. Not to mention the security nightmare of an incomprehensibly large dependency tree. Let's actively reject this madness.

[1]: https://github.com/hackfixme/miu

Yes, its absolutely the big fucking frameworks. In most cases it is the actual literal use of the frameworks, but even that isn't the real problem. The real problem is deeper. You can call it second order consequences.

Its developers that cannot optimize and cannot program without something like React. If you took React away would you suddenly not be able to do your job at all? That's horrible problem to have. The result is a bunch of toxic defensive posturing by people who suddenly appear not qualified to do the work.

If you cannot dig deeper you certainly cannot optimize deeper. That makes the assumption you are actually measuring things and optimizing things in the first place, which many developers aren't. Again, if a given developer lacks the capabilities to dive deeper they may also lack the capabilities to measure things, as is quite common.

Regarding the code examples in the docs:

It would be great if the examples for models and views would be from the same example.

Currently, the view example is something about users and the model is something about customers?

The interesting part for me is not how the individual components of the architecture work but how they connect...

That said, using Preact instead (a smaller and more modular react-style library) the file size is less than 5kB. Its almost a drop-in replacement for React too: https://preactjs.com/guide/v10/differences-to-react

If i make a similarly minimal app with Nue (the lib the article is about), export as production, and remove the favicon it seems to want to add automatically, the filesize is 28kB. I couldn't see a way to meaningfully reduce that in their docs, as its clearly exporting things that arent being used.

Its pretty disingenuous for them to compare an app to a single button, given their own single button implementation is massively overinflated too. It does appear to be a full app framework rather than just a view library though. So I'll definitely give it a whirl.

To the OP: From a lot of the comments here, including my own, comparing yourself in this way is only going to result in people calling you out on it. Its clear the lib has merit in its own right, but you aren't comparing like to like, and if the focus is on "button" apps, then you are still WAY behind some other libs in terms of export size.

Thank you so much for putting in the hard work by making it and I hope others can understand why this is important and use it instead of cargo culting React and making the web worse every single year.

TBC in React and its offspring, you can still model business logic outside of components, we just learned that most UI development is better served by keeping UI and its state closer.

Much like how Cosmic Inflation in the early universe left the imprint of microwave background radiation written exponentially large across the sky, I believe the exponential expansion of computing during the era of Moore's law left whole sections of scale in software not-fully-explored.

Specifically, as "average app sizes" went from 1K - 10K - 100K - 1M - 10M - 100M+, you could imagine the 1K-10K got fully explored because the space wasn't that big to begin with, and the 1M - 10M range got, if not explored at least inhabited, but it could be that that middle range of "neat applications that weigh in ~100K+ but less than 1M" didn't get completely explored because we didn't spend enough time in that era of computing.

A similar thing may be playing out in AI scaling, where we went from tiny to medium to huge model sizes, but now some new participants are going back and doing neat things with medium sized models.

Here is a 1 million rows table in JS with filtering, sorting, and pagination: https://htmlpreview.github.io/?https://gist.githubuserconten...

2. Benchmarks are just numbers without details. React+ReacDOM gzipped/minified is 40 kb in 2025. I doubt a button adds 30 kb. But if you really want to make small SPAs, Preact is just 4 kb and it doesn't require to learn a new bespoke templating DHTML-style thing.

3. From FAQ

> The WebAssembly example in our demo isn't about raw performance — it demonstrates something far more important: what becomes possible when your business logic is properly separated from presentation.

> But when your business logic lives in its own pure layer, entirely new possibilities emerge. Rust is just one example — you could model complex financial calculations, build sophisticated data visualization engines, or create real-time collaboration systems. Your logic can evolve independently of the interface, enabling the kind of architectural advances that the React monolith prevents.

The writer was high or delusional or bad at explaining the point. Nothing prevents you from putting logic into "its own pure layer" in any language. You can make it messy and impure with Rust/WASM/... just as you can keep it pure with pure JS. And it's not "entirely new" because people separated business logic for literally decades (and believe it or not many of them even did it while using React at the same time)

And meanwhile the Rust version is slower and bigger. "What becomes possible" is a mystery.

"React monolith" just takes the cake. React literally doesn't care how you separate your business logic, it's just a rendering layer. This ironically is a monolith SSG that does routing, YAML frontmatter, Markdown extensions, syntax highlighting and what not. Again, you are thinking about something like MarkoJS or QwikJS. Before you are trying to take something down you should probably understand the basics.

Don't get me wrong, it's a cool project. But it could be more humble because authors don't seem to fully understand themselves what exactly they are proposing.

I also hate JSX, and have my app setup so I create GUI elements programatically like "button = new Button("Save", db.save)". Templating has so many friction points I find it to not even be worth the complexity, expecially once you have templates containing other templates with looping and conditionals, etc, and you end up with just an extra layer of cognitive load. No thanks. We can do better. With the capabilities of modern JS (classes, imports, etc) we can phase out React and Vue.

Take Solid, Svelte or Vue (with or without Vapor mode) as reference and the picture looks different. Additionally when using custom components instead of large UI libs based on HTML elements like <dialog> or the recently announced stylable <select> element you have a very powerful, small and simple stack.

Still, they catched my interest. A lot. I'll dive into the docs to learn more. Maybe I'll be convinced to change my go-to stack to Nue ... damn, I had so many happy weeks with Vue. Maybe till Vue Vapor is out.

When I open https://mpa.nuejs.org/ and type "kind of rate limit" in the search box, I get 383 search results, and the URL updates to include the query: /app/search/?query=kind+of+rate+limit.

However, when I paste that URL directly into a new tab, I only see one result instead of 383.

If forced I would likely go with htmx.

Regards nue: do I need to know rust?

No TypeScript = No deal with me.

I wrote my first Javascript application back in the spring of 2025, and I am not aware of anyone who is willing to pay me enough money to voluntarily write Javascript again in a project of meaningful size.

Unfortunately, the tradeoffs are still in favor of react and will continue to be in favor of react for the foreseeable future.

Most importantly it is next to impossible to get developers to give up DX (and muscle memory) for smaller JS bundles.

Would love a pointer to THAT.

Or perhaps the caching could be better. e.g. if your'e using Tailwind CSS version XXX, why does the browser have to reload it every single time?

Local persistent storage isn't exactly at premium these days even for "lightweight" mobile devices.

I would hope React buttons work when people click on them though.

Also how you are thinking about app theme and design is really good.

This button demo... really ambivalent about it.

it relegates React, Vue etc to be view layers - purely view layers. all models / state etc handled by your monolith Rails, Laravel server. this simplifies a lot of things.

frameworks like Vue & Svelte have scoped styles which preserve knowledge of CSS. While Tailwind is convenient - a lot of people won't know the capability of CSS

and why it was named cascading & the customability of CSS for the user.

I've been following Nue for a while now, and I'm eager to use it for real world apps. Any updates on when the design system will be released? I know you're ambitious, but I'd suggest launching a single design system first to test the waters, gather feedback, and gain traction — rather than waiting to release everything at once (but losing out to the ecosystem).

I think react-virtualized and stack tables can easily handle 1 million rows client-side without a problem (I saw the demo somewhere).

Web development is about convenience, and the speed of development is far more important than ultra optimizations. People simply don't care about super optimizations because servers are so fast these days, and bandwidth is cheap, almost free.

But it's an interesting project. Good luck.