r/solidjs • • 3d ago

Solid apps in OCaml

Post image
50 Upvotes

Hi r/solidjs!

At Hypha we build software in OCaml, with an open stack of our own. The backend part is covered by Spindle, our fantastic web framework, so nothing to complain about there. The frontend is a different beast, though.

What would be really great is to build full-stack reactive apps in OCaml on Solid, from one coherent set of libraries, for ourselves and for our customers, so that backend and frontend share one great language, one toolset, and the same high bar.

Unfortunately for us, Solid never had complete OCaml bindings, so after some investigation I made our own, for Solid itself and for Kobalte. And for the sake of having one of the best UI kits around, I also ported HeroUI, nearly in full, from React and React Aria onto Solid and Kobalte. Then came charts (rhp) and Gravity UI's icons. Sorted.

Even if you've never tried OCaml, you should be able to read the code, as it's pretty close to JSX/TSX markup:

module S = Solidtype.Solid
module Jsx = Solidtype.Jsx

let%component make ~(label : string) () =
  let count, set_count = S.create_signal 0 in
  <button on_click=(fun _ -> S.update set_count (fun c -> c + 1))>
    (fun () -> Jsx.string (label ())) ": " (fun () -> Jsx.int (S.get count))
  </button>

Why OCaml? Glad you asked. Agents now write much of our code, and a model guesses wherever nothing tells it otherwise. OCaml's types leave it much less room to guess, and the compiler is fast enough to answer inside an agent's loop. It's also nice to have one language for the whole stack, as TypeScript or Clojure gives you, and OCaml does too.

The docs have plenty of live examples and everything you or your agents need to build modern web apps in OCaml and Solid.

šŸ‘‰ https://hyphatech.github.io/solidtype/


r/solidjs • • 4d ago

made some cool animated components for Solid (and React, Svelte)

8 Upvotes

Animated components you install as source with the shadcn CLI. Same components in Solid, React and Svelte. https://mizzle.saddy.me


r/solidjs • • 4d ago

Build polished Stripe-style UIs in Solid + Tailwind

10 Upvotes

TL;DR:Ā https://windframe.dev/styles/stripe

Hi everyone šŸ‘‹

I’ve been experimenting with generating interfaces inspired by Stripe’s design taste, combining crisp typography, generous spacing and bold gradients to make complex products feel clear and polished.

I ended up building a UI system that makes it really easy to generate interfaces using this design style when prompted, and it does so consistently. It generates both full UIs and assets that match the Stripe's design style

I also put together a template built around this style that you can use directly in your Solidjs projects as starting points.
You can access the template here
https://windframe.dev/styles/stripe

I made this a selectable style option when generating UIs on Windframe, so that when you can choose this preset style it gives your Solidjs interfaces that clean, polished look.

If you’re not familiar withĀ Windframe, it’s an AI visual editor that lets you generate polished UI with AI, tweak it visually in a canvas, and export clean production code in Solidjs (along with HTML, and other frameworks)

Appreciate any feedback or thoughts :)


r/solidjs • • 9d ago

Title: LinkedDataHub 6: the application is data

4 Upvotes

It's been a while since I posted about LinkedDataHub here. Version 6 is the biggest release since then: https://atomgraph.com/blog/linkeddatahub-6/

For anyone new to it: an application's domain model, forms, views, queries, charts and access rules are RDF documents. Its queries can run against the SPARQL endpoint your data already lives in. There is no application codebase. The same generic software runs every application, the way one browser reads every website.

  • Every document is a named graph, and the page's markup asserts the same graph the URL serves as Turtle. You can extract the RDFa and compare the two.

  • SPARQL selects the data and XSLT 3.0 renders it, on the server and in the browser (SaxonJS). There is no separate JavaScript front end.

  • With versioning on, every write is a git commit and history is served over Memento (RFC 7089). Writes to existing documents are conditional (If-Match).

  • Access control is WAC over the document hierarchy. Its model is formalised in Lean, and the server is tested against it.

  • Every dataspace serves /AGENTS.md, so an agent uses the same Linked Data interface as a person.

