PennyLaneAI · rniczh · Nov 28, 2025 · Oct 12, 2025 · Oct 16, 2025 · Oct 16, 2025
diff --git a/.dep-versions b/.dep-versions
@@ -1,7 +1,7 @@
 # Always update the version check in catalyst.__init__ when changing the JAX version.
 # To update JAX version alongside compatible dependency tags, run the following script:
 # python3 .github/workflows/set_dep_versions.py {JAX_version}
-jax=0.6.2
+jax=0.7.0
 stablehlo=0a4440a5c8de45c4f9649bf3eb4913bf3f97da0d
 llvm=113f01aa82d055410f22a9d03b3468fa68600589
 enzyme=v0.0.203
@@ -10,7 +10,9 @@ enzyme=v0.0.203
 
 # For a custom PL version, update the package version here and at
 # 'doc/requirements.txt'
-pennylane=0.44.0.dev31
+# TODO: uncomment and update to latest version of pennylane
+#       after https://github.com/PennyLaneAI/pennylane/pull/8525 is merged.
+# pennylane=0.44.0.dev31
 
 # For a custom LQ/LK version, update the package version here and at
 # 'doc/requirements.txt'

diff --git a/Makefile b/Makefile
@@ -117,6 +117,8 @@ frontend:
 	# versions of a package with the same version tag (e.g. 0.38-dev0).
 	$(PYTHON) -m pip uninstall -y pennylane
 	$(PYTHON) -m pip install -e . --extra-index-url https://test.pypi.org/simple $(PIP_VERBOSE_FLAG)
+    # TODO: remove after https://github.com/PennyLaneAI/pennylane/pull/8525 is merged.
+	$(PYTHON) -m pip install git+https://github.com/PennyLaneAI/pennylane@bump-jax-api-hashability
 	rm -r frontend/pennylane_catalyst.egg-info
 
 .PHONY: mlir llvm stablehlo enzyme dialects runtime oqc
@@ -134,7 +136,7 @@ enzyme:
 
 dialects:
 	$(MAKE) -C mlir dialects
-	
+
 .PHONY: dialect-docs
 dialect-docs:
 	$(MAKE) -C mlir dialect-docs

diff --git a/doc/releases/changelog-dev.md b/doc/releases/changelog-dev.md
@@ -69,6 +69,13 @@
 
 <h3>Improvements 🛠</h3>
 
