Graphics Card Injection for Legacy Hackintosh: Clover, OpenCore, and WhateverGreen

Building a Hackintosh with a legacy version of macOS — Mountain Lion through High Sierra — means the graphics card almost never works correctly out of the box. You get a black screen after the boot logo, a corrupted framebuffer, or no UI acceleration at all. The root cause is nearly always the same: macOS doesn't know how to initialise the GPU unless you inject explicit instructions into the I/O Registry. This process is called graphics card injection, and it's one of the most misunderstood steps in legacy Hackintosh configuration.

Injection is not about modifying the GPU firmware or flashing a custom VBIOS. It's a software-level operation that tells the macOS kernel the exact connector layout, memory size, and framebuffer personality for your card. Without injection, the system falls back to generic VESA modes — no hardware acceleration, no proper resolution detection. This article covers the three main methods for injecting a graphics card into a legacy Hackintosh: using the Graphics section of the Clover config.plist, using DeviceProperties in OpenCore, and using FakeSMC/WhateverGreen with custom patches. Each method has specific constraints depending on the macOS version and GPU generation.

Why Injection Matters for Legacy Versions

Modern macOS versions (Mojave and later) rely heavily on the WhateverGreen kext to handle GPU initialisation automatically. On older systems — especially 10.9 through 10.13 — WhateverGreen either doesn't exist or lacks support for certain cards. The boot loader must inject properties manually. The critical parameters include:

• device-id — overrides the PCI device ID so macOS recognises the GPU as a supported model
• vendor-id — usually 0x1002 for AMD, 0x10de for NVIDIA, 0x8086 for Intel
• model — a human-readable string such as “AMD Radeon HD 7870”
• ATY,Card# — a connector personality name like “Duke”, “Hamachi”, or “Ivy”
• hda-gfx — ties the GPU audio controller to the correct framebuffer
• @0,connector-type through @3,connector-type — defines the physical output ports

Without injection, macOS may still show a desktop, but it runs entirely in software rendering. OpenGL acceleration, Quartz Extreme, and video decode are all disabled. On some cards, the system panics at boot because the framebuffer tries to read a connector map that doesn't match the physical ports.

Method 1: Clover Graphics Injection (For OS X 10.9–10.13)

Clover’s Graphics section in the config.plist remains the simplest injection method for legacy builds. Locate the Graphics dictionary under config.plist > Graphics. The key parameters are:

For NVIDIA Kepler cards (GT 6xx/7xx), set Inject to <key>NVIDIA</key><true/> and leave FBName empty — macOS handles these natively after injection. For older AMD cards (Radeon HD 7xxx), you must match the FBName to the card’s connector layout. The most common personalities for Southern Islands GPUs are “Hamachi” (two DVI, one HDMI, one DP) and “Ivy” (two mini-DP, one HDMI, one DVI). Using the wrong personality will produce a black screen or scrambled output.

A frequent pitfall: Clover injection only works if SystemParameters > InjectKexts is set to Yes or Detect. If you boot with InjectKexts=No, the injection properties are ignored. Also, Clover’s injection does not override the device-id — you must add that manually under Devices > Arbitrary > Inject if macOS doesn't recognise the GPU at all.

Method 2: DeviceProperties Injection in OpenCore (For 10.10 and Later)

OpenCore handles injection through the DeviceProperties > Add section. Each GPU must be addressed by its full PCI path, which you can get from IORegistryExplorer or from Windows Device Manager. A typical entry for a Radeon HD 7870 looks like this in the config.plist:

<key>PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)</key>
<dict>
    <key>device-id</key>
    <data>AQAAAA==</data>
    <key>vendor-id</key>
    <data>gAQAAA==</data>
    <key>model</key>
    <string>AMD Radeon HD 7870</string>
    <key>ATY,Card#</key>
    <string>Hamachi</string>
    <key>@0,connector-type</key>
    <data>AAABAA==</data>
    <key>@1,connector-type</key>
    <data>AAABAA==</data>
    <key>@2,connector-type</key>
    <data>AAABAA==</data>
</dict>

The device-id and vendor-id are base64-encoded little-endian 32-bit integers. The connector-type values correspond to: AAABAA== for DVI (sense line 1), AAACAQ== for HDMI, and AAADAQ== for DisplayPort. Encoding these correctly is critical — a single wrong byte can cause the GPU to be unrecognised.

