Inference Products
Shared Endpoints
Access frontier models via an API
Dedicated Endpoints
Mission critical reliability
Custom models
Your model, peak performance
Deployment Options
Our Cloud
Fully managed, pay by usage
Your Cloud
Modular stack in your VPC
Pricing
Flexible plans for every team
Models
FLUX.2 Klein 4B
GLM 5.3 Flash
MiniMax M3
GLM 5.3
View All
Text to audio
Turn text into natural speech
Image generation
Generate images from text prompts
Code generation
Generate production-ready code
Video generation
Generate video from text + image
Agentic
Deploy AI agents anywhere
Custom Models
Kernel-level model control
Case Studies
Proven results from real customers
Models
FLUX.2 Klein 4B
GLM 5.3 Flash
MiniMax M3
GLM 5.3
View All
Model Library
Latest supported open models
LLM Inference Handbook
How inference works, from basics to production
MAX LLM Book
Build a modern LLM from the ground up
Mojo Quest
Learn Mojo through guided challenges
Mojo GPU Puzzles
Hands-on GPU programming, puzzle by puzzle
MAX
GenAI native modeling & serving
Mojo
The systems language for the AI era
Modular alliance program
LLVM, but for AI
Self-Hosted
MAX+Mojo self-hosted by you
Community
Build the future of AI together
Agentic Skills
Official AI agent skills from Modular
Modular Cloud
Deploy GenAI models, our cloud or yours
MAX
GenAI native modeling & serving
Mojo
The systems language for the AI era
About
Build AI for anyone, anywhere.
Careers
👋 We’re currently hiring!
Culture
What we believe
Contact Us
Request a demo
October 22, 2026
Modular Team
Product
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.
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.
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.
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"],
)
y = downsample(Tensor.ones([2, 8, 3])) # shape (2, 4, 3)
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
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.
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.
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.
match
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"
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.
not Movable
where
else
pip install --upgrade max
With the whole stack open, we can’t wait to see what you build. Share it on the Modular forum.
MAX is now source available and open to everyone
October 22, 2026
Modular 26.5: Mojo 1.0 is here!
August 11, 2026
Modular 26.4: SOTA MoE Serving, Model Bringup via Agent Skills, Mojo 1.0 Beta 2 and More
June 18, 2026
Build the future of AI with Modular
Sign up today
Signup to our Cloud Platform today to get started easily.
Browse open models
Browse our model catalog, or deploy your own custom model
Get all our latest news, announcements and updates delivered directly to your inbox. Unsubscribe at anytime.
⚠️ This form requires JavaScript to function. Please enable JavaScript in your browser to continue.
Your data is handled in accordance with Modular's Privacy Policy.
Thanks for signing up to our newsletter! 🚀
Thank you,
Modular Sales Team