The Universal Game Engine Theory: If It Runs Lua, It Ships

Level 1: If It Has an Engine, Call It a Racecar

Imagine someone says, “If something has an engine, then it’s a racecar.” By that logic, even a lawnmower or a tractor would be called a racecar, just because they have engines inside. 😄 Obviously, that’s a silly thing to say – a tractor isn’t built for racing, and a lawnmower isn’t a Formula 1 car, even though they both do have small engines. You’d laugh because you know they’re using a way too broad definition just for fun.

That’s exactly what’s going on with this programmer meme. It jokes that if a piece of software can run Lua scripts (Lua is just a kind of little programming language), then congratulations, that software is a “game engine” now! That’s as silly as calling a tractor a racecar. Wireshark, for example, is a very serious tool for looking at network data – calling it a game engine is like calling a screwdriver a musical instrument just because you can tap it to make a sound. It’s funny because it’s such an exaggeration.

In simple terms, the meme is playing with labels. A game engine is something you use to make video games. Lua is often used in real game engines, but Lua can also be found in other non-game programs. So the joke is: “Hey, if it has Lua, let’s pretend it’s the same as those big fancy game-making tools.” We all know that’s not true, and that’s why it makes us grin. It’s a bit like calling your homework notebook a library because it has some words in it – technically, there are words, but it’s not at all the same thing as a real library. The humor comes from that obvious mismatch and the playful imagination that turns a boring thing into a “game” by labeling it so.

Level 2: Lua in All the Tools

Let’s break down the joke in simpler terms. First, some definitions:

• Lua: Pronounced “LOO-ah,” this is a small programming language famous for being easy to embed in other software. Think of Lua as a lightweight scripting language – a way to write quick programs (“scripts”) that another application can run internally. Developers often include Lua in their apps so that users or plugin writers can extend the app’s functionality without changing the core code. It’s like giving your app a little interpreter sidekick that can execute user-provided instructions. Lua is very popular in situations where performance and low memory usage matter (for example, in games or even inside things like routers).

