One option is to statically link against musl libc [1].
The kernel ABI is about the only stable thing you can rely on (which is something you _can't_ rely on for macOS or Windows).
In Windows's case, technically accurate but not really relevant, since the interface for working with the base DLLs like kernel32, user32, etc. hasn't changed.
https://stackoverflow.com/questions/3430400/linux-static-lin...
Can't imagine many Linux gamers are going to need NSS support in their game binaries. It's a bit of a stretch to say glibc doesn't support static linking, perhaps "officially" it doesn't, its just not all the extended features are going to work.
Static linking is generally going to be frowned upon these days however since you're effectively linking security issues into the binary forever.
glibc unicode tables are huge, musl are tiny.
glibc uses assembler optimizations for everything, whilst musl uses compiler auto-vectorization, which mostly beats handwritten assembly, esp. with constant arguments.
I currently use Linux and it is much better than Windows (although I didn't like the desktop environment so I uninstalled it, but customizing the system is what I do regardless of what operating system).
If you don't want to worry about the glibc version on your users' machines, you can just ship your dynamic linker and use it to run your executable in your wrapper script (you do have one, right?). Why's that so hard?
Having said that, I strongly prefer Linux's explicit shared object search paths and very user-friendly dynamic linker to Window's implicit search scheme (aka the DLL hell). If that means I need to add my dynamic linker along with a couple lines of wrapper script so my binaries work, so be it.
And, you can even avoid the wrapper script if you can make sure your stuff is always installed to a standard location (eg. /opt/yourcompany) and you pass -Wl,rpath to your linker (at compile time) but I really don't see the point.
If Linux Desktop were one singe different platform there wouldn't be a problem. Instead it is effectively some ridiculously large number of platforms.
* If you're a GUI app you can also speak X11 with GLX and its up to the user to have something that understands your messages.
* If you want desktop integration you use one of the many dbus protocols and it's up to the user's DE to understand your requests.
* If you distribute through Steam you may also depend on the Steam runtime, but you have to be careful to only depend on what's provided.
* If you distribute through Flatpak or Snap you can also depend on any of the provided runtimes or build your own for maybe easier maintainability. It's essentially 'bundle everything' as a service.
tl;dr depend on protocols and runtimes, not libraries.
Also, nothing is stopping you from building against Ubuntu:latest. It's more cumbersome but Linux users will typically find a way to make your stuff work on other distros.
This is not the mentality of anyone who cares about the user experience of the product.
What's the gap between Linux/Windows and Mac OS ?
Windows is finally introducing a diagnostic in the task manager to show which applications have high DPI support. The modern option, per-monitor awareness, isn't even possible on Linux with the X display server - it requires Wayland.
Wayland isn’t an option for me yet because I need screensharing under Hangouts, etc.
You can’t mix the HiDPI internal screen with, say, a 1440 external monitor with Gnome on X11. Scaling is applied equally across both.
Also if you drop back to plain text e.g. during boot up the internal screen will show text at 100% scaling and the text is tiny.
I guess that might be something BIOS could take care of but it’s currently a problem.
Sorry, can’t offer comparisons to Windows, I just work with macOS and Linux.
I currently have eight VMs each with different distros. Mostly it's for testing library compatability on install and input weirdness.
That's a lot of testing.
From what I understand about Snap, the only difference is that that the One True Repo is installed by default.
AppImage is another option he could consider, which requires no repos or additional installs, just flipping the execute bit on the AppImage file. Unfortunately even that is spotty because there is no standard set of libraries to rely on like there is on other platforms, so he'd pretty much have to include everything from glibc up to be safe.
10 years ago developing on linux as a game developer was way worse than windows and MacOS, now there is no real difference at all. I speak as a long time UNIX user, Linux was terrible for C++ devleopment, debugging and asset creation/viewing (compared to the others) making gamedev tougher than it needed to be.
10 years ago linux's OpenGL drivers were behind even MacOS and way behind Windows OpenGL which was behind DirectX by quite some way. Now Linux's drivers are fairly good although it's still a nightmare upgrading radeon drivers and NVidia's drivers seem to be fickle. This leads to a lot of bugs from users and supporting various distro/hw/driver combinations.
Libraries like libSDL(2) were less mature 10 year ago, multi monitor, input and sound support were patchy because the Linux landscape was fragmented and buggy. Now libSDL2 is pretty much spot on. Mutli-monitor is doable (not as good as macOS but as good as windows), input is pretty good and sound is OK (but most people use FMOD which is superb).
Where Linux falls behind is deployment. No I am not going to ship my source for you to compile. itch.io and Steam go a long way to make it easy to deploy and crucially update the game. It's still a PITA to deploy a compiled app on Linux with unclear glibc versions and amazingly it's worse than MS DLL hell of MSVC redistributable shambles.
It's not impossible to overcome but it's a PITA for a small market. Not a good position to be in. I support macOS and Linux as well as Windows because I believe in plurality but I can see why many chose not to. Don't think that using Unity or Unreal make anything easier either. In many ways they are worse than a well written custom engine.
[1] https://executionunit.itch.io/smith-and-winston