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

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 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, the buildOpenworkRuntimeConfigObject function demonstrates standard TypeScript patterns including typed parameters and async/await patterns:

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 and exported via packages/ui/src/react/index.ts combines JSX syntax with TypeScript typing:

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:

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 declares typescript as a dev dependency and defines the pnpm workspace layout
• Server core: 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 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, 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. 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), while the frontend utilizes TSX for React components (exemplified in 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.

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