mlir-rs/melior

The rustic MLIR bindings in Rust

What it solves

Melior provides a safe and complete Rust API for interacting with MLIR (Multi-Level Intermediate Representation), removing the need to work directly with the complex and potentially unsafe MLIR C API.

How it works

It acts as a high-level wrapper around the MLIR C API, utilizing Rust's type system to implement a more sane ownership model for MLIR objects. It maps C-style creation and getter functions to idiomatic Rust naming conventions and handles the conversion of strings to UTF-8.

Who it’s for

Developers building compilers or machine learning frameworks in Rust who need to leverage the power of MLIR for intermediate representation and optimization.

Highlights

  • Type-Safe Wrapper: Simplifies the MLIR C API into a more accessible Rust interface.
  • Ownership Management: Uses specific naming conventions (e.g., Ref suffixes for borrowed objects) to manage MLIR's loose ownership model.
  • Dialect Support: Allows for the registration and loading of various MLIR dialects.
  • Crate Integration: Easily installable via cargo add melior.

Related

  • Project
    google/heir

    An MLIR-based compiler toolchain for homomorphic encryption that allows developers to write encrypted computations and deploy them across multiple HE libraries and schemes.

  • Project
    graniet/llm

    A Rust library providing a unified API to interact with multiple LLM backends, enabling multi-step chains, agentic workflows, and a standardized REST API.

  • Project
    chelsea0x3b/cudarc

    A minimal and safe Rust API wrapper for the NVIDIA CUDA toolkit, providing ergonomic abstractions for GPU memory management and kernel execution.

  • Project
    numba/llvmlite

    A lightweight Python binding for LLVM that simplifies the creation of JIT compilers by providing a stable interface to LLVM's IR builder, optimizer, and JIT compiler APIs.

  • Project
    Abraxas-365/langchain-rust

    langchain-rust is a Rust implementation of LangChain, providing a framework for building LLM-powered applications with composable chains, agents, memory, document loaders, and integrations with many LLMs, embedding models, and vector stores.