Open Source

Without it, this project simply wouldn't exist.

Starting with the language itself - .NET and C#
Going through the UI framework - Avalonia UI
Ending with the media player - LibVLCSharp

Without these tools being available for free, I wouldn't be able to make this project a reality.

There are, however, issues with going open-source.

There is a good talk from Dylan Beattie about the issues open-source projects face that pretty much nails it. I recommend watching it first:
Open Source, Open Mind: The Cost of Free Software

Below are some of the issues, at the bottom is the future or current plan for how the project will be sustained.

The issues

As many of you may already know, open-source projects usually have a hard time surviving.
Many projects end up being abandoned and eventually stop working or become too outdated to use.

Why?

Time and money.

People who develop these projects usually do so in their own free time and out of their own pockets.
Most people have to get a job to support themselves and their families.
This leads to less free time and mental resources being available for side projects.

It feels good to help people by providing them with software that solves their problems.
But that can't be converted into food or a rent payment.

• .NET / C# is backed by Microsoft and a large community
• Avalonia is offering additional services and features in their paid license
• VLC is also trying to monetize additional services like consulting/support and plugins that add the player in places like Unity

For most projects to stay alive, they need to be maintained, and to do that, they need to be sustainable.

This project has two parts:

1. The project logic - The players and server logic for this project
2. The backend / "LukLibs" - a collection of libraries handling things like: connections, encryption, permissions, configuration, logging, etc.

The project logic itself has taken quite a bit of time and iterations to reach the current state, and will always take more.
But that is small in comparison to the backend.

It took years of on-and-off learning and developing to write all the logic/libraries to have all the features that currently exist.

I would like as many people to benefit from it as possible.
But, I would also like that to include me as well.

Theft / Malware

When all of the source code is available, just taking it becomes very easy.

There is the issue of someone just taking the code, making their own version, and monetizing the crap out of it without any gain for the original developer.

Especially these days with AI tools being capable of scanning entire codebases and modifying them as instructed.

There is effectively nothing that can be done against this, as I mention later on below with how easy it is to get the source code through de-compilation.
But no code being available adds that little bit of work required to make it happen, and doesn't end up just being scraped of GitHub.

What could be worse is someone taking the code and distributing malware or crypto miners pretending to be a legit version.

This is why the update system uses signatures and release keys in an attempt to prevent that from happening and to keep users safe.

I only hope I'll be able to keep the original version working and implement all necessary features to the point where no one has a reason to make a new version or search for other solutions.

Donations?

The first thing that comes to mind is accepting donations through something like Patreon or GitHub Sponsors to support development.

That is indeed a possibility and may be set up at some point as a starting point.

With that being said.
How many people do you know that support the open-source projects they use?

The money we earn usually goes towards ongoing expenses or gets saved up for something else.
Donating to open-source software is usually not a part of the thought process.

The percentage of users that use the software, have disposable income, and donate is probably low.
And when they do, it's rarely a monthly subscription to support ongoing development.

I don't know how accurate I am here.
I am basing this on numbers I see looking at some other open-source projects that have GitHub stars in the tens or hundreds of thousands.
And all of the projects that get abandoned, otherwise die due to a lack of funding, attempt to aggressively monetize their users, or transition to a commercial license at some point and get backlash for it.

So, what is the plan?

For the time being, there is no public code repository.
Mainly because I am keeping development private.

The code standard in my projects is "I like it this way" and "I want it written like that."
Which is not exactly a very inviting/friendly environment for outside contributions.

There is certainly code that doesn't align with the "industry standard" way things are done.
Some things are "reinventing the wheel."

But this approach has led me to make something that works better than anything else ever did for me and, hopefully, many others.

The code might eventually be public, with a correct license, once I get it to a point I'm happy with.
The backend libraries changed a lot over the years.
There are things I would like to be done better, some things should be renamed, and others should be re-organized before the code goes into a public repository.

If you wish to look at the code to see what it's doing in a more readable form and make sure it doesn't do anything malicious, we could arrange an "audit" and talk things through.

Especially if you think the networking/security approach has a flaw that could break encryption.

Additionally, C# is, I think, one of the easiest languages to decompile.
One ILSpy download and executable pick, and you see it all.

