Table of Contents

The Need for Speed in the Terminal

When automating complex logic in the terminal, we often outgrow Bash or Zsh. We turn to general-purpose languages to handle JSON parsing, math, or heavy workloads. But which language is best for terminal scripts?

Python is the undisputed king of modern development, but it carries heavy overhead. LuaJIT, however, is a silent assassin. It powers game engines, proxies, and embedded systems with unbelievable speed.

Let’s unpack the obvious and non-obvious performance differences between LuaJIT and Python, and see why Lua is perfect for small terminal scripts.

The Sprint: Startup Time & Memory Footprint

When you execute a script, every millisecond counts. Python has to fire up the CPython interpreter, load packages, and parse standard libraries. This introduces dozens of milliseconds of latency.

For long-running web servers, this is fine. But for command-line tools—especially those running on every prompt redraw—you feel the lag.

LuaJIT, written in highly optimized assembly and C, is basically a ghost. Startup time is essentially zero. It wins the race before Python even gets its shoes on.

Python also carries massive memory overhead because everything is an object. A baseline LuaJIT process takes barely a couple of megabytes of RAM. You can run hundreds of instances concurrently without breaking a sweat.

Benchmark: Roda vs The World

To prove this, I built roda.lua, an elegant terminal spinner utility. It can be used as a standalone executable in bash scripts or as a pure Lua library.

I benchmarked Roda against popular spinner tools in Go (gum), Node.js (ora), and Python (halo). Each tool was wrapped in a script that spawned a spinner and slept for 1 second.

Here are the hyperfine results on an M-series Mac:

Command	Mean [s]	Min [s]	Max [s]	Relative
bash test_roda.sh	1.027 ± 0.002	1.023	1.030	1.00
bash test_gum.sh	1.043 ± 0.004	1.038	1.053	1.02 ± 0.00
node test_ora.mjs	1.095 ± 0.005	1.087	1.105	1.07 ± 0.01
python3 test_halo.py	1.097 ± 0.035	1.062	1.148	1.07 ± 0.03

Notice the ~70ms overhead from Node.js and Python just to start the interpreter and load imports. Go is fast, but compiled binaries still carry a small penalty. LuaJIT’s execution is near-instantaneous.

Here’s how easily you can use Roda as a standalone CLI in your bash scripts:

# Wrap long-running commands with elegant visual feedback
roda --title "Installing dependencies..." -- npm install

Or as a lightweight Lua library:

local roda = require("roda")

local spinner = roda("Processing..."):start()
-- Execute heavy logic here...
spinner:succeed("Done!")

The Marathon: Tracing JIT Magic

For long-running processes, Python parses byte code step-by-step. It runs at a steady but predictable pace.

LuaJIT destroys it in raw CPU-bound performance because it’s a tracing Just-In-Time compiler. It watches the code as it runs and identifies “hot loops”.

When a loop executes repeatedly, LuaJIT records the exact path taken, compiles it directly into hyper-optimized machine code, and swaps it out on the fly.

For pure math or loop-heavy marathons, LuaJIT achieves speeds that rival native C or C++. Python simply cannot compete without third-party tools.

Integration: Zero-cost FFI Calls

Nobody writes everything in pure Lua or Python. You must talk to the OS and C libraries. In Python, crossing the C-API boundary requires heavy boxing, unboxing, and handling the Global Interpreter Lock (GIL).

LuaJIT features a legendary built-in Foreign Function Interface (FFI). It parses C headers directly. You just paste C function signatures into your Lua code.

The magic happens when the tracing JIT compiler encounters the FFI boundary. It compiles the Lua code and the C function call into a single, seamless block of machine code.

The overhead of calling a C function from LuaJIT is essentially zero. While Python takes an elevator down to ask a C library for data, LuaJIT knocks down the wall and merges the rooms.

Choosing the Right Tool

If you’re building a massive web backend, an AI model, or need a massive ecosystem of libraries, Python remains your best friend.

If your script is evolving into a complex utility requiring strict types, network calls, and concurrency, consider TypeScript (via Bun) or Go.

But if you need to embed a scripting language, write high-performance network gateways, or build terminal scripts where zero-latency startup is mandatory, LuaJIT is the heavy hitter you need.

References

1. Pall, Mike. “The LuaJIT Project.” LuaJIT. http://luajit.org/luajit.html
2. Pall, Mike. “FFI Semantics.” LuaJIT. http://luajit.org/ext_ffi_semantics.html
3. Kolleh, TJ. “Roda: Elegant terminal spinners for bash scripts and Lua.” GitHub. https://github.com/tkolleh/roda.lua