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

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
  @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
  

  GPU-specific coordinates for MMA tile processing

• 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
  @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()
  

  Using low level warp GPU instructions ergonomically

• 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"
  

  Call a Mojo function from Python

• 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
  @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)
  

  Define a custom GPU subtraction kernel

• 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
  Mojo extension in VSCode