If you are afraid that the software connects to anything, you are most likely a more cautious user (rightfully so).
I would recommend tools like Wireshark to see for yourself that there is no network traffic outside of what you want to happen.

Keep in mind that automatic update checking is implemented and can be disabled.

In the future there might be additional connections to other backend servers for additional functionality like a server browser.

Future

When you offer something for free, people are happy.
When you ask them later to compensate you for your work, they are angry.
They feel betrayed as you are suddenly asking for payment for something that was free.

I'm saying it upfront to not leave any ambiguity.
If the project ever gets a wider audience and becomes stable, I will try to monetize it.
I am thinking of a single-time purchase that will cover client and server use.

But, I am not going to force everyone to pay when you don't even know if you will ever be using the software more than once or a few times a year.

All features will be available regardless of purchase status.
The idea is that you can download and use the software for free, but you will get a startup notification/pop-up asking you to consider supporting the project and purchasing it.

If you like the project, intend to keep using it, and have the means to support it, you can purchase it, and the pop-up will be removed. (A thank you will probably be added somewhere)

If you don't purchase, you can keep using it, the popup will just keep reminding you that you can always do so.
(Don't know about you, but I tend to forget which software I should support without anything reminding me)

There is also an idea that there might be an optional additional service available with additional features for a small monthly fee.
Things that rely on me hosting more servers. (thus the payment)

The hope is that with this model, it will be possible to continue ongoing development.
If it's not, I may ask for donations in the even more distant future.

If it doesn't work, the project may not receive updates as frequently or eventually almost at all.

I will not attempt to gather user data to sell or add any advertising to cover server hosting costs like it is done with almost all of todays websites/applications that appear to provide these features for free.

When the product/service is free, you are the payment.
Be it your data, attention, or other input you provide.

Services, applications, and websites pop up, provide a multitude of services, all for free.
Users jump on, everyone starts using them.
Then, after some time, things start to change.
Money is running out, users are not generating any revenue, and the service/app/website starts limiting features, removing them, or putting them behind a subscription.
Advertisements appear, and maybe a shop is added with a push for users to start using it.

This process is called Enshittification.
It is observed over and over again, things start out nice for the users.
Then the focus shifts to becoming profitable, and users are either monetized in some way or leave.

These projects are unsustainable from the start, running on a constant loss, backed by investments, hoping to get as many users as possible, make it hard to leave, and later on squeeze their wallets.

People keep going for it since nothing can beat "free".
They don't understand or care how the monetization works since there will eventually be "the next big thing" that everyone will jump over to once the previous thing degrades badly enough.

I am trying to make the project sustainable from the start or not do it at all.
With the current approach of "free with a pop-up", I may still never see any income, but I don't want to force anyone to pay for something they haven't even tried.

Limited features, trial periods, even when tied to some form of account, are very easily bypassed and only lead to cracked versions of the software being distributed with who knows what else put in it.

In an ideal world, people would support the free and open source software they use, incentivizing doing more of it.
But that is unfortunately not the world we live in.

There is open source code out there with downloads and user counts in the millions or billions at this point.
Some libraries are dependencies that are used in others, and those are used in others in a chain of code that eventually powers everything we use directly or indirectly.

Relevant xkcd 2347:

If the authors/maintainers of these libraries/packages/projects would get even a fraction of the revenue made using their code, these people would never have to worry about their financial situation ever again.
They could dedicate even more of their time to improving the code, fixing bugs, and implementing new features.

Instead, they might get a thank you on a good day, but usually just more opened issues or bug reports asking them to fix as soon as possible because someone is loosing money since their application isn't working correctly.

All while the authors/maintainers have to work their day job to avoid becoming homeless.

Sure, there are some who are compensated for their work, but those are the exceptions, not the standard.

If this project manages to get any revenue.
I intend to keep passing on some of it to the projects I rely on.
They provide me with the tools I need and are the reason I was able to gain said revenue.
It is only fair for them to also benefit from their work.

I am laying it all out here to not have to explain it to everyone one-by-one. 🙂

It's all still a faraway future if it happens at all.
I am hoping that this approach will be sustainable and a benefit for all involved.