The architecture is ten years older than this release. It came out of Linked Data projects in different domains and finding out what they had in common. The releases leading up to 6 are where it got the tooling it had been missing.

It is open source (Apache 2.0): https://github.com/AtomGraph/LinkedDataHub

The current release is 6.4.0. There is no data migration from 5.x, but the namespaces moved: https://docs.linkeddatahub.com/reference/migrating-from-5x/

Two public sites run it: https://linkeddatahub.com/ and https://linkeddata.lt/, which connects Lithuanian public registers into a single knowledge graph.

The architecture is developed from existing Web standards in my book, First Principles of the Web, free to read: https://firstprinciplesoftheweb.org/

I'd be interested in where this architecture would or wouldn't fit the applications you're building.


r/solidjs • • 10d ago

Working on docs for Birchly

4 Upvotes

r/solidjs • • 12d ago

Solid 2 made my soul cry.

31 Upvotes

Hi everyone! I want to share my thoughts here and, if possible, hear from others in the community.

I don't actually follow updates about Solid.js, and today I saw that Solid.js v2 will no longer feature synchronous rendering, and I am deeply disappointed because of it.

We have a large admin panel built on Solid.js, and the reason we picked it is the most straightforward rendering across any other UI frameworks I've been working with, and now, in version 2, it is gone.

As for me, even with all the problems, synchronous rendering was a killer feature on the market, as it made the code as easy to read as possible; it helped us to deliver features faster, with far fewer bugs than you usually having in React.


r/solidjs • • 19d ago

Any news on SolidJS 2?

36 Upvotes

I know they’ve been releasing RC versions for a while but I was wondering how far we are from a production ready release.


r/solidjs • • 21d ago

Made a Countup.js library but for SolidJS

10 Upvotes

It's basically just the countup.js library but I rewrote it in SolidJS (It's not just a wrapper over the original library!) so it's reactive!

In theory, it should very closely resemble the original library with most features implemented correctly and about 3.3kB minified, relying heavily on Intl.NumberFormat for formatting.

Is the website pure AI slop? Yes. Is the test suite also AI slop? Yes. But is the actual code itself AI slop? No, it's pure human slop! Anyways just wanted to try my hands on writing a library and felt like sharing it with others. Feedback is always welcomed.

Website: https://solid-countup.d6f4e5.me/

Gitlab: https://gitlab.com/d6f4e5/solid-countup (Or github mirror https://github.com/d6f4e5/solid-countup )


r/solidjs • • 22d ago

Reactive HTML Plots (RHP) 2.0 update

Thumbnail
gallery
22 Upvotes

Hi everyone!

So almost a month ago, I made a post looking for people interested in contributing to the open-source visualization library that I am working on. This library uses SolidJS to construct charts using HTML elements, CSS, and JS (<- implied of course) rather than drawing everything in canvas or an SVG. Since that post, I have gotten into communication with two people who are working on important goals we are trying to achieve.

In this period, a lot of progress has been made on many fronts.

First, let me link the project (if you like it, give the repo a star!):

Rhp 2.0 released and has seen significant improvements since.

Performance is one of those areas. Out of the gate rhp 2.0 shows top-tier speeds when it comes to data updates -> chart visual response. It beats out most other charting libraries in this. For example, a changed value reaches the screen in about 1 to 2.5 ms in Chromium, against 12 ms for Recharts and 16 ms for Chart.js.

The weak point still remains the DOM and the slowdown you get when you have many DOM updates occurring at once. The good news is we have made significant progress in this. Rhp can now do 1,000 bars updating at the same time repeatedly at 30fps.

Large data scatter plots were also a pain point due to CSS being customizable for every Dot component which means a ton of style calculations when you have 10,000 Dot components changing. So I created a special ManyDots component that incorporates optimizations and breaks some rules specifically for this case. Styling is handled differently for this component to achieve 20fps for 10,000 changing "dots" which is about a 2-3x performance increase.

Im proud to say that now, overall, I think RHP 2.0 is pretty competitive against many of the best libraries out.

(if your charts have like 20,000 or more changing elements, its still best to go with a library that draws charts in Canvas)

