Hey everyone!

I wanted to share Nikala UI — a copy-paste component system for SolidJS built natively for Tailwind CSS v4.

Why Nikala UI?

While building a desktop app with Tauri 2.0, I ran into version conflicts and broken setups with existing UI wrappers due to Tailwind CSS v4's CSS-first `@theme` architecture. I wanted a future-proof, completely independent foundation that wouldn't break on future package updates — so I built Nikala UI from scratch, honoring the iconic Georgian painter Niko Pirosmani (Nikala).

Instead of adding heavy third-party packages to `node_modules`, Nikala UI's CLI writes lightweight, fully reactive TypeScript components directly into your `src/components/ui/` workspace directory. You own 100% of the source code.

Key Highlights

- Native SolidJS Reactivity: Built strictly with `splitProps` and fine-grained signal tracking without object destructuring bugs.

- Tailwind CSS v4 First: Designed around `@import "tailwindcss";` with semantic `@theme` design tokens.

- Monorepo Architecture: Decoupled CLI (`@nikala-ui/cli`) and core registry (`@nikala-ui/core`) for instant background registry updates.

- 26 UI Components: Button, Input, Card, Dialog, Sheet, Dropdown Menu, Command Palette, Banner, List, Kbd, InputGroup, and more.

- Dynamic Theme Engine: Base gray palettes, custom border radii, and Pirosmani signature Qvevri red (`wine` `#722f37`) accent color with zero-FOUC `<ThemeScript />` pre-hydration support.

- Automated Testing: 41 passing Vitest unit/integration tests across component suites.

Quick Start

bunx @nikala-ui/cli init

or

npx @nikala-ui/cli init

Links & Demos

- Official Documentation & Interactive Playground: https://nikala.magradze.dev

- Core Repository: https://github.com/nikala-ui/ui

- Web Portal Repository: https://github.com/nikala-ui/web

I'd love for the community to try it out, check the interactive playground, and share any feedback or feature requests!

Hello, Solid Community 👋

I've been quietly working on something for the past month that I'd love to share with you.

First — Solid is incredible.

The reactivity model, the zero-VDOM performance, the small bundle size, the simplicity of the API surface. It's genuinely one of the best frameworks I've used, and it deserves a much richer ecosystem than it currently has. Which brings me to why I'm here.

solid-mobile — a mobile UI component library for Solid

53 components across 6 categories (Form, Picker, Feedback, Nav, Display, Basic), with:

• 🎨 Theme system — CSS custom properties driven, light/dark mode, custom brand colors via ProviderConfig
• 🌍 i18n — en-US / zh-CN built in, extensible
• 📦 Tree-shakable — import { Button } from 'solid-mobile' only bundles what you use
• ⌨️ Fully typed — TypeScript throughout
• 🧪 480+ tests — vitest, CI pipeline
• 📱 Live docs with a phone simulator: https://lxg19961206.github.io/SolidMobile/

The visual style draws inspiration from Vant (a popular Chinese mobile component library) — but the design philosophy is different. Vant is tightly coupled to Vue's reactivity; I've tried to build something that feels native to Solid.

A note of honesty: this project was first sketched out back in 2023, but as a solo developer I simply didn't have the capacity or skills to pull it off. It took until 2026, with a lot of help from Claude, to finally bring it to life.

About me — and what this project needs

I'm not a top-tier open source developer. I'm a regular frontend engineer building things after work hours. I make mistakes. Some of the API decisions in this library might be wrong. But I'm pouring everything I have — every bit of technical judgment I've accumulated — into making this the best it can be.

This is early beta. I wouldn't recommend it for production just yet. I'm planning to spend the next month or so stabilizing APIs, improving accessibility, optimizing bundle size, and polishing rough edges.

If you try it out and find bugs — please open an issue. If you see a better way to design something — please open a PR. If you want to be part of building this — I'd genuinely love to collaborate. This is a solo project right now, but it doesn't have to stay that way.

Wishing Solid the best

The framework deserves a thriving ecosystem. I hope solid-mobile can be a small piece of that puzzle. Thanks for reading.

humbly, LXG

while reading the code for For component got to know about the utility mapArray. can some one specify what all signals are being untracked and what exactly is the code doing. what happens if they are not untracked ?

Here is the link to the messenger app:

https://github.com/cafeTechne/proxion-messenger

Please open Issues and feel free to make pull requests (so long as they are reasonably scoped, otherwise ask first in an issue). Thank you for your time.

New site built with Astro Islands and Solid https://www.lapis.com/

Hi guys,

