# What Programming Languages Does the Cloudflare/Computer Repository Use?

> Discover the programming languages powering the cloudflare/computer repository. Learn about TypeScript, JavaScript, JSON, YAML, and shell scripts used in Cloudflare Workers.

- Repository: [Cloudflare/computer](https://github.com/cloudflare/computer)
- Tags: programming-languages
- Published: 2026-08-09

---

**The cloudflare/computer repository is built almost entirely with TypeScript, which compiles to JavaScript for execution in the Cloudflare Workers runtime, while using JSON, YAML, and shell scripts for configuration and tooling.**

The cloudflare/computer project provides a virtual computer environment running on Cloudflare's edge infrastructure. If you are exploring the codebase to understand its architecture or contribute to its development, you will find that **TypeScript** serves as the primary programming language across all core packages.

## Primary Language: TypeScript

The repository adopts TypeScript as its sole implementation language for business logic. Every core library—including `packages/computer`, `packages/computerd`, `packages/dofs`, and `packages/rpc`—is authored entirely in `.ts` source files that leverage modern ECMAScript features.

### Core Package Structure

The monorepo organizes functionality into distinct TypeScript packages:

- **`packages/computer`** – Contains the main workspace API ([`src/workspace.ts`](https://github.com/cloudflare/computer/blob/main/src/workspace.ts)) for managing virtual file systems.
- **`packages/computerd`** – Implements the daemon process with FUSE virtual file system support in [`src/fuse/vfs.ts`](https://github.com/cloudflare/computer/blob/main/src/fuse/vfs.ts).
- **`packages/dofs`** – Provides the distributed object filesystem with SQLite-backed storage defined in [`src/storage.ts`](https://github.com/cloudflare/computer/blob/main/src/storage.ts).
- **`packages/rpc`** – Handles remote procedure calls via Durable Objects, with client logic in [`src/client.ts`](https://github.com/cloudflare/computer/blob/main/src/client.ts).

Each package maintains strict TypeScript typing throughout, utilizing **async/await** patterns, ES modules, and class-based architectures consistent with modern Node.js and Cloudflare Workers development.

### TypeScript Implementation Patterns

The codebase demonstrates idiomatic TypeScript usage with explicit type annotations and interface definitions. For example, in [`packages/computer/src/workspace.ts`](https://github.com/cloudflare/computer/blob/main/packages/computer/src/workspace.ts), the `Workspace` class exposes strongly-typed methods for file operations:

```ts
import { Workspace } from '@cloudflare/computer';

// Initialise a workspace that points to a virtual FS root.
const ws = new Workspace({
  root: '/tmp/my-workspace',
  // optional: provide a custom logger
  logger: console,
});

// Use the workspace to read a file.
async function readFile(path: string) {
  const file = await ws.open(path, 'r');
  const content = await file.read();
  console.log(`Contents of ${path}:`, content.toString());
}

readFile('example.txt');

```

Similarly, the RPC client in [`packages/rpc/src/client.ts`](https://github.com/cloudflare/computer/blob/main/packages/rpc/src/client.ts) uses TypeScript generics to ensure type-safe communication with Durable Objects:

```ts
import { RpcClient } from '@cloudflare/computer-rpc';

// Connect to a Durable Object that implements the RPC interface.
const client = new RpcClient('my-do-id');

// Example: invoke a sync driver method.
async function syncNow() {
  const result = await client.syncDriver.sync();
  console.log('Sync result:', result);
}

syncNow();

```

## Runtime Artifacts and Configuration

While TypeScript dominates the source code, the repository contains several ancillary languages that support the build pipeline and runtime deployment.

### Compiled JavaScript Output

The TypeScript source transpiles to plain JavaScript for execution within the Cloudflare Workers V8 isolate. Generated bundles appear under `dist/` directories within each package, representing the deployable runtime code. However, these JavaScript files are build artifacts rather than manually authored source.

### Configuration and Tooling Languages

Development workflows rely on declarative configuration formats:

- **JSON** – Used for [`package.json`](https://github.com/cloudflare/computer/blob/main/package.json) manifests, [`tsconfig.json`](https://github.com/cloudflare/computer/blob/main/tsconfig.json) compiler configurations, and Wrangler deployment settings.
- **YAML** – Appears in CI/CD pipeline definitions and GitHub Actions workflows.
- **Shell scripts** – Build automation, testing utilities, and deployment helpers reside in `script/*.sh` files (e.g., [`script/run-fs-tests.sh`](https://github.com/cloudflare/computer/blob/main/script/run-fs-tests.sh)).

These files facilitate the development lifecycle but do not constitute the runtime application logic.

### Native Dependencies

The repository references a small native component through the `fuse-native` package, declared via TypeScript definition files ([`fuse-native.d.ts`](https://github.com/cloudflare/computer/blob/main/fuse-native.d.ts)). The actual native source code exists in external dependencies and is not maintained within the cloudflare/computer repository itself.

## Key Source Files by Language

The following table maps specific file paths to their respective languages and purposes:

| File Path | Language | Purpose |
|-----------|----------|---------|
| [`packages/computer/src/workspace.ts`](https://github.com/cloudflare/computer/blob/main/packages/computer/src/workspace.ts) | TypeScript | Core API for virtual workspace management. |
| [`packages/computerd/src/fuse/vfs.ts`](https://github.com/cloudflare/computer/blob/main/packages/computerd/src/fuse/vfs.ts) | TypeScript | FUSE virtual file system implementation. |
| [`packages/dofs/src/storage.ts`](https://github.com/cloudflare/computer/blob/main/packages/dofs/src/storage.ts) | TypeScript | SQLite storage layer for distributed objects. |
| [`packages/rpc/src/client.ts`](https://github.com/cloudflare/computer/blob/main/packages/rpc/src/client.ts) | TypeScript | RPC client for Durable Object communication. |
| [`examples/think/src/index.ts`](https://github.com/cloudflare/computer/blob/main/examples/think/src/index.ts) | TypeScript | Example application demonstrating API usage. |
| [`script/run-fs-tests.sh`](https://github.com/cloudflare/computer/blob/main/script/run-fs-tests.sh) | Shell | Filesystem testing and benchmarking utilities. |

## Summary

- **TypeScript** is the exclusive language for all application logic across the four core packages.
- **JavaScript** appears only as compiled output in `dist/` directories for Cloudflare Workers deployment.
- **JSON and YAML** handle package configuration and CI/CD orchestration.
- **Shell scripts** provide build and test automation in the `script/` directory.
- No native C/C++ or Rust source code exists within the repository; native FUSE bindings are imported via external npm packages.

## Frequently Asked Questions

### Is the cloudflare/computer repository written in JavaScript or TypeScript?

The repository is written in **TypeScript**. While the code ultimately executes as JavaScript within the Cloudflare Workers runtime, all source files use the `.ts` extension and leverage TypeScript's type system, interfaces, and generics for compile-time safety.

### What runtime environment does cloudflare/computer target?

The project targets the **Cloudflare Workers** runtime, a V8-based JavaScript environment. The TypeScript source compiles to ECMAScript modules compatible with the Workers platform, utilizing the Durable Objects API for stateful operations.

### Does the repository contain any native code or C++ extensions?

No. While the project interfaces with native FUSE functionality through the `fuse-native` package, the actual native implementation exists in external dependencies. The repository itself contains only TypeScript declaration files ([`fuse-native.d.ts`](https://github.com/cloudflare/computer/blob/main/fuse-native.d.ts)) to provide type definitions for these external bindings.

### What build tools does cloudflare/computer use for TypeScript compilation?

The repository uses standard TypeScript compiler configurations ([`tsconfig.json`](https://github.com/cloudflare/computer/blob/main/tsconfig.json)) alongside Wrangler for Cloudflare Workers deployment. Shell scripts in the `script/` directory orchestrate complex build sequences, testing, and benchmarking workflows.