What Programming Languages Are Primarily Used in HolaOS? A Complete Technical Breakdown

HolaOS is built almost entirely with TypeScript—the language powers the desktop UI, Electron main process, and all runtime services, with small supporting roles for JavaScript, Shell, and Rust-based native dependencies.

HolaOS is an open-source AI operating system developed by holaboss-ai. Understanding its language stack helps contributors navigate the codebase and organizations evaluate its technical foundation. This article examines the actual source files in the holaOS repository to identify exactly which programming languages drive each layer of the system.

TypeScript: The Core Language of HolaOS

TypeScript dominates the HolaOS codebase. Every major application layer—from React components to backend services—is written in .ts or .tsx files using modern ES-module syntax and strong typings.

Desktop Application Layer (TSX)

The desktop UI uses TypeScript JSX for all visual components. In apps/desktop/src/lib/fileIcon.tsx, the FileIcon component demonstrates the typical pattern:

// apps/desktop/src/lib/fileIcon.tsx
import { Icon as IconifyIcon } from "@iconify/react";

const IMAGE_EXTENSIONS = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg"]);

export const FileIcon = ({ ext }: { ext: string }) => {
  if (IMAGE_EXTENSIONS.has(ext)) return <IconifyIcon icon="mdi:image" />;
  // …other cases
  return <IconifyIcon icon="mdi:file" />;
};

This file exports a typed React component that conditionally renders icons based on file extensions. The ext parameter is explicitly typed as string, and the component uses the IconifyIcon dependency for consistent icon rendering across the desktop environment.

Runtime Services Layer (TS)

Server-side and runtime logic lives in standard .ts files. The StateStore class in runtime/state-store/src/store.ts provides a generic state management implementation:

// runtime/state-store/src/store.ts
export class StateStore {
  private data: Record<string, unknown> = {};

  get<T>(key: string): T | undefined {
    return this.data[key] as T | undefined;
  }

  set<T>(key: string, value: T): void {
    this.data[key] = value;
  }
}

The class uses TypeScript generics (<T>) to provide type-safe storage and retrieval. The Record<string, unknown> type for data ensures flexible yet bounded storage, while the generic methods preserve type information across the get/set boundary.

Supporting Languages in the HolaOS Repository

While TypeScript handles the primary workload, three additional languages play specific supporting roles.

JavaScript (Node .mjs)

Build tooling and CI pipelines use Node-style .mjs files with ES modules. The scripts/clean.mjs utility demonstrates this pattern:

// scripts/clean.mjs
import { rmSync } from "node:fs";
const dirs = ["out", "build", "dist"];
for (const d of dirs) rmSync(d, { recursive: true, force: true });
console.log("🧹 Cleaned:", dirs.join(", "));

This script uses node:fs with synchronous removal and runs without TypeScript compilation overhead—ideal for build-time utilities.

Shell (.sh)

Installation scripts and CI workflow utilities use standard shell scripting. These handle environment setup, dependency installation orchestration, and pipeline coordination that benefits from direct system command integration.

Rust (Via Native Dependencies)

Rust appears only through pre-compiled native dependencies—not source files in the repository. The better-sqlite3 package and similar modules provide performance-critical SQLite bindings. The Rust code is compiled and distributed as binaries; HolaOS consumes these as dependencies rather than maintaining Rust source.

Language	Extensions	Role in HolaOS	Source in Repo?
TypeScript	.ts, .tsx	Application logic, UI, services	Yes—primary codebase
JavaScript	.mjs	Build scripts, CI helpers	Yes—ancillary tooling
Shell	.sh	Installation, workflow utilities	Yes—scripts directory
Rust	(binary crates)	Native performance modules	No—consumed as deps

TypeScript Configuration and Monorepo Structure

The TypeScript setup follows a workspace-based monorepo pattern. The runtime/state-store/tsconfig.json configures strict compiler options for the state-store package, with package.json at the repository root defining workspaces and shared scripts. This structure lets HolaOS maintain consistent typing across independently versioned packages.

Summary

• TypeScript is the sole primary language—every user-facing feature and core service uses it
• TSX files power the React-based desktop UI
• Plain TS files implement runtime services with generics for type safety
• JavaScript (.mjs) handles build-time automation without compilation overhead
• Shell scripts manage system-level installation and CI workflows
• Rust provides native performance only through external dependencies—no Rust source is maintained in holaOS

Frequently Asked Questions

Is HolaOS written entirely in TypeScript?

Nearly all source code is TypeScript. The repository contains .ts and .tsx files for all application logic, with small JavaScript and Shell scripts for tooling. Rust appears only through compiled dependencies—not original source.

Why does HolaOS use .mjs files instead of TypeScript for scripts?

Build scripts like scripts/clean.mjs skip TypeScript compilation to reduce startup time and eliminate build-step dependencies for CI pipelines. These utilities are simple enough that dynamic typing doesn't introduce maintenance risk.

Does HolaOS require Rust knowledge to contribute?

No. The Rust code in better-sqlite3 and similar packages is maintained externally. Contributors work exclusively with TypeScript, JavaScript, and Shell files within the holaOS repository itself.

What framework does HolaOS use for its desktop interface?

The desktop UI uses React with TypeScript JSX (.tsx files), rendered through Electron for cross-platform desktop distribution. The FileIcon component in apps/desktop/src/lib/fileIcon.tsx demonstrates this React + TypeScript pattern.

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