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

> Discover the primary programming languages powering HolaOS. Learn how TypeScript, JavaScript, Shell, and Rust contribute to its technical foundation.

- Repository: [holaboss.ai/holaOS](https://github.com/holaboss-ai/holaOS)
- Tags: programming-languages
- Published: 2026-08-15

---

**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`](https://github.com/holaboss-ai/holaOS/blob/main/apps/desktop/src/lib/fileIcon.tsx), the `FileIcon` component demonstrates the typical pattern:

```tsx
// 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`](https://github.com/holaboss-ai/holaOS/blob/main/runtime/state-store/src/store.ts) provides a generic state management implementation:

```ts
// 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:

```js
// 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`](https://github.com/holaboss-ai/holaOS/blob/main/runtime/state-store/tsconfig.json) configures strict compiler options for the state-store package, with [`package.json`](https://github.com/holaboss-ai/holaOS/blob/main/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`](https://github.com/holaboss-ai/holaOS/blob/main/apps/desktop/src/lib/fileIcon.tsx) demonstrates this React + TypeScript pattern.