One wooden crate divided in two, the left half open showing dense machined gears and copper tubing, the right half sealed under a bolted steel lid and a closed padlock, photoreal  # Qualcomm Open Sourced the Mojo Compiler. The Runtime You Actually Ship Didn't Come With It.  On 18 August Modular published the Mojo compiler and toolchain under Apache 2.0 with LLVM exceptions, a week after the language hit 1.0. Four years of an open community around a closed compiler ended in one commit.  Two things did not travel with it. The README says the project is not accepting compiler contributions yet, with end of year as the target. And MAX, the inference engine you would actually deploy, sits in the same repository under a different license.  Read the license per layer, not per repository. The compiler gives you exit rights. The runtime gives you terms.  ## The split runs down the middle of one repo  github.com/modular/modular holds both halves. The README states the repository is licensed under Apache 2.0 with LLVM exceptions, then notes separately that MAX usage and distribution are governed by the Modular Community License. One clone, two grants.  The Apache side covers the language: compiler, toolchain, standard library. The standard library has taken outside patches since 2024 and the MAX kernels opened in 2025, so the compiler was the last closed piece, and now it is public.  The Community License side covers MAX. It lets you prepare derivative works and sublicense and distribute them in object code form. Object code form is the phrase to sit with. You can ship something built on MAX. You cannot hand someone the modified source of the runtime the way Apache would let you.  The terms did get looser, and that deserves saying plainly. The old MAX license capped free production use at eight accelerators outside x86, Arm and NVIDIA, and required written permission before running on custom hardware. Both requirements are gone. If you evaluated MAX last year and filed it under vendor lock-in, the arithmetic has changed since.  ## Contributions are the actual steering wheel  Verbatim from the repository: "We aren't accepting contributions to the Mojo compiler yet."  That sentence carries the governance story, not the license file. A license decides what you may do with the code you already have. The contribution policy decides whether the code you have resembles the code that ships next quarter. Those are two different questions and right now they have two different answers.  Ownership is why it is worth tracking. Qualcomm completed its acquisition of Modular on 29 July for roughly $4 billion in stock, with Chris Lattner moving into an EVP role over advanced AI software and platforms. Mojo's entire pitch is hardware neutrality: x86 and Arm CPUs, NVIDIA and AMD GPUs, Apple Silicon, Google TPUs, AWS Trainium, and Qualcomm's own Cloud AI 100 Ultra and Dragonfly accelerators. That list is now curated by a company that sells two entries on it.  None of that is sinister, and publishing the compiler is a genuine check against the obvious worry. But when the AMD backend and the Qualcomm backend both want engineering attention in the same sprint, the license does not adjudicate. Headcount does, and headcount reports to Qualcomm.  ## What Apache 2.0 actually buys you  The reflex answer is that you can fork it. Price that against the work. Forking a compiler that targets seven hardware families means owning LLVM backend maintenance, kernel libraries, and a test matrix spanning ROCm and CUDA versions. Modular reached state of the art on AMD's MI355 in fourteen days using the people who wrote the compiler. Your fork does not have those people.  The realistic value is narrower, and still worth having.  Continuity is the big one. If a backend you depend on gets deprioritized, the code does not vanish along with the roadmap decision. You can pin a commit, carry a patch, and keep shipping while you plan a migration on your own schedule instead of a vendor's.  Audit is the second. When a kernel runs slower than the hardware should allow, you can read the lowering yourself rather than filing a ticket and waiting for someone to reproduce it.  Reproducibility is the third. Building from source against a pinned commit takes your build off a vendor's binary release cadence.  Exit, sight, and reproducibility. Not a vote on direction.  ## The clause your agents should read  One provision in the Community License deserves surfacing for anyone pointing coding agents at their dependency tree.  MAX may not be used as training data, fine-tuning data, or input to any AI system in order to produce software that reimplements or substitutes for MAX. Modular's FAQ draws the line explicitly: you cannot feed the source to a model to generate a reimplementation, a port to another language, or a substitute runtime. You can use AI tools to read, analyze, improve or explain MAX, and to build software that runs on or interoperates with it.  Take that as written, because it was written with care. Comprehension is permitted. Competitive regeneration is not.  The hard part is that your tooling cannot see the difference. An engineer asking an agent to explain how MAX schedules work across devices is on the permitted side. The same engineer in the same session asking for a minimal version that does the same thing has crossed. Same tool, same context window, same source file loaded.  Expect more source-available licenses to draw this boundary, because that is where the commercial exposure sits. If your dependency policy tracks SPDX identifiers and nothing else, it does not capture this at all. The check that would catch it is not a scanner, it is knowing which of your dependencies carry source-available terms and telling the people running agents which ones those are.  ## Three questions before you depend on it  Which layer am I depending on? The compiler and language are Apache 2.0, so fork freely. The runtime is Community License, so read it properly.  What happens if my hardware target gets deprioritized? Apache covers the compiler, so carrying a patch is available to you. Budget the effort rather than assuming the option is free.  Does my AI usage policy distinguish reading source from regenerating it? For source-available dependencies, that distinction is now contractual rather than cultural.  The compiler going public is good news, and Lattner licensing it the way he licensed LLVM and Swift is a deliberate signal to systems people who have been burned before. It reads as credible because the same person made the same call twice.  Just do not let the Apache badge on the repository answer a question about the artifact you are actually linking against. In this repository those are different files with different rules, and the one that runs in production is the one with terms.