omarchy-ui 0.0.8-x86_64-linux → 0.0.9-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbe75336899d8f9674166011c929469db798869f88b32f45a3b61505b0713d01
-  data.tar.gz: bb5f2e4f0dfec4578992d17d5f3fdc5530d5b2c73d4aeebcfada553355077f94
+  metadata.gz: 82c12f3f51c0d9242be7386a4994c4f3fe8b333d04489e4055b671054cb2f0e2
+  data.tar.gz: e693d5b68a5ad055b40fbb910b4bb6ef41b6de7405027396305f256ad744875d
 SHA512:
-  metadata.gz: 9776119537e37548ea84ca4129647a6f94b64944ae75315e776db661220aefeb4cc80527ed93a1b1c9410e0b80d2a547c77a2aae6674f770decc354bdee2a505
-  data.tar.gz: 6856581d58533845967d37daae2679cbf9601f9555aa724b9a9cbf04da0a62a8b15cd146df6d3b36551dec85ad29a13189ba1bdb01a143c2a3cfed87f46d2bb4
+  metadata.gz: 807cb5e30c33130681351065bc7fce902a7c4c125f1c6b47e8827db0ec6b49695745ab60d61da9475153f8abf1422940df280154af797ede39ef218a9097c449
+  data.tar.gz: c2f3532f53a5725e7c6e7cd9de667ebbb2dddd086204af8172f8b262c010e4fef2470b73716a7496c9859d396f43b22814e03926949944e2e1c080e1e64ca5a2

data/README.md

@@ -10,7 +10,7 @@
 </p>
 
 <p align="center">
-  <img alt="Omarchy UI 0.0.8" src="https://img.shields.io/badge/Omarchy_UI-0.0.8-b7ff5a?style=flat-square&labelColor=111711">
+  <img alt="Omarchy UI 0.0.9" src="https://img.shields.io/badge/Omarchy_UI-0.0.9-b7ff5a?style=flat-square&labelColor=111711">
   <img alt="Ruby 3.1 or newer" src="https://img.shields.io/badge/Ruby-3.1%2B-cc342d?style=flat-square&logo=ruby&logoColor=white">
   <img alt="Zui 0.0.10" src="https://img.shields.io/badge/Zui-0.0.10-7ee14b?style=flat-square&labelColor=111711">
   <img alt="241 components" src="https://img.shields.io/badge/components-241-75d943?style=flat-square&labelColor=111711">
@@ -46,8 +46,8 @@ and the Omarchy adapter.
 </table>
 
 > [!IMPORTANT]
-> Omarchy UI currently targets **Omarchy on x86-64 Linux** and is marked experimental. The reusable
-> Zui application module can also run with Zui's native host on Linux, macOS, and Windows.
+> Omarchy UI currently targets **Omarchy on x86-64 Linux**. Reusable Zui application modules can
+> also run through Zui's native host on Linux, macOS, and Windows.
 
 ## Choose a workflow
 
@@ -59,15 +59,16 @@ and the Omarchy adapter.
 
 ## Requirements
 
-- Omarchy on x86-64 Linux;
-- Ruby 3.1 or newer while installing the gem and developing applications;
-- optional Qt modules for components that use features such as Quick 3D or Multimedia.
+- Omarchy on x86-64 Linux
+- Ruby 3.1 or newer for installation and development
+- Qt 6 development tools, CMake, Ninja, and a C++ compiler for `bundle`, `validate`, and `push`
+- Optional Qt modules for components that use features such as Quick 3D or Multimedia
 
-Omarchy UI generates a complete Omarchy-compatible application or plugin package from the
-developer's Ruby and assets. It owns the Omarchy metadata, entry points, adapter, validation,
-tree-shaken Zui QML, and embedded mruby runtime. The finished package does not need Ruby or framework
-gems. A component fails with an explicit error when its required Qt module or resource is unavailable;
-Omarchy UI never substitutes a different component.
+Omarchy UI turns Ruby and assets into an Omarchy-compatible application or plugin. It owns the
+metadata, entry points, adapter, validation, tree-shaken and AOT-compiled Zui QML, and embedded mruby
+runtime. Omarchy UI invokes the build tools; projects do not contain CMake files or distribution
+scripts. The finished package does not require Ruby or framework gems. Components report a clear
+error when a required Qt module or resource is unavailable.
 
 ## Quick start
 
@@ -79,7 +80,7 @@ gem install omarchy-ui
 
 The gem installs the compatible Zui version as a dependency.
 
-### 2. Generate a complete project
+### 2. Generate a project
 
 ```bash
 omarchy_ui new Counter
@@ -93,13 +94,12 @@ omarchy_ui new "System Status" --plugin
 cd system-status
 ```
 
