What Programming Languages Does Pumpkin-MC/Pumpkin Use?

Pumpkin-MC/Pumpkin is written exclusively in Rust, with all source code, build scripts, and executable components implemented using the Rust programming language.

Pumpkin-MC/Pumpkin is a Minecraft server implementation whose entire source tree is authored in Rust. According to the repository's Cargo workspace configuration and file structure, the project contains no Python, JavaScript, Java, or other programming languages—only Rust source files (.rs) and Cargo configuration.

The Rust-Only Codebase

Pumpkin is a Rust-only codebase. All executable components, libraries, and build logic are written in Rust, as evidenced by the repository's Cargo workspace setup and the absence of other language files. The project uses Cargo as its build system, with the top-level Cargo.toml defining a workspace that aggregates dozens of internal crates.

Workspace Configuration and Key Files

Cargo.toml Workspace

The root Cargo.toml defines the Rust workspace structure, listing member crates such as pumpkin, pumpkin-config, pumpkin-protocol, and pumpkin-data. This configuration manages dependencies and build settings across the entire project using Rust's native tooling.

Server Entry Point

The server entry point lives in pumpkin/src/main.rs. This file implements an asynchronous main function using Tokio, Rust's popular async runtime:

// Starting the Pumpkin server – a typical snippet from `pumpkin/src/main.rs`
#[tokio::main]
async fn main() {
    // Load configuration from the working directory
    let config = PumpkinConfig::load(&std::env::current_dir().unwrap());

    // Initialise the server with the loaded configuration and vanilla data
    let pumpkin_server = PumpkinServer::new(
        config.basic,
        config.advanced,
        VanillaData::load(),
    ).await;

    // Run the server
    pumpkin_server.start().await;
}

Configuration Library

Core configuration structures are defined in pumpkin-config/src/lib.rs:

// Defining the configuration struct – excerpt from `pumpkin-config/src/lib.rs`
pub struct PumpkinConfig {
    pub basic: PumpkinBasicConfig,
    pub advanced: PumpkinAdvancedConfig,
    // …other fields omitted for brevity
}

Protocol and Data Implementation

Additional crates handle specific subsystems:

• pumpkin-protocol/src/lib.rs implements the network protocol for both Java and Bedrock editions
• pumpkin-data/src/lib.rs provides Rust data types for items, blocks, and game entities

Absence of Secondary Languages

Unlike many Minecraft-related projects that mix Java, Kotlin, or scripting languages, Pumpkin contains no .py, .js, .java, or similar authored source files. The project may generate auxiliary files (such as WebAssembly interface descriptors) during the build process, but the authored code that drives the server is exclusively Rust.

Summary

• Pumpkin-MC/Pumpkin uses Rust exclusively as its programming language
• The project organizes code as a Cargo workspace defined in the root Cargo.toml
• Key files include pumpkin/src/main.rs (entry point) and pumpkin-config/src/lib.rs (configuration)
• No other programming languages appear in the source tree

Frequently Asked Questions

Is Pumpkin-MC/Pumpkin written in Java like Vanilla Minecraft?

No. While the official Minecraft server runs on the Java Virtual Machine, Pumpkin is implemented exclusively in Rust. The server initializes using #[tokio::main] in pumpkin/src/main.rs rather than Java-based entry points.

What build system does Pumpkin use?

Pumpkin uses Cargo, Rust's native build system and package manager. The workspace configuration in Cargo.toml manages dependencies across all member crates including pumpkin-protocol and pumpkin-data.

Does Pumpkin contain any non-Rust source files?

The repository contains no .py, .js, .java, or similar authored code files. While the build process may generate auxiliary files such as WebAssembly interface descriptors, the implementation code is 100% Rust.

How does Pumpkin handle asynchronous operations?

Pumpkin uses the Tokio async runtime, as indicated by the #[tokio::main] attribute on the main function in pumpkin/src/main.rs. This provides the asynchronous foundation necessary for handling Minecraft's network I/O and concurrent player connections.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}