Linux host · Classic PowerPC output

Build ClassicPowerPC Macintoshsoftware from Linux.

macMAKE is a Linux-native development toolchain for Classic Mac OS PowerPC applications, featuring CodeWarrior-style project semantics, native CFM linking, PEF generation, resource processing, and Macintosh application packaging.

See how it works Explore the CLI reference Prompt for your coding agent ↓

Latest public release: v0.1.1. Real-guest runtime acceptance on Mac OS 9.2.2 is verified.

macMAKE v0.1.1 adds experimental, bounded native M68000 C application builds.

For coding agents

Give your agent the macMAKE workflow.

Copy this offline-first setup prompt into your coding agent. It explains how to locate only the MSL and Universal Interfaces files a project needs, then directs the agent to discover the installed CLI, inspect your project, build, and validate artifacts without guessing the manifest format.

The prompt stays in your browser. It is not sent to MPLS LLC.

Preview the prompt

I want to build or troubleshoot a Classic Macintosh application in this project using the installed macMAKE version on Linux.

Scope: macMAKE v0.1.1 is the latest public release for Linux x86-64. It builds Classic PowerPC CFM/PEF applications primarily in C, and adds a bounded experimental native M68000 segmented C profile. It is not CFM-68K or general System 6–9 compatibility. Earlier PowerPC System 7 and Mac OS 8 versions have not yet been verified. Native 68K and Mac OS X boundaries are described on the compatibility page. makePAD was observed in QEMU Mac OS 9.2.2 accepting text, showing its unsaved-changes dialog, and returning to Finder, with real-guest runtime acceptance verified. Runtime evidence is application-, macMAKE-build-, and OS-specific. Read https://macmake.dev/compatibility/ and use the installed CLI's `macmake help` to confirm what that exact version supports. Do not invent capabilities or infer runtime support from a successful Linux build.

Start with the installed macMAKE executable as the source of truth. Do not guess commands, flags, or manifest keys from another version.

1. Discover the local interface:
   macmake --version
   macmake help
   macmake help --all --json
   macmake schema manifest --json
   Use focused help such as `macmake help build`, `macmake help manifest`, and `macmake help sdk` when needed.
2. Read this repository's AGENTS.md and project documentation. Find the project manifest and inspect it with `macmake inspect PROJECT`. Identify the exact target name from the project and CLI output. Do not invent target architectures, OS support, SDK paths, or manifest options.
3. Begin with read-only checks: `macmake sdk list` and `macmake doctor PROJECT --target "EXACT TARGET"`. Follow the installed CLI's help for the exact syntax and interpret diagnostics before changing files.
4. If a manifest needs to be created or corrected, read `macmake help manifest` and the JSON schema first. Use only supported fields and values. For a CodeWarrior project, check `macmake help import-cw-xml` if an XML project export is available.
5. The separate dependency repository is https://github.com/mplsllc/macMAKELibs.git. Use `macmake sdk fetch --minimal` only if this command appears in the installed CLI's help and the project requests the matching PPC C SDK profile. It fetches a pinned subset; it is not a license grant. Otherwise inspect an existing authorized checkout or use Git sparse checkout. For a Classic PowerPC C project, relevant locations can include `MSL_C/MSL_Common/Include`, `MSL_C/MSL_MacOS/Include`, `MSL_C/MSL_MacOS/Lib/PPC`, `MSL_Extras/MSL_Common/Include`, `MSL_Extras/MSL_MacOS/Include`, `MSL_Extras/MSL_MacOS/Lib/PPC`, `MSL_Runtime_PPC_D.Lib` at the repository root, `Universal/Interfaces/CIncludes`, `Universal/Interfaces/ComponentIncludes`, `Universal/Interfaces/RIncludes`, and `Universal/Libraries`. Do not fetch `MSL_C++`, Win32, Mach-O, or unrelated API trees for a CFM/PEF C target. Use only materials you are authorized to use. Confirm exact inputs from the installed CLI and project diagnostics; never invent SDK paths or runtime requirements. Register the actual Universal Interfaces root with `macmake sdk add PATH --id macos9-sdk` only when the manifest requires it; this changes the user SDK catalog.
6. When the project and providers are ready and a build is requested, run `macmake build PROJECT --target "EXACT TARGET"`. The build writes generated files. Do not run `macmake clean` without asking first because it deletes generated outputs. Do not stage or copy Macintosh files unless I requested it.
7. Read the build evidence and inspect the generated PEF, resources, Finder metadata, and MacBinary output using `macmake help inspect-artifact` for the exact options. Report artifact paths, structural validation results, and useful error output.
8. Separate Linux build/structural checks from Mac OS 9 runtime behavior. Do not run QEMU or claim the application launches in Mac OS 9 unless I confirm that guest test.
9. `macmake run` supports an interactive QEMU Mac OS 9.2.2 profile; it does not transfer a host artifact into HFS, automate Finder, or independently assert application behavior. Keep host structural checks separate from guest observations.
10. Make the smallest project change that addresses a diagnosed problem. Do not modify original application sources unless needed for my request. Explain what changed and what remains unresolved.

If `macmake` is not installed, read https://macmake.dev/install.html and use the official installer. The installer is per-user and needs no root access. For a project-specific manual dependency checkout, use sparse checkout to fetch only the paths the manifest and diagnostics require; do not download unrelated architectures or language runtimes. After a successful installer run it sends a best-effort install-completion event to Umami unless disabled. Tell me before installing and offer `--no-analytics` or `MACMAKE_DISABLE_ANALYTICS=1`; the event counts successful installer runs, not unique machines. If installation fails, report that clearly and stop installation.

One native workflow

From source files to a transport-ready application.

Use one project manifest and the ordinary macmake commands for the supported build path.

01
Describe the project

Declare targets, source membership, access paths, runtime inputs, resources, and application metadata in macmake.toml.
02
Compile and link

Build a PowerPC CFM application with the bundled Linux toolchain and authorized SDK and runtime files you provide.
03
Inspect and package

Validate PEF structure, compose resources and Finder metadata, and write a MacBinary II application package.

Built for the classic target

A focused toolchain for the work at hand.

C-first projects

The qualified v0.1.1 C paths target Classic PowerPC CFM/PEF; an independent M68000 path is experimental and bounded.

Classic PowerPC output

Link CFM imports and produce PEF executables with resources and Finder metadata.

Discoverable CLI

Command help, a manifest schema, and agent workflows are available offline in the executable.

Compatibility

Designed around CodeWarrior project semantics.

macMAKE v0.1.1 is the latest public release for Linux x86-64. It qualifies Classic PowerPC CFM/PEF C application builds and includes a bounded experimental native M68000 C profile. makePAD was observed running under QEMU Mac OS 9.2.2, with real-guest runtime acceptance verified. This is one app-specific result, not universal runtime compatibility. CFM-68K and Mac OS X targets are unsupported, and Apple/Metrowerks SDK materials are not included.

Review OS-by-OS evidence