-Both commands create a ready-to-run Ruby project. Omarchy UI generates the complete compliant
-application or plugin package; developers do not write QML, shell entry points, or an Omarchy
-manifest by hand.
+Both commands create a ready-to-run Ruby project. Developers write the interface and behavior;
+Omarchy UI generates the Omarchy package without application-owned QML, shell entry points, or
+handwritten manifests.
 
-Each project includes a Ruby-native `config.rb` containing its type, identity, release version,
-entry point, and—for plugins—public marketplace metadata. `bundle`, `validate`, and `push` read this
-single configuration when assembling the complete package.
+Each project includes a Ruby-native `config.rb` with its type, identity, version, entry point, and
+plugin metadata. `bundle`, `validate`, and `push` use this single configuration.
 
 The generator creates a small, host-independent project:
 
@@ -120,8 +120,8 @@ counter/
 omarchy_ui run main.rb
 ```
 
-`run` bundles the project's Ruby entry point, asks Zui to tree-shake the QML runtime, prepares the Omarchy host,
-then launches it through Quickshell.
+`run` bundles the project's Ruby entry point, asks Zui to tree-shake the QML runtime, prepares the
+Omarchy host, and launches it through Quickshell.
 
 ## Application model
 
@@ -246,16 +246,15 @@ QML is not required.
 
 ## Omarchy plugins
 
-Generate a complete plugin project with one command:
+Generate a plugin project with one command:
 
 ```bash
 omarchy_ui new "System Status" --plugin
 cd system-status
 ```
 
-The generated project already satisfies Omarchy's structural requirements. Developers work in Ruby
-and add their own assets; Omarchy UI owns the required plugin metadata, shell surfaces, native host,
-tree-shaken Zui package, validation, and install lifecycle.
+Developers work in Ruby and add their own assets. Omarchy UI supplies the plugin metadata, shell
+surfaces, native host, tree-shaken Zui package, validation, and installation lifecycle.
 
 The Ruby entry point uses ordinary Zui components:
 
@@ -282,8 +281,8 @@ OmarchyUI.plugin do
 end
 ```
 
-`bar_widget` and `panel :status` are the complete developer-facing surface declarations. Omarchy UI
-maps them to the required Omarchy shell entry points when it builds or stages the plugin.
+`bar_widget` and `panel :status` are the developer-facing surface declarations. Omarchy UI maps them
+to the required shell entry points when it builds or stages the plugin.
 
 ### Validate and install
 
@@ -292,8 +291,8 @@ omarchy_ui validate
 omarchy_ui push
 ```
 
-`validate` generates and checks the complete plugin without mutating the Ruby project. `push` safely
-builds, validates, installs, enables, and reloads the plugin for development.
+`validate` generates and checks the plugin without modifying the Ruby project. `push` builds,
+validates, installs, enables, and reloads it for development.
 
 During development, suppress either lifecycle action when needed:
 
@@ -302,10 +301,6 @@ omarchy_ui push --no-enable
 omarchy_ui push --no-restart
 ```
 