RHP MCP Server and Agent skill released

I also released an MCP Server and Agent skill so you can have AI agents create charts with your data! I improved this greatly and it works beautifully. From my tests, this skill produces better looking, less buggy, more professional looking Charts out of the box than the Claude's built-in dataviz skill. It requires more prompting to get the same level of output using the dataviz skill than rhp. However, rhp uses about 50-70% more tokens on average. The main reason for this is that rhp has a built in checker that checks and corrects common issues in Charts that are generated and the output "artifact" is a bit more sophisticated. Without asking for anything specific, the rhp skill will produce an HTML that displays the interactive chart. This HTML has some bells and whistles including a download button that downloads the chart in its latest state as a png. It also has a fit to screen view that resizes the chart so it can be viewed in its entirety at once without scrolling.

Out of the box, rhp skill/mcp:

  • Produces more original and creative charts. What this means is that when you don't tell the agent how the chart should look (what layout, palette, chart type), the skill will produce a different looking chart (that still shows what you want to show) 3 out 4 times while the dataviz skill does so about 1 out of 4 times.

  • Produces charts that look more like an infographic.

  • Produces charts that adjust layout or orientation to suit different screen sizes better (like phone screens). The dataviz charts just zoom in/out.

  • Styles UI inputs/toggles/buttons in line with Chart theme and aesthetic. These elements don't give the feeling that the same component library was used.

  • Packages the chart in an HTML that is easy to repurpose and has a modern, clean and simple viewer interface.

  • Output artifact is smaller and contains less code.

  • 45 recipes to guide chart construction and can also be used as style references in prompts

Overall, you get more with less prompting. I have already used it to create Charts that reached the top of the infographics subreddit last week.

What we are still working on

  1. Improving Agent Skill cost efficiency. Basically, making it leaner. The goal is to bring it down to +30% the cost of just using the dataviz skill. At this point, I believe what rhp skill produces is well worth the difference. Even currently I think it is worth it...

  2. Making a framework agnostic version. A collaborator is working on this. The tricky part here is keeping our performance wins.

  3. Better landing page


r/solidjs • • Oct 07 '26

Melbourne Compose - Functional Programming in-person Meetup. Thurs Oct 15. Ben Hutchison on "VDOM or Not VDOM"

Thumbnail
reddit.com
8 Upvotes

r/solidjs • • Oct 01 '26

A cool framework-agnostic animation library for streaming

12 Upvotes

Hey all,

I’ve been working on a small library called Stream Morph.

The idea is to make streamed responses feel less like content is constantly being appended/re-rendered, and more like the response is gradually taking shape.

Demo: https://stream-morph.vercel.app/

It’s framework agnostic and can be used with any kind of streamed content. The demo includes plain text, Markdown, code blocks, charts, images, reasoning sections, Mermaid diagrams and a few more complex response flows.

The library handles the motion between updates, while your own renderer/app stays responsible for the actual content. So it isn’t tied to a specific AI SDK or framework.

A basic example looks roughly like this:

import { createStreamMorph } from "stream-morph";

const stream = createStreamMorph(response);

for await (const chunk of incomingStream) {
  stream.write(chunk);
}

stream.finish();

I mainly built it because I wanted streamed interfaces to feel a bit more intentional without having to build custom animation logic for every response type.

The package itself is already working and the demo is live. I’m still cleaning up some things around CI, tests and the repo setup, but the GitHub repository will be open sourced shortly as well.

Would be interested to hear what people think, especially about the animation behaviour/performance and any edge cases you’d expect from real streaming responses.


r/solidjs • • Sep 30 '26

What's the equivalent of next and sveltekit for solid?

13 Upvotes

I want to build static site generation.


r/solidjs • • Sep 28 '26

Need a serious contributor to work with me on my open-source data visualization library

35 Upvotes

Hi guys,

I am looking for someone to work with me on a project called rhp (2.0) that has gotten pretty large in size. It is a solid-native charting/plotting library designed for web infographic-style data visualizations. Styling and interactivity were key to the tech stack choice and why I avoided SVG or Canvas for creating plots. This project was inspired by several beautiful and highly interactive hand-made (hard-coded) graphs and charts I found on a few websites I visited.

