What Programming Languages and Frameworks Are Used in OpenWork?

OpenWork is built primarily with TypeScript and React for its cross-platform UI and server logic, augmented by Rust for performance-critical native workloads, and packaged as an Electron desktop application using Vite for bundling.

OpenWork is an open-source monorepo maintained by different-ai that combines modern web technologies with systems-level performance. Understanding what programming languages and frameworks are used in OpenWork reveals a carefully selected stack designed for type safety, developer velocity, and cross-platform deployment across macOS, Windows, and Linux.

Core Programming Languages

TypeScript for Full-Stack Development

TypeScript serves as the primary programming language throughout the OpenWork monorepo, driving the UI components, Electron application, API clients, and server-side logic. The codebase leverages modern TypeScript features with strict configuration, compiling to JavaScript for both Node.js and browser environments. In packages/ui/package.json, the project declares React as a peer dependency and uses tsup for bundling the component library, ensuring fast builds and proper type declarations.

Rust for Native Performance

For performance-critical operations and native system integration, OpenWork incorporates Rust via the microsandbox architecture. Located in examples/microsandbox-openwork-rust/Cargo.toml, this crate demonstrates how native Rust code integrates with the broader ecosystem, utilizing crates such as reqwest for HTTP operations. Developers can build this component using standard Cargo workflows:

cd examples/microsandbox-openwork-rust
cargo run --release

Frontend Frameworks and Architecture

React with Modern Concurrent APIs

The user interface foundation relies on React, specifically leveraging React 18/19 concurrent APIs for improved rendering performance. The UI package exposes components through @openwork/ui/react, as implemented in packages/ui/src/react/index.ts. This architecture allows developers to import type-safe components throughout the application:

import { Button } from '@openwork/ui/react'

export default function Demo() {
  return (
    <Button
      variant="primary"
      onClick={() => alert('OpenWork says hello!')}
    >
      Click me
    </Button>
  )
}

Electron Desktop Shell

OpenWork distributes as a native desktop application using Electron, with the main process entry point located in the apps/desktop directory. The Electron shell wraps the React/Vite frontend, providing access to native OS APIs while maintaining a web-based development workflow. The root package.json defines development scripts that launch the Electron environment:

pnpm dev

For isolated development profiles with separate user data directories, OpenWork supports environment-specific execution:

OPENWORK_DEV_PROFILE=auto pnpm dev:worktree

Vite for Build Tooling

The project uses Vite as its primary bundler and development server, offering fast Hot Module Replacement (HMR) and optimized production builds. This configuration powers the dev:ui scripts and package builds throughout the monorepo, replacing slower traditional bundlers for the UI package and desktop applications.

Supporting Libraries and Infrastructure

Styling and Schema Validation

Tailwind CSS provides utility-first styling throughout the component library, enabling rapid UI development without leaving the TypeScript context. For runtime type safety, OpenWork integrates Zod for schema validation, ensuring data integrity across API boundaries and form submissions.

State Management and Data Fetching

The stack includes TanStack Query for server state management and data fetching, handling caching, synchronization, and background updates automatically. For client-side state, OpenWork utilizes Zustand, a lightweight state management solution that avoids the boilerplate of larger alternatives while maintaining full TypeScript inference.

Database and Authentication Services

Backend services within the monorepo (referred to as "Den" services) employ Drizzle as the type-safe database layer, allowing developers to define schemas and queries with full autocomplete support. Authentication is handled by Better-Auth, providing a scaffolded, type-safe auth system that integrates with the Drizzle ORM layer.

Summary

• TypeScript powers the majority of the codebase, from React components to server logic, compiled using tsup and Vite.
• Rust handles native performance-critical workloads via the microsandbox example in examples/microsandbox-openwork-rust/Cargo.toml.
• React with concurrent APIs forms the UI foundation, distributed through Electron for cross-platform desktop deployment.
• Tailwind CSS, Zod, TanStack Query, Zustand, Drizzle, and Better-Auth provide the styling, validation, state management, and authentication infrastructure.
• Development workflow uses pnpm with scripts defined in the root package.json for launching the Electron application.

Frequently Asked Questions

Is OpenWork built entirely in TypeScript?

No, while TypeScript is the primary language for the UI, server logic, and Electron application, OpenWork also includes Rust components for native performance. The examples/microsandbox-openwork-rust directory contains a complete Cargo project that demonstrates how Rust integrates with the TypeScript ecosystem.

Why does OpenWork use Rust alongside TypeScript?

Rust provides memory safety and performance characteristics necessary for system-level operations that would be inefficient in JavaScript. According to the OpenWork source code, the Rust microsandbox example handles native workloads that require closer hardware interaction or computationally intensive tasks outside the Electron sandbox.

What desktop framework does OpenWork use?

OpenWork uses Electron to package the React application as a native desktop client. The main process code resides in apps/desktop, while the renderer process runs the Vite-bundled React application, allowing the app to function on macOS, Windows, and Linux from a single codebase.

How is the UI library compiled in OpenWork?

The UI package in packages/ui is compiled using tsup, a TypeScript bundler powered by esbuild. This configuration, defined in packages/ui/package.json, generates both CommonJS and ESM outputs with proper type declarations, allowing consumption by the Electron app and other workspace packages.

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