One language, any hardware. Systems-level performance. Pythonic syntax.

Why should I use Mojo?

• Easier

  GPU Programming Made Easy

  Traditionally, writing custom GPU code means diving into CUDA, managing memory, and compiling separate device code. Mojo simplifies the whole experience while unlocking top-tier performance on NVIDIA and AMD GPUs.

  Get Started With GPUs
    # GPU-specific coordinates for MMA tile processing
    @parameter
    for n_mma in range(num_n_mmas):
        alias mma_id = n_mma * num_m_mmas + m_mma
        var mask_frag_row = mask_warp_row + m_mma * MMA_M
        var mask_frag_col = mask_warp_col + n_mma * MMA_N
        @parameter
        if is_nvidia_gpu():
            mask_frag_row += lane // (MMA_N // p_frag_simdwidth)
            mask_frag_col += (lane * p_frag_simdwidth) % MMA_N
        elif is_amd_gpu():
            mask_frag_row += (lane // MMA_N) * p_frag_simdwidth
            mask_frag_col += lane % MMA_N
  

• Performant

  Bare metal performance on any GPU

  Get raw GPU performance without complex toolchains. Mojo makes it easy to write high-performance kernels with intuitive syntax, zero boilerplate, and native support for NVIDIA, AMD, and more.

  GPU Fundamentals
    # Using low level warp GPU instructions ergonomically
    
    @parameter
    for i in range(K):
        var reduced = top_k_sram[tid]
        alias limit = log2_floor(WARP_SIZE)
    
        @parameter
        for j in reversed(range(limit)):
            alias offset = 1 << j
            var shuffled = TopKElement(
                warp.shuffle_down(reduced.idx, offset),
                warp.shuffle_down(reduced.val, offset),
            )
            reduced = max(reduced, shuffled)
    
        barrier()
  

• Interoperable

  Use Mojo to extend python

  Mojo interoperates natively with Python so you can speed up bottlenecks without rewriting everything. Start with one function, scale as needed—Mojo fits into your codebase

  Intro to Python Interop
    if __name__ == "__main__":
        # Calling into a Mojo `passthrough` function from Python:
        result = hello_mojo.passthrough("Hello")
        print(result)
  

    fn passthrough(value: PythonObject) raises -> PythonObject:
        """A very basic function illustrating passing values to and from Mojo."""
        return value + " world from Mojo"
  

• Community

  Build with us in the open to create the future of AI

  Mojo has more than  750K+ lines of open-source code with an active community of 50K+ members. We're actively working to open even more to build a transparent, developer-first foundation for the future of AI infrastructure.

  View Open Kernel Repo
  750k

  lines of open-source code

• MOJO + MAX

  Write GPU Kernels with MAX

  Traditionally, writing custom GPU code means diving into CUDA, managing memory, and compiling separate device code. Mojo simplifies the whole experience while unlocking top-tier performance on NVIDIA and AMD GPUs.

  Read more
    # Define a custom GPU subtraction kernel
    
    @compiler.register("mo.sub")
    struct Sub:
        @staticmethod
        fn execute[target: StaticString, _trace_name: StaticString]
            z: FusedOutputTensor,
            x: FusedInputTensor,
            y: FusedInputTensor,
            ctx: DeviceContextPtr,
        capturing raises:
            @parameter
            @always_inline
            fn func[width: Int](idx: IndexList[z.rank]) -> SIMD[z.dtype, width]:
                var lhs = rebind[SIMD[z.dtype, width]](x._fused_load[width](idx))
                var rhs = rebind[SIMD[z.dtype, width]](y._fused_load[width](idx))
                return lhs - rhs
    
            foreach[
                func,
                target=target,
                _trace_name=_trace_name,
            ](z, ctx)
  

• Interoperable

  Powering Breakthroughs in Production AI

  Top AI teams use Mojo to turn ideas into optimized, low-level GPU code. From Inworld’s custom logic to Qwerky’s memory-efficient Mamba, Mojo delivers where performance meets creativity.

  Inworld Case Study

  Qwerky Case Study
  • Inworld

    Inworld used Mojo to define high-efficiency custom kernels to create things like a tailored silence-detection kernel that runs directly on the GPU.

  • Qwerky

    Mojo enables Qwerky to compile custom GPU kernels accelerating Mamba's linear-time complexity for conversation history

• Performant

  World-Class Tools, Out of the Box

  Mojo ships with a great VSCode debugger and works with dev tools like Cursor and Claude. Mojo makes modern dev workflows feel seamless.

  Get VSCode Extension