LIFT

Language for Intelligent Frameworks and Technologies

The first Intermediate Representation built natively for both AI and Quantum Computing.

Simulate before you run. Compile once. Optimise everywhere.

Overview

LIFT is a unified compiler infrastructure that treats AI computation (tensors, gradients, attention) and quantum computation (qubits, gates, noise models) as first-class citizens in the same SSA-based intermediate representation. One .lif source file, one .lith config, one pipeline: simulate, predict, optimise, compile.

 .lif source ──► LIFT-CORE (SSA IR) ──► SIMULATE ──► PREDICT ──► OPTIMISE ──► COMPILE
                      │                                                          │
          ┌───────────┼───────────┐                                 ┌────────────┼────────────┐
     LIFT-TENSOR  LIFT-QUANTUM  LIFT-HYBRID                    CUDA (GPU)   OpenQASM 3   LLVM (CPU)   ONNX
     110 tensor   48 gates     21 hybrid                      H100/A100    IBM/Rigetti   AVX-512      TensorRT
     operations   Kraus/QEC     VQC/VQE ops                    MI300        IonQ          OpenMP       PyTorch

Why LIFT?

No existing IR handles both AI and quantum in a single representation.

Key: Y = implemented, ~ = partial, - = not supported

What makes LIFT unique

1. One IR for AI + Quantum -- Both are equal citizens in the same SSA graph. Joint optimisation across classical and quantum operations.
2. Noise in the type system -- Every quantum gate carries T1/T2, fidelity, crosstalk metadata. The compiler reasons about noise at every stage.
3. Linear qubit types -- The no-cloning theorem enforced at compile time. Double-use of a qubit is a type error, not a runtime crash.
4. Simulation-first compilation -- FLOP count, peak memory, circuit depth, expected fidelity, energy cost -- all computed before hardware runs. Budget violations halt compilation with actionable suggestions.
5. One config language -- The .lith file replaces 6-8 separate configuration files across frameworks.

Architecture

  USER        .lif source  |  .lith config  |  lift(1) CLI
  FRONTEND    Lexer > Parser > AST > SSA Builder  |  Importers: ONNX, PyTorch FX, OpenQASM 3
  DIALECTS    LIFT-CORE  |  LIFT-TENSOR  |  LIFT-QUANTUM  |  LIFT-HYBRID
  ANALYSIS    Shape inference  |  FLOP count  |  Noise sim  |  Energy model  |  Roofline
  PASSES      TensorFusion  FlashAttention  GateCancellation  RotationMerge  LayoutMapping  CSE ...
  BACKENDS    CUDA (PTX)  |  OpenQASM 3  |  LLVM IR  |  ONNX (opset 21)  |  XLA (planned)
  HARDWARE    H100 / A100 / MI300  |  IBM Kyoto / Rigetti / IonQ  |  TPU

Crate Map

Quick Start

# Install Rust 1.80+
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Clone and build
git clone https://github.com/rustnew/Lift.git
cd lift
cargo build --release

# Run tests (535 tests)
cargo test --workspace

Example: Tensor Program

cat > hello.lif << 'EOF'
#dialect tensor
module @test {
    func @forward(%x: tensor<4xf32>) -> tensor<4xf32> {
        %out = "tensor.relu"(%x) : (tensor<4xf32>) -> tensor<4xf32>
        return %out
    }
}
EOF

lift verify  hello.lif    # Check IR well-formedness
lift analyse hello.lif    # FLOPs, shapes, memory estimate
lift print   hello.lif    # Pretty-print the IR

Example: Quantum Circuit

#dialect quantum
module @bell {
    func @bell_state() -> (bit, bit) {
        %q0 = "quantum.init"() : () -> qubit
        %q1 = "quantum.init"() : () -> qubit
        %q0 = "quantum.h"(%q0)         : (qubit) -> qubit
        %q0, %q1 = "quantum.cx"(%q0, %q1) : (qubit, qubit) -> (qubit, qubit)
        %b0 = "quantum.measure"(%q0) : (qubit) -> bit
        %b1 = "quantum.measure"(%q1) : (qubit) -> bit
        return %b0, %b1
    }
}

The .lith Configuration

One file controls the entire compilation pipeline:

compilation {
    target {
        gpu  { backend = "cuda"  arch = "sm_90"  memory_limit_gb = 80 }
        qpu  { provider = "ibm"  backend_name = "ibm_kyoto"  shots = 4096 }
    }
}
optimization {
    pipeline = ["canonicalize", "tensor-fusion", "gate-cancellation", "layout-mapping"]
}
prediction {
    budget { max_latency_ms = 200  min_fidelity = 0.92  max_memory_gb = 40 }
}

Optimisation Passes

Current Status

Test suite: 535 tests, 100% pass rate across 14 crates.

Roadmap

Contributing

See CONTRIBUTING.md for code style and PR process.

Citation

@software{lift2025,
  title  = {LIFT: Language for Intelligent Frameworks and Technologies},
  author = {Martial-FOSSOUO},
  year   = {2025},
  url    = {https://github.com/lift-framework/lift},
  note   = {Unified IR for AI and Quantum Computing}
}

License

MIT -- see LICENSE.