-> [!WARNING]
-> Omarchy plugins execute as unsandboxed user code inside the shell environment. Review the Ruby,
-> assets, generated package, and provenance before installing a third-party plugin.
-
 ## Command-line reference
 
 ```text
@@ -314,11 +309,11 @@ omarchy_ui <command> [arguments]
 
 | Command | Arguments | Result |
 | --- | --- | --- |
-| `omarchy_ui new NAME` | One project name | Creates a complete Omarchy application project |
-| `omarchy_ui new NAME --plugin` | One project name and `--plugin` | Creates a complete Omarchy-compliant plugin project |
+| `omarchy_ui new NAME` | One project name | Creates an Omarchy application project |
+| `omarchy_ui new NAME --plugin` | One project name and `--plugin` | Creates an Omarchy plugin project |
 | `omarchy_ui run FILE` | One Ruby entry point | Runs an application through the Omarchy/Quickshell host |
-| `omarchy_ui bundle [DIRECTORY]` | Zero or one project directory | Generates the complete distributable package and prints its location |
-| `omarchy_ui validate [DIRECTORY]` | Zero or one plugin directory | Stages the complete plugin and delegates validation to `omarchy plugin validate` |
+| `omarchy_ui bundle [DIRECTORY]` | Zero or one project directory | Generates the distributable package and prints its location |
+| `omarchy_ui validate [DIRECTORY]` | Zero or one plugin directory | Stages the plugin and delegates validation to `omarchy plugin validate` |
 | `omarchy_ui push [DIRECTORY]` | Optional `--no-enable` and `--no-restart` | Atomically installs and activates a validated plugin |
 | `omarchy_ui version` | None | Prints the installed Omarchy UI version |
 
@@ -327,19 +322,29 @@ not forward arbitrary Ruby arguments.
 
 ## Packaging
 
-Create the complete distributable package from the project root:
+Create the distributable package from the project root:
 
 ```bash
 omarchy_ui bundle
 ```
 
-Omarchy UI prints the generated package location. It automatically assembles the bundled Ruby and
-assets, Omarchy metadata and entry points, native host, checksummed runtime provenance, and only the
-Zui QML components used by the project. Application packages receive a direct launcher; plugin
-packages are validated against Omarchy's requirements before the command succeeds. Omarchy UI pins
-Zui 0.0.10 so generated QML exactly matches the Zui core embedded in the deterministic mruby runtime.
-The source `config.rb` remains the authoritative build configuration; plugin manifests are generated
-from it in the distributable package and are never maintained separately by the developer.
+Omarchy UI assembles the Ruby source and assets, Omarchy entry points, native host, checksummed
+runtime, and only the Zui components used by the project. It then AOT-compiles the generated QML into
+a content-addressed Qt module and discards the generated component, control, theme, and font source
+tree. Applications receive a direct launcher; plugins must pass Omarchy validation before the
+command succeeds. Omarchy UI pins Zui 0.0.10 so the compiled UI matches the Zui core embedded in the
+deterministic mruby runtime.
+
+Current Omarchy manifests resolve entry points by filename, so a package retains four minimal loader
+files: `App.qml`, `Service.qml`, `Panel.qml`, and `BarWidget.qml`. They contain only an import and a
+compiled type instance; the application interface is stored in native `.so` artifacts. The package
+also includes `omarchy-ui-qml-bundle.json` with the module URI and exact Qt version, plus
+`omarchy-ui-qml-bundle.sha256` for artifact verification. `QML_PROVENANCE.md` explains the native
+artifacts for package reviewers. Compiled packages should be built against the Qt version shipped by
+their target Omarchy release.
+
+The source `config.rb` is the build configuration. Omarchy UI generates plugin manifests from it;
+developers never maintain a separate manifest.
 
 ## Component catalog
 
@@ -406,10 +411,12 @@ Zui DSL · state · events · bindings · scheduler
           │
           │ versioned JSON render, patch, event, and effect protocol
           ▼
-Omarchy Service.qml process bridge ───── embedded mruby runtime
+Omarchy process bridge ───────────────── embedded mruby runtime
           │
           ▼
-Zui ControlNode + native component catalog
+Tree-shaken Zui host + component catalog
+          │
+          │ bundle: Qt AOT module + four loader shims
           │
           ▼
 App window · Omarchy panel · Omarchy bar widget
@@ -427,8 +434,9 @@ The dependency direction is deliberate:
 - **Applications own** Ruby source, assets, state, behavior, and reusable UI modules.
 
 At bundle, validation, and push time, Omarchy UI asks Zui to analyze the bundled Ruby syntax and
-generate only the required component adapters plus their renderer dependencies. The four Omarchy
-host files then replace Zui's generic desktop host. Read the full [QML ownership and adapter
+generate only the required component adapters plus their renderer dependencies. Omarchy UI overlays
+its host, compiles the complete generated QML graph into a content-addressed Qt module, and emits the
+minimal loader files required by Omarchy. Read the full [QML ownership and adapter
 boundary](docs/qml-support.md).
 
 ## Runtime integrity

data/lib/omarchy_ui/cli.rb

@@ -114,14 +114,17 @@ module OmarchyUI
       config = ProjectConfig.load(source)
       entrypoint = config&.entrypoint || "main.rb"
       raise ArgumentError, "#{entrypoint} not found: #{source}" unless File.file?(File.join(source, entrypoint))
+      precompiled = config.nil? && compiled_package?(source)
       destination = File.join(source, "dist", config&.slug || File.basename(source))
       raise ArgumentError, "bundle destination already exists: #{destination}" if File.exist?(destination)
       FileUtils.mkdir_p(destination)
-      entries = application_entries(source, config:)
+      entries = precompiled ? package_entries(source) : application_entries(source, config:)
       FileUtils.cp_r(entries.map { |entry| File.join(source, entry) }, destination)
-      config.write_manifest(destination) if config&.plugin?
-      bundle_ruby_entrypoint(source, destination, entrypoint:)
-      Runtime.install_package(destination)
+      unless precompiled
+        config.write_manifest(destination) if config&.plugin?
+        bundle_ruby_entrypoint(source, destination, entrypoint:)
+        Runtime.install_package(destination, compiled: !config.nil?)
+      end
       plugin = config ? config.plugin? : File.file?(File.join(destination, "manifest.json"))
       if plugin
         raise ArgumentError, "bundled plugin validation failed" unless system("omarchy", "plugin", "validate", destination)
@@ -140,6 +143,8 @@ module OmarchyUI
         export OMARCHY_UI_RUNTIME="$app_dir/omarchy-ui-runtime"
         export OMARCHY_UI_PROJECT_DIR="$app_dir"
         export OMARCHY_UI_RUBY_PROGRAM="$app_dir/#{entrypoint}"
+        export QML2_IMPORT_PATH="$app_dir${QML2_IMPORT_PATH:+:$QML2_IMPORT_PATH}"
+        export QML_IMPORT_PATH="$app_dir${QML_IMPORT_PATH:+:$QML_IMPORT_PATH}"
         export QT_LOGGING_RULES="${QT_LOGGING_RULES:+$QT_LOGGING_RULES;}qt.qpa.services.warning=false"
         exec quickshell --path "$app_dir/App.qml"
       SH
@@ -161,6 +166,18 @@ module OmarchyUI
       Dir.children(source).reject { |entry| %w[.git dist].include?(entry) || generated.include?(entry) }
     end
 
+    def package_entries(source)
+      Dir.children(source).reject { |entry| %w[.git dist].include?(entry) }
+    end
+
+    def compiled_package?(source)
+      report = File.join(source, QmlCompiler::REPORT)
+      return false unless File.file?(report)
+
+      QmlCompiler.verify!(source)
+      true
+    end
+
     def push(arguments)
       enable = !arguments.delete("--no-enable")
       restart = !arguments.delete("--no-restart")
@@ -213,14 +230,17 @@ module OmarchyUI
     def stage_project(source, parent: nil, prefix: ".omarchy-ui-staging-")
       raise ArgumentError, "project directory not found: #{source}" unless File.directory?(source)
       config = ProjectConfig.load(source)
+      precompiled = config.nil? && compiled_package?(source)
       staging = parent ? Dir.mktmpdir(prefix, parent) : Dir.mktmpdir(prefix)
-      entries = application_entries(source, config:)
+      entries = precompiled ? package_entries(source) : application_entries(source, config:)
       FileUtils.cp_r(entries.map { |entry| File.join(source, entry) }, staging) unless entries.empty?
-      config.write_manifest(staging) if config&.plugin?
-      entrypoint = config&.entrypoint || "main.rb"
-      if File.file?(File.join(staging, entrypoint))
-        bundle_ruby_entrypoint(source, staging, entrypoint:)
-        Runtime.install_package(staging)
+      unless precompiled
+        config.write_manifest(staging) if config&.plugin?
+        entrypoint = config&.entrypoint || "main.rb"
+        if File.file?(File.join(staging, entrypoint))
+          bundle_ruby_entrypoint(source, staging, entrypoint:)
+          Runtime.install_package(staging, compiled: !config.nil?)
+        end
       end
       staging
     rescue StandardError

data/lib/omarchy_ui/generator.rb

@@ -139,7 +139,8 @@ module OmarchyUI
         omarchy_ui bundle
         ```
 