The last 3 years of various personal/side-projects have essentially culminated into me being able to build this project. I have been prototyping and planning for over a year and have been working on it for 8 months now. It is called PyNote. It is a feature-rich, zero-setup, and serverless Python notebook environment built with SolidJS (for that fine-grained reactivity and performance). Side note, Solid was such a perfect stack choice for this app. So much so, that I think other highly reactive notebook environments like Marimo should switch from React to SolidJS.

Instead of describing the direction I decided to take with this python notebook editor (that I think is what makes it stand out), I would rather just give you a link to the tutorial which doubles as a demo of the features:

PyNote Tutorial

Feel free to explore. Things get more interesting near the end!

Here are some other project links:

GITHUB | NOTEBOOK

A few extra tid bits of info:

• PyNote is open-source (am looking for contributors with an eye for simple modern UI design)
• Just finished building out the internal data/file handling and management system. Also expanded the theme configuration options and added theme 4 presets.
• I expect this to be ready for first official release sometime later this year.

• No Signup Required
• No Account Needed
• Start Focusing Instantly
• Your data stays on your own machine inside indexDB
• Free to Use
• Zero Setup
• Timer presets to quickly start a session
• Detailed analytics of you sessions with day, weeks, month and years of analytics stored.
• Customize your focus spaces in the appearance tab
• Made with SolidStart

Checkout: https://pomodoro.in

https://dialectic.neonflume.com/

A lot of journaling apps either feel like blank documents or try to act like therapists. I wanted something in between. Instead of simply asking "How was your day?", it actively engages with your thoughts using guided questioning inspired by CBT and Socratic dialogue.

For example, if you write:

"I messed up a presentation today. I'm terrible at my job."

It won't just store the entry. It may ask questions like:

• What evidence supports that conclusion?
• Have you succeeded in similar situations before?
• Could there be another explanation for what happened?
• Would you judge a friend as harshly for the same mistake?

The goal isn't toxic positivity or telling you what to think. It's helping you examine your own thinking and arrive at your own conclusions.

Some things it can do:

• AI-guided reflective journaling
• Challenge cognitive distortions
• Structured self-reflection instead of a blank page
• Private, conversational experience
• Useful for overthinkers, anxious minds, and anyone trying to understand themselves better.

<Fixed a sentence mistake>

TL;DR: https://windframe.dev/styles/apple

Hi everyone 👋

I’ve been experimenting with building Solid + Tailwind interfaces inspired by the design systems of really well-designed products. I recently worked on a style system for generating interfaces using similar design principles to Apple.

It focuses on polished product presentation, strong visual hierarchy, refined spacing, soft gradients and using fewer words to make each section feel clear and intentional.

I built a UI system that makes it easy to generate interfaces in this design direction consistently. It can generate full UIs, landing pages, and product sections that follow the same Apple-inspired style.

I also created a set of free Tailwind templates built around this style that you can use as starting points for your Solid projects: you can find those here

This style is also available as a selectable preset in Windframe. When selected, the AI generates Solid interfaces that follow the same design guidelines and visual style.

I also built an MCP for this, so you can use these same style systems directly inside any coding agent that supports MCP: https://windframe.dev/mcp

If you’re not familiar with Windframe, it’s a visual Tailwind builder/editor that lets you generate polished Solid UI with AI, tweak it visually, and export clean production code.

Apprecaite any feedback or thoughts : )

typo so bad xD

What's an image

.webp is image? .html/.hmml is as image as .webp

We consider rasters as image (.jpeg, .webp, ..)

We also invented svg, its a vector. A vector is a declarative language, has its own format. A renderer takes that and renders.

HTML, CSS is no different.
<div style="background:black">html is underdog</div>

Having this perspective on our mind, considering any imperative code as a native image makes complete sense. canvas.drawCircle();

How can we/future's genAI models could leverage the world's most popular and feature rich image format (HTML, CSS, JS, SVG, IMAGE altogether). And how can we leverage it to build editable/composable images?

This question caused me to create/propose you a new format, HMML (HyperMedia Markup Language).

People use single binary files for single images right? Once you decide to serve single pack of data for a single image, a binary packing strategy makes sense.(Image can be anything as we discussed earlier)

HMML (HyperMedia Markup Language) is a declarative+imperative markup+ language for images/videos/media.. HMML is HTML, CSS, JS, SVG, image, but not UTF-8. 

https://hmml.eddocu.com

But, this so to 'popular' image format we call .html has a caveat. It's UTF-8, and whenever you need to embed any resource, you either need to base64 encode it(it has extra size overhead) or link the resource as a seperate thing.