What I need help with

I need help revamping rhp-home which I now want to be the "product"-style landing page (even though this library is free and open-source). The current landing page can be repurposed somewhat but it still needs to be built out to sell people on using the library. We also need to work on framework ports or making rhp framework agnostic. Currently, I managed to get rhp 2.0 working server-side (again) and I created a react wrapper port. I want real ports because users of each framework need to be able to build their own plots without knowing solidjs.

I also need help finding and adding support/examples for other types of plots where data and information can be grouped together visually (for example, each data value has an associated image and labels and area in chart).

Also, I am evaluating a possible upgrade to Solid 2.0. I think its too early atm but if there are performance gains or other things that benefit this project, it is worth considering.

I also want to work on AI agent adaptors or mcp servers that allow agents to create these plots using the library (while at the same time, keeping developers as first class users).

Overall, rhp performs pretty well compared to many other libraries. It's of course slower than the fastest SVG and Canvas plotting libraries but thats expected given DOM and CSS which I do not want to give up (they are core features of the library). It's also pretty light-weight.

(below is extra info...its a long read)

---

Background to explain the current state of project

A long time ago (3 years ago) I created rhp which used to be short for react html plots. rhp (now called reactive html plots) is a charting library that is designed for creating interactive, dynamic, and visual infographic-type plots. Especially the types that are structured a certain way.

Obviously, I built rhp 1.0 using react and for multiple reasons such as size of user base. However, I over complicated and over-engineered the hell out of it. It was a mess because of two conflicting/competing directions I was trying to aim it towards. It was a mess but I learned a whole lot. I tried to force signal behavior and fine-grained reactivity in react to get better performance when data changes and even created a mini serializable virtual-dom. The pain of trying to squeeze performance and make it usable taught me what I should have done and how I should have built things from the start. Lessons learned. I got it working and performing ok but I was not satisfied with many things so I never promoted it. Anyways, I paused the project and put a disclaimer that I intended to revamp the whole thing.

I attempted a reworking a year later but it was a huge undertaking and stopped midway into refactoring and moving the project over to using solidjs instead of react.

Recently, thanks to AI and additional things I learned to keep in mind from my refactor, I was able to rebuild this project! Thanks to all of my notes and all of my existing code (that I coded prior to AI boom) I was able to give AI agents everything they needed and the correct instructions and specs to get this project as close to how I wanted it as I could. There were even additional places for performance improvements I was able to find thanks to Opus 5.5's performance testing approaches.

I wanted to talk about AI's involvement for transparency reasons and to make it clear that rhp 2.0 is currently an AI assisted project. However, the original code that the AI worked with and took from was all mine. Most of the endeavor was telling AI what I wanted it to strip out and explaining why I did certain things so it is aware of my goal and does not copy over things that no longer suit our goal or are superfluous/redundant. And also simplification and reorganization (reducing the number of blocks and their complexity..ie reducing excessive configurability).

More about RHP 2.0

rhp expects devs to code the CSS to style the chart themselves. Or grab styles from someone else's plot. Plot layout is simplified by reducing to the common denominator (a template component that we call a 'slat') which is built using a small number of building blocks. The result is that even if your plot layout is sightly different from someone else's, it is easy to adapt their CSS to work with yours. Sometimes it will be just plug n' play. This is explained in more detail in the docs.

EDIT:

If you see stutters in the video, it's something that resulted in the upload to reddit. There are no stutters in the actual video or the transitions/animations in the plots (that I can see).


r/solidjs • • Sep 25 '26

I made a route progress bar for Solid Router

Thumbnail
solid-route-progress.vercel.app
32 Upvotes

I built a route progress bar for Solid Router, since I couldn't find one for my SolidStart app.

  • SSR support

  • Full-page navigations via the Navigation API

  • Styling with CSS variables or Tailwind CSS v4

  • ~2.8 KB, no dependencies

demo: https://solid-route-progress.vercel.app/

https://stackblitz.com/github/kecan0406/solid-route-progress/tree/main/examples/solidstart?file=src%2Fapp.tsx