-        Omarchy UI generates the complete self-contained application package required by Omarchy.
+        Omarchy UI tree-shakes and compiles the UI, then generates the complete self-contained
+        application package required by Omarchy.
       MARKDOWN
     end
 
@@ -168,8 +169,8 @@ module OmarchyUI
         ```
 
         Write the plugin interface and behavior in Ruby under `main.rb` and `components/`.
-        Public plugin identity and release metadata live in `config.rb`. Omarchy UI uses it to
-        generate and validate the complete Omarchy-compatible plugin package.
+        Public plugin identity and release metadata live in `config.rb`. Omarchy UI tree-shakes and
+        compiles the UI, then generates and validates the complete Omarchy-compatible plugin package.
       MARKDOWN
     end
 

data/lib/omarchy_ui/project_config.rb

@@ -115,6 +115,7 @@ module OmarchyUI
       value = @data[:type]
       value.respond_to?(:to_sym) ? value.to_sym : value
     end
+
     def application? = type == :application
     def plugin? = type == :plugin
     def name = @data.fetch(:name)

data/lib/omarchy_ui/qml_compiler.rb

@@ -0,0 +1,386 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "json"
+require "open3"
+require "pathname"
+require "tmpdir"
+
+module OmarchyUI
+  class QmlCompiler
+    FORMAT_VERSION = 1
+    ENTRY_TYPES = {
+      "App.qml" => "App",
+      "BarWidget.qml" => "BarWidget",
+      "Panel.qml" => "Panel",
+      "Service.qml" => "Service"
+    }.freeze
+    SOURCE_ENTRIES = (ENTRY_TYPES.keys + %w[ControlNode.qml Components Controls Theme Fonts]).freeze
+    COMPILED_ROOT = "OmarchyUI"
+    REPORT = "omarchy-ui-qml-bundle.json"
+    CHECKSUM = "omarchy-ui-qml-bundle.sha256"
+    PROVENANCE = "QML_PROVENANCE.md"
+
+    def self.compile!(path)
+      new(path).compile!
+    end
+
+    def self.verify!(path)
+      new(path).verify!
+    end
+
+    def initialize(path)
+      @path = File.expand_path(path)
+    end
+
+    def compile!
+      validate_sources!
+      tools = build_tools
+      qt_version = qt_version!(tools.fetch(:qtpaths))
+
+      Dir.mktmpdir("omarchy-ui-qml-compile-") do |temporary|
+        source = File.join(temporary, "source")
+        build = File.join(temporary, "build")
+        stage_sources(source)
+        qml_files = relative_files(source, "**/*.qml")
+        resources = relative_files(source, "Fonts/**/*") +
+          %w[Controls/qmldir Theme/qmldir].select { |entry| File.file?(File.join(source, entry)) }
+        fingerprint = source_fingerprint(source, qml_files + resources, qt_version:)
+        segment = "B#{fingerprint[0, 20]}"
+        uri = "OmarchyUI.Bundles.#{segment}"
+        target = "omarchy_ui_bundle_#{segment.downcase}"
+        module_path = File.join(*uri.split("."))
+
+        File.write(File.join(source, "CMakeLists.txt"), cmake_project(
+          qml_files:,
+          resources: resources.sort,
+          uri:,
+          target:,
+          module_path:
+        ))
+        configure!(tools.fetch(:qt_cmake), source, build)
+        build!(tools.fetch(:cmake), build)
+        deploy!(
+          build:,
+          module_path:,
+          target:,
+          uri:,
+          fingerprint:,
+          qml_files:,
+          resources:,
+          source:,
+          expected_qt_version: qt_version
+        )
+      end
+    end
+
+    def verify!
+      report_path = File.join(@path, REPORT)
+      raise ArgumentError, "compiled QML report is missing: #{report_path}" unless File.file?(report_path)
+
+      report = JSON.parse(File.read(report_path))
+      unless report["format"] == "qt-aot-qml-module" && report["format_version"] == FORMAT_VERSION
+        raise ArgumentError, "unsupported compiled QML package format"
+      end
+      ENTRY_TYPES.each_key do |entry|
+        raise ArgumentError, "compiled QML entry shim is missing: #{entry}" unless File.file?(File.join(@path, entry))
+      end
+      module_path = safe_relative_path(report.fetch("module_path"))
+      raise ArgumentError, "compiled QML qmldir is missing" unless File.file?(File.join(@path, module_path, "qmldir"))
+
+      artifacts = report.fetch("artifacts")
+      raise ArgumentError, "compiled QML package must contain two libraries" unless artifacts.length == 2
+      artifacts.each do |artifact|
+        relative = safe_relative_path(artifact.fetch("path"))
+        unless relative.start_with?("#{module_path}/") && relative.end_with?(".so")
+          raise ArgumentError, "compiled QML artifact is outside its module: #{relative}"
+        end
+        absolute = File.join(@path, relative)
+        raise ArgumentError, "compiled QML artifact is missing: #{relative}" unless File.file?(absolute)
+        unless File.size(absolute) == artifact.fetch("bytes") &&
+            Digest::SHA256.file(absolute).hexdigest == artifact.fetch("sha256")
+          raise ArgumentError, "compiled QML artifact checksum mismatch: #{relative}"
+        end
+      end
+      report
+    rescue JSON::ParserError, KeyError, TypeError => error
+      raise ArgumentError, "invalid compiled QML report: #{error.message}"
+    end
+
+    private
+
+    def safe_relative_path(path)
+      value = path.to_s
+      clean = File.expand_path(value, @path)
+      unless !value.empty? && !Pathname.new(value).absolute? && clean.start_with?("#{@path}/")
+        raise ArgumentError, "unsafe compiled QML path: #{value.inspect}"
+      end
+      clean.delete_prefix("#{@path}/")
+    end
+
+    def validate_sources!
+      missing = ENTRY_TYPES.keys.reject { |entry| File.file?(File.join(@path, entry)) }
+      missing << "ControlNode.qml" unless File.file?(File.join(@path, "ControlNode.qml"))
+      return if missing.empty?
+
+      raise ArgumentError, "cannot compile QML; generated files are missing: #{missing.join(', ')}"
+    end
+
+    def build_tools
+      {
+        qt_cmake: find_executable("/usr/lib/qt6/bin/qt-cmake", "qt-cmake"),
+        qtpaths: find_executable("/usr/lib/qt6/bin/qtpaths", "qtpaths6", "qtpaths"),
+        cmake: find_executable("cmake"),
+        ninja: find_executable("ninja"),
+        compiler: find_executable("c++", "g++", "clang++")
+      }
+    end
+
+    def qt_version!(qtpaths)
+      output, error, status = Open3.capture3(qtpaths, "--query", "QT_VERSION")
+      version = output.strip
+      return version if status.success? && !version.empty?
+
+      detail = error.strip
+      raise ArgumentError, "could not determine the Qt build version#{detail.empty? ? '' : ": #{detail}"}"
+    end
+
+    def find_executable(*candidates)
+      candidates.each do |candidate|
+        if candidate.include?(File::SEPARATOR)
+          return candidate if File.file?(candidate) && File.executable?(candidate)
+          next
+        end
+
+        ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).each do |directory|
+          path = File.join(directory, candidate)
+          return path if File.file?(path) && File.executable?(path)
+        end
+      end
+      raise ArgumentError, "compiled QML packaging requires #{candidates.first}"
+    end
+
+    def stage_sources(destination)
+      FileUtils.mkdir_p(destination)
+      SOURCE_ENTRIES.each do |entry|
+        source = File.join(@path, entry)
+        next unless File.exist?(source)
+
+        FileUtils.cp_r(source, File.join(destination, entry))
+      end
+    end
+
+    def relative_files(root, pattern)
+      Dir.glob(File.join(root, pattern), File::FNM_DOTMATCH)
+        .select { |path| File.file?(path) }
+        .map { |path| path.delete_prefix("#{root}/") }
+        .sort
+    end
+
+    def source_fingerprint(root, files, qt_version:)
+      digest = Digest::SHA256.new
+      digest << "omarchy-ui-qml-bundle\0" << FORMAT_VERSION.to_s << "\0"
+      digest << "qt\0" << qt_version << "\0"
+      files.sort.each do |relative|
+        digest << relative << "\0" << File.binread(File.join(root, relative)) << "\0"
+      end
+      digest.hexdigest
+    end
+
+    def cmake_project(qml_files:, resources:, uri:, target:, module_path:)
+      <<~CMAKE
+        cmake_minimum_required(VERSION 3.21)
+
+        project(OmarchyUICompiledBundle LANGUAGES CXX)
+
+        find_package(Qt6 6.8 REQUIRED COMPONENTS Core Qml Quick QuickControls2)
+        qt_standard_project_setup(REQUIRES 6.8)
+
+        qt_add_library(#{target} SHARED)
+        qt_add_qml_module(#{target}
+          URI #{uri}
+          VERSION 1.0
+          OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/#{module_path}"
+          QML_FILES
+        #{cmake_entries(qml_files)}
+          RESOURCES
+        #{cmake_entries(resources)}
+          DISCARD_QML_CONTENTS
+          NO_LINT
+        )
+
+        set(module_output "${CMAKE_BINARY_DIR}/#{module_path}")
+        set_target_properties(
+          #{target}
+          #{target}plugin
+          PROPERTIES
+            LIBRARY_OUTPUT_DIRECTORY "${module_output}"
+            BUILD_RPATH "\\$ORIGIN"
+            BUILD_WITH_INSTALL_RPATH TRUE
+            INSTALL_RPATH "\\$ORIGIN"
+        )
+
+        target_compile_options(
+          #{target}
+          PRIVATE
+            "-ffile-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}=."
+            "-ffile-prefix-map=${CMAKE_CURRENT_BINARY_DIR}=."
+        )
+        target_compile_options(
+          #{target}plugin
+          PRIVATE
+            "-ffile-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}=."
+            "-ffile-prefix-map=${CMAKE_CURRENT_BINARY_DIR}=."
+        )
+        target_link_options(#{target} PRIVATE "-Wl,--build-id=none")
+        target_link_options(#{target}plugin PRIVATE "-Wl,--build-id=none")
+        target_link_libraries(
+          #{target}
+          PRIVATE Qt6::Core Qt6::Qml Qt6::Quick Qt6::QuickControls2
+        )
+
+        file(WRITE "${CMAKE_BINARY_DIR}/qt-version.txt" "${Qt6Core_VERSION}\n")
+      CMAKE
+    end
+
+    def cmake_entries(entries)
+      entries.map { |entry| "    #{cmake_string(entry)}" }.join("\n")
+    end
+
+    def cmake_string(value)
+      escaped = value.gsub("\\", "\\\\").gsub('"', '\\"')
+      %Q("#{escaped}")
+    end
+
+    def configure!(qt_cmake, source, build)
+      run_build_command!(
+        "QML configure",
+        qt_cmake,
+        "-S", source,
+        "-B", build,
+        "-G", "Ninja",
+        "-DCMAKE_BUILD_TYPE=Release"
+      )
+    end
+
+    def build!(cmake, build)
+      run_build_command!("QML compilation", cmake, "--build", build, "--parallel")
+    end
+
+    def run_build_command!(label, *command)
+      environment = {
+        "LC_ALL" => "C.UTF-8",
+        "SOURCE_DATE_EPOCH" => "1",
+        "TZ" => "UTC"
+      }
+      output, error, status = Open3.capture3(environment, *command)
+      return if status.success?
+
+      detail = "#{output}\n#{error}".lines.last(40).join.strip
+      raise ArgumentError, "#{label} failed#{detail.empty? ? '' : ":\n#{detail}"}"
+    end
+
+    def deploy!(build:, module_path:, target:, uri:, fingerprint:, qml_files:, resources:, source:,
+      expected_qt_version:)
+      built_module = File.join(build, module_path)
+      artifact_names = ["lib#{target}.so", "lib#{target}plugin.so", "qmldir"]
+      missing = artifact_names.reject { |name| File.file?(File.join(built_module, name)) }
+      unless missing.empty?
+        raise ArgumentError, "QML compilation did not produce: #{missing.join(', ')}"
+      end
+      qt_version = File.read(File.join(build, "qt-version.txt")).strip
+      unless qt_version == expected_qt_version
+        raise ArgumentError,
+          "Qt compiler mismatch: qtpaths reported #{expected_qt_version}, CMake found #{qt_version}"
+      end
+
+      compiled_root = File.join(@path, COMPILED_ROOT)
+      FileUtils.remove_entry(compiled_root) if File.directory?(compiled_root)
+      destination = File.join(@path, module_path)
+      FileUtils.mkdir_p(destination)
+      artifact_names.each { |name| FileUtils.cp(File.join(built_module, name), destination) }
+      qmldir = File.join(destination, "qmldir")
+      File.write(qmldir, File.read(qmldir).rstrip + "\n")
+
+      SOURCE_ENTRIES.each { |entry| remove_generated(File.join(@path, entry)) }
+      ENTRY_TYPES.each do |entry, type|
+        File.write(File.join(@path, entry), entry_shim(module_path, type, uri:))
+      end
+
+      artifact_paths = artifact_names.filter_map do |name|
+        next if name == "qmldir"
+
+        relative = File.join(module_path, name)
+        absolute = File.join(@path, relative)
+        {
+          "path" => relative,
+          "sha256" => Digest::SHA256.file(absolute).hexdigest,
+          "bytes" => File.size(absolute)
+        }
+      end
+      report = {
+        "format" => "qt-aot-qml-module",
+        "format_version" => FORMAT_VERSION,
+        "qt_version" => qt_version,
+        "module_uri" => uri,
+        "module_path" => module_path,
+        "source_fingerprint" => fingerprint,
+        "source_files" => qml_files.length,
+        "source_bytes" => (qml_files + resources).sum { |file| File.size(File.join(source, file)) },
+        "entry_shims" => ENTRY_TYPES.keys,
+        "artifacts" => artifact_paths
+      }
+      File.write(File.join(@path, REPORT), JSON.pretty_generate(report) + "\n")
+      checksums = artifact_paths.map { |artifact| "#{artifact.fetch('sha256')}  #{artifact.fetch('path')}" }
+      File.write(File.join(@path, CHECKSUM), checksums.join("\n") + "\n")
+      File.write(File.join(@path, PROVENANCE), provenance(report))
+      report
+    end
+
+    def remove_generated(path)
+      File.directory?(path) ? FileUtils.remove_entry(path) : FileUtils.rm_f(path)
+    end
+
+    def entry_shim(module_path, type, uri:)
+      import = type == "App" ? uri : %Q("#{module_path}")
+      <<~QML
+        import QtQuick
+        import #{import} as Compiled
+
+        Compiled.#{type} {}
+      QML
+    end
+
+    def provenance(report)
+      artifacts = report.fetch("artifacts").map do |artifact|
+        "- `#{artifact.fetch('path')}` — `#{artifact.fetch('sha256')}`"
+      end.join("\n")
+      <<~MARKDOWN
+        # Compiled QML provenance
+
+        Omarchy UI generated this package's native Qt module from the tree-shaken Zui and
+        Omarchy host QML graph. Generated QML source contents were discarded after AOT compilation.
+
+        - Format: `#{report.fetch('format')}` version #{report.fetch('format_version')}
+        - Qt: `#{report.fetch('qt_version')}`
+        - Module: `#{report.fetch('module_uri')}`
+        - Source fingerprint: `#{report.fetch('source_fingerprint')}`
+
+        ## Artifacts
+
+        #{artifacts}
+
+        Verify the packaged libraries from the plugin directory:
+
+        ```bash
+        sha256sum --check #{CHECKSUM}
+        ```
+
+        `App.qml`, `Service.qml`, `Panel.qml`, and `BarWidget.qml` are the minimal loader shims
+        required by Omarchy's file-based entry-point contract. Application UI lives in the compiled
+        module recorded by `#{REPORT}`.
+      MARKDOWN
+    end
+  end
+end

