EricFrost

That's 60 Wh per person in the U.S.

I started Solarite several years ago because I wanted something simpler to use than the existing js ui frameworks. Features like:

- not having to setup a build environment or wait for compilation

- no signals or other dance to setup my data

- class based components, where I could pass arguments to sub-components as constructor args

- scoped styles, two-way binding and other nice to haves.

- not having the limitations of shadow dom (Lit)

- Just be a library I can import anywhere, not be a whole framework.

I wasn't able to find anything that did all of the above. It has a score of 1.08 on the js-framework-benchmark, which is faster than just about every widely known competitor, and most of the faster ones have implementation note "penalties" for not conforming to the benchmark requirements.

Source: https://github.com/eric-frost/solarite

Docs: https://eric-frost.github.io/solarite/docs/

Js-Framework-Benchmark: https://krausest.github.io/js-framework-benchmark/current.ht...

I've used Solarite in production for a few years for an internal work project, but I could use more feedback on the API before I feel comfortable releasing version 1.0.

I wrote Solarite b/c I wanted a simple and fast web component solution without a compilation step.

https://eric-frost.github.io/solarite/

I created Solarite ( https://eric-frost.github.io/solarite/ ) and use it everywhere to create complex app UI in the browser, so I'm invested in web components.

I think NOT using shadowdom is usually the solution for shared stylesheets. So many of my problems have been solved by just letting the styles cascade.

I also now use AI to build everything and I read less than 5% of the code it writes. I think web components still matter because AI still needs clean and organized code. It can brute force things the hard way, but organized code lets AI move faster with less tokens, less bugs, and less code shipped to the browser.

I assumed Solarite would be at a disadvantage because it's not widely known and AI's aren't trained much on it, but I've found that even the earlier models could use it well, and do so before I released it and before it could have been in any of their training data.

In my experience iframes are far too slow.

Yes, Solarite will take any children of your element and reparent them into a <slot> element if your component has one. Or just append them to the end if not.

Wanting scoped styles without shadow DOM was one of several reasons I wrote my own library, Solarite: https://eric-frost.github.io/solarite/

This seems like a good place to plug Solarite, a library I built and have used for several years.

https://eric-frost.github.io/solarite/

It supports passing arguments via attributes to constructors. And you can pass complex arguments to nested components without serializing them. No signals and no build step either, just import and use on your regular data. And it's faster than just about all the others.

I've written something close to this called Solarite... that uses web components. There's no build step and no signals, but unlike your example, each instance is bundled together in a class, and you need to manually call render() when it's time to redraw. But I actually prefer having that control.

https://eric-frost.github.io/solarite/

This seems like a good place to plug Solarite, my own js ui library.

https://eric-frost.github.io/solarite/

There are no signals, proxies, or decorators, or any compilation. You just use plain data. Though the trade-off is that you have to call render() yourself. I prefer it that way though.

That's new. I had tried several times and always got a response saying it was a conspiracy theory. The recent GLM-5.3-Flash also wouldn't give me the real details.

So much that you can instantly tell if a model is Chinese by asking it about Tiananmen Square.

This seems like a good place to plug my own library, solarite:

https://eric-frost.github.io/solarite/

I was also tired of the "all or nothing" of other libraries. Just let me import a js file and then make a class that's a web component. I don't want to setup a whole dang build environment.

With Solarite you just write the markup as a javascript template, change your data however, and then call render(), where it only updates the DOM that should change.

And you can use the component as a tag in your server-rendered page.

Perlin Noise: The Video Game

This seems like a good place for me to share TaskPilot, which shows you and lets you manage everything running in the background on Linux. Services, SystemD timers, cron, autostart, ports in use, snaps, containers, mounts, and more

https://github.com/eric-frost/taskpilot

I had the same idea but never took it beyond one AI generated image:

https://imgur.com/a/XozIBRb