# What Programming Languages and Frameworks Are Used in OpenWork?

> Discover the programming languages and frameworks powering OpenWork. Learn about its use of TypeScript, React, Rust, and Vite for efficient cross-platform development.

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

---

**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`](https://github.com/different-ai/openwork/blob/main/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`](https://github.com/different-ai/openwork/blob/main/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:

```bash
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`](https://github.com/different-ai/openwork/blob/main/packages/ui/src/react/index.ts). This architecture allows developers to import type-safe components throughout the application:

```tsx
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`](https://github.com/different-ai/openwork/blob/main/package.json) defines development scripts that launch the Electron environment:

```bash
pnpm dev

```

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

```bash
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`](https://github.com/different-ai/openwork/blob/main/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`](https://github.com/different-ai/openwork/blob/main/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`](https://github.com/different-ai/openwork/blob/main/packages/ui/package.json), generates both CommonJS and ESM outputs with proper type declarations, allowing consumption by the Electron app and other workspace packages.