data/lib/omarchy_ui/runtime.rb

@@ -16,8 +16,14 @@ module OmarchyUI
     AUDIT_FILES = %w[
       omarchy-ui-runtime.sha256 runtime-provenance.json RUNTIME_PROVENANCE.md
     ].freeze
-    GENERATED_ENTRIES = (ADAPTER_FILES + ZUI_GENERATED_ENTRIES +
-      [TREE_SHAKE_REPORT, "omarchy-ui-runtime"]).freeze
+    GENERATED_ENTRIES = (ADAPTER_FILES + ZUI_GENERATED_ENTRIES + [
+      TREE_SHAKE_REPORT,
+      QmlCompiler::COMPILED_ROOT,
+      QmlCompiler::REPORT,
+      QmlCompiler::CHECKSUM,
+      QmlCompiler::PROVENANCE,
+      "omarchy-ui-runtime"
+    ]).freeze
 
     def executable
       override = ENV["OMARCHY_UI_RUNTIME"]
@@ -39,7 +45,7 @@ module OmarchyUI
       FileUtils.rm_f(temporary) if temporary && File.exist?(temporary)
     end
 
-    def install_package(path, framework_root: FRAMEWORK_ROOT, project: path)
+    def install_package(path, framework_root: FRAMEWORK_ROOT, project: path, compiled: false)
       FileUtils.mkdir_p(path)
       GENERATED_ENTRIES.each do |entry|
         generated = File.join(path, entry)
