# OpCore Simplify: generating an OpenCore EFI from a hardware report > OpCore Simplify is a Python tool that turns a hardware report and ACPI dump into an OpenCore EFI folder. It removes the kext-by-kext guesswork, but it does not remove the troubleshooting. **lzhoang2801/OpCore-Simplify** — A tool designed to simplify the creation of OpenCore EFI - Repository: https://github.com/lzhoang2801/OpCore-Simplify - Website: https://lzhoang2801.github.io/gathering-files/opencore-efi - Stars: 7,455 · Forks: 702 - Language: Python - License: BSD-3-Clause - Published: 2026-09-22 · Updated: 2026-09-22 · Language: en - Canonical page: https://hysenlabs.com/projects/lzhoang2801-opcore-simplify ## The manual EFI assembly problem OpCore Simplify targets An OpenCore EFI is a folder of kexts, ACPI tables and a config.plist whose entries must agree with each other. A machine with a supported AMD GPU and an unsupported NVIDIA card needs different kexts than the same board with the discrete card disabled. Getting that wrong usually shows up as a boot that stalls before the installer, with no error message pointing at the kext that caused it. The project's own warning is explicit: the Hackintosh journey still requires understanding basic concepts from the Dortania Guide, testing and troubleshooting during installation, and patience. The README states the tool does not guarantee a successful installation in the first attempt. That framing matters. OpCore Simplify is for someone who has decided to build an OpenCore EFI and wants the baseline decisions made for them, not for someone who wants a one-click macOS installer. ## How the hardware report drives kext and ACPI selection The pipeline starts with a hardware inventory. On Windows the tool offers an `E. Export hardware report` option, which the README recommends because it captures the hardware configuration and BIOS at build time. Alternatively, the separate Hardware Sniffer project produces a `Report.json` plus an ACPI dump, and the user loads both into OpCore Simplify manually. From that report the tool selects ACPI patches and kexts. It integrates SSDTTime for common patches such as FakeEC, FixHPET, PLUG and RTCAWAC, and adds its own patches: redirecting the first CPU entry to an active CPU, disabling the UNC0 device, creating an RTC device for HEDT systems, fixing `_PRW` sleep values (GPRW, UPRW, HP special) so the machine does not wake immediately, and adding devices including ALS0, BUS0, MCHC, PMCR, PNLF, RMNE, IMEI, USBX and XOSI. Unsupported or unused PCI devices, such as a GPU, Wi-Fi card or NVMe controller, can be disabled through Optimus and Bumblebee methods or a disable-gpu property. Before each build the tool checks for and updates OpenCorePkg and kexts from Dortania Builds and GitHub releases. That means two runs on the same machine can produce different EFI contents, which is worth knowing if you are trying to reproduce an earlier build. ## Installing OpCore Simplify and building a first EFI There is no package to install. The README directs you to the repository's Code button, then Download ZIP, and to extract the archive wherever you want it. The launcher differs per platform. On Windows, run the batch file: ```bash OpCore-Simplify.bat ``` On macOS, run the command file: ```bash OpCore-Simplify.command ``` On Linux, the README says to run the Python script with an existing Python interpreter: ```bash python3 OpCore-Simplify.py ``` The repository root contains `OpCore-Simplify.bat`, `OpCore-Simplify.command`, `OpCore-Simplify.py`, an `updater.py` and a `Scripts/` directory, which matches those three entry points. After the launcher opens, the README's flow is: select the hardware report, let the Compatibility Checker show supported and unsupported devices and the macOS version your hardware supports, accept or adjust the default macOS version, review the ACPI patches and kexts, then choose Build OpenCore EFI. The tool downloads the needed OpenCorePkg and kext files during the build. You should end up with an EFI folder to copy onto the EFI partition of your install USB. ## Where OpCore Simplify stops helping The support tables are the boundary. Intel CPUs are listed from Nehalem and Westmere through Arrow Lake; AMD Ryzen and Threadripper require AMD Vanilla. Intel integrated graphics are covered from Iron Lake to Ice Lake, which means an Intel iGPU newer than 10th generation is not in the table. AMD discrete coverage names Navi 23, Navi 22 and Navi 21 plus older series. NVIDIA coverage is Kepler, Pascal, Maxwell, Fermi and Tesla, all of which sit outside what recent macOS releases support. If your GPU is not in those lists, the Compatibility Checker is where you find out, and the tool will not conjure support that macOS does not have. The README also marks custom ACPI patches, kexts and SMBIOS adjustments as not recommended, which is an odd thing for a customization tool to say and worth taking literally. Those options exist, but the defaults are the tested path. The updater is a second source of variability: because OpenCorePkg and kexts are fetched before each build, a config that worked last month may not be byte-identical today. ## OpCore Simplify against building from the Dortania guide by hand The real alternative is the manual route: work through the Dortania OpenCore Install Guide, pick each kext and SSDT yourself, and assemble config.plist in a plist editor. The difference is not effort, it is where the knowledge lives. Manual assembly forces you to learn why a given SSDT is present and what each kext does, so when a boot fails you have a mental model to debug against. OpCore Simplify front-loads that work into a hardware report and hands you a result. That trade is reasonable for a first build on well-covered hardware, where the defaults are likely to be close. It is a poor trade when your hardware sits near the edge of the support tables, because you inherit a configuration whose reasoning you did not write down. The README's own advice to read the Dortania guide alongside the tool is the honest position: the generated EFI is a starting point, not a substitute for understanding it. ## Licence, maintenance and the cost of keeping an EFI current OpCore Simplify is BSD-3-Clause, which permits use and redistribution with the licence text retained. That covers the tool. It does not cover OpenCorePkg or the kexts the tool downloads, each of which carries its own licence, so a redistributed EFI folder is a separate question from redistributing OpCore Simplify itself. This is a description of the licence identifier, not legal advice. The last push to the repository was on 2026-08-27. The repository is not archived. There are no retrieved releases, so the download path in the README is the ZIP archive of the main branch rather than a tagged version. Practically, that means updating the tool means re-downloading the branch, and because the build step fetches OpenCorePkg and kexts from upstream each time, an old copy of the tool will pull current components. Rebuilding an EFI you made months ago will not reproduce it exactly, and the README does not document rollback to a previous component set. ## Conclusion OpCore Simplify suits a builder who can already read the Dortania guide and wants a defensible starting EFI instead of assembling kexts by hand. It is the wrong tool if your GPU, Wi-Fi card or macOS target falls outside the supported tables and you expect the tool to fix that. Before trusting a build, open the Compatibility Checker and confirm your CPU, GPU and macOS version are listed, then keep the generated EFI on a USB stick you can rewrite. ## FAQ ### What is OpCore Simplify? It is a Python tool that builds an OpenCore EFI folder from a hardware report and ACPI dump. It selects ACPI patches and kexts automatically and downloads OpenCorePkg and kexts from Dortania Builds and GitHub releases before each build. ### How do I use OpCore Simplify on Linux? The README says to run OpCore-Simplify.py with an existing Python interpreter. The repository root contains OpCore-Simplify.py alongside the Windows and macOS launchers. ### How do I use OpCore Simplify? Download the ZIP from the repository, extract it, and run the launcher for your platform: OpCore-Simplify.bat on Windows, OpCore-Simplify.command on macOS, or OpCore-Simplify.py with an existing Python interpreter on Linux. Then select a hardware report, review the Compatibility Checker output, and choose Build OpenCore EFI. ### Is OpCore Simplify safe to run? The README does not document what the tool does with system data. What it does state is that it downloads OpenCorePkg and kexts from Dortania Builds and GitHub releases before each EFI build, and that the project is BSD-3-Clause licensed. ## Sources - [Issues](https://github.com/lzhoang2801/OpCore-Simplify/issues) - [License: BSD-3-Clause](https://github.com/lzhoang2801/OpCore-Simplify/blob/main/LICENSE) - [lzhoang2801/OpCore-Simplify on GitHub](https://github.com/lzhoang2801/OpCore-Simplify) - [Project website](https://lzhoang2801.github.io/gathering-files/opencore-efi) - [README](https://github.com/lzhoang2801/OpCore-Simplify/blob/main/README.md) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/lzhoang2801-opcore-simplify