What Programming Languages Does the Cloudflare/Computer Repository Use?

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) for managing virtual file systems.
• packages/computerd – Implements the daemon process with FUSE virtual file system support in src/fuse/vfs.ts.
• packages/dofs – Provides the distributed object filesystem with SQLite-backed storage defined in src/storage.ts.
• packages/rpc – Handles remote procedure calls via Durable Objects, with client logic in 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, the Workspace class exposes strongly-typed methods for file operations:

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 uses TypeScript generics to ensure type-safe communication with Durable Objects:

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 manifests, 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).

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). 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	TypeScript	Core API for virtual workspace management.
packages/computerd/src/fuse/vfs.ts	TypeScript	FUSE virtual file system implementation.
packages/dofs/src/storage.ts	TypeScript	SQLite storage layer for distributed objects.
packages/rpc/src/client.ts	TypeScript	RPC client for Durable Object communication.
examples/think/src/index.ts	TypeScript	Example application demonstrating API usage.
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) 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) alongside Wrangler for Cloudflare Workers deployment. Shell scripts in the script/ directory orchestrate complex build sequences, testing, and benchmarking workflows.

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