What Programming Languages Does Omarchy Use? A Complete Technical Breakdown

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:

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

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 file exemplifies this pattern, managing widget registration and state propagation:

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

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