LuaJIT is only distributed as a source package. This page explains how to build and install LuaJIT with different operating systems and C compilers.

For the impatient (on POSIX systems):

make && sudo make install



LuaJIT currently builds out-of-the box on most systems:

OS Min. Version Requirements LuaJIT Versions
Windows 7 x86 or x64, ARM64: TBA v2.0 –
Linux     v2.0 –
*BSD     v2.0 –
macOS (OSX) 10.4   v2.1 –
POSIX   mmap, dlopen v2.0 –
Android 4.0 Recent Android NDK v2.0 –
iOS 3.0 Xcode iOS SDK v2.1 –
PS3   PS3 SDK v2.0 – v2.1 EOL
PS4   PS4 SDK (ORBIS) v2.0 –
PS5   PS5 SDK (PROSPERO) v2.1 –
PS Vita   PS Vita SDK (PSP2) v2.0 – v2.1 EOL
Xbox 360   Xbox 360 SDK (XEDK) v2.0 – v2.1 EOL
Xbox One   Xbox One SDK (DURANGO) v2.1 –
Nintendo Switch   NintendoSDK + NX Addon v2.1 –

The codebase has compatibility defines for some more systems, but without official support.


Building LuaJIT requires a recent toolchain based on GCC, Clang/LLVM or MSVC++.

The Makefile-based build system requires GNU Make and supports cross-builds. Batch files are provided for MSVC++ builds and console cross-builds.

CPU Architectures

CPU Bits Requirements Variants LuaJIT Versions
x86 32 v2.1+: SSE2   v2.0 –
x64 64     v2.0 –
ARM 32 ARMv5+, ARM9E+ hard-fp + soft-fp v2.0 –
ARM64 64   ARM64le + ARM64be v2.1 –
PPC32 32   hard-fp + soft-fp v2.0 – v2.1 EOL
PPC/e500 32 e500v2   v2.0 EOL
MIPS32 32 MIPS32r1 – r5 hard-fp + soft-fp v2.0 –
MIPS64 64 MIPS64r1 – r5 hard-fp + soft-fp v2.1 –
MIPS64 64 MIPS64r6 hard-fp + soft-fp v2.1 EOL
RISC-V 64 RVA22+   TBA

There are no plans to add historic architectures or to continue support for end-of-life (EOL) architectures, for which no new CPUs are commonly available anymore. Likewise, there are no plans to support marginal and/or de-facto-dead architectures.

Configuring LuaJIT

The standard configuration should work fine for most installations. Usually there is no need to tweak the settings. The following files hold all user-configurable settings:

Please read the instructions given in these files, before changing any settings.

POSIX Systems (Linux, macOS, *BSD etc.)


Depending on your distribution, you may need to install a package for GCC, the development headers and/or a complete SDK. E.g. on a current Debian/Ubuntu, install libc6-dev with the package manager.

The recommended way to fetch the latest version is to do a pull from the git repository.

Alternatively, download the latest source package of LuaJIT (pick the .tar.gz). Move it to a directory of your choice, open a terminal window and change to this directory. Now unpack the archive and change to the newly created directory (replace XX.YY.ZZ with the version you downloaded):

tar zxf LuaJIT-XX.YY.ZZ.tar.gz

Building LuaJIT

The supplied Makefiles try to auto-detect the settings needed for your operating system and your compiler. They need to be run with GNU Make, which is probably the default on your system, anyway. Simply run:


This always builds a native binary, depending on the host OS you're running this command on. Check the section on cross-compilation for more options.

By default, modules are only searched under the prefix /usr/local. You can add an extra prefix to the search paths by appending the PREFIX option, e.g.:

make PREFIX=/home/myself/lj2

Please use the LuaJIT 2.1 branch to compile for macOS (OSX).

Installing LuaJIT

The top-level Makefile installs LuaJIT by default under /usr/local, i.e. the executable ends up in /usr/local/bin and so on. You need root privileges to write to this path. So, assuming sudo is installed on your system, run the following command and enter your sudo password:

sudo make install

Otherwise specify the directory prefix as an absolute path, e.g.:

make install PREFIX=/home/myself/lj2

Obviously the prefixes given during build and installation need to be the same.

Windows Systems


Either install one of the open source SDKs (MinGW or Cygwin), which come with a modified GCC plus the required development headers. Or install Microsoft's Visual Studio (MSVC).

Next, pull from the git repository or download the source package and unpack it using an archive manager (e.g. the Windows Explorer) to a directory of your choice.

Building with MSVC

Open a "Visual Studio Command Prompt" (either x86 or x64), cd to the directory where you've unpacked the sources and run these commands:

cd src

Check the msvcbuild.bat file for more options. Then follow the installation instructions below.

Building with MinGW or Cygwin

Open a command prompt window and make sure the MinGW or Cygwin programs are in your path. Then cd to the directory of the git repository or where you've unpacked the sources. Then run this command for MinGW:


Or this command for Cygwin:


Then follow the installation instructions below.

Installing LuaJIT

Copy luajit.exe and lua51.dll (built in the src directory) to a newly created directory (any location is ok). Add lua and lua\jit directories below it and copy all Lua files from the src\jit directory of the distribution to the latter directory.

There are no hardcoded absolute path names — all modules are loaded relative to the directory where luajit.exe is installed (see src/luaconf.h).

Cross-compiling LuaJIT

The GNU Makefile-based build system allows cross-compiling on any host for any supported target, as long as both architectures have the same pointer size. If you want to cross-compile to any 32 bit target on an x64 OS, you need to install the multilib development package (e.g. libc6-dev-i386 on Debian/Ubuntu) and build a 32 bit host part (HOST_CC="gcc -m32").