• Game engine: This is the main software platform used to build a video game. A game engine provides lots of features you need for games: rendering graphics on screen, playing sounds, detecting collisions in a world, physics simulation for movement, handling user input, etc. Examples of game engines include Unity, Unreal Engine, and Godot. They basically are the "kitchen" where games are cooked, providing all the ingredients and tools. Most game engines also let game developers write scripts to define how the game objects behave (like how an enemy AI moves, or what happens when you pick up an item). Sometimes those scripts are written in languages like Lua (for instance, some older or custom engines use Lua, while others use Python, C# or their own scripting languages).

• Wireshark: This is a tool for network engineers and developers to inspect network traffic. Imagine you could capture all the data packets going in and out of a computer – Wireshark lets you do that and see what’s inside those packets. It’s used for debugging network issues, security research, learning network protocols, etc. Wireshark has a graphical interface where you see lists of packets, but importantly for this meme, it also has a feature where you can write Lua scripts to add new capabilities. For example, if you have a custom network protocol (data format) that Wireshark doesn’t understand by default, you can script Wireshark (in Lua) to decode it and display it nicely. Lua basically allows power-users to teach Wireshark new tricks without modifying its C++ source code.

• Neovim (nvim): Neovim is a modern text editor that runs in the terminal (command-line). It’s an improved version of Vim, which itself is a very famous terminal-based editor loved by programmers. Vim/Neovim are known for their efficiency and steep learning curve (you control it with keyboard commands). Neovim introduced the ability to configure and extend the editor using Lua scripts. This means instead of using Vim’s old configuration language, you can write Lua code to do things like create new editor commands, define custom text manipulations, or integrate other tools. For instance, you might write a Lua script in Neovim to automatically format your code or to add a game-like status bar with fun info — the sky’s the limit if you’re willing to script it.

• CLI: This stands for Command-Line Interface. It’s basically using text commands in a terminal window to interact with programs (as opposed to clicking buttons in a graphical user interface). Neovim is often used as a CLI program (inside your terminal), though it can be run with a GUI as well. We mention CLI because Neovim and Vim are quintessential command-line tools for coding. Wireshark, on the other hand, is usually graphical, but it’s definitely a developer tool rather than a game.

Now, the joke: The tweet said “a game engine is anything that can execute Lua scripts.” The author is being facetious – they don’t literally mean it as a definition, they’re jokingly claiming it. The reason this is funny is that it stretches the definition of "game engine" way beyond how we normally use it. It’s as if someone said, “Hey, if a piece of software lets you run Lua code inside it, tada! – it qualifies as a game-making engine.” By that logic, tons of unlikely programs suddenly become "game engines."

For example, since Wireshark lets you run Lua scripts, the tweet jokingly calls Wireshark a game engine (even though Wireshark’s purpose is analyzing network packets, nothing to do with games). Similarly, since Neovim can run Lua scripts, someone joked that Neovim is a game engine – but “the game is just not very fun.” In plain terms, that reply means: Yes, you can kind of treat using Neovim like playing a game by scripting and configuring it, but it’s a pretty boring game meant for work! 😅

This is an example of developer humor where people take a small common feature and use it to humorously equate very different things. It’s like saying, “if two things both have X, then they’re basically the same.” Here X = “Lua scripting ability.” Of course, in reality, Wireshark is not a game engine at all – you can’t easily make a video game in Wireshark (it’s meant for totally different tasks, like dissecting a TCP handshake or analyzing packets from a web traffic capture). And Neovim is not designed as a game engine – it’s for editing text and code. But because these tools share the quirky trait that you can script them with Lua (just as some game engines use Lua scripting), developers find it funny to put a game engine “label” on them. It’s an absurd classification that makes you chuckle because it’s so obviously off-base.

Another reason this joke lands in the developer community is the ubiquity of Lua. You might not realize, but Lua is hiding inside a lot of applications! It’s in some video games for modding, it's in certain applications like Wireshark, some database systems like Redis allow Lua scripting, and even some web servers (via modules in Nginx) use Lua for customization. So if you sarcastically decide “anything that contains Lua is a game engine,” you suddenly can claim all sorts of tech as game engines. It’s a form of dev banter – nobody actually believes it, but it’s fun to riff on. On Twitter (or X), developers often engage in this kind of back-and-forth, each adding a twist:

• Dev A: “Haha, by that definition even Wireshark is a game engine.”
• Dev B: “Oh, then Neovim too! Though configuring Neovim is more like a torture game 😂.”
• Dev C: “Does that mean my smart fridge that runs Lua scripts is a game console?!” (Yep, people might actually quip something like that.)

The reply "the game is just not very fun" encapsulates the joke well. It acknowledges, okay, Neovim could be considered a "game" if you view writing code configurations as a game, but let's be honest, it’s not what anyone except a nerdy programmer would call fun. It adds a layer of self-deprecating humor: we developers sometimes treat our work tools like games or hobbies. Some of us do enjoy tweaking our editors or automating tasks – it’s a “game” where the high score is productivity. But it’s a niche kind of fun.

In summary, this meme plays with the overlap between game development terminology and developer tooling reality. It uses Lua, a programming language common to both domains, as the bridge of the joke. For a newcomer: just know that Lua is everywhere, game engines often use it, and now even your plain tools might use it. But no, installing Lua in your program doesn’t truly turn it into Fortnite – it’s just a funny exaggeration that shows how far-reaching one little language can be!

Level 3: Achievement Unlocked: Game Engine Mode

In this tweet thread, an experienced dev can’t help but laugh at the bold proclamation: “a game engine is anything that can execute Lua scripts.” It’s a classic bit of developer hyperbole. The joke riffs on the fact that Lua has become so ubiquitous as an embedded scripting tool that people half-joke it’s the hallmark of a “game engine”. In proper terms, a game engine is a software framework for building games (think Unity, Unreal Engine, or Godot) – it handles graphics rendering, physics, input, and more. Crucially, many game engines allow game-specific scripting (often in Lua or a similar language) so designers can define game logic without rebuilding the engine. The tweet humorously flips this around: if having Lua scripting is a defining trait of game engines, then by golly, any software that can run Lua must itself be a game engine!

The original poster doubles down in a reply, joking: “(Wireshark is a game engine btw)”. Now, Wireshark is a venerable network packet analysis tool – basically, an application for sniffing network traffic and dissecting protocols. Not exactly anyone’s idea of a game. But Wireshark does include a Lua scripting API! (It allows users to write Lua scripts to decode custom network protocols or automate analysis tasks.) By the tweet’s cheeky logic, that little scripting feature suddenly crowns Wireshark as a “game engine.” Ridiculous? Absolutely – and that absurdity is the point. It’s funny because we know Wireshark isn’t a game development tool at all, yet here we are calling it an engine as if you could make Super Mario: Packet Edition with it.

Another user joins in with a reply: “nvim is a game engine. the game is just not very fun.” This one hits close to home for many developers. Neovim (often invoked as the nvim command) is a popular CLI text editor, a modern fork of the classic Vim. It’s powerful, keyboard-centric, and famously configurable – in fact, Neovim has Lua built in for users to script and extend the editor. So yes, you can write Lua scripts to customize Neovim, effectively programming your editor to do new tricks. The tongue-in-cheek remark suggests that using Neovim is like playing a game… just not an entertaining one for most people. After all, spending a weekend tweaking your .vimrc (configuration) or writing editor plugins is a form of challenge, even enjoyment, for some nerdy folks, but it’s not exactly Minecraft. The “game” in Neovim might consist of slaying error messages and leveling up your editing efficiency. It’s a playful self-own: we geeks turn our tools into playful battlegrounds, even if outsiders don’t see the fun.

This whole exchange is a great slice of dev humor. It’s exaggerating a real trend: embedding scripting languages in all sorts of developer tools. Over the years, many serious applications have added scripting hooks to make them more flexible. Text editors, network tools, build systems, you name it – chances are there’s a Lua (or Python, or JavaScript) API in there. We do this because it’s immensely useful: instead of hard-coding every feature, developers ship a mini “extension language” so users can automate tasks or add plugins. But the side effect is we end up joking that our command-line tools and productivity apps are so powerful they might as well be considered game engines or operating systems. (There’s a running joke that Emacs – an older programmable editor – is actually a decent operating system, lacking only a good editor 😉. That’s because it can do email, web, and yes, even games like Tetris, all thanks to its embedded Lisp scripting.) In the same vein, Neovim with Lua and Wireshark with Lua have breached that wall of extensibility where the tool stops being just a tool and starts feeling like a platform you can bend to your will.

Why Lua specifically? Seasoned devs know that Lua has a reputation for popping up everywhere. It earned this spot because of its simplicity and tiny footprint. Compared to, say, embedding Python (which brings along a larger runtime), embedding Lua in a C/C++ program is lightweight and straightforward. Game developers in the late ‘90s and 2000s made Lua their go-to for AI scripting and modding. Networking and systems tools later adopted it for user scripting for the same reasons. The result is an inside joke: “Does your app secretly run Lua? Congrats, you’ve unknowingly created a game engine!” It’s a gentle ribbing of our industry’s tendency to jam full programmability into everything. We’ve reached a point where the line between a specialized application and a general-purpose engine is blurry.

From an architectural perspective, calling everything with a Lua interpreter a “game engine” is obviously a stretch. It deliberately ignores all the hard parts that make a real game engine (rendering pipelines, asset management, physics simulation, etc.). But that’s the comedy – we’re using an overly broad definition on purpose. It’s terminology satire. In everyday dev life, we often see terms get stretched like this. For example, call any script a “AI” these days and someone will joke “that’s just a bunch of if statements.” Here, call any scriptable tool a “game engine” and watch the purists facepalm and the insiders smirk. It’s the same energy as saying “my text editor is a AAA game now because I can write Lua in it.”

Ultimately, this meme resonates with those of us who straddle the line between game development and general tooling/CLI work. It’s a cross-pollination of humor: folks who know how a game engine works and folks who customize developer tools both get the reference. The next time you discover your favorite tool has a Lua scripting plugin, you might joke with your team, “Careful, we’re basically running a game engine now!” It’s a lighthearted way to appreciate how amazingly flexible (and over-engineered) our modern tools have become. Achievement unlocked, indeed. 🏆

Level 4: Turning Tools into Turing Machines

On a theoretical level, embedding Lua into a program essentially gives that program a full-fledged Turing-complete interpreter inside it. In other words, once an application can execute arbitrary Lua scripts, it’s capable of performing any computation (in theory) that a general computer can. This is a profound computer science concept: a system that can run a Turing-complete language can simulate anything, given enough time and memory – even the logic of a video game. By incorporating a Lua scripting engine, tools like Wireshark or Neovim secretly gain the power to do far more than their original purpose. They become, in an abstract sense, universal computing machines in disguise.

From this vantage point, the meme’s claim isn’t entirely facetious: if Wireshark can run user-defined Lua code, there’s nothing fundamental (besides practicality) stopping someone from writing a game within Wireshark. 🤯 Of course, rendering graphics or real-time input in a network analyzer would be ludicrously impractical, but computationally it’s possible. This tongue-in-cheek idea leans on the concept of Turing completeness – the idea that a simple scripting interface can be as powerful as any programming environment. It’s reminiscent of how creative hackers get Doom running on toasters and fridges; once you have a programmable layer, the device’s original intent can be subverted into doing wild, unintended things. A Lua interpreter inside your tool is like a tiny virtual CPU eagerly waiting to execute any logic you throw at it.

The historical reason Lua shows up everywhere is its design as an embeddable language. Back in the day, game developers needed a way to let game designers mod behavior without touching the complex C++ engine code. Lua was perfect: it’s lightweight (small memory footprint, easily integrated in C/C++ programs) and yet powerful. Academic papers and GDC talks from the early 2000s praised Lua for enabling flexible game logic. As a result, many game engines included a Lua virtual machine as a core component. Now fast-forward: that same tiny Lua VM proved handy outside games too. It’s been snuck into all kinds of software (from database servers to text editors) because it provides a safe, sandboxed way to execute custom scripts. In each case, the host application + Lua interpreter combo essentially forms a miniature platform. Conceptually, it’s as if these tools have a hidden “computer inside the computer.” The meme exploits this notion by joking that once that threshold is crossed – once your tool can run code – you’ve accidentally created a “game engine.” It’s a playful reminder of a deep truth in computing: with enough programmability, any system can, in principle, mimic any other system.