format PE CONSOLE
entry start

include 'win32a.inc'

LUA_MULTRET = -1

section '.text' code readable executable

  start:
    invoke  GetModuleHandle,0
    mov     [hInstance],eax
    invoke  GetStdHandle,STD_OUTPUT_HANDLE
    mov     [hStdout],eax

; Get a new lua context: lua allocates the memory and return a ponter in eax
; This context is the state for the lua thread in execution. We don't need to
; mess with it. Simply pass it as the first argument to any lua function. 
    invoke  luaL_newstate
; Store lua state for later reference (api functions don't change esi)
    mov     esi,eax

; Load lua standard libraries into the context
    invoke  luaL_openlibs,esi

; Load the script file
    invoke  luaL_loadfilex,esi,script_name,NULL
    cmp     eax,0
    je      .script_loaded
    invoke  lua_tolstring,esi,-1,0
    invoke  wsprintf,buffer,script_error,eax
    invoke  WriteFile,[hStdout],buffer,eax,io_bytes,NULL
    mov     eax,1
    jmp     exit

  .script_loaded:
    invoke  lua_createtable,esi,0,0
    mov     edi,1
  .start_loop:
    push    0 edi
    fild    qword [esp]
    fstp    qword [esp]
    invoke  lua_pushnumber,esi
    mov     eax,edi
    add     eax,edi
    push    0 eax
    fild    qword [esp]
    fstp    qword [esp]
    invoke  lua_pushnumber,esi
    invoke  lua_rawset,esi,-3
    inc     edi
    cmp     edi,5
    jle     .start_loop
    invoke  lua_setglobal,esi,table_name

; Run the script into the context
    invoke  lua_pcallk,esi,0,LUA_MULTRET,0,0,0
    cmp     eax,0
    je      .show_result
    invoke  lua_tolstring,esi,-1,io_bytes
    invoke  wsprintf,buffer,run_error,eax
    invoke  WriteFile,[hStdout],buffer,eax,io_bytes,NULL
    mov     eax,1
    jmp     exit

  .show_result:
    invoke  lua_tonumberx,esi,-1,0
    fist    dword [esp]  
    invoke  wsprintf,buffer,return_message
    invoke  WriteFile,[hStdout],buffer,eax,io_bytes,NULL
    invoke  lua_settop,esi,-2
    invoke  lua_close,esi
    mov     eax,0
  exit:
    invoke  ExitProcess,eax

section '.bss' readable writeable

  hInstance dd ?  ; instance handle
  hStdout   dd ?  ; standard output handle
  io_bytes  dd ?  ; total bytes written
  buffer    rb 256

section '.data' readable

  script_name TCHAR 'script.lua',0
  script_error TCHAR "Couldn't load file: %s",13,10,0
  run_error TCHAR "Failed to run script: %s",13,10,0
  return_message TCHAR "Script returned %i",13,10,0
  program_name TCHAR 'lua test',0
  table_name TCHAR 'foo',0

section '.idata' import data readable writeable

  library kernel,'KERNEL32.DLL',\
    lua53,'LUA53.DLL',\
    user,'USER32.DLL'

  import kernel,\
    GetModuleHandle,'GetModuleHandleA',\
    ExitProcess,'ExitProcess',\
    GetStdHandle,'GetStdHandle',\
    WriteFile,'WriteFile'

  import lua53,\
    luaL_error,'luaL_error',\
    luaL_loadfilex,'luaL_loadfilex',\
    luaL_newstate,'luaL_newstate',\
    luaL_openlibs,'luaL_openlibs',\
    lua_close,'lua_close',\
    lua_createtable,'lua_createtable',\
    lua_pcallk,'lua_pcallk',\
    lua_pushnumber,'lua_pushnumber',\
    lua_rawset,'lua_rawset',\
    lua_setglobal,'lua_setglobal',\
    lua_settop,'lua_settop',\
    lua_tolstring,'lua_tolstring',\
    lua_tonumberx,'lua_tonumberx'

  import user,\
    wsprintf,'wsprintfA'    

I dislike Lua's bytecode, it's bloated as hell.

I'm no Lua coder, but IIRC, the bytecode output is optional. By that I mean that the main "lua" can be built without the compiler frontend and only include the interpreter.