gucci-on-fleek

> To me, it seems odd not to care.

If you don't mind me asking, why do you think that? I'm not trying to start a debate, and I'm sympathetic to many of the reasons why some people are against LLMs (the environment, copyright issues, loss of jobs, not liking chatbots, not trusting the current companies, etc.), but I'm curious why you are against them.

(I don't really understand one being so against LLMs that one tries to avoid software that contains even small amounts of LLM-written code, but I know that a lot of well-informed people feel this way, and it seems far more likely that I'm the one missing something rather than everyone else being wrong.)

I'm not the OP, but I would personally say that not wanting to work with LLM-generated output (including that submitted via PRs and issues) is reasonable, but not wanting to use LLM-generated code from well-regarded established projects (not vibe-coded slop) is veering closer to tribalism.

Because to me, it's entirely fair to care about the process when you're the one working with it, but if you've never looked at the code and it works well, it seems odd to care how 10% of it was produced.

I still wouldn't quite use the loaded "tribalism" term here myself though, because there are still a few valid reasons to be skeptical of LLM-generated code, but for many people, their hard anti-LLM stance appears to be more of a shibboleth than a principled stance from my perspective.

Isn't there already a natural "tax" of the cost of office space?

> you may have to compile each binary module

Correct, but I'd argue that you need to do this anyways (well, I do this anyways), because I don't like the alternative of redistributing binaries compiled by random third parties from the internet.

> link everything against the Lua VM, and write glue/loading code to make everything work together (see the comment below regarding LuaSocket)

> Of course, it's possible. But it's a lot of manual work, especially for newcomers.

To be clear, I think that your project is great, but this really isn't that much work:

  # FILE: .gitignore
  program
  *.luac
  *.o
  
  # FILE: Makefile
  CFLAGS := -std=c23 -Wall -Wextra -Werror
  
  ifeq "${mode}" "debug"
      CFLAGS += -ggdb3 -fanalyzer -fsanitize=address,undefined,leak
  else
      CFLAGS += -O2 -flto -s
  endif
  
  %.luac: %.lua
      luac -o $@ $^
  
  %.o: %.c
      ${CC} -c -o $@ $< ${CFLAGS}
  
  c_libraries := library.o
  lua_libraries := main.luac
  
  program: main.c ${c_libraries} ${lua_libraries}
      ${CC} -o $@ $< ${c_libraries} ${CFLAGS} -llua
  
  // FILE: library.c
  #include <lauxlib.h>
  #include <lua.h>
  #include <lualib.h>
  #include <stdcountof.h>
  
  static int test(lua_State *L) {
      lua_pushstring(L, "Hello from C!");
      return 1;
  }
  
  int luaopen_library(lua_State *L) {
      luaL_Reg library[] = {
          {"test", test},
          {nullptr, nullptr},
      };
      luaL_newlib(L, library);
      return 1;
  }
  
  // FILE: main.c
  #include <lauxlib.h>
  #include <lua.h>
  #include <lualib.h>
  #include <stdcountof.h>
  
  #define preload_c_lib(name)                       \
      do {                                          \
          extern int luaopen_##name(lua_State * L); \
          lua_pushcfunction(L, luaopen_##name);     \
          lua_setfield(L, -2, #name);               \
      } while (0)
  
  #define preload_lua_lib(name)                                         \
      do {                                                              \
          luaL_loadbufferx(L, &name[0], countof(name) - 1, #name, "b"); \
          lua_setfield(L, -2, #name);                                   \
      } while (0)
  
  static void initialize_modules(lua_State *L) {
      // Load standard modules.
      luaL_openlibs(L);
  
      // Load external modules.
      lua_getglobal(L, "package");
      lua_getfield(L, -1, "preload");
  
      // "main.lua"
      static char const main[] = {
          #embed "main.luac" suffix(, '\0')
      };
      preload_lua_lib(main);
  
      // "library.o"
      preload_c_lib(library);
  
      lua_settop(L, 0);
  }
  
  int main() {
      lua_State *L = luaL_newstate();
  
      // Initialize the modules.
      initialize_modules(L);
  
      // Run main script
      if (luaL_dostring(L, "require('main')()") != LUA_OK) {
          printf("Error: %s", lua_tostring(L, -1));
      }
  
      lua_close(L);
      return 0;
  }
  
  -- FILE: main.lua
  return function()
      local library = require("library")
      print(library.test())
      print("Hello from Lua!")
  end

To run:

  $ make && ./program
  cc -o program main.c library.o -std=c23 -Wall -Wextra -Werror -O2 -flto -s -llua
  Hello from C!
  Hello from Lua!

> Some platforms (Windows I see you !) don't permit to link binary modules to a static executable

If you have the source code for these modules, you can statically link to them too. I've done this myself for Windows a few times, and it works pretty well in my experience.

I wouldn't consider static linking + #embed to be hacky though, and that's all that it takes to deploy a standalone Lua program.

Does the version number going from v7.X->v8.0 mean that this is a larger update than v7.8->v7.9, or does the numbering just automatically roll over to the next major version when it reaches vX.9?