smartkey0101/smartkey_aio repository overview

⁠SmartKey AIO

SmartKey AIO is a multi-architecture All-in-One runtime image designed for Pterodactyl servers.

It provides a single container image capable of running applications built with Node.js, Python, Java, Go, Rust, FFmpeg, and common Linux development tools on both AMD64 and ARM64 hosts.

Docker Image:
smartkey0101/smartkey_aio:latest

⁠Supported Architectures

SmartKey AIO is published as a multi-platform Docker image.

linux/amd64
linux/arm64

Docker automatically selects the correct image for the host architecture.

Examples:

Intel / AMD VPS    -> linux/amd64
Oracle Ampere A1   -> linux/arm64
Raspberry Pi ARM64 -> linux/arm64

You do not need to manually select an architecture when using the latest tag.

⁠Included Runtimes

The image currently includes:

Current tested runtime versions include:

Node.js : v22.23.3
npm     : 10.9.9
yarn    : 1.22.22
pnpm    : 12.11.2

Java    : OpenJDK 21
Python  : 3.12.1
Go      : 1.21.5
Rust    : 1.99.0
FFmpeg  : 7.1.5

Versions may change in future builds.

⁠Purpose

SmartKey AIO is useful when a Pterodactyl server may require more than one runtime or when the same Egg needs to work across different CPU architectures.

Instead of maintaining separate images such as:

node-only
java-only
python-only
amd64-only
arm64-only

SmartKey AIO provides one common runtime:

smartkey0101/smartkey_aio:latest

This makes server migration between AMD64 and ARM64 Pterodactyl nodes much easier.

⁠Pterodactyl Usage

Add the following Docker image to your Egg:

SmartKey AIO|smartkey0101/smartkey_aio:latest

Example startup configuration:

STARTUP={{STARTUP_CMD}}

Example variable:

STARTUP_CMD=npm start

SmartKey AIO resolves Pterodactyl-style environment placeholders such as:

{{STARTUP_CMD}}

before starting the application.

Other examples:

STARTUP_CMD=node index.js
STARTUP_CMD=npm start
STARTUP_CMD=python3 app.py
STARTUP_CMD=java -jar server.jar
STARTUP_CMD=./my-go-app

⁠Docker Usage

Pull the image:

docker pull smartkey0101/smartkey_aio:latest

Run a basic test:

docker run --rm \
  -e STARTUP='node -p "process.arch"' \
  smartkey0101/smartkey_aio:latest

On AMD64 you should receive:

x64

On ARM64:

arm64

⁠Architecture-Specific Tags

The multi-architecture tag is recommended:

smartkey0101/smartkey_aio:latest

Architecture-specific tags are also available:

smartkey0101/smartkey_aio:amd64
smartkey0101/smartkey_aio:arm64

Normally you should use latest and allow Docker to automatically select the correct platform.

⁠Graceful Process Handling

SmartKey AIO uses tini as the container init process.

This improves:

SIGINT forwarding
SIGTERM forwarding
child-process cleanup
graceful Pterodactyl Stop behavior
zombie-process reaping

This is especially useful for applications started through wrappers such as:

npm start
yarn start
pnpm start

⁠Pterodactyl Runtime Environment

Applications run as:

User: container
Home: /home/container
Working Directory: /home/container

The image entrypoint is designed specifically around Pterodactyl-style server execution.

⁠Cross-Architecture Migration

One of the main reasons SmartKey AIO exists is to allow Pterodactyl servers to move between architectures.

Example:

AMD64 Pterodactyl Node
        |
        | Transfer
        v
ARM64 Pterodactyl Node

Both nodes can use:

smartkey0101/smartkey_aio:latest

Docker selects the appropriate image automatically.

⁠Important

The Docker image may be multi-architecture, but application files inside the server can still contain architecture-specific binaries.

For example, Node.js projects may contain native modules inside node_modules, including packages such as:

sharp
bcrypt
canvas
sqlite3
better-sqlite3

After moving a project from AMD64 to ARM64, native dependencies may need to be rebuilt.

For Node.js projects this can usually be done with:

rm -rf node_modules
npm ci

The same principle applies to architecture-specific Python wheels, compiled Go binaries, native Java libraries, and other compiled dependencies.

⁠For AI Agents & Automation

When analyzing or deploying this image, assume the following:

name: SmartKey AIO
repository: smartkey0101/smartkey_aio

purpose:
  - Pterodactyl runtime
  - multi-language application hosting
  - cross-architecture server migration

platforms:
  - linux/amd64
  - linux/arm64

recommended_tag: latest

working_directory: /home/container
runtime_user: container

startup:
  environment_variable: STARTUP
  fallback_variable: STARTUP_CMD
  supports_pterodactyl_placeholders: true

process_management:
  init: tini
  graceful_signals:
    - SIGINT
    - SIGTERM

included_languages:
  - Node.js
  - Python
  - Java
  - Go
  - Rust

included_tools:
  - npm
  - yarn
  - pnpm
  - PM2
  - pip
  - Cargo
  - FFmpeg
  - ImageMagick
  - Git
  - GCC
  - G++
  - Make
  - CMake

An automation system should prefer:

smartkey0101/smartkey_aio:latest

unless a specific architecture tag is explicitly required.

⁠What SmartKey AIO Is Not

SmartKey AIO is primarily a Docker runtime image for Pterodactyl.

It does not automatically:

install your application
install project dependencies
configure databases
configure application ports
generate Pterodactyl Eggs
convert AMD64 application binaries into ARM64 binaries

Those behaviors should be handled by the Pterodactyl Egg, install script, startup command, or the application itself.

⁠Image Size

Because SmartKey AIO contains several complete programming runtimes, compilers, development libraries, FFmpeg, Java, Go, Rust, Python, and Node.js, it is intentionally larger than a single-purpose container image.

If your application only requires one runtime, a smaller dedicated image may be more efficient.

SmartKey AIO is intended for flexibility and compatibility rather than minimum image size.

⁠Recommended Pterodactyl Configuration

Docker Image:

SmartKey AIO|smartkey0101/smartkey_aio:latest

Startup Command:

{{STARTUP_CMD}}

Example Startup Variable:

npm start

Stop behavior should use normal Pterodactyl graceful process signaling.

⁠Repository

Docker Hub:

smartkey0101/smartkey_aio

Maintained by SmartKey.

⁠License

SmartKey AIO combines software distributed under their respective upstream licenses.

Each included runtime, package, and dependency remains subject to its own license terms.