OpenCore has a distinct advantage over Clover: it applies properties before any kext loads, which avoids race conditions that sometimes cause Clover’s injection to fail on certain motherboards. However, OpenCore requires the exact PCI path. If you move the GPU to a different slot, you must update the path. For dual-GPU setups, each card needs its own dictionary keyed to its unique path.

Method 3: WhateverGreen with Custom Framebuffer Patches (10.12–10.14)

For macOS Sierra, High Sierra, and early Mojave, the WhateverGreen kext can automate most of the injection if you supply a small set of boot arguments or device properties. This method is less invasive because WhateverGreen handles the ACPI patching and connector fix-ups at runtime.

The standard approach is to add the boot argument -wegnoegpu to disable injection for all GPUs, then selectively enable injection for the target card via DeviceProperties. For example, to inject a Radeon RX 580 on High Sierra, you add:

• device-id = 0xDF67 (or whatever the actual device ID is)
• ATY,Card# = Orinoco (a common framebuffer for Polaris)
• @0,connector-type = 04000000 (DisplayPort in hex, not base64)

WhateverGreen applies the framebuffer fix-ups automatically based on the ATY,Card# you specify. It also corrects the connector type ordering, which is often scrambled on AMD cards. The downside is that older versions of WhateverGreen (pre-1.3.0) don't support cards older than the Radeon HD 7xxx series. If you are building a Hackintosh with an HD 5xxx or 6xxx GPU, you must use Clover or OpenCore injection directly.

For NVIDIA cards on High Sierra, WhateverGreen can inject the NVIDIA personality, but it's usually unnecessary — the built-in NVDAStartup.kext handles Kepler and Maxwell cards natively once the nv_disable=1 boot argument is removed. Only inject properties for NVIDIA if you need to override the VRAM size or force a specific display output.

Diagnosing Injection Failures

When injection fails, the symptoms are predictable. The most common is a black screen immediately after the boot logo. To diagnose, boot with -v and watch for messages like IOConsoleUsers: gIOScreenLock... 0 — this usually indicates that the framebuffer initialised but the connector map is wrong. Another clue is the absence of AMDRadeonX4000 or GeForce kexts in the verbose output. If the system falls back to AppleGraphicsControl with no GPU acceleration, injection didn't apply.

Use IORegistryExplorer to check whether your GPU node contains the injected properties. If the properties are missing, the boot loader didn't apply them — verify the PCI path and the syntax of your config.plist. If the properties are present but the screen is still black, the connector-type values are likely incorrect. Try a different ATY,Card# or manually adjust the connector-type data to match your monitor’s physical port.

For users running OS X 10.9 Mavericks, note that injection behaves differently because the kernel doesn't support the modern IOKit matching system. On Mavericks, you must also inject hda-gfx under the GPU’s IOReg entry to enable audio over HDMI. This property is often overlooked and causes the HDMI port to remain silent even if video works.

Preserving a Working Configuration

Once you have a stable injection setup, save the exact config.plist and a copy of the IORegistry dump to your EFI partition backup. Legacy GPUs are becoming harder to replace, and a small change in the framebuffer personality can break the entire graphics stack. If you later upgrade macOS to a newer version, the same injection settings often carry over — but always test with a clone of your system drive first.

For builds that rely on Clover injection, consider migrating to OpenCore on the same hardware. OpenCore’s DeviceProperties method is more deterministic and survives macOS updates better. The migration involves copying the GPU properties from the Clover Graphics dictionary into the OpenCore DeviceProperties > Add section, converting the data to base64 where needed. Several community tools can automate this conversion, but manual verification using a hex editor is safer for critical properties like connector-type.

If you are working with a Hackintosh that uses a X79 or X99 chipset, be aware that the ACPI tables on those platforms sometimes interfere with GPU power management. A separate fix for AGPM (Apple Graphics Power Management) may be required to prevent the card from staying at idle clocks or failing to wake from sleep. The process for editing the AGPM kext is covered in detail in our guide Fixing macOS Sleep/Wake on Legacy Hackintosh by Editing AGPM Kext. Apply those patches after you confirm that injection works correctly, because AGPM modifications depend on the exact framebuffer name.

Finally, always keep a known-good backup of your EFI folder on a separate USB drive. A misconfigured injection property can render the system unbootable, and without a backup you may have to rebuild the entire configuration from scratch. Test each injection change by booting once with -v and checking for GPU-related messages before committing the change to your main boot drive.