# What Programming Languages Does Pumpkin-MC/Pumpkin Use?

> Discover if Pumpkin-MC/Pumpkin uses Rust. This article details the programming language exclusively powering the Pumpkin-MC/Pumpkin project. Learn more about its Rust implementation.

- Repository: [Pumpkin MC/Pumpkin](https://github.com/Pumpkin-MC/Pumpkin)
- Tags: getting-started
- Published: 2026-07-23

---

**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`](https://github.com/Pumpkin-MC/Pumpkin/blob/main/Cargo.toml) defining a workspace that aggregates dozens of internal crates.

## Workspace Configuration and Key Files

### Cargo.toml Workspace

The root [`Cargo.toml`](https://github.com/Pumpkin-MC/Pumpkin/blob/main/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`](https://github.com/Pumpkin-MC/Pumpkin/blob/main/pumpkin/src/main.rs). This file implements an asynchronous main function using Tokio, Rust's popular async runtime:

```rust
// 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`](https://github.com/Pumpkin-MC/Pumpkin/blob/main/pumpkin-config/src/lib.rs):

```rust
// 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`](https://github.com/Pumpkin-MC/Pumpkin/blob/main/pumpkin-protocol/src/lib.rs)** implements the network protocol for both Java and Bedrock editions
- **[`pumpkin-data/src/lib.rs`](https://github.com/Pumpkin-MC/Pumpkin/blob/main/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`](https://github.com/Pumpkin-MC/Pumpkin/blob/main/Cargo.toml)
- Key files include [`pumpkin/src/main.rs`](https://github.com/Pumpkin-MC/Pumpkin/blob/main/pumpkin/src/main.rs) (entry point) and [`pumpkin-config/src/lib.rs`](https://github.com/Pumpkin-MC/Pumpkin/blob/main/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`](https://github.com/Pumpkin-MC/Pumpkin/blob/main/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`](https://github.com/Pumpkin-MC/Pumpkin/blob/main/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`](https://github.com/Pumpkin-MC/Pumpkin/blob/main/pumpkin/src/main.rs). This provides the asynchronous foundation necessary for handling Minecraft's network I/O and concurrent player connections.