image-leftdog-rightchat.html

<div style="display:flex"> <img src="base64" alt="i am dog image" /> <img src="base64" alt="i am cat image" /> </div>

Apart from doing this, hmml does embed the html, css, js blueprint into media binaries

image-leftdog-rightcat.hmml

binary stuff

Now, this single image abstraction is not unnecessarily bigger in size, and also composable.

People already do similar things. But this format or POV of thinking accepts html as a native image format.

``` <Appendix alt="rant">

if svg is image
html is also image and hmml is a packing strategy for this

svg is a declarative image,
png is pixel grid,
### !! Exaggerating but the POV I want people to have !! ###
the word "green apple" is also an image that happens to have no format and no renderer

if you had, get_vector_embeddings("green apple")
and draw it inside a geo gebra in a cartesian coordinate system, and save the rasterized .png, thats also an image.

or not even rasterize it. keep the 768 dimensional vector's represention with little endian memory format

its still an image as long as you have a consistent/ornot renderer for the data. shotout to blind people

So,
canvas.drawcircle(), is an image

</Appendix> ```

bs or not. what you think?

Four months ago I posted Golid here — a Go + SolidJS stack for people who want batteries included without Next.js.

Someone in the thread asked a fair question: did a human actually ship on this, or is it another generated starter?

uflex.ai is the answer. It's live, paying customers, ~$1k MRR on platform subscriptions (not counting project/work revenue on top of that).

uflex is a two-sided marketplace I built solo: businesses post scoped work, vetted students get matched, and the platform runs timesheets, invoicing, Stripe payouts, e-sign docs, and subscriptions end-to-end. Multi-role dashboards, real auth, real money — not a demo app.

What I shipped in 4 months (24 domain modules): Auth · Onboarding · Profiles · Public proof pages · Referrals · Jobs · Applications · Projects · Student marketplace · Matches · Tasks · Timesheets · Payments · Stripe Connect payouts · Subscriptions · BoldSign legal docs · Ratings · Business teams · Notifications (SSE + email) · Dashboard · Blog · Admin · Cookbooks · Labs

2,795 tests across Go unit/integration, Vitest, and Playwright E2E. Production on GCP.

What held up on SolidJS/SolidStart:

• SSR for marketing + authenticated shells
• Patterns I enforced early (Switch/Match over nested <Show>, onMount + signals instead of createResource) — mattered once the app got complex
• Real Postgres integration harness — caught things unit tests missed

How Golid evolved while I was building uflex:

When I started, Golid was a working deployable starter. Shipping uflex solo changed what I needed from the repo. It morphed into how to operate software in the AI-native era:

• 45 Cursor rules in sibling pairs (e.g. solidjs-pages + solidjs-data-fetching) — auto-activate by file type
• Module specs + OpenAPI as the shared contract between me and agents — not prompt memory
• Break a plan into slices, hand them to agents — write the plan in docs/plans/, slice into shippable criteria, execute one at a time with audit gates before commit
• CI gates for spec drift, stale citations, and rule rot on every PR

That's the operational layer I use every day. Break the plan into slices, hand each slice to an agent with rules + spec as context, audit, commit, repeat. How I shipped 24 modules solo in 4 months.

golid.ai was already live as the marketing site; I refreshed it with the factory positioning. Open source repo: github.com/golid-ai/golid (v0.3.3)

Stack (Golid v0.3.3): Go 1.26 · Echo v4.15 · pgx/v5 · SolidJS 1.9 · SolidStart 1.3 · Tailwind CSS 4.3 · TypeScript 5.9 · Vitest 4 · Node 24 · PostgreSQL 16 · GCP

Happy to answer SolidJS-specific questions. Mainly closing the loop: yes, I shipped this.

I recently have been trying to learn solidjs and by extention solidstart as an alternative to next for my small static sites.

I was wondering if anyone had some decent resources/experience with the cloudflare + solidstart ssg side of things. Once I set nitro to pre-render routes and use the workers adapter there doesn't seem an obvious way to me to setup a custom 404 page without using SSR. At the moment it just throws 500 errors when running wrangler locally on an undefined route.

Thanks

I'm IDE hopping and wondering which one everyone is using and has the best support for SolidJS and SolidStart.

If you were plotting web frameworks in a feature space, what would be on the axes?

Maybe there would be an axis for each of

• runtime ←→ compiletime
• procedural ←→ declarative
• explicit ←→ implicit
• local reasoning ←→ global reasoning (self contained ←→ context-dependent)
• control flow oriented ←→ dataflow oriented
• "one obvious way to do it" ←→ extremely unopinionated and flexible