github: https://github.com/kecan0406/solid-route-progress

Feedback welcome, especially on any edge cases I missed!


r/solidjs • • Sep 22 '26

The Grand Unifying Architecture of Frontend

Thumbnail
dev.to
81 Upvotes

Solid 2.0's async design is not a happy coincidence. But the result of chasing finally being able to unify all frontend architecture.


r/solidjs • • Sep 15 '26

I ported evilcharts for solidjs use

14 Upvotes

I ported EvilCharts to https://solid-evilcharts.pages.dev/

EvilCharts is a set of good-looking React chart components built on Recharts and Echarts. I was building a dashboard in solidjs and i needed charts, so i ported it. AI helped a lot.

Right now, i am leveraging the use of Echarts only. After this is stable, I will add a layer for tanstack charts.

Please check it out, try it out (hopefully it works hahaha) and lemme know what you think.

repo is here: https://github.com/thesambayo/solid-evilcharts

P:S:
also working on https://solid-arc.brimble.app/
a shadcn-like setup for solidjs that uses ark ui as the base component system.
ark ui is pretty first class for solidjs as well.
https://github.com/thesambayo/solid-arc


r/solidjs • • Sep 04 '26

A typed Promise.race() with keyed results and optional cancellation!

Thumbnail
npmjs.com
9 Upvotes

Hola guapas,

I made a small ESM-only utility called better-race.

The idea is simple: Promise.race() gives you the first value, but not where it came from. This keeps the task key connected to its value in TypeScript:

import { race } from "better-race";

const winner = await race(
  {
    eu: ({ signal }) => fetch("https://eu.example.com/user/42", { signal }),
    us: ({ signal }) => fetch("https://us.example.com/user/42", { signal }),
  },
  { abortLosers: true },
);

console.log(winner.key); // "eu" | "us"
console.log(winner.value); // Response

It also supports AbortSignal and optional loser cancellation.

It’s intentionally tiny -> no scheduler, framework adapters, retries, or dependencies. I’d genuinely appreciate feedback on the API and semantics.

The next tag also includes raceUntil(): it keeps racing until a result passes an accept predicate, so an early null does not have to win.


r/solidjs • • Sep 03 '26

Good example of an API for state that is sharable between different pages?

8 Upvotes

Kind of really struggling to think of what a nice API should look like for fetching & storing data that is meant to be kept in client-side state across page visits.

I understand that things like fetch calls should go into createMemo blocks so that they could be utilized by Loading and Errored boundary components, but what if that data needs to live across page visits?

I can put a const user = createMemo(() => api.fetchUserData()) in the main entrypoint component, but then I'm kinda lost when I want to keep the user state when moving to a user profile page.

In e.g. Vue it's typical I believe to fetch when mounting a component, then save the result to some other module which will be imported from another page and have access to the same state that was just fetched. With Solid 2, well, I'm not sure how to move/keep the state that was acquired asynchronously across components.

Maybe I'm missing something from the API (I have to confess I've yet to read a lot of the docs), but so far it feels a lot more complicated that expected. If it helps, my backend is not TS, so I'm not using any of the server/ssr features.

I remember using a similar API such as this in a project a couple years back. Can't think of how this should look like in idiomatic solid :(

  const fetchData = () => {
    http.getAuthUser({
      onSuccess(data) {
        userStore.setUser(data); // userStore is then imported in a different page, the data kept and ready to use
      },
      onUnauthorized() {
        //
      },
      onServerError(err) {
        toasterStore.show(err);
      },
    });
  };

r/solidjs • • Sep 02 '26

I'm building Solid Native

72 Upvotes

I've been building React Native apps for a long time. They all start fast. Keeping them fast as they grew is another story.

More state, more dependencies, more devs, and suddenly you are doing re-render arithmetic in your head. Is this selector too broad? Did that context wake the whole screen? Is the animation fighting the JS thread?

Obviously large React Native apps can be built. I'm just tired of what it takes to keep a large one feeling fast.

And then I found Solid.

