# What Programming Language Is OpenWork Written In? A Deep Dive into the TypeScript Codebase

> Discover that OpenWork is written in TypeScript. Explore its monorepo architecture and how it compiles to JavaScript while keeping static typing.

- Repository: [Different AI/openwork](https://github.com/different-ai/openwork)
- Tags: deep-dive
- Published: 2026-08-01

---

**OpenWork is written primarily in TypeScript**, utilizing a monorepo architecture with pnpm workspaces that compiles to JavaScript at build time while maintaining strict static typing across the entire stack.

The open-source **OpenWork** repository (maintained by different-ai) demonstrates a modern TypeScript-first approach to building full-stack applications. Understanding what programming language powers OpenWork reveals why the project emphasizes type safety, developer experience, and scalable architecture through its extensive use of `.ts` and `.tsx` files.

## Why OpenWork Uses TypeScript

TypeScript serves as the backbone of OpenWork's development strategy. The root [`package.json`](https://github.com/different-ai/openwork/blob/main/package.json) declares **TypeScript** as a dev dependency, establishing the foundation for type-safe development across all packages. This choice enables the project to leverage modern ES modules while catching potential errors at compile time rather than runtime.

The repository organizes code as a **monorepo** using **pnpm workspaces**, allowing shared type definitions and utilities to propagate consistently between server and client code. According to the source code in `different-ai/openwork`, this structure ensures that interfaces defined in one package remain synchronized throughout the entire application.

## Key TypeScript Files in the OpenWork Repository

### Server-Side Runtime Configuration

Core server logic resides entirely in TypeScript files. In [`apps/server/src/openwork-runtime-config.ts`](https://github.com/different-ai/openwork/blob/main/apps/server/src/openwork-runtime-config.ts), the `buildOpenworkRuntimeConfigObject` function demonstrates standard TypeScript patterns including typed parameters and async/await patterns:

```typescript
export async function buildOpenworkRuntimeConfigObject(
  config?: ServerConfig,
  workspaceId?: string,
): Promise<Record<string, unknown>> {
  const runtimeConfig = config && workspaceId
    ? await readEffectiveRuntimeOpencodeConfig(config, workspaceId)
    : {};
  return buildOpenworkRuntimeConfigObjectFromSnapshot(runtimeConfig);
}

```

This implementation uses `Record<string, unknown>` for type-safe configuration objects and optional chaining through nullable parameters.

### React UI Components with TSX

Frontend code leverages **TSX** (TypeScript JSX) for strongly-typed React components. The `PlatformDetect` component in [`packages/ui/src/react/platform-detect.ts`](https://github.com/different-ai/openwork/blob/main/packages/ui/src/react/platform-detect.ts) and exported via [`packages/ui/src/react/index.ts`](https://github.com/different-ai/openwork/blob/main/packages/ui/src/react/index.ts) combines JSX syntax with TypeScript typing:

```tsx
export function PlatformDetect() {
  const isMac = process.platform === "darwin";
  return <div>{isMac ? "Running on macOS" : "Running on another OS"}</div>;
}

```

This approach ensures that props and state remain strictly typed throughout the component tree, preventing common React runtime errors related to missing or incorrectly typed properties.

### Shared Type Definitions

Centralized type definitions live under `packages/types/src/`, emphasizing the repository's commitment to static typing. These pure type definitions create contracts between different parts of the monorepo:

```typescript
export interface Workspace {
  id: string;
  name: string;
  createdAt: Date;
}

```

By isolating interfaces like `Workspace` in dedicated type packages, OpenWork ensures consistency between server APIs and client-side consumption.

## Monorepo Structure and Build Pipeline

The OpenWork codebase organizes functionality across multiple packages while maintaining TypeScript standards throughout. Key configuration files include:

- **Root configuration**: [`package.json`](https://github.com/different-ai/openwork/blob/main/package.json) declares `typescript` as a dev dependency and defines the pnpm workspace layout
- **Server core**: [`apps/server/src/openwork-runtime-config.ts`](https://github.com/different-ai/openwork/blob/main/apps/server/src/openwork-runtime-config.ts) contains server-side business logic written entirely in TypeScript
- **Enterprise services**: [`packages/enterprise-mcp-mock-server/src/runtime/mock-server.ts`](https://github.com/different-ai/openwork/blob/main/packages/enterprise-mcp-mock-server/src/runtime/mock-server.ts) demonstrates backend services implemented with TypeScript

The build process compiles these TypeScript files to JavaScript, preserving modern ES module syntax while optimizing for runtime performance. This compilation step occurs across all packages in the workspace, ensuring that type checking happens before deployment.

## Summary

- **OpenWork is written primarily in TypeScript**, with files using `.ts` and `.tsx` extensions throughout the monorepo.
- The repository uses **pnpm workspaces** to manage multiple TypeScript packages under a single root configuration.
- Server logic appears in files like [`apps/server/src/openwork-runtime-config.ts`](https://github.com/different-ai/openwork/blob/main/apps/server/src/openwork-runtime-config.ts), while React components use TSX in `packages/ui/src/react/`.
- **Type definitions** are centralized in `packages/types/src/` to maintain consistency across the full stack.
- The project compiles TypeScript to JavaScript at build time while preserving static typing benefits during development.

## Frequently Asked Questions

### Is OpenWork purely TypeScript or does it contain JavaScript?

OpenWork is **TypeScript-first**, meaning all source code is written in TypeScript (`.ts` and `.tsx` files). While the build process generates JavaScript artifacts for runtime execution, the repository contains minimal handwritten JavaScript, as the entire architecture relies on TypeScript's type system for safety and developer experience.

### What build tools does OpenWork use to compile TypeScript?

The repository uses standard TypeScript compilation as indicated by the `typescript` dev dependency in the root [`package.json`](https://github.com/different-ai/openwork/blob/main/package.json). Combined with **pnpm workspaces**, the build pipeline processes TypeScript files across all packages in the monorepo, converting them to JavaScript while maintaining module boundaries and type contracts.

### Does OpenWork use TypeScript for both frontend and backend?

Yes, OpenWork employs TypeScript across the entire stack. The backend uses `.ts` files for server logic (as seen in [`apps/server/src/openwork-runtime-config.ts`](https://github.com/different-ai/openwork/blob/main/apps/server/src/openwork-runtime-config.ts)), while the frontend utilizes **TSX** for React components (exemplified in [`packages/ui/src/react/index.ts`](https://github.com/different-ai/openwork/blob/main/packages/ui/src/react/index.ts)). This unified language choice enables shared type definitions and consistent development patterns between client and server code.

### Where are the type definitions located in the OpenWork repository?

Shared type definitions reside in `packages/types/src/`, containing interfaces like `Workspace` that define data structures used throughout the application. Additionally, individual packages such as `packages/ui/src/react/` and `apps/server/src/` contain local type definitions specific to their domains, all written in TypeScript syntax.