# How OCLP-Mod Manages Patch Priorities for Multiple Hardware Variants

> Discover how OCLP-Mod efficiently manages patch priorities for multiple hardware variants using a deterministic three-tier system ensuring correct configurations override defaults.

- Repository: [laobamac/oclp-mod](https://github.com/laobamac/oclp-mod)
- Tags: how-to-guide
- Published: 2026-03-05

---

**OCLP-Mod resolves conflicting patches through a deterministic three-tier priority system where SMBIOS spoofing levels cascade from Minimal to Advanced, hardware-variant arrays process from generic to specific, and the EFI builder sequences operations so that later writes automatically override earlier configurations.**

When modernizing legacy Macs with the OpenCore Legacy Patcher Mod (OCLP-Mod), systems often present multiple hardware variants—such as mixed GPU families, dual board IDs, or combinations of legacy and modern components—that require conflicting patches. The laobamac/oclp-mod repository implements a strict, deterministic priority scheme to ensure the most specific and aggressive patches take precedence. This article examines the exact mechanisms governing OCLP-Mod patch priorities, referencing the actual source implementation.

## The Three-Tier Priority Mechanism in OCLP-Mod

OCLP-Mod implements patch prioritization through three interconnected mechanisms that all follow the same fundamental principle: **last-write-wins** within a deterministic processing order.

### SMBIOS Spoofing Levels: Minimal, Moderate, and Advanced

The first layer of priority control resides in [`oclp_mod/efi_builder/smbios.py`](https://github.com/laobamac/oclp-mod/blob/main/oclp_mod/efi_builder/smbios.py). The `BuildSMBIOS` class implements three distinct handlers: `_handle_minimal()`, `_handle_moderate()`, and `_handle_advanced()`. These methods are invoked sequentially based on the `self.constants.serial_settings` value, with each level overwriting the same configuration keys in the `self.config["PlatformInfo"]` dictionary.

Because each handler explicitly sets identical keys—such as `SystemProductName`, `BoardProduct`, and `UpdateSMBIOS`—the **Advanced** level automatically supersedes **Moderate**, which in turn supersedes **Minimal**. This cascading overwrite ensures that when users select higher spoofing levels, the corresponding patches take absolute priority.

### Hardware-Variant Arrays and Dataset Ordering

The second priority mechanism operates through ordered arrays in [`oclp_mod/datasets/model_array.py`](https://github.com/laobamac/oclp-mod/blob/main/oclp_mod/datasets/model_array.py). This file defines `SupportedSMBIOS` and related hardware-variant lists as sequential Python arrays. The entries are deliberately ordered from generic to specific—for example, `MacPro3,1` appears before `MacPro6,1`, which precedes `MacBookPro8,2`.

When the patcher iterates through these arrays, it processes matches from top to bottom. Later entries in the array—representing more specific hardware variants—overwrite earlier, more generic configurations in the same configuration dictionary. This **top-to-bottom processing order** guarantees that highly specific patches always take precedence over generic fallback patches when a system matches multiple hardware profiles.

### Patch-Application Order in the EFI Builder

The final tier of priority control occurs in [`oclp_mod/efi_builder/build.py`](https://github.com/laobamac/oclp-mod/blob/main/oclp_mod/efi_builder/build.py). The main build orchestrator instantiates multiple builder classes—including `BuildSMBIOS` and graphics/audio builders from [`oclp_mod/efi_builder/graphics_audio.py`](https://github.com/laobamac/oclp-mod/blob/main/oclp_mod/efi_builder/graphics_audio.py)—and calls their configuration methods in a specific sequence.

Critically, `BuildSMBIOS` executes **after** other builders have populated the configuration. The `set_smbios()` method is invoked late in the build process (around lines 81-163 in [`build.py`](https://github.com/laobamac/oclp-mod/blob/main/build.py)), ensuring that SMBIOS patches represent the final write to shared configuration keys. Because every builder writes to the same OpenCore configuration dictionary—targeting keys like `PlatformInfo → SMBIOS` and `DeviceProperties`—the **last write wins** principle applies deterministically.

## Step-by-Step Patch Resolution Flow

Understanding how these mechanisms interact requires examining the exact execution flow:

1. **Hardware Detection**: The system identifies real hardware via [`oclp_mod/support/utilities.py`](https://github.com/laobamac/oclp-mod/blob/main/oclp_mod/support/utilities.py), gathering the actual model identifier (`self.constants.computer.real_model`) and board IDs through sysctl calls.

2. **SMBIOS Level Selection**: Command-line arguments (`--minimal_smbios`, `--moderate_smbios`, `--advanced_smbios`) set `self.constants.serial_settings`. If unspecified, the default "Minimal" level applies.

3. **Sequential Handler Execution**: In `BuildSMBIOS.set_smbios()` (lines 121-127 in [`smbios.py`](https://github.com/laobamac/oclp-mod/blob/main/smbios.py)), conditional blocks select the appropriate handler. Each handler updates identical configuration keys, causing progressive overwrites:

```python

# Lines 121-127 in oclp_mod/efi_builder/smbios.py

if self.constants.serial_settings == "Minimal":
    self._handle_minimal()
elif self.constants.serial_settings == "Moderate":
    self._handle_moderate()      # overwrites Minimal values

elif self.constants.serial_settings == "Advanced":
    self._handle_advanced()      # overwrites both previous levels

```

Each handler method (lines 148-300) sets identical keys:

```python

# From _handle_advanced() - overwrites previous levels

self.config["PlatformInfo"]["UpdateSMBIOS"] = True
self.config["PlatformInfo"]["SystemProductName"] = "MacBookPro14,3"
self.config["PlatformInfo"]["BoardProduct"] = "Mac-551B86E5744E2388"

```

4. **Variant Array Processing**: The patcher iterates through `SupportedSMBIOS` in [`model_array.py`](https://github.com/laobamac/oclp-mod/blob/main/model_array.py), applying matches in array order. Specific variants appearing later in the list overwrite generic entries processed earlier:

```python

# oclp_mod/datasets/model_array.py

SupportedSMBIOS = [
    "MacPro3,1",        # Generic Nehalem-era workstation

    "MacPro6,1",        # More specific trash can model

    "MacBookPro8,2",    # Highly specific Sandy Bridge laptop

    # Later entries overwrite earlier ones when matched

]

```

5. **Final Configuration Assembly**: In [`build.py`](https://github.com/laobamac/oclp-mod/blob/main/build.py), the `BuildSMBIOS` instance executes after graphics and audio builders, ensuring SMBIOS patches constitute the final write to the OpenCore configuration before output to `OpenCore/config.plist`.

## Why Specific Patches Win Over Generic Ones

The priority system relies on **deterministic overwriting** rather than conditional logic or merge algorithms. When multiple hardware variants match a single system, OCLP-Mod does not attempt to combine patches or select the "best" match through complex heuristics. Instead, it processes entries in a fixed order and allows subsequent writes to identical dictionary keys to replace previous values.

This architecture provides three critical advantages:

- **Predictability**: Behavior is identical across every build because the processing order is hardcoded in the source files.
- **Auditability**: Developers can trace exactly which patch will apply by examining the array order in [`model_array.py`](https://github.com/laobamac/oclp-mod/blob/main/model_array.py) and the handler sequence in [`smbios.py`](https://github.com/laobamac/oclp-mod/blob/main/smbios.py).
- **Specificity Guarantee**: Because specific variants are listed after generic ones in the datasets, they always receive the final write, ensuring tailored patches override broad compatibility fixes.

## Practical Implementation Examples

The following code excerpts demonstrate the actual priority logic implemented in OCLP-Mod:

**SMBIOS Level Hierarchy:**

```python

# oclp_mod/efi_builder/smbios.py (lines 121-127)

if self.constants.serial_settings == "Minimal":
    self._handle_minimal()
elif self.constants.serial_settings == "Moderate":
    self._handle_moderate()      # Overwrites Minimal values

elif self.constants.serial_settings == "Advanced":
    self._handle_advanced()      # Overwrites both previous levels

```

**Configuration Key Overwrites:**

```python

# From _handle_advanced() method

self.config["PlatformInfo"]["UpdateSMBIOS"] = True
self.config["PlatformInfo"]["SystemProductName"] = "MacBookPro14,3"
self.config["PlatformInfo"]["BoardProduct"] = "Mac-551B86E5744E2388"

```

**Build Orchestration Sequence:**

```python

# oclp_mod/efi_builder/build.py (lines 81-163)

# Graphics and audio builders execute first

self.build_graphics_audio()
self.build_firmware()

# SMBIOS builder executes last for final priority

smbios_builder = BuildSMBIOS(self.constants)
smbios_builder.set_smbios()

```

## Summary

OCLP-Mod manages patch priorities for multiple hardware variants through a deterministic, three-tiered overwriting system:

- **SMBIOS spoofing levels** cascade from Minimal to Advanced, with each higher level overwriting the configuration keys set by previous handlers in [`smbios.py`](https://github.com/laobamac/oclp-mod/blob/main/smbios.py).
- **Hardware-variant arrays** in [`model_array.py`](https://github.com/laobamac/oclp-mod/blob/main/model_array.py) are ordered from generic to specific, ensuring that later, more specific entries overwrite earlier matches during iteration.
- **Build orchestration** in [`build.py`](https://github.com/laobamac/oclp-mod/blob/main/build.py) sequences the SMBIOS builder to execute after other patch builders, guaranteeing that the final write to shared OpenCore configuration keys determines the active patch set.

This architecture ensures that when a single system presents multiple hardware variants, the most appropriate and specific patches take precedence through deterministic, last-write-wins logic.

## Frequently Asked Questions

### How does OCLP-Mod handle conflicting patches from different hardware variants?

When conflicting patches exist, OCLP-Mod does not merge them or use selection heuristics. Instead, it processes hardware variants in the order they appear in [`oclp_mod/datasets/model_array.py`](https://github.com/laobamac/oclp-mod/blob/main/oclp_mod/datasets/model_array.py), with later entries overwriting earlier ones. Similarly, SMBIOS handlers in [`smbios.py`](https://github.com/laobamac/oclp-mod/blob/main/smbios.py) overwrite previous levels. The last write to any configuration key wins, ensuring deterministic resolution.

### Can I force a specific SMBIOS level to override automatic detection?

Yes. OCLP-Mod provides command-line flags that directly control SMBIOS priority. Passing `--advanced_smbios` forces the `_handle_advanced()` method to execute, overwriting any values set by Minimal or Moderate handlers. The `--moderate_smbios` flag similarly supersedes Minimal settings. If no flag is specified, the system defaults to the Minimal level.

### Why does the build order in [`build.py`](https://github.com/laobamac/oclp-mod/blob/main/build.py) matter for patch priority?

The sequence in [`oclp_mod/efi_builder/build.py`](https://github.com/laobamac/oclp-mod/blob/main/oclp_mod/efi_builder/build.py) determines which component writes last to the shared OpenCore configuration dictionary. Graphics and audio builders execute before `BuildSMBIOS`, meaning their patches populate the config first. Because `BuildSMBIOS.set_smbios()` runs last (around lines 81-163), its writes to keys like `PlatformInfo` and `DeviceProperties` override any previous values, establishing final patch priority.

### Where are hardware-variant priorities defined in the source code?

Hardware-variant priorities are primarily defined in [`oclp_mod/datasets/model_array.py`](https://github.com/laobamac/oclp-mod/blob/main/oclp_mod/datasets/model_array.py) through the ordering of the `SupportedSMBIOS` list. Generic entries like `MacPro3,1` appear early in the array, while specific variants like `MacBookPro8,2` appear later. Additionally, SMBIOS spoofing priorities are defined in [`oclp_mod/efi_builder/smbios.py`](https://github.com/laobamac/oclp-mod/blob/main/oclp_mod/efi_builder/smbios.py), where the handler methods are structured to overwrite previous configuration levels progressively.