You need to specify TARGET_SYS whenever the host OS and the target OS differ, or you'll get assembler or linker errors. E.g. if you're compiling on a Windows or macOS host for embedded Linux or Android, you need to add TARGET_SYS=Linux to the examples below. For a minimal target OS, you may need to disable the built-in allocator in src/Makefile and use TARGET_SYS=Other. Don't forget to specify the same TARGET_SYS for the install step, too.

The examples below only show some popular targets — please check the comments in src/Makefile for more details.

# Cross-compile to a 32 bit binary on a multilib x64 OS
make CC="gcc -m32"

# Cross-compile on Debian/Ubuntu for Windows (mingw32 package)
make HOST_CC="gcc -m32" CROSS=i586-mingw32msvc- TARGET_SYS=Windows

The CROSS prefix allows specifying a standard GNU cross-compile toolchain (Binutils, GCC and a matching libc). The prefix may vary depending on the --target the toolchain was built for (note the CROSS prefix has a trailing "-"). The examples below use the canonical toolchain triplets for Linux.

Since there's often no easy way to detect CPU features at runtime, it's important to compile with the proper CPU or architecture settings. You can specify these when building the toolchain yourself. Or add -mcpu=... or -march=... to TARGET_CFLAGS. For ARM it's important to have the correct -mfloat-abi=... setting, too. Otherwise, LuaJIT may not run at the full performance of your target CPU.

# ARM soft-float
make HOST_CC="gcc -m32" CROSS=arm-linux-gnueabi- \

# ARM soft-float ABI with VFP (example for Cortex-A8)
make HOST_CC="gcc -m32" CROSS=arm-linux-gnueabi- \
     TARGET_CFLAGS="-mcpu=cortex-a8 -mfloat-abi=softfp"

# ARM hard-float ABI with VFP (armhf, requires recent toolchain)
make HOST_CC="gcc -m32" CROSS=arm-linux-gnueabihf-

make HOST_CC="gcc -m32" CROSS=powerpc-linux-gnu-
# PPC/e500v2 (fast interpreter only)
make HOST_CC="gcc -m32" CROSS=powerpc-e500v2-linux-gnuspe-

# MIPS big-endian
make HOST_CC="gcc -m32" CROSS=mips-linux-
# MIPS little-endian
make HOST_CC="gcc -m32" CROSS=mipsel-linux-

You can cross-compile for Android using the Android NDK. Please adapt the environment variables to match the install locations and the desired target platform. E.g. Android 4.1 corresponds to ABI level 16.

# Android/ARM, armeabi-v7a (ARMv7 VFP), Android 4.1+ (JB)

make HOST_CC="gcc -m32" CROSS=$NDKCROSS \
     TARGET_LD=$NDKCC TARGET_AR="$NDKBIN/llvm-ar rcus" \

Please use the LuaJIT 2.1 branch to compile for iOS (iPhone/iPad).

Cross-compiling for consoles

Building LuaJIT for consoles requires both a supported host compiler (x86 or x64) and a cross-compiler from the official console SDK.

Due to restrictions on consoles, the JIT compiler is disabled and only the fast interpreter is built. This is still faster than plain Lua, but much slower than the JIT compiler. The FFI is disabled, too, since it's not very useful in such an environment.

The following commands build a static library libluajit.a, which can be linked against your game, just like the Lua library.

To cross-compile for PS3 from a Linux host (requires 32 bit GCC, i.e. multilib Linux/x64) or a Windows host (requires 32 bit MinGW), run this command:

make HOST_CC="gcc -m32" CROSS=ppu-lv2-

To cross-compile for the other consoles from a Windows host, open a "Native Tools Command Prompt for VS". You need to choose either the 32 or the 64 bit version of the host compiler to match the target. Then cd to the src directory below where you've unpacked the sources and run the build command given in the table:

Console Bits Build Command
PS4 64 ps4build
PS Vita 32 psvitabuild
Xbox 360 32 xedkbuild

Please check out the comments in the corresponding *.bat file for more options.

Embedding LuaJIT

LuaJIT is API-compatible with Lua 5.1. If you've already embedded Lua into your application, you probably don't need to do anything to switch to LuaJIT, except link with a different library:

Additional hints for initializing LuaJIT using the C API functions:

Hints for Distribution Maintainers

The LuaJIT build system has extra provisions for the needs of most POSIX-based distributions. If you're a package maintainer for a distribution, please make use of these features and avoid patching, subverting, autotoolizing or messing up the build system in unspeakable ways.

There should be absolutely no need to patch luaconf.h or any of the Makefiles. And please do not hand-pick files for your packages — simply use whatever make install creates. There's a reason for all the files and directories it creates.

The build system uses GNU make and auto-detects most settings based on the host you're building it on. This should work fine for native builds, even when sandboxed. You may need to pass some of the following flags to both the make and the make install command lines for a regular distribution build:

The build system has a special target for an amalgamated build, i.e. make amalg. This compiles the LuaJIT core as one huge C file and allows GCC to generate faster and shorter code. Alas, this requires lots of memory during the build. This may be a problem for some users, that's why it's not enabled by default. But it shouldn't be a problem for most build farms. It's recommended that binary distributions use this target for their LuaJIT builds.

The tl;dr version of the above:

make amalg PREFIX=/usr && \
make install PREFIX=/usr DESTDIR=/tmp/buildroot

Finally, if you encounter any difficulties, please contact me first, instead of releasing a broken package onto unsuspecting users. Because they'll usually gonna complain to me (the upstream) and not you (the package maintainer), anyway.