Discord bot stacks we host right now

Current language support

We currently support three runtime environments that cover the vast majority of Discord bots in production today. Each environment is containerised and isolated, meaning your bot runs in its own sandboxed process with dedicated resources. Below you will find details on each stack, the libraries they support, and how they fit into the broader Discord bot development ecosystem.

Understanding Discord Bot Runtimes

A runtime environment is the software layer that executes your bot's code and provides access to system resources like networking, file I/O, and memory management. When you write a Discord bot, your code does not interact with the operating system directly. Instead, it runs inside a runtime that translates your high-level instructions into low-level operations. Understanding how each runtime works helps you write more efficient code and troubleshoot issues when they arise.

Node.js is built on the V8 JavaScript engine, which compiles JavaScript to native machine code at execution time using a technique called just-in-time compilation. V8's garbage collector manages memory automatically, reclaiming objects that are no longer referenced by your code. Node.js adds a standard library on top of V8 that provides modules for file system access, networking, cryptography, and other system-level operations. The event loop is the core of Node.js: it continuously checks for pending events such as incoming WebSocket messages from Discord, completed file reads, or timer callbacks, and dispatches them to the appropriate handler functions. This single-threaded event loop model means your bot processes one event at a time, but because I/O operations are non-blocking, the event loop is free to handle other events while waiting for network responses or disk reads to complete. For CPU-intensive tasks like image processing, Node.js provides worker threads that run in parallel.

Python's runtime operates differently. CPython, the standard Python interpreter, reads your source code, compiles it to bytecode, and executes that bytecode on a virtual machine. The Global Interpreter Lock, commonly known as the GIL, ensures that only one thread executes Python bytecode at a time, which simplifies memory management but limits true parallelism for CPU-bound work. Discord bot libraries in Python work around this limitation by using asyncio, Python's built-in asynchronous I/O framework. With asyncio, your bot defines coroutines that can yield control while waiting for I/O operations, allowing other coroutines to run in the meantime. This cooperative multitasking model achieves concurrency without threading and is conceptually similar to Node.js's event loop, though the implementation details differ significantly.

Package management is another area where the two ecosystems diverge. Node.js uses npm, which installs packages into a node_modules directory within your project. Each package can specify its own dependency tree, and npm resolves version conflicts by nesting dependencies. A typical Discord bot project might have a node_modules folder containing hundreds of packages, but only a handful are direct dependencies listed in your package.json. Python uses pip, which installs packages globally or into a virtual environment. Dependencies are listed in a requirements.txt file with pinned versions, and pip installs them in a flat structure. Dependency conflicts in Python are resolved at install time and can occasionally require manual intervention if two packages need incompatible versions of a shared dependency. On MonkeyBytes, both package managers are available through the console, and dependencies are preserved between restarts.

Memory behaviour differs between the two runtimes as well. Node.js allocates memory from V8's managed heap, which has a default limit that varies by version but is typically around 1.5GB on 64-bit systems. V8's garbage collector runs periodically to free unused memory, and it uses a generational strategy that separates short-lived objects from long-lived ones for more efficient collection. Python's memory management uses reference counting as its primary mechanism, supplemented by a cyclic garbage collector that handles reference cycles. In practice, Python bots tend to have a slightly higher baseline memory footprint than Node.js bots performing the same tasks, because the CPython interpreter itself consumes more memory than V8 for equivalent workloads. Within the 1GB allocation provided by MonkeyBytes, both runtimes have plenty of headroom for most Discord bots, but developers working with large caches, image buffers, or database connection pools should monitor their memory usage through the panel.

Choosing the Right Stack for Your Bot

The best language for your Discord bot depends on your existing experience, the libraries you want to use, and the specific requirements of your project. There is no universally superior choice. Node.js and Python are both capable of building any type of Discord bot, from simple moderation tools to complex multi-server applications with databases, web dashboards, and music playback. The differences lie in developer ergonomics, ecosystem tooling, and performance characteristics for specific workloads.

If you are already comfortable with JavaScript from web development, Node.js is the natural starting point. The discord.js library has the largest community of any Discord API wrapper, which means you will find the most tutorials, guides, and Stack Overflow answers for common problems. Discord.js also tends to receive support for new Discord API features faster than libraries in other languages, because the Discord API itself uses JSON over WebSocket, which is native territory for JavaScript. The npm ecosystem provides packages for virtually any integration you might need, from database drivers to HTTP clients to image processing libraries. Node.js also excels at I/O-heavy workloads, which describes most Discord bots: receiving events, querying APIs, reading from databases, and sending responses.

If you prefer Python's syntax and readability, or if your bot involves data processing, machine learning, or scientific computation, Python is the stronger choice. Python's standard library is more comprehensive than Node.js's for tasks like string manipulation, regular expressions, and data structures. Libraries like NumPy, pandas, and scikit-learn are available through pip if your bot needs to perform calculations or data analysis. The discord.py ecosystem is mature and well-documented, and forks like Nextcord and Pycord ensure that the Python Discord community continues to evolve. Python's asyncio model requires you to think explicitly about asynchronous execution using async and await keywords, which can be a learning curve for beginners but leads to clear and predictable code once understood.

For developers who are still learning and want the fastest possible iteration cycle, the Nodemon stack offers a meaningful advantage. Being able to save a file and see your changes take effect immediately, without manually restarting your bot or reconnecting to the Discord gateway, significantly reduces the time between writing code and testing it. This is especially valuable when you are experimenting with command handlers, event listeners, or embed formatting, where small adjustments are common. Once your bot is stable and deployed for production use, you can switch to the standard Node.js stack to avoid unnecessary restarts from accidental file modifications.

Performance is rarely the deciding factor for Discord bots. The Discord API itself imposes rate limits that cap how many requests your bot can make per second, and the gateway connection processes events sequentially. A bot that serves a single Discord server or even a handful of servers will never approach the performance limits of either Node.js or Python within the 1GB memory and 150% CPU allocation provided by MonkeyBytes. Performance becomes relevant only at significant scale, typically hundreds or thousands of servers, and at that point you would likely need dedicated infrastructure regardless of language. For the vast majority of bot projects, choose the language you are most productive in, and you will be well served.