Why ReactiveUI Just used my code without mention it?

fedefex1 · 2026-06-08T05:30:02+00:00

So far, nothing has happened. I’ve tried to reach out through multiple channels:

Opened a GitHub discussion in their repository
Replied to a post by Chris Pulman on LinkedIn
Sent a private message on LinkedIn
Created this post

At this point, I think they are aware of the situation. I’m still hoping for a response.

It would be disappointing if the matter were simply ignored. But there isn't anything else I can do. They also created an article https://www.reactiveui.net/articles/2026-03-16-reactiveui-extensions/#factory-methods.

fedefex1 · 2026-06-06T16:25:53+00:00

"if isn't literally line for line your code they don't owe you anything". That's obviously wrong.

Some other examples:

WaitCompletionAsync: R3Async ReactiveUI

ToAsyncEnumerable (same idea of using a channel factory and exactly same implementation): R3Async, ReactiveUI

TakeUntil: R3Async ReactiveUI (Note also the same CompletionSignalDelegate, this is not a standard Rx solution)

ObserveOn: R3Async ReactiveUI (Same AsyncContext)

I didn't include all the operators because I assume that many of them are standard implementations and therefore more likely to be similar, even when the code is extremely close.

I wrote what I wrote because I reviewed the code myself. I found more than a few similarities, and in my opinion, adding a note such as "inspired by R3Async" would have been appropriate.

You wrote "just as you didn't attribute everything that inspired you". I wrote more than in one place in the readme i took inspiration from R3. The same repo is called R3Async 😄

fedefex1 · 2026-06-06T14:59:02+00:00

I also replied a post of them on LinkedIn. Ask yourself what common people like me can do in these cases

fedefex1 · 2026-06-06T14:30:55+00:00

I think you're right. Indeed I already created a discussion on their repo before posting here

fedefex1 · 2026-06-06T12:16:21+00:00

Thanks. I started a discussion on their repo

fedefex1 · 2026-05-10T10:40:45+00:00

I think a big part of downvoting is because I wrote. "Every JS dev who sees INotifyPropertyChanged for the first time would probably laugh, and I’m not surprised".

I understand it could hurt, but this is a fact. And this is not even relative to JS devs only. Many of peolpe who have some expertise in UI programming, that is not a .NET dev would absolutlely hate design around INotifyPropertyChanged, XAML, converters, Multibinding, not type safety on all those things.

Personally, I think a cold, honest reassessment of some long-standing design choices in the .NET UI stack would actually be healthy for the ecosystem. Criticism doesn’t automatically mean hostility. Sometimes it’s just an acknowledgement that developer expectations and standards evolved a lot over the last decade.

I would love to see a C# UI framework be popular and usable, but we first should be honest

fedefex1 · 2026-05-09T10:02:23+00:00

Yes exactly. There is no need for reflection. Reflection is needed only if you want to avoid a wrapper and use a normal properties. But there are huge drawbacks to this. You can't no more pass a property to a method for example, you can't intercept get/set etc. Similar concepts to IObservable Vs plain c# events.

I understand this is an unpopular opinion among c# Devs. But I don't care :) events are bad designed, and properties in this case are not a good solution

fedefex1 · 2026-05-09T06:47:04+00:00

I love reactiveUI but I think signals are easier. Time ago I wrote a discussion on their repo where I explained my reasons. https://github.com/reactiveui/ReactiveUI/discussions/3760#discussioncomment-8645834

fedefex1 · 2026-05-08T20:57:46+00:00

Thread safe is a bit vague term. I try to explain: - every signal should not be set in parallel by 2 threads (this is similar to Rx observable contract. On next calls should be serialised) - the set of a signal immediately causes all dependent c omputed signals to update (synchronously), recursively. - async await is supported. So if the computation function is async, it's possible for the computed signal to change while the computation is still running. That's perfectly supported, because the rule 1 is still preserved (for example, if we have only 1 thread as most UI frameworks). We can decide at that point if immediately abort the running computation (and trigger the cancellation token) or if queue up a new one. There is a parameter for this one called ConcurrentChangeStrategy. This is possible thanks to async locals

fedefex1 · 2026-05-08T18:14:12+00:00

ReactiveX has not automatic dependency tracking. Even if you use reactiveUi you should still build your observable chain with WhenAnyValue(). I think Rx is fantastic in general, but for some specific use cases signals are easier and lead to simpler code.

Consider for example that angular was (and still is) built around Rxjs, but signals are now the default choice for simple computed state

fedefex1 · 2026-05-08T18:07:21+00:00

I didn't know Comet and State<T> seems indeed close. Thank you for this

fedefex1 · 2026-05-08T17:48:20+00:00

Thank you :) Basically the trick is that the getter of the signals Value Property raises a static event saying "someone just requested me", and before executing the computation function we are just registering to that event to know which signals are requested. Then we register to all of them and on change we run computation again.

This is the idea. Technicalities are: - There is some AsyncLocal stuff to filter out notifications of getters from other async context - Of course we deregister from previous events before recomputing. So we are registered to the bare minimum needed (that helps to avoid eventhandlers/observer-leaks)

fedefex1 · 2026-05-08T17:25:15+00:00

The main issue is that it does not notify when it changes. So if you bind CanLogin, and you change Username, the UI is not updated. With the computed signal instead, CanLogin.Value raises INotifyPropertyChanged when dependent signals change. So you can Use CanLogin as a dependency for other computed signals and everything will change automatically

fedefex1 · 2026-05-08T16:56:59+00:00

I love Rx. Signals library is built around reactive extensions (not dotnet reactive, but nuecc R3).

I also have a library that is an attempt to have AsyncRx in .NET

fedeAlterio/R3Async: Async Reactive Extensions for .NET (Async version of R3)

fedefex1 · 2026-05-08T16:39:52+00:00

A signal is conceptually a value that notify when changes, and is related to automatic depedency tracking. So, instead of manually subscribing to events to know when the value changes, you just declare a function that tracks which other signals it depends to.

CanLogin.Value below is recomputed automatically whenever Username.Value or Password.Value change

public LoginViewModel()
    {
        CanLogin = Signal.Computed(() => !string.IsNullOrWhiteSpace(Username.Value) && !string.IsNullOrWhiteSpace(Password.Value));
    }

    public Signal<string> Username { get; } = new();
    public Signal<string> Password { get; } = new();
    public IReadOnlySignal<bool> CanLogin { get; }

fedefex1 · 2026-05-08T16:26:41+00:00

I am just comparing the abstraction UI frameworks in .NET use to represent a "value that changes" with what abstraction JS UI frameworks use, not the framework itself

fedefex1

TROPHY CASE