Programming Languages Used in Orca Development: A Technical Deep Dive

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, 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, demonstrating how TypeScript spans both frontend and backend contexts in Electron.

The src/shared/workspace-name.ts file illustrates typical TypeScript utility patterns:

// 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.

// 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 declares project metadata and scripts, while 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 script cleans development profiles and reinstalls dependencies:

#!/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:

# 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. 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, 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

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, 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.

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