How to pass Unicode utf8 as command line arguments to a Lua script?

This is a known flaw in Windows terminal, Lua is not a unicode program, so Windows always passes command line arguments in the OEM encoding to Lua regardless of the active code page.

Workaround 1 is to change the OEM encoding to UTF-8: https://superuser.com/a/1435645/995824. Note that this is a global setting.

Workaround 2 is to read a UTF-8 encoded file instead of passing it through the command line. Here is an auto version, it creates a temp file and pass the argument through redirection (suprise, Windows remains encoding in redirection):

run.cmd:

@ECHO OFF
CHCP 65001
ECHO %1 > temp.txt
lua.exe test.lua < temp.txt
DEL temp.txt

test.lua:

local txt = io.stdin:read('l')
-- note: txt will contain a trailing \r

run:

run.cmd かسжГ > test.txt

Workaround 3 is to update the main function in lua.c to use CommandLineToArgvW, and recompile lua.

remove main function and replace it with

// int main (int argc, char **argv) {
// Why static?
// We make real_main() static to limit its scope to this .c file only. It’s a helper, not a global function — so we keep it private.
static int real_main(int argc, char **argv) {

  int status, result;
  lua_State *L = luaL_newstate();  /* create state */
  if (L == NULL) {
    l_message(argv[0], "cannot create state: not enough memory");
    return EXIT_FAILURE;
  }
  lua_gc(L, LUA_GCSTOP);  /* stop GC while building state */
  lua_pushcfunction(L, &pmain);  /* to call 'pmain' in protected mode */
  lua_pushinteger(L, argc);  /* 1st argument */
  lua_pushlightuserdata(L, argv); /* 2nd argument */
  status = lua_pcall(L, 2, 1, 0);  /* do the call */
  result = lua_toboolean(L, -1);  /* get result */
  report(L, status);
  lua_close(L);
  return (result && status == LUA_OK) ? EXIT_SUCCESS : EXIT_FAILURE;
}

// Prevent <windows.h> from pulling in almost *every*
// Windows header (saves compile time & namespace pollution).
// What does WIN32_LEAN_AND_MEAN mean?
// When you #include <windows.h>, by default it drags in a huge set of APIs (graphics, networking, multimedia, COM, etc.), which:
    // Slows down compilation,
    // Pollutes the global namespace with tons of macros and typedefs,
    // Can lead to name clashes or unexpected dependencies.
// By defining WIN32_LEAN_AND_MEAN before including windows.h, you tell it to skip loading the least used parts of the API, giving you a slimmer, faster compile with only the core kernel and user interface functions. It doesn’t change functionality — it just leaves out the rarely needed headers so your build is cleaner and faster.
#define WIN32_LEAN_AND_MEAN

#include <windows.h>    // for CommandLineToArgvW, LocalFree
#include <shellapi.h>   // for CommandLineToArgvW prototype
#include <stdlib.h>     // for malloc/free, EXIT_FAILURE


// Our single entry point: always a console ‘main’, no subsystem tricks.
// int main(int argc_unused, char **argv_unused) {
int main(void) {
  // 1) Grab the *true* Unicode command line from the OS.
  //    CRT’s argv is already lost if launched in UTF 8 mode,
  //    so we ask the shell directly.
  int wargc;
  wchar_t **wargv = CommandLineToArgvW(GetCommandLineW(), &wargc);
  if (!wargv) return EXIT_FAILURE;

  // 2) Build a parallel UTF 8 argv[] array of char*.
  //    We’ll pass this to the Lua engine.
  char **argv = malloc((wargc + 1) * sizeof(char*));
  if (!argv) {
    LocalFree(wargv);
    return EXIT_FAILURE;
  }

  for (int i = 0; i < wargc; i++) {
    // Figure out how many bytes we need in UTF 8 (including the '\0').
    int need = WideCharToMultiByte(
                  CP_UTF8,                // convert *to* UTF-8
                  0,                      // default flags
                  wargv[i], -1,           // input wchar_t*
                  NULL, 0,                // output buffer = NULL → length only
                  NULL, NULL              // no fallback chars
               );
    if (need <= 0) {
      argv[i] = NULL;
      continue;
    }

    // Allocate & convert
    argv[i] = malloc(need);
    if (!argv[i]) {
      // on malloc failure, clean up what we already did
      for (int j = 0; j < i; j++) free(argv[j]);
      free(argv);
      LocalFree(wargv);
      return EXIT_FAILURE;
    }
    WideCharToMultiByte(
      CP_UTF8, 0, wargv[i], -1,
      argv[i], need,
      NULL, NULL
    );
  }
  argv[wargc] = NULL;  // null terminate the list

  // 3) Call the original Lua startup, passing our UTF 8 args.
  int result = real_main(wargc, argv);

  // 4) Free everything
  for (int i = 0; i < wargc; i++) free(argv[i]);
  free(argv);
  LocalFree(wargv);

  return result;
}

then edit Makefile the one inside src to add -lshell32 to gcc
so
$(CC) -shared -o
becomes
$(CC) -shared -lshell32 -o

then call chcp 65001 before you call lua