Modular 26.7: Opening up MAX

The headline of Modular 26.7 is one we've wanted to write for a long time: this release opens the MAX graph compiler, MAX runtime, and device extensibility hooks for everyone. This means that MAX is now fully source-available, and can be built and modified by hardware innovators, researchers, and everyone else who loves making accelerators go "brr." This release also brings an eager mode that gets you debugging custom ops in a fraction of the time, decision model support, and the next step in Mojo's growth into a systems programming language.

MAX is now fully source-available

At our recent ModCon conference, we committed to opening up MAX, and we're delivering on that promise.

The full source for MAX is now available: hardware backends, the graph compiler, the runtime, and more. Our new MAX License is intentionally permissive: you can use, modify, extend, and build commercial products with MAX, without licensing fees or royalties. If you've wanted to bring up MAX on your own accelerator, this is where to start, and you can see the existing implementation for NVIDIA, AMD, Apple Silicon, and CPUs as a reference point. We plan to release source for the MAX plugins for other chips, including Qualcomm Dragonfly and Google TPU, in the coming months.

Why not Apache 2.0?

The MAX License allows nearly everything Apache 2.0 does: use, modify, extend, and build commercial products with MAX, with no fees or royalties. The difference comes down to fragmentation. We’ve spent decades maintaining major open source projects and have seen the challenges they face. MAX aims to unify the programming model across hardware, and incompatible platform-specific versions would undermine that goal. The Modular alliance program is how we solve this, giving hardware vendors and partners a shared path to build on MAX without splintering the ecosystem. As with Mojo, we expect our approach to evolve as the technology matures and we hear from the community.

There's far more in the MAX source code than we can cover here, so we wrote a separate post on what's included and what you can build with it.

What's new in MAX

Eager mode for faster development

MAX has long had an advanced graph compiler that performs automatic fusion and other optimizations for peak performance. But during development, fast iteration often matters more than peak performance. MAX now has full eager mode support, including your custom ops, and it shares a single code path with the graph compiler, so the code you run in eager mode is the same as what you compile and ship.

Declare an op once, call it directly on a Tensor, then reuse it unchanged inside a compiled Module. That makes the development loop much faster: on a slice of Gemma 4 31B, eager mode reaches the first token in about 30 seconds, compared to about 110 seconds compiled.

Here’s an example of how eager mode works with custom ops:

n, w, c = custom.Symbols("n", "w", "c")
downsample = custom.declare(
    "downsample",
    inputs={"x": custom.TemplateType(DType.float32, [n, w, c])},
    outputs=[custom.TemplateType(DType.float32, [n, w // 2, c])],
    custom_extensions=["path/to/kernels"],
)

# Eager: runs immediately.
y = downsample(Tensor.ones([2, 8, 3]))        # shape (2, 4, 3)

# Compiled: same op inside a Module.
class Encoder(Module):
    def forward(self, x: Tensor) -> Tensor:
        return downsample(x) * 2.0

model = Encoder().compile(TensorType(DType.float32, ["batch", 8, 3], device=Encoder().device))
y = model(Tensor.ones([2, 8, 3]))             # same op, now compiled

Support for System One/decision models, new modalities, and more models

There’s been a lot of recent excitement about the new modality of System One/decision models, due to their ability to enable zero-shot classification in a very inexpensive manner. MAX has added initial support for these decision models, including Decider 2B, through the new v1/decisions and v1/systemone API endpoints.

MAX has also added support for MiMo-V2.6-Flash, GLM-5.3-Flash, and Muse-Glimmer, with KDA and sparse MLA.

In addition to new capabilities, we continue to improve existing model families. Several ops that used to round-trip through the CPU now run entirely on the GPU, which gives a 2.6x prefill speedup for Qwen and GLM models.

Mojo 1.2: growing into a systems language

With 1.0, Mojo proved itself as a language for high-performance code across heterogeneous hardware. Now we're leaning into the next phase of the Mojo roadmap: Mojo as a systems programming language.

Pattern matching

Mojo 1.2's flagship new feature is pattern matching. The match statement lets you replace long chains of conditionals with clear, structured cases, and the compiler can check that you've handled every one of them.

def classify_point(p: Tuple[Int, Int]) -> String:
    match p:
        case 0, 0:
            return "origin"
        case x, 0 if x < 0:
            return String("negative x-axis:", x)
        case x, 0:
            return String("x-axis:", x)
        case 0, y:
            return String("y-axis:", y)
        case x, y:
            return String("point:", x, ",", y)

As a bonus, it also works at compile-time:

def classify_type[T: AnyType]() -> String:
    comptime match T:
        case == Int:
            return "integer"
        case == String:
            return "string"
        case _:
            return "other"

More expressive traits and constraints

Structs can now explicitly opt out of trait conformance (for example, by declaring themselves not Movable), and where clauses accept an else branch so you can state exactly why a constraint failed. Both make generic code easier to read and easier to debug.

See the Mojo changelog for the full list of changes in 1.2.

Get started

• Upgrade with pip install --upgrade max
• Read the MAX License blog post and FAQ
• Explore the full MAX 26.7 changelog
• Check out the full Mojo 1.2 changelog

With the whole stack open, we can’t wait to see what you build. Share it on the Modular forum.