# What Programming Languages Does Omarchy Use? A Complete Technical Breakdown

> Discover the programming languages Omarchy uses. Explore its multi-language architecture featuring Bash, QML, JavaScript, JSON, and TOML for system scripting, UI, logic, and configuration.

- Repository: [37signals/omarchy](https://github.com/basecamp/omarchy)
- Tags: deep-dive
- Published: 2026-08-19

---

**Omarchy relies on a multi-language architecture combining Bash for system-level scripting, QML for declarative UI components, and embedded JavaScript for application logic, alongside JSON and TOML for configuration management.**

Omarchy, developed by Basecamp, is a modern, scriptable desktop environment that leverages specific programming languages for distinct architectural layers. Understanding what programming languages Omarchy uses reveals how the project balances low-level system automation with fluid, native-looking user interfaces.

## Core Programming Languages in the Omarchy Stack

Omarchy's codebase is organized into distinct language-specific layers, each handling responsibilities from system orchestration to visual presentation.

### Bash – System Orchestration and CLI Utilities

**Bash** serves as the foundation for Omarchy's command-line interface and system management utilities. These scripts orchestrate package updates, configuration refreshes, and UI toggles through the `omarchy-*` command suite found in the `bin/` directory.

In `bin/omarchy-update`, the update logic demonstrates how Bash bridges the operating system and the desktop environment:

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

# omarchy-update – orchestrates a full system update

set -euo pipefail

# Update packages via pacman/AUR

omarchy-pkg-add --update

# Refresh the desktop UI after the update

omarchy-refresh-config omarchy-theme-current

```

This script executes system updates and triggers UI refreshes, illustrating how Bash provides the glue between the OS package manager and the graphical layer.

### QML – Declarative UI Development

**QML** (Qt Meta Language) powers the visual layer of Omarchy, defining panels, widgets, and window components through declarative syntax. The entry point for the shell interface lives in `shell/shell.qml`, which instantiates the entire desktop composition.

QML's declarative nature allows Omarchy to react to state changes without imperative boilerplate. For example, `shell/plugins/panels/weather/Panel.qml` defines a weather widget using property bindings:

```qml
Panel {
    id: weatherPanel
    width: 200; height: 40
    label: "Weather"
    // JavaScript call to fetch data
    Component.onCompleted: WeatherService.refresh()
}

```

### JavaScript – Business Logic and Dynamic Behaviors

**JavaScript** embedded within QML handles service communication, data models, and event processing. Unlike standalone Node.js applications, Omarchy's JavaScript runs within the Qt Quick runtime, interacting directly with QML properties and signals.

The [`shell/plugins/bar/BarModel.js`](https://github.com/basecamp/omarchy/blob/main/shell/plugins/bar/BarModel.js) file exemplifies this pattern, managing widget registration and state propagation:

```javascript
// TrayModel.js – provides a list of active tray icons
import { AppSearch } from '../../services/AppSearch.js';

export default class TrayModel {
    constructor() {
        this.icons = [];
        this.refresh();
    }
    refresh() {
        this.icons = AppSearch.activeTrayApps();
    }
}

```

### JSON and TOML – Configuration and Theming

While not programming languages in the traditional sense, **JSON** and **TOML** are essential data formats driving Omarchy's behavior. These files store theme definitions, color schemes, and default settings that both QML and JavaScript consume at runtime.

The `default/themed/vscode-theme.json.tpl` file demonstrates how theme data is structured as templates before being processed into active configurations.

## How the Language Layers Interact

Omarchy's architecture follows a clear separation of concerns across its programming languages:

1. **Bash scripts** interact directly with the operating system, package managers, and file system
2. **QML components** render the native UI and define user-facing layouts
3. **JavaScript modules** process data, manage application state, and handle service communication
4. **Configuration files** provide declarative settings that control runtime appearance and behavior

This separation allows developers to extend specific layers without disrupting others. Modifying a theme requires only JSON edits, while adding system functionality involves Bash scripting.

## Key Source Files by Language

Understanding what programming languages Omarchy uses requires examining representative files in the basecamp/omarchy repository:

- **`bin/omarchy-update`** (Bash): Entry point for system updates, demonstrating CLI orchestration
- **`shell/shell.qml`** (QML): Root UI definition that instantiates panels and widgets
- **[`shell/plugins/bar/BarModel.js`](https://github.com/basecamp/omarchy/blob/main/shell/plugins/bar/BarModel.js)** (JavaScript): Core model for the top bar, handling widget registration
- **`shell/plugins/panels/weather/Panel.qml`** (QML with JS): Functional panel combining declarative UI with JavaScript service calls
- **`default/themed/vscode-theme.json.tpl`** (JSON): Template for theme color schemes consumed by the UI layer

## Summary

- **Omarchy uses Bash** for system-level scripting and the `omarchy-*` CLI utilities that manage updates and configuration
- **QML provides the declarative UI layer**, defining panels, widgets, and visual components in files like `shell/shell.qml`
- **Embedded JavaScript powers business logic**, handling models, services, and dynamic behaviors within the Qt Quick runtime
- **JSON and TOML** supply configuration data and theming definitions that drive runtime appearance
- This multi-language approach enables Omarchy to remain highly extensible while offering native performance and scriptable automation

## Frequently Asked Questions

### Is Omarchy primarily a JavaScript project?

No. While JavaScript handles application logic within the UI layer, Omarchy is fundamentally a multi-language project. The system relies heavily on **Bash** for core functionality and **QML** for interface rendering. JavaScript operates within the constraints of the Qt Quick environment rather than as a standalone runtime.

### Why does Omarchy use QML instead of HTML/CSS?

Omarchy uses **QML** because it provides native hardware-accelerated rendering through Qt Quick, direct access to system APIs, and tighter integration with the underlying operating system than HTML-based solutions. QML's property binding system also creates more efficient reactive UI updates compared to browser-based rendering engines.

### Can I extend Omarchy using only Bash scripts?

Yes. Many Omarchy extensions and customizations can be accomplished through **Bash** alone by creating new `omarchy-*` command scripts in the `bin/` directory. These scripts can interface with the UI through configuration refresh commands, making it possible to add functionality without touching QML or JavaScript code.

### What role do JSON templates play in Omarchy theming?

**JSON templates** (like `vscode-theme.json.tpl` in the `default/themed/` directory) define color schemes and visual parameters that Omarchy processes into active configurations. These files allow users to customize the desktop appearance declaratively, with changes being consumed by QML components and JavaScript services at runtime to update the UI instantly.