# Programming Languages Used in Orca Development: A Technical Deep Dive

> Explore the programming languages powering Orca, including TypeScript, JavaScript, JSON, Shell, PowerShell, and CSS. Understand the tech stack behind this Electron application.

- Repository: [Stably/orca](https://github.com/stablyai/orca)
- Tags: deep-dive
- Published: 2026-05-25

---

**Orca is built primarily with TypeScript as a modern Electron application, complemented by JavaScript build scripts, JSON configuration files, Shell and PowerShell automation scripts, and CSS for styling.**

The Orca project by Stably AI is a cross-platform desktop application built on the Electron framework. Understanding the programming languages used in Orca development reveals a strategic mix of type-safe application code and lightweight automation scripts. The repository at `stablyai/orca` organizes these languages to separate core runtime logic from platform-specific build helpers.

## Core Application Languages

### TypeScript (Primary Development Language)

TypeScript dominates the Orca codebase, providing static typing for the Electron renderer process, main process, and shared utilities. In [`src/renderer/src/web/web-runtime-client.ts`](https://github.com/stablyai/orca/blob/main/src/renderer/src/web/web-runtime-client.ts), the renderer-side web runtime client implements browser-facing functionality with full type safety. The core Node-side relay logic lives in [`src/relay/relay.ts`](https://github.com/stablyai/orca/blob/main/src/relay/relay.ts), demonstrating how TypeScript spans both frontend and backend contexts in Electron.

The [`src/shared/workspace-name.ts`](https://github.com/stablyai/orca/blob/main/src/shared/workspace-name.ts) file illustrates typical TypeScript utility patterns:

```typescript
// src/shared/workspace-name.ts
export function normalizeWorkspaceName(name: string): string {
  // Trim whitespace and replace illegal filesystem characters
  return name.trim().replace(/[<>:"/\\|?*]/g, '-');
}

```

### JavaScript (Node.js Scripts)

JavaScript appears primarily in build-time helpers and scripts that must execute without TypeScript compilation. The `config/scripts/ensure-native-runtime.mjs` file uses ES modules (`.mjs`) to handle native runtime verification for Node or Electron environments.

```javascript
// config/scripts/ensure-native-runtime.mjs
import { execSync } from 'node:child_process';

const runtime = process.argv.includes('--runtime=node') ? 'node' : 'electron';
console.log(`Ensuring native runtime for ${runtime}…`);
execSync(`pnpm rebuild ${runtime}`, { stdio: 'inherit' });

```

### JSON (Configuration)

JSON files manage package dependencies and compiler settings. The [`package.json`](https://github.com/stablyai/orca/blob/main/package.json) declares project metadata and scripts, while [`tsconfig.json`](https://github.com/stablyai/orca/blob/main/tsconfig.json) controls TypeScript compilation parameters, enabling strict type-checking across the monorepo.

## Platform-Specific and Styling Languages

### Shell Scripts (Unix/Linux/macOS)

Bash scripts handle development automation and CI tasks. The [`config/scripts/dev-fresh-profile.sh`](https://github.com/stablyai/orca/blob/main/config/scripts/dev-fresh-profile.sh) script cleans development profiles and reinstalls dependencies:

```bash
#!/usr/bin/env bash

# config/scripts/dev-fresh-profile.sh

set -e
rm -rf ~/.config/orca
pnpm install
echo "✅ Fresh dev profile ready"

```

### PowerShell (Windows Automation)

Windows-specific functionality relies on PowerShell scripts located in `native/computer-use-windows/`. The `runtime.ps1` file initializes native Windows integrations for computer-use features:

```powershell

# native/computer-use-windows/runtime.ps1

Write-Host "Setting up Windows computer‑use runtime..."

# Placeholder for future native commands

```

### CSS and HTML

CSS drives the user interface appearance through Tailwind CSS and Shadcn UI components, defined in files like [`src/renderer/src/assets/main.css`](https://github.com/stablyai/orca/blob/main/src/renderer/src/assets/main.css). HTML appears primarily in documentation rather than application logic.

## Architecture Benefits of This Language Mix

This polyglot approach optimizes for Electron's unique constraints. TypeScript provides type safety for the complex IPC (Inter-Process Communication) between renderer and main processes. JavaScript modules execute build tasks immediately without compilation overhead. Shell and PowerShell scripts abstract platform differences in native binary handling. CSS delivers consistent styling across operating systems.

## Summary

- **TypeScript** constitutes the majority of Orca source code, handling all core application logic in `src/renderer/` and `src/relay/`
- **JavaScript** (ES modules) powers build scripts in `config/scripts/` that manage native dependencies
- **JSON** configures the project through [`package.json`](https://github.com/stablyai/orca/blob/main/package.json), [`tsconfig.json`](https://github.com/stablyai/orca/blob/main/tsconfig.json), and other tool configurations
- **Shell scripts** automate Unix-based development workflows and cleanup tasks
- **PowerShell** manages Windows-specific native integrations in `native/computer-use-windows/`
- **CSS** implements the Tailwind-based design system in [`src/renderer/src/assets/main.css`](https://github.com/stablyai/orca/blob/main/src/renderer/src/assets/main.css)

## Frequently Asked Questions

### Is Orca written entirely in TypeScript?

While the core application logic is TypeScript, Orca uses JavaScript for build scripts, Shell/PowerShell for platform automation, and JSON for configuration. The repository follows a pragmatic approach where TypeScript handles complex application state, while simpler scripts remain JavaScript for immediate execution.

### Why does Orca use JavaScript instead of TypeScript for build scripts?

JavaScript modules (`.mjs`) in `config/scripts/` run directly under Node.js without a compilation step. This eliminates build-time dependencies for the build scripts themselves, ensuring they execute immediately when setting up the development environment or CI pipelines.

### What are the PowerShell scripts used for in Orca development?

PowerShell scripts in `native/computer-use-windows/` handle Windows-specific native integrations, particularly for computer-use automation features. These scripts bridge the gap between the Electron application and Windows system APIs that require PowerShell execution contexts.

### Where is the main styling code located in the Orca repository?

The primary CSS styling resides in [`src/renderer/src/assets/main.css`](https://github.com/stablyai/orca/blob/main/src/renderer/src/assets/main.css), which defines Tailwind CSS tokens and Shadcn UI component styles. This file serves as the definitive source for the application's visual design system across all platforms.