2xsaiko

Ugh, that would complicate things. If that’s the case, all I can say is that’s really negligent (and goes into what I originally said about lack of stable ABI really ruining Rust for me — technically I said static linking but that’s really the core issue)

Ventoy is completely insane in terms of how it works fwiw: https://discourse.nixos.org/t/custom-nixos-installer-plug-install-play-how-to-achieve-this/61710/13

Yes, that is true. And yet, there are C++ LGPL libraries which as you say do in principle have the same problem. It should be safe if you’re careful about not using generics in the library’s public interface, or at least only generic code that is essentially just stubs calling the real logic. (I haven’t actually tried this myself tbh.)

In general any kind of inlined code is always a problem when doing this, even C can have this with macros, or “static final” integer constants in Java.

I should have definitely mentioned this and Rust’s ABI stability though, yeah. As for that, keeping the same compiler version is generally not a problem since all of them are available.

There are two ways of using library code in an executable program: dynamically linked libraries – also shared libraries – (these are DLL files on Windows, so files on Linux, dylib files on Mac), and statically linking libraries, which are embedded into the program executable at build time (specifically the link step which is generally the last).

Dynamically linked libraries just store a reference to the library file name, and when the program is run, the dynamic linker searches for these library files on disk and loads them into the program memory, whereas as I already said above statically linked libraries already are part of the program executable code so nothing special has to be done there at runtime.

This has nothing to do with bin packages inherently, which usually use at least a couple dynamically linked libraries anyway (libc at least). In fact every Rust program dynamically links to libc by default as at least glibc is impossible afaik to statically link. Some of them ship dynamic libraries along with the program binary (you see this a lot with Qt since it is pretty hard to link statically), some of them link their dependencies statically, some just expect the system to have certain versions of shared libraries available.

The special thing about Rust is that it really does not want you to output dynamically linked Rust libraries and link them to Rust programs, at least if they’re not inside the same project, since it does not have a stable interface for Rust code to Rust code calls (and a couple other reasons). This means you cannot ship a Rust shared library as a system package that programs in other packages can link against, like you can with for example C or Swift languages. Every dependency has to be built inside the same project the final executable is also in.

library code licensed under it must be able to be replaced.

Does this mean you need to be able to make a reproducible build? Or need to be able to swap code for something else? Wouldn’t that inherently break a program?

It does not mean you need to make a reproducable build, it just means users must be able to modify the LGPL licensed parts. For example, the library loads a file from a specific path that you want to change, you must be able to change that path by editing the library source code. This is trivial if it’s a shared library since you can just build your own where the path is changed and tell the dynamic linker to load that instead of the original, but with a closed-source statically linked binary you cannot easily change it if it does not provide the object files. These are essentially mostly final compiled code produced from source code files but not yet linked together into an executable, and significantly the LGPL parts are isolated files which can be swapped out with your own and then linked together again.

Doing this does not inherently break a program as long as the interface of the library (like function names, parameter types, general behavior of the code) stays compatible with the original one shipped with the program.

FWIW static linking is also fine with LGPL (see my comment).

Specifically for libraries licensed as LGPL, a lot of the time with Rust I hear the justification that it forces anything using it to also be (L)GPL, because Rust always links libraries statically¹ into the final binary and therefore does not meet the requirement of the LGPL that library code licensed under it must be able to be replaced.

This is absolutely not the case however, precompiled binaries can just ship all the object files it is linked from along with it so users can replace the object files of the LGPL library with their own custom version, or just the source code for open-source software, which also meets the requirement of course.

¹ something I could rant about for hours as this is lowkey one of the two things that ruins Rust for me but I digress

It’s certainly not a universal thing either, no other language I know does it.

Once I asked on linguistics (or maybe English language) stackexchange about the origins of it, but it got deleted as duplicate of a related but definitely different question. Most satisfying stackexchange interaction

And https://iocaine.madhouse-project.org/ (this is the one I’m running myself)

Eh, works for me for home use. I just have it running on the same machine as the NFS server. The only thing that bothers me is that I can’t use normal Kerberos for SMB, I’d have to set up Samba AD. Boooo

I even managed to make it work with just mDNS as I’m currently in a horrible network I don’t control.

macFUSE

I don’t know what you expected, that is a huge hack.

NFS is insecure out of the box so typically tunnelled over TLS

Set up Kerberos, it will also give you correct file ownership and then you don’t need any additional tunnel.

They do not allow that, but yeah, it’s just their OS which only allows access to the relevant system interface for their own app. Apple doesn’t let you send SMS with third-party apps either for example.

Though admittedly, Google is putting proprietary extensions on top of it in their client, and they are apparently running a lot of carriers’ RCS endpoints, and using their servers when the carrier doesn’t support it at all. Which is fair, but imo does not make RCS itself inherently proprietary.

(However this is also to some extent warranted, since carriers were and still are dragging their feet a lot implementing it despite RCS being a required part of 5G carrier services IIRC¹. This seems to me like another IPv6 situation.)

This claims to work on a rooted Android phone (or one where you have control over the system image), and the underlying library is platform-independent so you could use it to implement RCS for a Linux or other phone: https://github.com/Hirohumi/RustyRcs. I haven’t tested it though since I also don’t Android (anymore).

¹ Though maybe that was just for 5G standalone, which no carrier is doing yet anyway.

It’s not proprietary, it’s an open standard from the GSMA. Stop spreading this nonsense.

Can you explain how you disagree? Is it about incentives to be corrupt (or against) depending on the system?

Huh, I didn’t know MSHTML as used in IE was also called Trident. I thought Trident was specifically early Edge before they switched to Blink.