This is a big forwards-compatibility risk. Suppose glibc adds a new symbol, and then a GPU driver adds a dependency on that symbol. The user wants to run an old executable with the updated GPU driver (maybe the old GPU driver doesn’t support their GPU). Normally, this would work fine: the user has to use a new copy of glibc, which will be compatible with both the new GPU driver and the old executable. But with your approach, the GPU driver is forced to use the glibc reimplementation which has been statically linked into the executable. Which, since the executable is old, can’t possibly implement the new symbol.<p>The same issue would occur if glibc adds a new version of an existing symbol and then the GPU driver is recompiled. (Or, for that matter, if a GPU driver adds a dependency on a symbol which glibc has always supported but which isn’t in the subset that you reimplemented, though in theory that could be solved if you reimplemented 100% of the symbols.)
If you can figure out your own ELF loader, you can figure out how to build a partially static executable that doesn't need this. You can mix static and dynamic linking. Build tooling around that is just shit.
I don't know much about musl.<p>> GPU: Vulkan and OpenGL drivers are supplied by the host as shared objects, usually built against glibc, and a fully static musl binary cannot normally dlopen() them.<p>Why? Have people managed to break the ancient concept of shared libraries, and this is a fix for that?
Because glibc and GNU set a terrible precedent. On GNU/Linux systems the shared binary interpreter / loader, GCC compiler, the C library and the system C/C++ ABI all depend into each other. You cannot change any of them independently. All shared libraries depend on the specific glibc version to load them into memory to be able to use that specific glibc version as their C library and make calls like dlopen.<p>Shared libraries have always been broken in Linux. Unfortunately many things like GPU drivers, graphics libraries and NSS need shared libraries to dynamically load certain runtimes (because you don't want to load all possible GPU drivers in existence to your RAM). So an ecosystem has been developed on top of terrible ABI and architecture GNU/glibc provided.
Yeah, it's mind boggling how everything hard depends on glibc, even critical graphics systems.<p>I've become obsessed with getting rid of it, especially after I realized contributing to GNU itself was a dead end. Freestanding Linux programming turned out to be much more fun.
> All shared libraries depend on the specific glibc version to load them into memory to be able to use that specific glibc version as their C library<p>That's currently the real core of the problem.<p>The loader (and libdl) need to be decoupled from the glibc itself under Linux.<p>Without that, any attempt to ship static binaries (or any binary with a different Libc) will be a source of perpetual pain.<p>nss plugins and its associated pain (sssd and avahi) are an other examples of that.
> system C/C++ ABI<p>C++ abi should not be included in this. It is independent from the other pieces and historically a source of incompatibility on its own.<p>Saying "C/C++ abi" as if they are the same is looney tunes, the former is very simple and stable and the latter is very complex.
> the former is very simple<p>Somehow most of my portability issues seem to be caused by glibc, its symbol versioning and close ties to the dynamic loader. Minor versions aren't compatible, no two Linux distros ship the same version and you can't just provide your own without also patching in your own dynamic loader.<p>At least as far as the defaults on Linux go I consider C the root of all evil.
See: <a href="https://news.ycombinator.com/item?id=49355262">https://news.ycombinator.com/item?id=49355262</a><p>How libstdc++ initializes global variables absolutely depends on glibc and ld-linux.so. That is part of C++ ABI.
While I don't disagree with some of the pain you describe, you conveniently gloss over the fact that gnu developed a system that worked, and then made it free to everyone to consult and use.
In what sense do binary interpreter / loader, GCC compiler, C library and system C/C++ ABI dependent on each other? I have certainly mixed different versions of all these components without problems so far.
When you compile GCC you need to provide a full glibc installation as your target. It is also a dependency of libstdc++.<p>C++ global/static variable initialization depends on the specific version of glibc (they don't usually break compat, but they can and they did in the past) which also provides ld-linux.so that loads those global variable placeholders in the correct manner such that glibc and libstdc++ can initialize them correctly.<p>This is just one example. Thread local variables and behavior of things like pthreads with signal, fork etc all depend on glibc.
I can't comment on the C++, I can imagine there plenty of issues, but for C I don't see this. You need some libc if you compile with gcc, but this generally does not introduce a hard version dependency on the specific version (there may be a minimum requirement if you compile against a new version that a symbol with a different ABI).
I don’t imagine that you’re unaware of any of this, but: ld.so and libc.so are heavily interdependent in deliberately undocumented ways with Glibc and outright the same file with shared Musl. And while you might usually get away with using any old GCC with the right architecture and ABI (especially for C; cf the musl-gcc hack), technically it needs to be built to target a specific libc version (particularly via symbol versioning; I’ve long wanted to gather a set of patches to build an old Glibc and subsequently a cross-compiler using a new GCC so I could avoid PyPA’s manylinux monster or its moral equivalent for compatible dynamic binaries in simple cases). The C compiler of course is tied to the C ABI, and this wouldn’t be really worth mentioning except for the time where the GCC devs accidentally the whole SysV i386 ABI and pretended that the stack was always 16-byte aligned, why do you ask, except on RHEL. The C++ parts I can’t really comment on.
I am not really sure. For ld.so and libc.so I may believe this. The C ABI is very stable, and if you use a new symbol from a newer glibc, you certainly depend on it, but this can also be avoided. In any case, I do not see what is fundamentally misdesigned here. I can't quite image how it could work differently. If you upgrade something so that the e ABI changed you natually need to update other components. Static linking certainly seems a very poor replacement for this.
For example, the itanium unwind ABI implementation lies between these three entities.
The interpreter/loader <i>is</i> glibc and a key part of bootstrapping an executable built against glibc is loading libc itself before continuing on to load the program. Versioning is a problem when distributing binaries linked against a newer glibc to distros that ship an older one. The C compiler doesn't really care as much.
> all shared libraries depend on the specific glibc version to load them<p>Not really, though. glibc uses symbol versions that are forward but not backward compatible. If you got an error that said "this program was built for a newer version of <distro>" would you say the same thing?<p>Note this is the same (if not worse) on MacOS, and on windows you used to distribute the CRT with your application just to deal with the same problem.
See <a href="https://news.ycombinator.com/item?id=49355262">https://news.ycombinator.com/item?id=49355262</a> .<p>Yes glibc has some backwards compat but you cannot load a binary compiled with a newer version of glibc using an older ld-linux.so. That's because the interdependency. Nor you can load binaries that depend on different libc.so files with glibc systems<p>I cannot comment on macOS, I have never used it. However this is not a problem with Windows. You can ship a newer CRT or you can install it as a system component using Microsoft's MSI. The dependency is one way on Windows. CRT purely depends on Win32. Moreover the loader is completely independent and DLLs are loaded into their own unique scoped namespace unlike Linux that loads them in global symbol namespace. That's why you can mix and match DLLs compiled for different CRT versions.
In what way are they "broken" when Linux runs fine on millions of boxes? Sure, it might be a pain for proprietary software, but if your app is open source it's not that hard to build it on whichever distro you want. If your app is popular enough the distro maintainer will build it for you
musl has no problem building and using shared libraries.<p>What you can't do is build something statically with musl and then reliably dlopen shared libraries built with glibc.
Well, now it's possible! Furthermore, SoLo binaries can run, without modification, on glibc-based distros, alpine, and soon on android/bionic (not committed yet).
musl does not perfectly emulate all aspects of glibc, so trying to use libraries that assume glibc can sometimes lead to problems.
On the one hand, this is technically true, but on the other, what serious issues do you know that will cause problems in practice? I run tests on 1,000 of the most popular Debian packages.
Not anymore, but for -years- it did DNS wrong because of the author being pedantic about an RFC wording.
Mostly about precompiled libraries (proprietary software) and libraries and software that use GNU extensions.
How this differs (is better!) from prior art - <a href="https://github.com/pg83/solo#how-this-differs-from-prior-work" rel="nofollow">https://github.com/pg83/solo#how-this-differs-from-prior-wor...</a>
Note: That md file is LLM spew (like most of rest of codebase).<p><a href="https://github.com/pg83/solo/commits/main/README.md" rel="nofollow">https://github.com/pg83/solo/commits/main/README.md</a><p><a href="https://github.com/pg83/solo/commits/main/" rel="nofollow">https://github.com/pg83/solo/commits/main/</a>
What are your plans around the maintenance of this project, how would you feel about solo being incorporated into the musl build for graphics.gd ?
Do people say "so", "ess-oh" or "dot-ess-oh"? The title "a .so" is clunky to the "ess-oh" gang.
If you dynamically sold an SO are you still static even if you did it "custom" ?
At that point it's a dynamic loader in another name?
Technically, you're right, it's a dynamic loader. Technically, it's pure dynamic loading.<p>If we look at the issue at its core, we're still a statically linked program in a hostile environment, forced to dynamically load device drivers from the system.<p>It's similar to Golang; on MacOS, it has to use libSystem, even though otherwise, these are the statically linked Go binaries we're used to and love.<p>Let me add a little more detail: if I use vdso with gettimeofday in a statically linked program on Linux, am I still a statically linked program, or not? :)
It is a testament to the complete failure of the GNU/Linux userland that something like this seems at all attractive to spend time on (or, it seems, LLM tokens).<p>Actually, scratch that, because Windows and macOS have historically struggled with ABI compatibility as well (macOS less so, due to not caring about backward compatibility in the first place).<p>How did we get to the point where people feel they need to go to the length of embedding an ELF loader in their binary (!!) rather than just linking with glibc?
I'm mostly taken aback all the solutions devised to go around the issue, especially the container-based ones. I really disliked it when I grabbed the flatpak version of Blender only to find out that it can't have HIP support. (they might have fixed it by now but you get the point)
Linux loves to leave papercuts unfixed or undocumented for decades. The solution is to build against an older version of glibc but no one tells you that or how to do it.
Luckily Zig makes this quite easy to do. In Mach[0] we are able to just `zig build -Dtarget=x86_64-linux-gnu.2.28` to build GUI apps against an ~8 year old glibc version for maximum compatibility.<p>This is possible because Zig allows for targeting most glibc versions out of the box with its cross-compilation support.<p>[0] <a href="https://machengine.org" rel="nofollow">https://machengine.org</a>
It's a pretty poor solution, to be honest.<p>1) Why should I limit myself to the available APIs?<p>2) Not just glibc. For example, if I build against the latest libstdc++, it will automatically support the more recent glibc. And pinning the old libstdc++ -well, that's just not a good idea.
Complete failure is strong words when lots and lots of Linux boxes are running just fine.<p>I think the disconnect is mostly people that can't decide if they want a stable distro or a rolling release distro. Most everyone uses a stable distro because it's stable, but then the want some up-to-date software that isn't ore-built for their (crusty old) stable distro and they get annoyed. My solution was to finally give in and embrace a rolling release distro (I use arch, btw). If there isn't a package for something I want, it's not hard to build something myself because all my build tools, kernel, and libs are up to date.<p>Other reasons to want static linking is to distribute proprietary software with no source code available. Linux certainly does not cater to that scenario and I suppose some might call that a complete failure ¯ \ _ ( ツ ) _ / ¯
Glibc has a terrible history of binary incompatibility. If that's so hard to believe, try running binaries built on one distribution on other distributions. Linux has two stable ABIs: the kernel ABI for static programs, and, ironically, WINE.
I haven’t heard of this and I don’t think you’re right. Glibc, for all its faults, as a general rule does backward compatibility well. The problem is if you compile against a newer glibc (common in CI by default) and try to run on a distro with an older (common in the wild). If your CI uses an older glibc you should be fine AFAIK.
<a href="https://bugzilla.redhat.com/show_bug.cgi?id=638477" rel="nofollow">https://bugzilla.redhat.com/show_bug.cgi?id=638477</a> is the most "famous" example.<p>There are also much less well-known "little things" that regularly pop up here and there.<p>> If your CI uses an older glibc you should be fine AFAIK.<p>In any case, my binaries work not only under glibc, but also under Alpine, and (work in progress) under android/bionic.
Not sure what you’re trying to show with that bug report but it’s not a case of cross distro glibc issues. If I read correctly it’s a vanilla behavioral change that exposed preexisting UB in flash.<p>Not sure how the comments about alpine or bionic relate either to my claim that cross distro glibc is fine.
It depends on how we define the ABI. I see it as a set of client-visible invariants that they rely on. In my world, glibc changed the client's visible invariants, breaking the client. The client works on one glibc-based host, but not on another. What is this if not "a case of cross-distro glibc issues?"<p>Overall, both of our points of view on compatibility were discussed well in that thread; we probably shouldn't repeat ourselves. :)
> Quite frankly, I find your attitude to be annoying and downright stupid.<p>- Linus Torvalds<p>That bug report was a good read.
according to appimage recommendations as long as you build against glibc with an earlier version than the system it's run on it should be fine.<p><a href="https://docs.appimage.org/reference/best-practices.html" rel="nofollow">https://docs.appimage.org/reference/best-practices.html</a><p>I hear you about WINE though.
So not completely static, since it must link against a libc :P
Why not just pass the GPU to a docker container?
How are we supposed to take this stuff seriously if the author (sic) isn't even willing to write the readme? Claude exists! If I want some slop I can push the button myself.
Disclaimer: This is a user’s perspective rather than a programmer’s perspective.<p>valid point. I am usually okay with LLM generated code since even if it might not be architecturally sound It is usually well commented and has tests and documentation for helping another agent/human debug any issues.<p>But, just the painful experience of debugging any dlopen related crashes and/or intermittent bugs; and the sheer amount of tokens burnt by an LLM chasing tangents when shown a stack trace; I wouldn’t touch this at least as a packager/consumer of certain apps for personal usage on older distros.
So far, AnyLinux-Appimages seem to be a mature solution with great support from the developers, in case anyone lands here for packaging applications to run on older distros.
Modern models, when properly managed with a human in the loop, write higher-quality code than humans and introduce significantly fewer bugs.
Therefore, it's quite the opposite - you should expect fewer "dlopen-related crashes and/or intermittent bugs."
> Modern models, when properly managed with a human in the loop, write higher-quality code than humans and introduce significantly fewer bugs.<p>I don't think anybody believes this, and interjecting it into every thread is not really convincing anyone.
Tell me, are there any substantive comments on the text, on what has been done, and on the technical implementation, and not on the form?
Isn't this a README? <a href="https://github.com/pg83/solo/blob/main/README.md" rel="nofollow">https://github.com/pg83/solo/blob/main/README.md</a>
Parents point is the readme was written by Claude. Signals low effort.
README.md was written by me, and I, of course, used claude/codex for it. In general, I do everything through claude/codex, the reasons are described in <a href="https://github.com/pg83/solo/blob/main/CONTRIBUTING.md" rel="nofollow">https://github.com/pg83/solo/blob/main/CONTRIBUTING.md</a> . And no, it's not low effort, and no, I don't see the point in wasting time de-claude-ifying the text just to avoid it looking like I didn't spend enough time on it.
You make it clear why you write all your code through a llm. But a README is not code. Presumably you would like people to read it. A machine authored readme reflects poorly on a project.
In any case, it's open source. If you don't like something, even if the project seems generally useful, go ahead and fix it. The PR came in. I'm an engineer and I can write good code, but that doesn't mean I can write good README.mds!
The author of the README is me, the machine just wrote it.
I am not a native speaker of English, my written English is simply terrible, no one wants to read the text that I wrote exactly :))
For context, I read Claude output every single day, I know what it is reliable with and what it is not. Or at least I have a feel for how much I can trust it.<p>It may not be clear to a non-english first language person, but when I read Claudes documentation, my brain immediately picks up claude-speak. Therefore, I expect the code to be generally correct, maybe, depending on how specific I was during my prompting. In no way shape or form do I really trust it, at least until i dig into the code and validate my mental model. And query the review for edge cases etc...<p>By writing your documentation with Claude, my brain immediately associates the quality of the project with the quality of unreviewed Claude output.<p>To a degree this is unfair, as it is like judging the quality of someone's work based on their accent.<p>But Claudes accent, has a high correlation with Claude, so unlike with people, where an accent has no bearing on technical ability, Claude being Claude does.<p>I would much rather read a typo ridden sentence than claudism, even just as a forward, explaining what you did vs the ai, and telling the users how much we should trust it.<p>Also, If you really insist on using AI to write, have another model rewrite docs/comments into regular English (opus 4.6 for example is much better than 4.7, 4.8, or 5.<p>It is open source so you can do whatever you like, but people (especially native English speakers) will discount your work, because Claude, especially opus 5 writes very very badly.<p>The people who say they would rather see a typo infested mess of a readme are serious. Or even just write in your native language and then have Claude translate.<p>Both of those are better indications of proof of effort than a Claude readme.
> Or even just write in your native language and then have Claude translate.<p>That's exactly what I did.
> By writing your documentation with Claude, my brain immediately associates the quality of the project with the quality of unreviewed Claude output.<p>I'm sorry, but I agree with the author: if a certain writing style makes you associate the work with low-quality, then that's <i>your</i> problem. The author shouldn't have to rewrite the readme just to avoid triggering your automatic unfounded associations. If you look at the substance of the work, including the test cases, then this is clearly not easy work that can be vibe coded in a single pass.<p>It's just like emdash. Everybody digs on how it's a signifier of LLM text, but I've used emdash for years because it's gramatically correct. I shouldn't have to stop using emdash just to avoid kneejerk reactions.
I think we're trying to tell you that we actually would prefer it.
I believe usually when someone complains about text written by a language model they are hoping to read human-written text instead of human-laundered LLM output.
Implicit assumption of gp is that the README is llm authored. (Which, I agree is how it reads to me.)
> backed by its own ELF loader (x86-64 and aarch64) and a glibc ABI bridge<p>Yacks
If you want to load the OpenGL/Vulkan vendor driver then unfortunately you don’t have much of a choice: those are linked against glibc, and I believe generally also against libwayland so screw off if you want a different protocol library (I might be wrong about the latter part). If you instead want to load plugins or whatnot into your statically linked executable, then personally I’d argue that you shouldn’t be emulating Linux dynamic linking semantics at all, because the whole late-bound global namespace thing is silly and wrong. (Solaris, which is where Glibc took this model from, moved away from it[1] as much as compatibility allowed, and so did Darwin[2], whereas Windows never made the mistake to begin with, but Glibc persisted and Musl copied it.)<p>[1] <a href="https://www.linker-aliens.org/blogs/rie/entry/direct_binding_now_the_default/" rel="nofollow">https://www.linker-aliens.org/blogs/rie/entry/direct_binding...</a><p>[2] <a href="https://web.archive.org/web/20011004090044/http://developer.apple.com/techpubs/macosx/ReleaseNotes/TwoLevelNamespaces.html" rel="nofollow">https://web.archive.org/web/20011004090044/http://developer....</a>
Please elaborate and explain to people with less knowledge why this is bad.
Mapping parts of files into executable memory, and then executing them, had better be bulletproof! Exploiting this seems like a direct path to RCE, and it's likely that this sort of library is used by privileged code.<p>Purely academically, this is a very cool piece of code! Just hoping that it gets a thorough vetting before used by privileged/security-critical software :)
Well, ld.so already does this, and it's no big deal. The Python interpreter also does this when executing a .py script (code is code, whether it's machine-readable or human-readable).<p>In any case, we take testing very seriously—every glibc shim we've written is covered with tests, and we run our loader against 1000 of the most popular Debian packages. The project has 100% code coverage. Perhaps, if I have the time, I'll also do some fuzzing on this thing.
similar energy to my <a href="https://github.com/lunixbochs/crossldso" rel="nofollow">https://github.com/lunixbochs/crossldso</a>