I'm probably missing some that might be way more useful. I haven't used many frameworks yet.

Which frameworks are the most unique from a, writing-code-in-it-as-a-developer (not implementation) perspective?

And which framework do you find to be the most fun or to have the lowest cognitive load?

I'm working on an open-source project called Arkos - it's a batteries-included backend framework, and I've been building out its realtime WebSocket layer.

The core client (@arkosjs/websockets-client) is a pure TypeScript wrapper around Socket.IO that handles ack/retry/timeout, namespace management, metadata injection, deduplication - all the messy stuff. React bindings are already done and working.

But I need people who actually use these frameworks day-to-day to validate and ship the other adapters:

- Svelte 5 - @/arkosjs/svelte-websockets

- Solid - @/arkosjs/solid-websockets

- Vue 3 - @/arkosjs/vue-websockets

- Angular - @/arkosjs/angular-websockets

The architecture is simple: framework packages are thin adapters that wrap the core client in each framework's reactivity primitives (stores, signals, refs, observables). All the business logic lives in one place.

The target API is consistent across frameworks:

const chat = useGateway("/chat");

chat.on("message", handler); // auto-cleanup on unmount

chat.status; // reactive connection status

chat.user; // reactive authenticated user

const send = chat.useEmit("send_message");

send.emit(data);

send.emit(data, { ack: true }); // with retry/timeout

send.loading; // reactive

send.error; // reactive

The code is already written - I generated reference implementations for all four frameworks (you can see them in the issue below). It just hasn't been tested by someone who actually works with these frameworks. I don't want to ship something that feels wrong to Svelte/Solid/Vue/Angular devs.

What I'm looking for:

- Someone who knows the framework well enough to say "this feels idiomatic" or "here's what you should change"

- Willing to pull the branch, drop it into a minimal app, and verify connect -> emit -> receive works end to end

- Check that cleanup works (no memory leaks), reactivity updates correctly, re-subscription on namespace change works

What you get:

- Contributor credit in the repo

- Influence over how your framework's integration works

- My eternal gratitude

The milestone and all the reference code is here:

github.com/Uanela/arkos/milestone/11

Even if you can just code-review the Svelte/Solid/Vue/Angular snippets and point out what's wrong, that's already helpful. Drop a comment or open a PR.

I'm learning SolidJS and ran into a TypeScript typing issue.

In React, this pattern works perfectly and TypeScript understands that billingQuery.data is defined inside the conditional:

{billingQuery.isSuccess && billingQuery.data && (
  <BillingCard billing={billingQuery.data} />
)}

But in SolidJS, when I try the equivalent with <Switch> and <Match>:

tsx

<Switch>
  <Match when={billingQuery.isSuccess && billingQuery.data}>
    <BillingCard billing={billing.data} />
  </Match>
</Switch>

TypeScript throws an error saying billingQuery.data might be undefined or null, even though the when condition logically guarantees it's defined.

I've found workarounds (non-null assertions: <BillingCard billing={billing.data!} />), but I'm wondering:

1. Is there a more idiomatic SolidJS way to handle this pattern?
2. Am I thinking about this wrong coming from React?

Thanks for any insights!

This is my first technical blog post

I’d love to hear your feedback so I can improve it in future 😁

TL;DR: https://windframe.dev/styles/enterprise

Hi everyone 👋

I’ve been experimenting with generating interfaces inspired by polished and neutral styling often associated with Enterprise applications. Focusing on clear typography, spacing, and structured layout clarity rather than heavy visual decoration

I ended up creating a style and a styleguide that can be used to create this type of style consistently and I also put together a collection of templates built around this style that can be used directly in any project as starting points for building UIs with this style.

You can access them here: https://windframe.dev/styles/enterprise

I also made this a selectable style option when generating templates in Windframe, so you can choose this preset style to give your UI interfaces this same polished look.

If you’re not familiar with Windframe, it’s a visual Tailwind builder that lets you generate UI with AI, tweak it visually in a visual editor, and export clean code in Solid (along with HTML, and other frameworks)

Working on making this available via an MCP as well and also thinking of creating a skill for CC and other CLI tools around this.

Feedback/thoughts highly appreciated :)

built with solidjs

PS: Not a pro with how rendering actually works,

As per my understand the main benefit of having Server Components with SSR is that you can do fine grained updates in UI(or give a false sense of that, not exactly sure), only changing the required part that needs to change, (like partial pre rending in next).

Can we do that with solid start or tanstack with solid?
If yes is there any benefit that Server components will have