stitches VS open-props

Over the past few years, I've worked with React apps utilising various CSS-in-JS libraries, starting with styled-components, transitioning through emotion, Theme UI, and finally Stitches. I've also integrated MUI, Mantine, and Chakra in numerous client projects.

Radix has some great ideas that challenge the way components are usually built. I'd love to use it, but am somewhat burned by how Stitches stopped being maintained due to the changes in React 18. Context: https://github.com/stitchesjs/stitches/discussions/1149#disc...

To be clear, it's not so much that they decided to not spend time, energy and money into maintaining it, but that there's seemingly been very little (if any) interest in letting others maintain it despite several people expressing interest. I'm sure it's scare handing over commit access, but if you're giving it up anyway then why not just do it, see what happens? Instead it's just dead in the water.

I'd happily pay license fees to use Radix and/or Stitches, if that guarantees maintenance. Sadly that's not an option it seems.

I work on a lot of more "creative" projects where frameworks like TailwindCSS or Bootstrap just don't cut it. My approach has always been to use some kind of library to ease the process of creating my own CSS framework that can then be used by other people. I find that Stitches does it pretty well. You set your design tokens, then you have IntelliSense to help people understand the design system.

Some libraries, such as Stitches, claim near-zero runtime performance overhead by tackling the first issue (parsing JavaScript CSS objects). Nevertheless, they still inject the parsed CSS into the DOM at runtime, which means they haven’t entirely eliminated the performance concerns.

Stitches allows you to map your design system

Define strict system of colors, spaces, etc then attempt to synchronize usage of it in both design and code (tools like https://vanilla-extract.style/ or https://stitches.dev/ can help with enforcing system on software side)

Curious to understand what is trending. We've been big fans of Stitches, however, unfortunately the project is no longer maintained.

There are some issues with SSR and NextJS in React 18: https://github.com/stitchesjs/stitches/issues/863

According to the docs, NextUI is a React UI library that allows you to make beautiful, modern, and fast websites/applications regardless of your design experience. It is created with React and Stitches, based on React Aria, and inspired by Vuesax.

Stitches CSS customization

There's still some boilerplate, but I'm a big fan of Open Props[0] because it takes a hybrid approach. CSS isn't necessarily reinventing the wheel, but allowing for easier / more powerful approaches to difficult layouts or things that would otherwise require JS. Bootstrap is fine but troubleshooting advanced layout issues involves a lot of inspecting elements to see what styles are actually being applied (at least in my experience, YMMV) so I'd personally always bet on CSS.

[0] https://open-props.style/

I don't quite get the hate for having CSS in another file. Do you also put all your react stuff in one single file ? That same logic and argument can be applied against all modularization.

And really 20-50 tailwind classes in a single element is VERY hard to read and keep in mind. No - it does not make things clear or understandable. One tends to need to re-read and scan over from the beginning and eyes glaze over. Esp if some elements only vary with a few classes missing. I guess it works for people with very high attention to detail and high amount of working memory. I only find it personally frustrating.

Maybe tailwind css works for some bright people. I did try it for a couple of projects and only felt pain.

However, the "atomic css" philosophy behind tailwind is great. I find framewroks like https://open-props.style/ far better to use.

Open Props adds to the set by providing extra custom properties for things like easing functions or animations.

> If you wanted to actually solve theming, what you should work for is not a constrained helper function like light-dark(), but instead a shared token schema. Today nearly every company has their own token schema and different ways of naming things in the semantic token layer. If we had a shard language here, not only would it be trivial to add light/dark theming (just redefine a few variables that are already provided for you), code could be shared between sites and inherit the theming/branding.

Isn't that the idea behind https://open-props.style/ (and https://theme-ui.com/ in JS land)?

I think it's a great idea, but hampered by the lack of adoption incentives for the very people that need to adopt it for it to become successful (design system/component library authors). It introduces constraints, but the promised interoperability is not really beneficial to the people who need to work within those constraints.

I do think that the real value of Tailwind comes from the utility classes, rather than css-in-html paradigm. You could achieve the same, for example, with Pollen.css [0] or Open Props [1].

[0] https://github.com/heybokeh/pollen

[1] https://github.com/argyleink/open-props

If you choose to style with plain CSS you can add design tokens as CSS variables with Open Props: https://open-props.style.

Some time ago I discovered Open Props which provides a lot of design tokens as CSS variables and started using it in some of my projects.

CSS: Open Props (https://open-props.style/)

https://open-props.style/ gives you design tokens as CSS variables. It’s CSS only and not Svelte specific.