To my React-trained brain, Solid felt like React if someone removed the part I had spent years optimizing around. Same JSX and components, but components run once and signals update only what depends on them. No virtual DOM. No reconciliation. No wondering whether one innocent change froze the whole app.

That was the part that made everything click. I wanted that feeling on a phone.

Kind of by accident, I also found react-native-graph, which draws with Skia and is extremely fast. It made me wonder what would happen if the whole application was rendered that way.

So I went down a rabbit hole. Turns out Flutter already owns its rendering pipeline (used Skia, now Impeller) and it's fast. Bun + JavaScriptCore, which is also one of the fastest JS engines out there, gave me the web APIs I was tired of polyfilling.

Now I had the three parts: Solid for the application, Bun for the JavaScript runtime, and Flutter for rendering.

So I cross-compiled Bun to run on iOS and Android, put Solid inside it, and let Flutter render what Solid describes.

I named it Skal, a mixture of Solid + Skia. (It also means cheers if you have ever watched a Viking show šŸ». )

I think of it as Solid Native.

Solid's universal renderer turns JSX into binary UI operations written into shared memory. Flutter reads the same bytes and renders the widget tree. No JSON or platform channel in the hot UI path. No DOM. No WebView.

When a signal changes, Solid already knows the exact consumer, so Skal sends the operation for that node and stops there.

It currently has 49 fast-path widget types, navigation, persistence, animations, overlays, and some native integrations. It runs on Android arm64, iOS, macOS, and the web. It is still early.

Here are some results from a Samsung Galaxy A14 5G running Android 15, with release builds on both sides and interleaved runs:

TestSkalReact Native
Dropped frames, image feed013
Tap to render, median3.53 ms7.30 ms
One frame of work (200 components x 10 reads + 1 update)0.05 ms0.80 ms
State updates per second, 288 cells103,8464,901
Idle CPU1.20%6.93%

What excites me is writing Solid code, running it on a real phone, and knowing that as the app grows, it still flies.

To try it, you need Bun and Flutter installed on your computer, plus the normal Xcode or Android tooling for the platform you want to run. Then:

npm create skal my-app
cd my-app
bun run dev:ios # or dev:android, dev:macos, dev:web

Or throw your AI at the Markdown docs.

Repo: https://github.com/skal-multiplatform/skal

If you already use Solid, what would Skal need before you would try it for a real mobile app?

Skal šŸ»


r/solidjs • • Sep 02 '26

I made Testate with solid 2.0, git-style snapshot, restore and diff for test databases

Thumbnail
gallery
7 Upvotes

I built Testate on Solid 2.0.0-rc.4 (solid-js + @solidjs/web, Vite plugin 3.0.0-next).

It's a self-hosted tool that snapshots the databases behind a system under test, restores any snapshot in seconds, and diffs what a test changed. ~180 TS/TSX files, ~12k lines of Solid, 147 user stories exercised end to end in a browser.

Repo: https://github.com/PT-Perkasa-Pilar-Utama/testate

Site: https://pt-perkasa-pilar-utama.github.io/testate/

Things that bit me on 2.0, and what I did about them.

1. There is no component library for Solid 2.

Ark UI, Kobalte, Corvu, and some on top of that like nikala, all target 1.x and the peer range lies:
I counted the missing APIs and gave up. Everything is hand-rolled on Tailwind: dialog, menu, tabs, toast, table parts. Forms were the exception. Formisch runs on 2.0 with a two-function patch (details in point 3). Make sense because still rc.

2. A flush loop in @solidjs/signals rc.4.

The dev build threw "Potential Infinite Loop Detected" about three times in ten full test runs, always on the data grid, never reproducible by hand. The production scheduler runs the same loop with no counter, so there it hangs instead.

Cause: setSignal re-opens a node's finished transition before it checks whether the write changes anything. A Loading boundary writes false over false on every drain pass, the transition looks live again, the drain goes round.

Nothing is dirty, nothing recomputes. Fix is one line, clearing the stamp in commitPendingNodes; it's a bun patch in the repo and upstream as solidjs/solid#3143 (closes #3140).

3. batch is gone, and a read after a write returns the old value until flush.

