Nolibc: A minimal C-library replacement shipped with the kernel

But on reflection, the reason why open source has been successful is all the duplicate projects. You pick the one closest to your needs and get your thing done. The ones that survive were simply meant to survive, for all sorts of reasons, but the least of them being cooperation for its own sake. Most successful open source is just somebody scratching their own itch.

So I'm wondering now about how you could encourage more of these one-off pet projects. What if all open source projects required a one-time lifetime license fee? The first time you use some open source project, you pay $1, and you have a license for life. You can adjust it for inflation, salary, cost of living, etc. But just imagine if every project were implicitly funded by everyone that used it. That would encourage more projects to appear, and incentivize them to be easier or better for the user. Plus the projects that are really popular yet have no funding, would finally have some.

Imagine if that idea grew to the point that a majority of software in the world were written by people who just got paid to write open source all day. A global economy of open source software. More software would become implicitly compatible, in order to deal with the deluge of competing software.

And so less expertise would be needed to combine different software into "a product". Companies would no longer need to spend as much time or money building up world-class engineering organizations just to kick out a CRUD app and take payments. Instead, companies could hire "integrators" to basically connect the unlimited array of "new apps" via "new pipes". A lack of expertise needed to make new products a reality would enable faster building of products, more reliably, with less expense.

Obviously, the more software that is used, the more we'd be paying for licensing. To deal with that, programmers would begin to merge their source trees together, to build more complete solutions, to lower licensing fees for users. More turn-key software, supported by more devs, that does more, for less money. Making it easier still to adopt the software and turn it into new products. In the end, programmers join forces to improve one product. But maybe that's just me scratching my own itch (˙ᵕ˙)

  struct auxiliary {
      long type;
      union {
          char *c_string;
          void *pointer;
          long integer;
      } as;
  };

  long main(long argc, char **argv, char **envp, struct auxiliary *auxv);

    /* this function is only used with arguments that are not constants or when
     * it's not known because optimizations are disabled. Note that gcc 12
     * recognizes an strlen() pattern and replaces it with a jump to strlen(),
     * thus itself, hence the asm() statement below that's meant to disable this
     * confusing practice.
     */
    static __attribute__((unused))
    size_t strlen(const char *str)
    {
            size_t len;
   
            for (len = 0; str[len]; len++)
                    asm("");
            return len;
    }
   
    /* do not trust __builtin_constant_p() at -O0, as clang will emit a test and
     * the two branches, then will rely on an external definition of strlen().
     */
    #if defined(__OPTIMIZE__)
    #define nolibc_strlen(x) strlen(x)
    #define strlen(str) ({                          \
            __builtin_constant_p((str)) ?           \
                    __builtin_strlen((str)) :       \
                    nolibc_strlen((str));           \
    })
    #endif

Wouldn't it be easier to just use a simpler POSIX-like OS to begin with? Or better yet, a so-called "library kernel" that effectively turns a userspace program into its own OS?

What's the upside of using the (relatively large and complex) Linux kernel for this? I doubt it's reliability, since the kernel in this particular configuration is essentially untested.