# What Programming Language Is Used in denoland/celld? A Deep Dive into the Rust Implementation

> Explore the denoland/celld repository and discover it's entirely implemented in Rust. Learn how Rust powers Deno's durable objects with Cargo, Tokio, and zero-cost abstractions.

- Repository: [Deno/celld](https://github.com/denoland/celld)
- Tags: deep-dive
- Published: 2026-09-05

---

**The denoland/celld repository is written entirely in Rust**, leveraging Cargo workspaces, Tokio for async runtime, and zero-cost abstractions to build a high-performance runtime for Deno's durable objects.

The `celld` project is Deno's distributed runtime for Durable Objects, and its source code reveals a sophisticated Rust codebase optimized for memory safety and concurrency. This article examines the language choice, architectural patterns, and key implementation details found in the repository.

## Rust as the Sole Programming Language

Every source file in denoland/celld uses the `.rs` extension. The project follows standard Rust conventions with a workspace structure defined in the top-level [`Cargo.toml`](https://github.com/denoland/celld/blob/main/Cargo.toml).

```toml

# Cargo.toml

[workspace]
members = ["crates/*"]

```

This workspace layout groups multiple crates (`celld`, `celld-logic`, `celld-ltx`, etc.) under unified compilation. The entry point at [`crates/celld/main.rs`](https://github.com/denoland/celld/blob/main/crates/celld/main.rs) demonstrates typical Rust patterns for systems programming.

## Core Architectural Components

### Async Runtime with Tokio

The codebase relies on **Tokio** (`tokio = "1"`) for non-blocking I/O and high concurrency. The [`main.rs`](https://github.com/denoland/celld/blob/main/main.rs) file initializes a multi-threaded runtime before starting the Celld manager:

```rust
// crates/celld/main.rs
let rt = runtime::Builder::new_multi_thread()
    .enable_all()
    .build()
    .expect("failed to create Tokio runtime");

```

This pattern appears throughout modules like [`crates/logic/routing.rs`](https://github.com/denoland/celld/blob/main/crates/logic/routing.rs) and [`crates/ltx/src/replica.rs`](https://github.com/denoland/celld/blob/main/crates/ltx/src/replica.rs), where async/await handles peer communication and storage operations.

### Memory Allocation Optimization

Performance-critical paths use **jemalloc** via `tikv_jemallocator::Jemalloc` as the global allocator. This replacement reduces fragmentation under heavy load compared to the standard Rust allocator.

### Error Handling with anyhow

All external interactions wrap results in `anyhow::Result` or custom error types. This approach leverages Rust's `?` operator for ergonomic error propagation while maintaining compile-time safety guarantees.

## Code Structure and Key Files

| File | Purpose |
|------|---------|
| [`Cargo.toml`](https://github.com/denoland/celld/blob/main/Cargo.toml) | Workspace definition and dependency management |
| [`crates/celld/main.rs`](https://github.com/denoland/celld/blob/main/crates/celld/main.rs) | Binary entry point, runtime initialization |
| [`crates/celld/runtime.rs`](https://github.com/denoland/celld/blob/main/crates/celld/runtime.rs) | `RuntimeManager` implementation for V8 isolate supervision |
| [`crates/logic/routing.rs`](https://github.com/denoland/celld/blob/main/crates/logic/routing.rs) | Request routing logic for local vs. remote handling |
| [`crates/ltx/src/lib.rs`](https://github.com/denoland/celld/blob/main/crates/ltx/src/lib.rs) | LTX storage layer for durable object state |

## Practical Example: Starting the Celld Runtime

The following snippet mirrors patterns from [`crates/celld/main.rs`](https://github.com/denoland/celld/blob/main/crates/celld/main.rs), showing how Rust's type system structures the runtime initialization:

```rust
use celld::actor::AppHandle;
use celld::runtime::{RuntimeManager, RuntimeOptions};

#[tokio::main]
async fn main() {
    let runtime_opts = RuntimeOptions {
        node: "node-1".into(),
        region: "us-east".into(),
        ..Default::default()
    };

    let mut manager = RuntimeManager::new(runtime_opts);
    manager.start().await.expect("failed to start Celld runtime");

    let app = AppHandle::new(manager);
    let _ = app.request("example-scope".into()).await;
}

```

This demonstrates **zero-cost abstractions**: generics and traits resolve at compile time, leaving no runtime overhead for the abstraction layers.

## Why Rust for denoland/celld?

The programming language choice of Rust delivers three critical capabilities for this distributed runtime:

- **Memory safety without garbage collection** — essential for long-running server processes handling millions of requests
- **Predictable performance** — zero-cost abstractions and explicit async boundaries prevent latency spikes
- **Fearless concurrency** — the ownership model guarantees thread safety at compile time, crucial for the `RuntimeManager` supervising multiple V8 isolates

## Summary

- The denoland/celld repository uses **Rust** exclusively as its programming language
- Cargo workspace structure organizes crates under `crates/*` with unified build management
- Tokio powers the async runtime throughout [`main.rs`](https://github.com/denoland/celld/blob/main/main.rs), [`runtime.rs`](https://github.com/denoland/celld/blob/main/runtime.rs), and routing logic
- jemalloc replaces the default allocator for production performance
- anyhow and custom error types provide ergonomics with safety guarantees

## Frequently Asked Questions

### What programming language is denoland/celld written in?

Rust. All source files carry the `.rs` extension, and the project uses Cargo for build management with a workspace spanning multiple crates.

### Does celld use any other programming languages besides Rust?

No. The implementation is pure Rust, including the V8 integration layer. JavaScript/TypeScript code runs inside the V8 isolates managed by the Rust runtime, but the celld project itself contains no C++, Go, or other host languages.

### Why did Deno choose Rust for the celld runtime?

Rust's ownership model prevents data races in the `RuntimeManager` that supervises concurrent V8 isolates. The zero-cost abstraction philosophy allows high-level, composable APIs in [`crates/logic/routing.rs`](https://github.com/denoland/celld/blob/main/crates/logic/routing.rs) without sacrificing the throughput required for edge computing workloads.

### Is the celld codebase suitable for learning Rust patterns?

Yes. The repository demonstrates production-grade patterns: workspace organization, Tokio integration, custom allocators, and structured error handling with `anyhow::Result`. Files like [`crates/celld/main.rs`](https://github.com/denoland/celld/blob/main/crates/celld/main.rs) and [`crates/ltx/src/lib.rs`](https://github.com/denoland/celld/blob/main/crates/ltx/src/lib.rs) serve as reference implementations for systems programming in Rust.