I usually point to https://docs.microsoft.com/en-us/dotnet/core/deploying/#self-contained-deployments-scd for an overview of self-contained deployment. Not familiar with that markdown doc... looks like useful info but quite technical.

@leecow, ideas on making this clearer? Add something to the beginning of the md doc to point people not interested or ready for that level of detail in the right direction?

There are some Raspberry Pi specific instructions at https://github.com/dotnet/core/blob/master/samples/RaspberryPiInstructions.md that uses a self-contained deployment.

Yeah, adding other pointers would be useful.

/cc @Thraka, who is working on a broader Linux documentation organization effort.

@dagood I completely understand and use self-contained apps. That is not the question.

Please create an example for Raspberry Pi if that's not much to ask.

I'm sorry, I think I missed your question then. I picked this one as the main point, what you wanted elaboration on and what your ultimate goal is:

... I mean, can you create an example for .NET Core 3.0 app for Raspberry Pi?

Does https://github.com/dotnet/core/blob/master/samples/RaspberryPiInstructions.md not help with this?

Just as a general note, we're going to be rewriting the publishing articles in the future to be a bit more clear just as to definitions and scenarios.

@alvipeo I'm still a bit new to linux, as it sounds like you are. But do a quick browse on https://en.wikipedia.org/wiki/List_of_Linux_distributions to sort of get an idea of how broad the linux world is. You can see that there some root distros families that serve as the base for many popular linux os distros.

Raspberry Pi comes with Raspbian, a Debian-based distro. It doesn't mean though that someone can't have some flavor of a Fredora-based distro and install it on the pi or something along those lines.

In general, I find that linux users are open to installing dependencies when they need them, so it may not be out of the question to just require users of your app to download the appropriate runtime first, and you can compile and distribute a framework-dependent executable instead of self-contained.