SolidJS pattern in other languages and frameworks

[JakkuSakura]

Hi all, I'm big fan of SolidJS. I wonder if there are SolidJS pattern libraries in other languages?

I've implemented SolidAvalonia and feels like I can use best of both worlds.

// 1. Create signals for state management
var (count, setCount) = CreateSignal(0);
var (step, setStep) = CreateSignal(1);
var (doubledCount, setDoubledCount) = CreateSignal(0);

// 2. Create derived values with memos and effects
CreateEffect(() => { setDoubledCount(count() * 2); });

private Component<TextBlock> CreateCountDisplay(Func<int> count, Func<int> doubledCount, Func<bool> isPositive)
{
    return Reactive(() => new TextBlock()
        .Text(() => $"Count: {count()}, Double: {doubledCount()}")
        .FontSize(16)
        .TextAlignment(TextAlignment.Center)
        .Foreground(() => isPositive() ? Brushes.Green :
            count() == 0 ? Brushes.Blue : Brushes.Red
        )
    );
}

I also attempted to implement one for gpui-rs, but I no longer use gpui anymore due to it's slow compile time and less mature ecosystem

[manimovassagh]

Cool project! There are a few notable implementations of the SolidJS reactive pattern in other ecosystems:

Rust:

• Leptos — probably the most well-known. Full-stack Rust web framework with signals, derived signals, and effects that are very close to the Solid model. Even the API naming (create_signal, create_memo, create_effect) is directly inspired by Solid.
• Sycamore — another Rust framework with fine-grained reactivity similar to Solid.

Kotlin:

• Compose (Jetpack Compose / Compose Multiplatform) — while the API surface looks different, the compiler-driven reactivity model shares DNA with the Solid approach. State reads are tracked, and only the composables that read changed state recompose.

Swift:

• SwiftUI @State/@Observable system is conceptually similar — property-level reactivity with automatic dependency tracking.

C#/.NET:

• Your SolidAvalonia project, and also Blazor reactivity (though more coarse-grained).

General/Multi-language:

• TC39 Signals proposal — there is an active TC39 proposal to bring signals into the JavaScript language spec itself, partly inspired by SolidJS, Preact Signals, and Angular Signals. If this lands, we will likely see fine-grained reactivity primitives adopted across many more frameworks and languages.

Leptos is probably the closest in spirit to Solid — Ryan and Greg Johnston (Leptos creator) have discussed the design parallels extensively.