@@ -67,6 +73,7 @@ module OmarchyUI
         source = File.join(framework_root, "vendor", "runtime", "x86_64-linux", file)
         FileUtils.cp(source, File.join(path, file)) if File.file?(source)
       end
+      QmlCompiler.compile!(path) if compiled
       path
     end
 

data/lib/omarchy_ui.rb

@@ -11,7 +11,7 @@ rescue LoadError
 end
 
 module OmarchyUI
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
   ZUI_VERSION = Zui::VERSION
   FRAMEWORK_ROOT = File.expand_path("..", __dir__)
 
@@ -128,4 +128,5 @@ end
 
 require_relative "omarchy_ui/project_config"
 require_relative "omarchy_ui/generator"
+require_relative "omarchy_ui/qml_compiler"
 require_relative "omarchy_ui/runtime"

data/vendor/runtime/x86_64-linux/RUNTIME_PROVENANCE.md

@@ -17,4 +17,4 @@ The workflow checks out every external input at a full commit digest, performs t
 builds, requires byte-identical executables, and signs the resulting SHA through GitHub's
 artifact attestation service. Machine-readable provenance is included in
 `runtime-provenance.json`; independent verification instructions are in
-[`docs/runtime-build.md`](../../../docs/runtime-build.md).
+the [runtime build documentation](https://github.com/AdamMusa/omarchy-ui/blob/main/docs/runtime-build.md).

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omarchy-ui
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: x86_64-linux
 authors:
 - Adam Moussa Ali
@@ -40,6 +40,7 @@ files:
 - lib/omarchy_ui/cli.rb
 - lib/omarchy_ui/generator.rb
 - lib/omarchy_ui/project_config.rb
+- lib/omarchy_ui/qml_compiler.rb
 - lib/omarchy_ui/runtime.rb
 - vendor/runtime/x86_64-linux/RUNTIME_PROVENANCE.md
 - vendor/runtime/x86_64-linux/omarchy-ui-runtime