+* Remove the hardcoded list of runtime operations in the frontend.
+  This will allow arbitrary PL gates to be represented without hyperparameters in MLIR.
+  For gates that do not have a QIR representation, a runtime error will be raised at execution.
+  Users can still decompose these gates via `qml.transforms.decompose`
+  when both capture and graph-decomposition are enabled.
+  [(#2215)](https://github.com/PennyLaneAI/catalyst/pull/2215)
+
 * `qml.PCPhase` can be compiled and executed with capture enabled.
   [(#2226)](https://github.com/PennyLaneAI/catalyst/pull/2226)
 

diff --git a/frontend/catalyst/__init__.py b/frontend/catalyst/__init__.py
@@ -18,12 +18,11 @@
 # pylint: disable=wrong-import-position
 
 import sys
-import types
 from os.path import dirname
 
 import jaxlib as _jaxlib
 
-_jaxlib_version = "0.6.2"
+_jaxlib_version = "0.7.0"
 if _jaxlib.__version__ != _jaxlib_version:
     import warnings
 

diff --git a/frontend/catalyst/autograph/ag_primitives.py b/frontend/catalyst/autograph/ag_primitives.py
@@ -62,7 +62,7 @@ def get_program_length(reference_tracers):
 
     if EvaluationContext.is_tracing():  # pragma: no branch
         jaxpr_frame = EvaluationContext.find_jaxpr_frame(reference_tracers)
-        num_jaxpr_eqns = len(jaxpr_frame.eqns)
+        num_jaxpr_eqns = len(jaxpr_frame.tracing_eqns)
 
     if EvaluationContext.is_quantum_tracing():
         quantum_queue = EvaluationContext.find_quantum_queue()
@@ -79,8 +79,8 @@ def reset_program_to_length(reference_tracers, num_jaxpr_eqns, num_tape_ops):
 
     if EvaluationContext.is_tracing():  # pragma: no branch
         jaxpr_frame = EvaluationContext.find_jaxpr_frame(reference_tracers)
-        while len(jaxpr_frame.eqns) > num_jaxpr_eqns:
-            jaxpr_frame.eqns.pop()
+        while len(jaxpr_frame.tracing_eqns) > num_jaxpr_eqns:
+            jaxpr_frame.tracing_eqns.pop()
 
     if EvaluationContext.is_quantum_tracing():
         quantum_queue = EvaluationContext.find_quantum_queue()

diff --git a/frontend/catalyst/device/qjit_device.py b/frontend/catalyst/device/qjit_device.py
@@ -56,44 +56,6 @@
 logger = logging.getLogger(__name__)
 logger.addHandler(logging.NullHandler())
 
-RUNTIME_OPERATIONS = [
-    "CNOT",
-    "ControlledPhaseShift",
-    "CRot",
-    "CRX",
-    "CRY",
-    "CRZ",
-    "CSWAP",
-    "CY",
-    "CZ",
-    "Hadamard",
-    "Identity",
-    "IsingXX",
-    "IsingXY",
-    "IsingYY",
-    "IsingZZ",
-    "SingleExcitation",
-    "DoubleExcitation",
-    "ISWAP",
-    "MultiRZ",
-    "PauliX",
-    "PauliY",
-    "PauliZ",
-    "PCPhase",
-    "PhaseShift",
-    "PSWAP",
-    "QubitUnitary",
-    "Rot",
-    "RX",
-    "RY",
-    "RZ",
-    "S",
-    "SWAP",
-    "T",
-    "Toffoli",
-    "GlobalPhase",
-]
-
 RUNTIME_OBSERVABLES = [
     "Identity",
     "PauliX",
@@ -109,11 +71,9 @@
 
 RUNTIME_MPS = ["ExpectationMP", "SampleMP", "VarianceMP", "CountsMP", "StateMP", "ProbabilityMP"]
 
-# The runtime interface does not care about specific gate properties, so set them all to True.
-RUNTIME_OPERATIONS = {
-    op: OperatorProperties(invertible=True, controllable=True, differentiable=True)
-    for op in RUNTIME_OPERATIONS
-}
+# A list of custom operations supported by the Catalyst compiler.
+# This is useful especially for testing a device with custom operations.
+CUSTOM_OPERATIONS = {}
 
 RUNTIME_OBSERVABLES = {
     obs: OperatorProperties(invertible=True, controllable=True, differentiable=True)
@@ -199,6 +159,14 @@ def extract_backend_info(device: qml.devices.QubitDevice) -> BackendInfo:
     return BackendInfo(dname, device_name, device_lpath, device_kwargs)
 
 
+def union_operations(
+    a: Dict[str, OperatorProperties], b: Dict[str, OperatorProperties]
+) -> Dict[str, OperatorProperties]:
+    """Union of two sets of operator properties"""
+    return {**a, **b}
+    # return {k: a[k] & b[k] for k in (a.keys() & b.keys())}
+
+
 def intersect_operations(
     a: Dict[str, OperatorProperties], b: Dict[str, OperatorProperties]
 ) -> Dict[str, OperatorProperties]:
@@ -223,8 +191,8 @@ def get_qjit_device_capabilities(target_capabilities: DeviceCapabilities) -> Dev
     qjit_capabilities = deepcopy(target_capabilities)
 
     # Intersection of gates and observables supported by the device and by Catalyst runtime.
-    qjit_capabilities.operations = intersect_operations(
-        target_capabilities.operations, RUNTIME_OPERATIONS
+    qjit_capabilities.operations = union_operations(
+        target_capabilities.operations, CUSTOM_OPERATIONS
     )
     qjit_capabilities.observables = intersect_operations(
         target_capabilities.observables, RUNTIME_OBSERVABLES

diff --git a/frontend/catalyst/from_plxpr/control_flow.py b/frontend/catalyst/from_plxpr/control_flow.py
@@ -25,7 +25,11 @@
 from pennylane.capture.primitives import for_loop_prim as plxpr_for_loop_prim
 from pennylane.capture.primitives import while_loop_prim as plxpr_while_loop_prim
 
-from catalyst.from_plxpr.from_plxpr import PLxPRToQuantumJaxprInterpreter, WorkflowInterpreter
+from catalyst.from_plxpr.from_plxpr import (
+    PLxPRToQuantumJaxprInterpreter,
+    WorkflowInterpreter,
+    _tuple_to_slice,
+)
 from catalyst.from_plxpr.qubit_handler import (
     QubitHandler,
     QubitIndexRecorder,
@@ -101,16 +105,21 @@ def _to_bool_if_not(arg):
 
 @WorkflowInterpreter.register_primitive(plxpr_cond_prim)
 def workflow_cond(self, *plxpr_invals, jaxpr_branches, consts_slices, args_slice):
-    """Handle the conversion from plxpr to Catalyst jaxpr for the cond primitive"""
-    args = plxpr_invals[args_slice]
+    """Handle the conversion from plxpr to Catalyst jaxpr for the cond primitive
+
+    Args:
+        consts_slices: List of tuples (start, stop, step) to slice consts for each branch
+        args_slice: Tuple (start, stop, step) to slice args from plxpr_invals
+    """
+    args = plxpr_invals[_tuple_to_slice(args_slice)]
     converted_jaxpr_branches = []
     all_consts = []
 
     # Convert each branch from plxpr to jaxpr
     for const_slice, plxpr_branch in zip(consts_slices, jaxpr_branches):
 
         # Store all branches consts in a flat list
-        branch_consts = plxpr_invals[const_slice]
+        branch_consts = plxpr_invals[_tuple_to_slice(const_slice)]
 
         evaluator = partial(copy(self).eval, plxpr_branch, branch_consts)
         new_jaxpr = jax.make_jaxpr(evaluator)(*args)
@@ -132,8 +141,13 @@ def workflow_cond(self, *plxpr_invals, jaxpr_branches, consts_slices, args_slice
 
 @PLxPRToQuantumJaxprInterpreter.register_primitive(plxpr_cond_prim)
 def handle_cond(self, *plxpr_invals, jaxpr_branches, consts_slices, args_slice):
-    """Handle the conversion from plxpr to Catalyst jaxpr for the cond primitive"""
-    args = plxpr_invals[args_slice]
+    """Handle the conversion from plxpr to Catalyst jaxpr for the cond primitive
+
+    Args:
+        consts_slices: List of tuples (start, stop, step) to slice consts for each branch
+        args_slice: Tuple (start, stop, step) to slice args from plxpr_invals
+    """
+    args = plxpr_invals[_tuple_to_slice(args_slice)]
     self.init_qreg.insert_all_dangling_qubits()
 
     dynalloced_qregs, dynalloced_wire_global_indices = _get_dynamically_allocated_qregs(
@@ -154,7 +168,7 @@ def handle_cond(self, *plxpr_invals, jaxpr_branches, consts_slices, args_slice):
     for const_slice, plxpr_branch in zip(consts_slices, jaxpr_branches):
 
         # Store all branches consts in a flat list
-        branch_consts = plxpr_invals[const_slice]
+        branch_consts = plxpr_invals[_tuple_to_slice(const_slice)]
 
         converted_jaxpr_branch = None
         closed_jaxpr = ClosedJaxpr(plxpr_branch, branch_consts)
@@ -205,11 +219,17 @@ def workflow_for_loop(
     args_slice,
     abstract_shapes_slice,
 ):
-    """Handle the conversion from plxpr to Catalyst jaxpr for the for loop primitive"""
+    """Handle the conversion from plxpr to Catalyst jaxpr for the for loop primitive
+
+    Args:
+        consts_slice: Tuple (start, stop, step) to slice consts from plxpr_invals
+        args_slice: Tuple (start, stop, step) to slice args from plxpr_invals
+        abstract_shapes_slice: Tuple (start, stop, step) to slice abstract shapes
+    """
     assert jaxpr_body_fn is not None
-    args = plxpr_invals[args_slice]
+    args = plxpr_invals[_tuple_to_slice(args_slice)]
 
-    consts = plxpr_invals[consts_slice]
+    consts = plxpr_invals[_tuple_to_slice(consts_slice)]
 
     converter = copy(self)
     evaluator = partial(converter.eval, jaxpr_body_fn, consts)
@@ -250,9 +270,15 @@ def handle_for_loop(
     args_slice,
     abstract_shapes_slice,
 ):
-    """Handle the conversion from plxpr to Catalyst jaxpr for the for loop primitive"""
+    """Handle the conversion from plxpr to Catalyst jaxpr for the for loop primitive
+
+    Args:
+        consts_slice: Tuple (start, stop, step) to slice consts from plxpr_invals
+        args_slice: Tuple (start, stop, step) to slice args from plxpr_invals
+        abstract_shapes_slice: Tuple (start, stop, step) to slice abstract shapes
+    """
     assert jaxpr_body_fn is not None
-    args = plxpr_invals[args_slice]
+    args = plxpr_invals[_tuple_to_slice(args_slice)]
 
     # Add the iteration start and the qreg to the args
     self.init_qreg.insert_all_dangling_qubits()
@@ -268,7 +294,7 @@ def handle_for_loop(
         self.init_qreg.get(),
     ]
 
-    consts = plxpr_invals[consts_slice]
+    consts = plxpr_invals[_tuple_to_slice(consts_slice)]
 
     jaxpr = ClosedJaxpr(jaxpr_body_fn, consts)
 
@@ -326,10 +352,16 @@ def workflow_while_loop(
     cond_slice,
     args_slice,
 ):
-    """Handle the conversion from plxpr to Catalyst jaxpr for the while loop primitive"""
-    consts_body = plxpr_invals[body_slice]
-    consts_cond = plxpr_invals[cond_slice]
-    args = plxpr_invals[args_slice]
+    """Handle the conversion from plxpr to Catalyst jaxpr for the while loop primitive
+
+    Args:
+        body_slice: Tuple (start, stop, step) to slice body consts from plxpr_invals
+        cond_slice: Tuple (start, stop, step) to slice cond consts from plxpr_invals
+        args_slice: Tuple (start, stop, step) to slice args from plxpr_invals
+    """
+    consts_body = plxpr_invals[_tuple_to_slice(body_slice)]
+    consts_cond = plxpr_invals[_tuple_to_slice(cond_slice)]
+    args = plxpr_invals[_tuple_to_slice(args_slice)]
 
     evaluator_body = partial(copy(self).eval, jaxpr_body_fn, consts_body)
     new_body_jaxpr = jax.make_jaxpr(evaluator_body)(*args)
@@ -367,14 +399,20 @@ def handle_while_loop(
     cond_slice,
     args_slice,
 ):
-    """Handle the conversion from plxpr to Catalyst jaxpr for the while loop primitive"""
+    """Handle the conversion from plxpr to Catalyst jaxpr for the while loop primitive
+
+    Args:
+        body_slice: Tuple (start, stop, step) to slice body consts from plxpr_invals
+        cond_slice: Tuple (start, stop, step) to slice cond consts from plxpr_invals
+        args_slice: Tuple (start, stop, step) to slice args from plxpr_invals
+    """
     self.init_qreg.insert_all_dangling_qubits()
     dynalloced_qregs, dynalloced_wire_global_indices = _get_dynamically_allocated_qregs(
         plxpr_invals, self.qubit_index_recorder, self.init_qreg
     )
-    consts_body = plxpr_invals[body_slice]
-    consts_cond = plxpr_invals[cond_slice]
-    args = plxpr_invals[args_slice]
+    consts_body = plxpr_invals[_tuple_to_slice(body_slice)]
+    consts_cond = plxpr_invals[_tuple_to_slice(cond_slice)]
+    args = plxpr_invals[_tuple_to_slice(args_slice)]
     args_plus_qreg = [
         *args,
         *[dyn_qreg.get() for dyn_qreg in dynalloced_qregs],