Formisch writes then reads inside one batch (reset above all), so on 2.0 a reset silently kept the old input. Patch: batch = fn => { const r = fn(); flush(); return r }.

4. STRICT_READ_UNTRACKED and FLUSH_IN_EFFECT_CALLBACK from a <dialog>**.**

Calling showModal() / close() inside an effect fires the browser's focus/blur handlers synchronously, and the form library reads signals in them. Solid 2 reports the reads as untracked and discards the writes' flush.

Both diagnostics come with no stack. I found where by wrapping console.warn in a Playwright addInitScript and printing new Error().stack for the matching code. Fix: open and close in a queueMicrotask. Same fix for onClose, which the browser fires while still dismissing.

5. onCleanup inside a 2.0 effect callback never runs.

The callback runs with no owner. Return the disposer from the effect instead; a setInterval I registered with onCleanup outlived the screen until I learned that.

6. Reading a pending async memo outside

<Loading> loaded fine under Vite and spun forever in the production bundle, ~250 requests a second. Two screens shipped that way. There's now an e2e project that drives the built bundle, not the dev server, and counts requests per endpoint per screen.

Lint carries the lessons: two-argument createEffect only, props read inside JSX or a tracked scope, class as a string or structured array, cyclomatic complexity 10, 300 lines a file.

Playwright's console watcher fails the run on any [A-Z_]{6,} warning code Solid's dev build emits, which is how most of the above got caught.


r/solidjs • • Sep 01 '26

Nikala UI – SolidJS + Tailwind v4 component system (now with Tauri v2 & SolidStart support)

29 Upvotes

Hey folks!

I’ve been building Nikala UI, a copy-paste component system and reactive primitives suite for SolidJS and Tailwind CSS v4.

I recently added desktop support for Tauri v2 alongside standard web apps and SolidStart.

You can check out all the components, hooks, live playground, and built-in MCP server directly on the site.

If you like the project, dropping a star on GitHub would mean a lot and gives me the motivation to keep actively building and improving it!

Site & Docs: https://nikala.dev
Playground: https://nikala.dev/playground
GitHub: https://github.com/nikala-ui/ui


r/solidjs • • Aug 29 '26

A small loader library that got slightly out of hand

19 Upvotes

Hey y’all,

I got slightly carried away with loading animations.

I wanted nicer loading states for my own projects, but most libraries I found were either tied to a framework, fairly limited, or required more than I wanted for something this small.

So I built loadersz, a small framework-agnostic loader library for the web.

I wanted something a bit more expressive than the usual CSS spinner, without pulling in a UI framework or a bunch of dependencies.

A few things I focused on:

- 150 (and more coming) different motion states
- Canvas 2D instead of GIFs/videos
- zero core dependencies
- a native custom element, so it works with basically any stack
- typed entry points for React, Vue, Angular, Svelte and more
- configurable speed, density, radius and color
- respects prefers-reduced-motion
- pauses rendering when the browser tab is hidden
- DPR aware/scaling
- tree-shakeable, attributes/config and lifecycle

Basic usage is just:

npm install loadersz

import 'loadersz';

<loadersz-loader state="racing" size="96" />

I also built an interactive playground where you can tweak the loaders live.

Demo: [loadersz.vercel.app](https://loadersz.vercel.app)
npm: [npmjs.com/package/loadersz](https://www.npmjs.com/package/loadersz)
Github: https://github.com/lumberjacque/loadersz-core

Would love some brutally honest feedback, especially on which animations you’d actually use in a real product.


r/solidjs • • Aug 26 '26

Async Solid - One Graph, Two Machines

Thumbnail
solidjs.com
41 Upvotes

r/solidjs • • Aug 26 '26

Is SolidJS no longer the fastest?

Post image
44 Upvotes

I remember that one of SolidJS’s initial selling points was its speed. In fact, that was one of the main reasons I would have chosen SolidJS over React or Vue if I were building an SPA.

However, looking at these benchmarks (https://octanejs.dev/benchmarks), it seems that other UI frameworks have caught up. Vue even appears to be faster now.

If I were choosing a UI framework today, why should I choose SolidJS over the alternatives?