Skip to content
BranchesTags

Repository files navigation

TestsCoverageDocumentationDOIPyPIForumLicense

Catalyst is an experimental package that enables just-in-time (JIT) compilation of hybrid quantum-classical programs.

Catalyst is currently under heavy development — if you have suggestions on the API or use-cases you'd like to be covered, please open an GitHub issue or reach out. We'd love to hear about how you're using the library, collaborate on development, or integrate additional devices and frontends.

Key Features

  • Compile the entire quantum-classical workflow, including any optimization loops.

  • Use Catalyst alongside PennyLane directly from Python. Simply decorate quantum code and hybrid functions with @qjit, leading to significant performance improvements over standard Python execution.

  • Access advanced control flow that supports both quantum and classical instructions.

  • Infrastructure for both quantum and classical compilation, allowing you to compile quantum circuits that contain control flow.

  • Built to be end-to-end differentiable.

  • Support for PennyLane-Lightning high performance simulators, and Amazon Braket devices. Additional hardware support, including QPUs, to come.

Overview

Catalyst currently consists of the following components:

  • Catalyst Compiler.

    The core Catalyst compiler is built using MLIR, with the addition of a quantum dialect used to represent quantum instructions. This allows for a high-level intermediate representation of the classical and quantum components of the program, resulting in advantages during optimization. Once optimized, the compiler lowers the representation down to LLVM + QIR, and a machine binary is produced.

  • Catalyst Runtime.

    The runtime is a C++ runtime with multiple-device support based on QIR that enables the execution of Catalyst-compiled quantum programs. A complete list of all backend devices along with the quantum instruction set supported by these runtime implementations can be found by visiting the runtime documentation.

In addition, we also provide a Python frontend for PennyLane and JAX:

  • PennyLane JAX frontend.

    A Python library that provides a @qjit decorator to just-in-time compile PennyLane hybrid quantum-classical programs. In addition, the frontend package provides Python functions for defining Catalyst-compatible control flow structures, gradient, and mid-circuit measurement.

Installation

Catalyst is officially supported on Linux (x86_64, aarch64) and macOS (arm64, x86_64) platforms, and pre-built binaries are being distributed via the Python Package Index (PyPI) for Python versions 3.10 and higher. To install it, simply run the following pip command:

pip install pennylane-catalyst

If you wish to contribute to Catalyst or develop against our runtime or compiler, instructions for building from source are also available.

Trying Catalyst with PennyLane

To get started using the Catalyst JIT compiler from Python, check out our quick start guide, as well as our various examples and tutorials in our documentation.

For an introduction to quantum computing and quantum machine learning, you can also visit the PennyLane website for tutorials, videos, and demonstrations.

Roadmap

  • Frontend: As we continue to build out Catalyst, the PennyLane frontend will likely be upstreamed into PennyLane proper, providing native JIT functionality built-in to PennyLane. The Catalyst compiler and runtime will remain part of the Catalyst project. If you are interested in working on additional frontends for Catalyst, please get in touch.

  • Compiler: We will continue to build out the compiler stack, and add quantum compilation routines. This includes an API for providing or writing Catalyst-compatible compilation routines. In addition, we will be improving the autodifferentiation support, and adding support for classical autodiff, additional quantum gradients, and quantum-aware optimization methods.

  • Runtime: We will be adding support for more devices, including quantum hardware devices. In addition, we will be building out support for hetereogeneous execution. If you are interested in working on connecting a quantum device with Catalyst, please get in touch.

To get the details right, we need your help — please send us your use cases by starting a conversation, or trying Catalyst out.

Contributing to Catalyst

We welcome contributions — simply fork the Catalyst repository, and then make a pull request containing your contribution.

We also encourage bug reports, suggestions for new features and enhancements.

Support

If you are having issues, please let us know by posting the issue on our GitHub issue tracker.

We also have a PennyLane discussion forum—come join the community and chat with the PennyLane team.

Note that we are committed to providing a friendly, safe, and welcoming environment for all. Please read and respect the Code of Conduct.

Authors

Catalyst is the work of many contributors.

If you are doing research using Catalyst, please cite our paper:

@article{
Ittah2024,
doi = {10.21105/joss.06720},
url = {https://doi.org/10.21105/joss.06720},
year = {2024},
publisher = {The Open Journal},
volume = {9},
number = {99},
pages = {6720},
author = {David Ittah and Ali Asadi and Erick Ochoa Lopez and Sergei Mironov and Samuel Banning and Romain Moyard and Mai Jacob Peng and Josh Izaac},
title = {Catalyst: a Python JIT compiler for auto-differentiable hybrid quantum programs},
journal = {Journal of Open Source Software}
}

License

Catalyst is free and open source, released under the Apache License, Version 2.0.

Acknowledgements

Catalyst makes use of the following libraries and tools, which are under their own respective licenses:

About

A JIT compiler for hybrid quantum programs in PennyLane

docs.pennylane.ai/projects/catalyst

Resources

Readme
License

Code of conduct

Code of conduct

Contributing

Contributing
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - n-io/catalyst: A JIT compiler for hybrid quantum programs in PennyLane · GitHub
Skip to content
BranchesTags
Repository files navigation
TestsCoverageDocumentationDOIPyPIForumLicense
Catalyst is an experimental package that enables just-in-time (JIT) compilation of hybrid
quantum-classical programs.
Catalyst is currently under heavy development — if you have suggestions on the API or use-cases
you'd like to be covered, please open an GitHub issue or reach out. We'd love to hear about how
you're using the library, collaborate on development, or integrate additional devices and
frontends.
Key Features
  • Compile the entire quantum-classical workflow, including any optimization loops.
  • Use Catalyst alongside PennyLane directly from Python. Simply decorate quantum code and hybrid
functions with @qjit, leading to significant performance improvements over standard Python
execution.
  • Access advanced control flow that supports both quantum and classical instructions.
  • Infrastructure for both quantum and classical compilation, allowing you to compile quantum
circuits that contain control flow.
  • Built to be end-to-end differentiable.
  • Support for PennyLane-Lightning high performance
simulators, and Amazon Braket
devices. Additional hardware support, including QPUs, to come.
Overview
Catalyst currently consists of the following components:
  • Catalyst Compiler.
    The core Catalyst compiler is built using MLIR, with the addition of a
quantum dialect used to represent quantum instructions. This allows for a high-level intermediate
representation of the classical and quantum components of the program, resulting in advantages
during optimization. Once optimized, the compiler lowers the representation down to LLVM +
QIR, and a machine binary is produced.
  • Catalyst
Runtime.
    The runtime is a C++ runtime with multiple-device support based on QIR that enables the execution
of Catalyst-compiled quantum programs. A complete list of all backend devices along with the quantum
instruction set supported by these runtime implementations can be found by visiting
the runtime documentation.
In addition, we also provide a Python frontend for PennyLane and JAX:
  • PennyLane JAX frontend.
    A Python library that provides a @qjit decorator to just-in-time compile PennyLane hybrid
quantum-classical programs. In addition, the frontend package provides Python functions for
defining Catalyst-compatible control flow structures, gradient, and mid-circuit measurement.
Installation
Catalyst is officially supported on Linux (x86_64, aarch64) and macOS (arm64, x86_64) platforms,
and pre-built binaries are being distributed via the Python Package Index (PyPI) for Python versions 3.10 and
higher. To install it, simply run the following pip command:
pip install pennylane-catalyst
If you wish to contribute to Catalyst or develop against our runtime or compiler, instructions for
building from source
are also available.
Trying Catalyst with PennyLane
To get started using the Catalyst JIT compiler from Python, check out our quick start
guide, as well as our
various examples and tutorials in our documentation.
For an introduction to quantum computing and quantum machine learning, you can also visit the
PennyLane website for tutorials, videos, and demonstrations.
Roadmap
  • Frontend: As we continue to build out Catalyst, the PennyLane frontend will likely be
upstreamed into PennyLane proper, providing native JIT functionality built-in to PennyLane. The
Catalyst compiler and runtime will remain part of the Catalyst project. If you are interested in
working on additional frontends for Catalyst, please get in touch.
  • Compiler: We will continue to build out the compiler stack, and add quantum compilation
routines. This includes an API for providing or writing Catalyst-compatible compilation routines.
In addition, we will be improving the autodifferentiation support, and adding support for
classical autodiff, additional quantum gradients, and quantum-aware optimization methods.
  • Runtime: We will be adding support for more devices, including quantum hardware devices. In
addition, we will be building out support for hetereogeneous execution. If you are interested in
working on connecting a quantum device with Catalyst, please get in touch.
To get the details right, we need your help — please send us your use cases by starting a
conversation, or trying Catalyst out.
Contributing to Catalyst
We welcome contributions — simply fork the Catalyst repository, and then make a pull
request containing your contribution.
We also encourage bug reports, suggestions for new features and enhancements.
Support
If you are having issues, please let us know by posting the issue on our GitHub issue tracker.
We also have a PennyLane discussion forum—come join the community
and chat with the PennyLane team.
Note that we are committed to providing a friendly, safe, and welcoming environment for all. Please
read and respect the Code of Conduct.
Authors
Catalyst is the work of many contributors.
If you are doing research using Catalyst, please cite our paper:
@article{
Ittah2024,
doi = {10.21105/joss.06720},
url = {https://doi.org/10.21105/joss.06720},
year = {2024},
publisher = {The Open Journal},
volume = {9},
number = {99},
pages = {6720},
author = {David Ittah and Ali Asadi and Erick Ochoa Lopez and Sergei Mironov and Samuel Banning and Romain Moyard and Mai Jacob Peng and Josh Izaac},
title = {Catalyst: a Python JIT compiler for auto-differentiable hybrid quantum programs},
journal = {Journal of Open Source Software}
}
License
Catalyst is free and open source, released under the Apache License, Version 2.0.
Acknowledgements
Catalyst makes use of the following libraries and tools, which are under their own respective
licenses:
About
A JIT compiler for hybrid quantum programs in PennyLane
docs.pennylane.ai/projects/catalyst
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - n-io/catalyst: A JIT compiler for hybrid quantum programs in PennyLane · GitHub
Skip to content
BranchesTags
Repository files navigation
TestsCoverageDocumentationDOIPyPIForumLicense
Catalyst is an experimental package that enables just-in-time (JIT) compilation of hybrid
quantum-classical programs.
Catalyst is currently under heavy development — if you have suggestions on the API or use-cases
you'd like to be covered, please open an GitHub issue or reach out. We'd love to hear about how
you're using the library, collaborate on development, or integrate additional devices and
frontends.
Key Features
  • Compile the entire quantum-classical workflow, including any optimization loops.
  • Use Catalyst alongside PennyLane directly from Python. Simply decorate quantum code and hybrid
functions with @qjit, leading to significant performance improvements over standard Python
execution.
  • Access advanced control flow that supports both quantum and classical instructions.
  • Infrastructure for both quantum and classical compilation, allowing you to compile quantum
circuits that contain control flow.
  • Built to be end-to-end differentiable.
  • Support for PennyLane-Lightning high performance
simulators, and Amazon Braket
devices. Additional hardware support, including QPUs, to come.
Overview
Catalyst currently consists of the following components:
  • Catalyst Compiler.
    The core Catalyst compiler is built using MLIR, with the addition of a
quantum dialect used to represent quantum instructions. This allows for a high-level intermediate
representation of the classical and quantum components of the program, resulting in advantages
during optimization. Once optimized, the compiler lowers the representation down to LLVM +
QIR, and a machine binary is produced.
  • Catalyst
Runtime.
    The runtime is a C++ runtime with multiple-device support based on QIR that enables the execution
of Catalyst-compiled quantum programs. A complete list of all backend devices along with the quantum
instruction set supported by these runtime implementations can be found by visiting
the runtime documentation.
In addition, we also provide a Python frontend for PennyLane and JAX:
  • PennyLane JAX frontend.
    A Python library that provides a @qjit decorator to just-in-time compile PennyLane hybrid
quantum-classical programs. In addition, the frontend package provides Python functions for
defining Catalyst-compatible control flow structures, gradient, and mid-circuit measurement.
Installation
Catalyst is officially supported on Linux (x86_64, aarch64) and macOS (arm64, x86_64) platforms,
and pre-built binaries are being distributed via the Python Package Index (PyPI) for Python versions 3.10 and
higher. To install it, simply run the following pip command:
pip install pennylane-catalyst
If you wish to contribute to Catalyst or develop against our runtime or compiler, instructions for
building from source
are also available.
Trying Catalyst with PennyLane
To get started using the Catalyst JIT compiler from Python, check out our quick start
guide, as well as our
various examples and tutorials in our documentation.
For an introduction to quantum computing and quantum machine learning, you can also visit the
PennyLane website for tutorials, videos, and demonstrations.
Roadmap
  • Frontend: As we continue to build out Catalyst, the PennyLane frontend will likely be
upstreamed into PennyLane proper, providing native JIT functionality built-in to PennyLane. The
Catalyst compiler and runtime will remain part of the Catalyst project. If you are interested in
working on additional frontends for Catalyst, please get in touch.
  • Compiler: We will continue to build out the compiler stack, and add quantum compilation
routines. This includes an API for providing or writing Catalyst-compatible compilation routines.
In addition, we will be improving the autodifferentiation support, and adding support for
classical autodiff, additional quantum gradients, and quantum-aware optimization methods.
  • Runtime: We will be adding support for more devices, including quantum hardware devices. In
addition, we will be building out support for hetereogeneous execution. If you are interested in
working on connecting a quantum device with Catalyst, please get in touch.
To get the details right, we need your help — please send us your use cases by starting a
conversation, or trying Catalyst out.
Contributing to Catalyst
We welcome contributions — simply fork the Catalyst repository, and then make a pull
request containing your contribution.
We also encourage bug reports, suggestions for new features and enhancements.
Support
If you are having issues, please let us know by posting the issue on our GitHub issue tracker.
We also have a PennyLane discussion forum—come join the community
and chat with the PennyLane team.
Note that we are committed to providing a friendly, safe, and welcoming environment for all. Please
read and respect the Code of Conduct.
Authors
Catalyst is the work of many contributors.
If you are doing research using Catalyst, please cite our paper:
@article{
Ittah2024,
doi = {10.21105/joss.06720},
url = {https://doi.org/10.21105/joss.06720},
year = {2024},
publisher = {The Open Journal},
volume = {9},
number = {99},
pages = {6720},
author = {David Ittah and Ali Asadi and Erick Ochoa Lopez and Sergei Mironov and Samuel Banning and Romain Moyard and Mai Jacob Peng and Josh Izaac},
title = {Catalyst: a Python JIT compiler for auto-differentiable hybrid quantum programs},
journal = {Journal of Open Source Software}
}
License
Catalyst is free and open source, released under the Apache License, Version 2.0.
Acknowledgements
Catalyst makes use of the following libraries and tools, which are under their own respective
licenses:
About
A JIT compiler for hybrid quantum programs in PennyLane
docs.pennylane.ai/projects/catalyst
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - n-io/catalyst: A JIT compiler for hybrid quantum programs in PennyLane · GitHub
Skip to content
BranchesTags
Repository files navigation
TestsCoverageDocumentationDOIPyPIForumLicense
Catalyst is an experimental package that enables just-in-time (JIT) compilation of hybrid
quantum-classical programs.
Catalyst is currently under heavy development — if you have suggestions on the API or use-cases
you'd like to be covered, please open an GitHub issue or reach out. We'd love to hear about how
you're using the library, collaborate on development, or integrate additional devices and
frontends.
Key Features
  • Compile the entire quantum-classical workflow, including any optimization loops.
  • Use Catalyst alongside PennyLane directly from Python. Simply decorate quantum code and hybrid
functions with @qjit, leading to significant performance improvements over standard Python
execution.
  • Access advanced control flow that supports both quantum and classical instructions.
  • Infrastructure for both quantum and classical compilation, allowing you to compile quantum
circuits that contain control flow.
  • Built to be end-to-end differentiable.
  • Support for PennyLane-Lightning high performance
simulators, and Amazon Braket
devices. Additional hardware support, including QPUs, to come.
Overview
Catalyst currently consists of the following components:
  • Catalyst Compiler.
    The core Catalyst compiler is built using MLIR, with the addition of a
quantum dialect used to represent quantum instructions. This allows for a high-level intermediate
representation of the classical and quantum components of the program, resulting in advantages
during optimization. Once optimized, the compiler lowers the representation down to LLVM +
QIR, and a machine binary is produced.
  • Catalyst
Runtime.
    The runtime is a C++ runtime with multiple-device support based on QIR that enables the execution
of Catalyst-compiled quantum programs. A complete list of all backend devices along with the quantum
instruction set supported by these runtime implementations can be found by visiting
the runtime documentation.
In addition, we also provide a Python frontend for PennyLane and JAX:
  • PennyLane JAX frontend.
    A Python library that provides a @qjit decorator to just-in-time compile PennyLane hybrid
quantum-classical programs. In addition, the frontend package provides Python functions for
defining Catalyst-compatible control flow structures, gradient, and mid-circuit measurement.
Installation
Catalyst is officially supported on Linux (x86_64, aarch64) and macOS (arm64, x86_64) platforms,
and pre-built binaries are being distributed via the Python Package Index (PyPI) for Python versions 3.10 and
higher. To install it, simply run the following pip command:
pip install pennylane-catalyst
If you wish to contribute to Catalyst or develop against our runtime or compiler, instructions for
building from source
are also available.
Trying Catalyst with PennyLane
To get started using the Catalyst JIT compiler from Python, check out our quick start
guide, as well as our
various examples and tutorials in our documentation.
For an introduction to quantum computing and quantum machine learning, you can also visit the
PennyLane website for tutorials, videos, and demonstrations.
Roadmap
  • Frontend: As we continue to build out Catalyst, the PennyLane frontend will likely be
upstreamed into PennyLane proper, providing native JIT functionality built-in to PennyLane. The
Catalyst compiler and runtime will remain part of the Catalyst project. If you are interested in
working on additional frontends for Catalyst, please get in touch.
  • Compiler: We will continue to build out the compiler stack, and add quantum compilation
routines. This includes an API for providing or writing Catalyst-compatible compilation routines.
In addition, we will be improving the autodifferentiation support, and adding support for
classical autodiff, additional quantum gradients, and quantum-aware optimization methods.
  • Runtime: We will be adding support for more devices, including quantum hardware devices. In
addition, we will be building out support for hetereogeneous execution. If you are interested in
working on connecting a quantum device with Catalyst, please get in touch.
To get the details right, we need your help — please send us your use cases by starting a
conversation, or trying Catalyst out.
Contributing to Catalyst
We welcome contributions — simply fork the Catalyst repository, and then make a pull
request containing your contribution.
We also encourage bug reports, suggestions for new features and enhancements.
Support
If you are having issues, please let us know by posting the issue on our GitHub issue tracker.
We also have a PennyLane discussion forum—come join the community
and chat with the PennyLane team.
Note that we are committed to providing a friendly, safe, and welcoming environment for all. Please
read and respect the Code of Conduct.
Authors
Catalyst is the work of many contributors.
If you are doing research using Catalyst, please cite our paper:
@article{
Ittah2024,
doi = {10.21105/joss.06720},
url = {https://doi.org/10.21105/joss.06720},
year = {2024},
publisher = {The Open Journal},
volume = {9},
number = {99},
pages = {6720},
author = {David Ittah and Ali Asadi and Erick Ochoa Lopez and Sergei Mironov and Samuel Banning and Romain Moyard and Mai Jacob Peng and Josh Izaac},
title = {Catalyst: a Python JIT compiler for auto-differentiable hybrid quantum programs},
journal = {Journal of Open Source Software}
}
License
Catalyst is free and open source, released under the Apache License, Version 2.0.
Acknowledgements
Catalyst makes use of the following libraries and tools, which are under their own respective
licenses:
About
A JIT compiler for hybrid quantum programs in PennyLane
docs.pennylane.ai/projects/catalyst
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - n-io/catalyst: A JIT compiler for hybrid quantum programs in PennyLane · GitHub
Skip to content
BranchesTags
Repository files navigation
TestsCoverageDocumentationDOIPyPIForumLicense
Catalyst is an experimental package that enables just-in-time (JIT) compilation of hybrid
quantum-classical programs.
Catalyst is currently under heavy development — if you have suggestions on the API or use-cases
you'd like to be covered, please open an GitHub issue or reach out. We'd love to hear about how
you're using the library, collaborate on development, or integrate additional devices and
frontends.
Key Features
  • Compile the entire quantum-classical workflow, including any optimization loops.
  • Use Catalyst alongside PennyLane directly from Python. Simply decorate quantum code and hybrid
functions with @qjit, leading to significant performance improvements over standard Python
execution.
  • Access advanced control flow that supports both quantum and classical instructions.
  • Infrastructure for both quantum and classical compilation, allowing you to compile quantum
circuits that contain control flow.
  • Built to be end-to-end differentiable.
  • Support for PennyLane-Lightning high performance
simulators, and Amazon Braket
devices. Additional hardware support, including QPUs, to come.
Overview
Catalyst currently consists of the following components:
  • Catalyst Compiler.
    The core Catalyst compiler is built using MLIR, with the addition of a
quantum dialect used to represent quantum instructions. This allows for a high-level intermediate
representation of the classical and quantum components of the program, resulting in advantages
during optimization. Once optimized, the compiler lowers the representation down to LLVM +
QIR, and a machine binary is produced.
  • Catalyst
Runtime.
    The runtime is a C++ runtime with multiple-device support based on QIR that enables the execution
of Catalyst-compiled quantum programs. A complete list of all backend devices along with the quantum
instruction set supported by these runtime implementations can be found by visiting
the runtime documentation.
In addition, we also provide a Python frontend for PennyLane and JAX:
  • PennyLane JAX frontend.
    A Python library that provides a @qjit decorator to just-in-time compile PennyLane hybrid
quantum-classical programs. In addition, the frontend package provides Python functions for
defining Catalyst-compatible control flow structures, gradient, and mid-circuit measurement.
Installation
Catalyst is officially supported on Linux (x86_64, aarch64) and macOS (arm64, x86_64) platforms,
and pre-built binaries are being distributed via the Python Package Index (PyPI) for Python versions 3.10 and
higher. To install it, simply run the following pip command:
pip install pennylane-catalyst
If you wish to contribute to Catalyst or develop against our runtime or compiler, instructions for
building from source
are also available.
Trying Catalyst with PennyLane
To get started using the Catalyst JIT compiler from Python, check out our quick start
guide, as well as our
various examples and tutorials in our documentation.
For an introduction to quantum computing and quantum machine learning, you can also visit the
PennyLane website for tutorials, videos, and demonstrations.
Roadmap
  • Frontend: As we continue to build out Catalyst, the PennyLane frontend will likely be
upstreamed into PennyLane proper, providing native JIT functionality built-in to PennyLane. The
Catalyst compiler and runtime will remain part of the Catalyst project. If you are interested in
working on additional frontends for Catalyst, please get in touch.
  • Compiler: We will continue to build out the compiler stack, and add quantum compilation
routines. This includes an API for providing or writing Catalyst-compatible compilation routines.
In addition, we will be improving the autodifferentiation support, and adding support for
classical autodiff, additional quantum gradients, and quantum-aware optimization methods.
  • Runtime: We will be adding support for more devices, including quantum hardware devices. In
addition, we will be building out support for hetereogeneous execution. If you are interested in
working on connecting a quantum device with Catalyst, please get in touch.
To get the details right, we need your help — please send us your use cases by starting a
conversation, or trying Catalyst out.
Contributing to Catalyst
We welcome contributions — simply fork the Catalyst repository, and then make a pull
request containing your contribution.
We also encourage bug reports, suggestions for new features and enhancements.
Support
If you are having issues, please let us know by posting the issue on our GitHub issue tracker.
We also have a PennyLane discussion forum—come join the community
and chat with the PennyLane team.
Note that we are committed to providing a friendly, safe, and welcoming environment for all. Please
read and respect the Code of Conduct.
Authors
Catalyst is the work of many contributors.
If you are doing research using Catalyst, please cite our paper:
@article{
Ittah2024,
doi = {10.21105/joss.06720},
url = {https://doi.org/10.21105/joss.06720},
year = {2024},
publisher = {The Open Journal},
volume = {9},
number = {99},
pages = {6720},
author = {David Ittah and Ali Asadi and Erick Ochoa Lopez and Sergei Mironov and Samuel Banning and Romain Moyard and Mai Jacob Peng and Josh Izaac},
title = {Catalyst: a Python JIT compiler for auto-differentiable hybrid quantum programs},
journal = {Journal of Open Source Software}
}
License
Catalyst is free and open source, released under the Apache License, Version 2.0.
Acknowledgements
Catalyst makes use of the following libraries and tools, which are under their own respective
licenses:
About
A JIT compiler for hybrid quantum programs in PennyLane
docs.pennylane.ai/projects/catalyst
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - n-io/catalyst: A JIT compiler for hybrid quantum programs in PennyLane · GitHub
Skip to content
BranchesTags
Repository files navigation
TestsCoverageDocumentationDOIPyPIForumLicense
Catalyst is an experimental package that enables just-in-time (JIT) compilation of hybrid
quantum-classical programs.
Catalyst is currently under heavy development — if you have suggestions on the API or use-cases
you'd like to be covered, please open an GitHub issue or reach out. We'd love to hear about how
you're using the library, collaborate on development, or integrate additional devices and
frontends.
Key Features
  • Compile the entire quantum-classical workflow, including any optimization loops.
  • Use Catalyst alongside PennyLane directly from Python. Simply decorate quantum code and hybrid
functions with @qjit, leading to significant performance improvements over standard Python
execution.
  • Access advanced control flow that supports both quantum and classical instructions.
  • Infrastructure for both quantum and classical compilation, allowing you to compile quantum
circuits that contain control flow.
  • Built to be end-to-end differentiable.
  • Support for PennyLane-Lightning high performance
simulators, and Amazon Braket
devices. Additional hardware support, including QPUs, to come.
Overview
Catalyst currently consists of the following components:
  • Catalyst Compiler.
    The core Catalyst compiler is built using MLIR, with the addition of a
quantum dialect used to represent quantum instructions. This allows for a high-level intermediate
representation of the classical and quantum components of the program, resulting in advantages
during optimization. Once optimized, the compiler lowers the representation down to LLVM +
QIR, and a machine binary is produced.
  • Catalyst
Runtime.
    The runtime is a C++ runtime with multiple-device support based on QIR that enables the execution
of Catalyst-compiled quantum programs. A complete list of all backend devices along with the quantum
instruction set supported by these runtime implementations can be found by visiting
the runtime documentation.
In addition, we also provide a Python frontend for PennyLane and JAX:
  • PennyLane JAX frontend.
    A Python library that provides a @qjit decorator to just-in-time compile PennyLane hybrid
quantum-classical programs. In addition, the frontend package provides Python functions for
defining Catalyst-compatible control flow structures, gradient, and mid-circuit measurement.
Installation
Catalyst is officially supported on Linux (x86_64, aarch64) and macOS (arm64, x86_64) platforms,
and pre-built binaries are being distributed via the Python Package Index (PyPI) for Python versions 3.10 and
higher. To install it, simply run the following pip command:
pip install pennylane-catalyst
If you wish to contribute to Catalyst or develop against our runtime or compiler, instructions for
building from source
are also available.
Trying Catalyst with PennyLane
To get started using the Catalyst JIT compiler from Python, check out our quick start
guide, as well as our
various examples and tutorials in our documentation.
For an introduction to quantum computing and quantum machine learning, you can also visit the
PennyLane website for tutorials, videos, and demonstrations.
Roadmap
  • Frontend: As we continue to build out Catalyst, the PennyLane frontend will likely be
upstreamed into PennyLane proper, providing native JIT functionality built-in to PennyLane. The
Catalyst compiler and runtime will remain part of the Catalyst project. If you are interested in
working on additional frontends for Catalyst, please get in touch.
  • Compiler: We will continue to build out the compiler stack, and add quantum compilation
routines. This includes an API for providing or writing Catalyst-compatible compilation routines.
In addition, we will be improving the autodifferentiation support, and adding support for
classical autodiff, additional quantum gradients, and quantum-aware optimization methods.
  • Runtime: We will be adding support for more devices, including quantum hardware devices. In
addition, we will be building out support for hetereogeneous execution. If you are interested in
working on connecting a quantum device with Catalyst, please get in touch.
To get the details right, we need your help — please send us your use cases by starting a
conversation, or trying Catalyst out.
Contributing to Catalyst
We welcome contributions — simply fork the Catalyst repository, and then make a pull
request containing your contribution.
We also encourage bug reports, suggestions for new features and enhancements.
Support
If you are having issues, please let us know by posting the issue on our GitHub issue tracker.
We also have a PennyLane discussion forum—come join the community
and chat with the PennyLane team.
Note that we are committed to providing a friendly, safe, and welcoming environment for all. Please
read and respect the Code of Conduct.
Authors
Catalyst is the work of many contributors.
If you are doing research using Catalyst, please cite our paper:
@article{
Ittah2024,
doi = {10.21105/joss.06720},
url = {https://doi.org/10.21105/joss.06720},
year = {2024},
publisher = {The Open Journal},
volume = {9},
number = {99},
pages = {6720},
author = {David Ittah and Ali Asadi and Erick Ochoa Lopez and Sergei Mironov and Samuel Banning and Romain Moyard and Mai Jacob Peng and Josh Izaac},
title = {Catalyst: a Python JIT compiler for auto-differentiable hybrid quantum programs},
journal = {Journal of Open Source Software}
}
License
Catalyst is free and open source, released under the Apache License, Version 2.0.
Acknowledgements
Catalyst makes use of the following libraries and tools, which are under their own respective
licenses:
About
A JIT compiler for hybrid quantum programs in PennyLane
docs.pennylane.ai/projects/catalyst
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - n-io/catalyst: A JIT compiler for hybrid quantum programs in PennyLane · GitHub
Skip to content
BranchesTags
Repository files navigation
TestsCoverageDocumentationDOIPyPIForumLicense
Catalyst is an experimental package that enables just-in-time (JIT) compilation of hybrid
quantum-classical programs.
Catalyst is currently under heavy development — if you have suggestions on the API or use-cases
you'd like to be covered, please open an GitHub issue or reach out. We'd love to hear about how
you're using the library, collaborate on development, or integrate additional devices and
frontends.
Key Features
  • Compile the entire quantum-classical workflow, including any optimization loops.
  • Use Catalyst alongside PennyLane directly from Python. Simply decorate quantum code and hybrid
functions with @qjit, leading to significant performance improvements over standard Python
execution.
  • Access advanced control flow that supports both quantum and classical instructions.
  • Infrastructure for both quantum and classical compilation, allowing you to compile quantum
circuits that contain control flow.
  • Built to be end-to-end differentiable.
  • Support for PennyLane-Lightning high performance
simulators, and Amazon Braket
devices. Additional hardware support, including QPUs, to come.
Overview
Catalyst currently consists of the following components:
  • Catalyst Compiler.
    The core Catalyst compiler is built using MLIR, with the addition of a
quantum dialect used to represent quantum instructions. This allows for a high-level intermediate
representation of the classical and quantum components of the program, resulting in advantages
during optimization. Once optimized, the compiler lowers the representation down to LLVM +
QIR, and a machine binary is produced.
  • Catalyst
Runtime.
    The runtime is a C++ runtime with multiple-device support based on QIR that enables the execution
of Catalyst-compiled quantum programs. A complete list of all backend devices along with the quantum
instruction set supported by these runtime implementations can be found by visiting
the runtime documentation.
In addition, we also provide a Python frontend for PennyLane and JAX:
  • PennyLane JAX frontend.
    A Python library that provides a @qjit decorator to just-in-time compile PennyLane hybrid
quantum-classical programs. In addition, the frontend package provides Python functions for
defining Catalyst-compatible control flow structures, gradient, and mid-circuit measurement.
Installation
Catalyst is officially supported on Linux (x86_64, aarch64) and macOS (arm64, x86_64) platforms,
and pre-built binaries are being distributed via the Python Package Index (PyPI) for Python versions 3.10 and
higher. To install it, simply run the following pip command:
pip install pennylane-catalyst
If you wish to contribute to Catalyst or develop against our runtime or compiler, instructions for
building from source
are also available.
Trying Catalyst with PennyLane
To get started using the Catalyst JIT compiler from Python, check out our quick start
guide, as well as our
various examples and tutorials in our documentation.
For an introduction to quantum computing and quantum machine learning, you can also visit the
PennyLane website for tutorials, videos, and demonstrations.
Roadmap
  • Frontend: As we continue to build out Catalyst, the PennyLane frontend will likely be
upstreamed into PennyLane proper, providing native JIT functionality built-in to PennyLane. The
Catalyst compiler and runtime will remain part of the Catalyst project. If you are interested in
working on additional frontends for Catalyst, please get in touch.
  • Compiler: We will continue to build out the compiler stack, and add quantum compilation
routines. This includes an API for providing or writing Catalyst-compatible compilation routines.
In addition, we will be improving the autodifferentiation support, and adding support for
classical autodiff, additional quantum gradients, and quantum-aware optimization methods.
  • Runtime: We will be adding support for more devices, including quantum hardware devices. In
addition, we will be building out support for hetereogeneous execution. If you are interested in
working on connecting a quantum device with Catalyst, please get in touch.
To get the details right, we need your help — please send us your use cases by starting a
conversation, or trying Catalyst out.
Contributing to Catalyst
We welcome contributions — simply fork the Catalyst repository, and then make a pull
request containing your contribution.
We also encourage bug reports, suggestions for new features and enhancements.
Support
If you are having issues, please let us know by posting the issue on our GitHub issue tracker.
We also have a PennyLane discussion forum—come join the community
and chat with the PennyLane team.
Note that we are committed to providing a friendly, safe, and welcoming environment for all. Please
read and respect the Code of Conduct.
Authors
Catalyst is the work of many contributors.
If you are doing research using Catalyst, please cite our paper:
@article{
Ittah2024,
doi = {10.21105/joss.06720},
url = {https://doi.org/10.21105/joss.06720},
year = {2024},
publisher = {The Open Journal},
volume = {9},
number = {99},
pages = {6720},
author = {David Ittah and Ali Asadi and Erick Ochoa Lopez and Sergei Mironov and Samuel Banning and Romain Moyard and Mai Jacob Peng and Josh Izaac},
title = {Catalyst: a Python JIT compiler for auto-differentiable hybrid quantum programs},
journal = {Journal of Open Source Software}
}
License
Catalyst is free and open source, released under the Apache License, Version 2.0.
Acknowledgements
Catalyst makes use of the following libraries and tools, which are under their own respective
licenses:
About
A JIT compiler for hybrid quantum programs in PennyLane
docs.pennylane.ai/projects/catalyst
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - n-io/catalyst: A JIT compiler for hybrid quantum programs in PennyLane · GitHub
Skip to content
BranchesTags
Repository files navigation
TestsCoverageDocumentationDOIPyPIForumLicense
Catalyst is an experimental package that enables just-in-time (JIT) compilation of hybrid
quantum-classical programs.
Catalyst is currently under heavy development — if you have suggestions on the API or use-cases
you'd like to be covered, please open an GitHub issue or reach out. We'd love to hear about how
you're using the library, collaborate on development, or integrate additional devices and
frontends.
Key Features
  • Compile the entire quantum-classical workflow, including any optimization loops.
  • Use Catalyst alongside PennyLane directly from Python. Simply decorate quantum code and hybrid
functions with @qjit, leading to significant performance improvements over standard Python
execution.
  • Access advanced control flow that supports both quantum and classical instructions.
  • Infrastructure for both quantum and classical compilation, allowing you to compile quantum
circuits that contain control flow.
  • Built to be end-to-end differentiable.
  • Support for PennyLane-Lightning high performance
simulators, and Amazon Braket
devices. Additional hardware support, including QPUs, to come.
Overview
Catalyst currently consists of the following components:
  • Catalyst Compiler.
    The core Catalyst compiler is built using MLIR, with the addition of a
quantum dialect used to represent quantum instructions. This allows for a high-level intermediate
representation of the classical and quantum components of the program, resulting in advantages
during optimization. Once optimized, the compiler lowers the representation down to LLVM +
QIR, and a machine binary is produced.
  • Catalyst
Runtime.
    The runtime is a C++ runtime with multiple-device support based on QIR that enables the execution
of Catalyst-compiled quantum programs. A complete list of all backend devices along with the quantum
instruction set supported by these runtime implementations can be found by visiting
the runtime documentation.
In addition, we also provide a Python frontend for PennyLane and JAX:
  • PennyLane JAX frontend.
    A Python library that provides a @qjit decorator to just-in-time compile PennyLane hybrid
quantum-classical programs. In addition, the frontend package provides Python functions for
defining Catalyst-compatible control flow structures, gradient, and mid-circuit measurement.
Installation
Catalyst is officially supported on Linux (x86_64, aarch64) and macOS (arm64, x86_64) platforms,
and pre-built binaries are being distributed via the Python Package Index (PyPI) for Python versions 3.10 and
higher. To install it, simply run the following pip command:
pip install pennylane-catalyst
If you wish to contribute to Catalyst or develop against our runtime or compiler, instructions for
building from source
are also available.
Trying Catalyst with PennyLane
To get started using the Catalyst JIT compiler from Python, check out our quick start
guide, as well as our
various examples and tutorials in our documentation.
For an introduction to quantum computing and quantum machine learning, you can also visit the
PennyLane website for tutorials, videos, and demonstrations.
Roadmap
  • Frontend: As we continue to build out Catalyst, the PennyLane frontend will likely be
upstreamed into PennyLane proper, providing native JIT functionality built-in to PennyLane. The
Catalyst compiler and runtime will remain part of the Catalyst project. If you are interested in
working on additional frontends for Catalyst, please get in touch.
  • Compiler: We will continue to build out the compiler stack, and add quantum compilation
routines. This includes an API for providing or writing Catalyst-compatible compilation routines.
In addition, we will be improving the autodifferentiation support, and adding support for
classical autodiff, additional quantum gradients, and quantum-aware optimization methods.
  • Runtime: We will be adding support for more devices, including quantum hardware devices. In
addition, we will be building out support for hetereogeneous execution. If you are interested in
working on connecting a quantum device with Catalyst, please get in touch.
To get the details right, we need your help — please send us your use cases by starting a
conversation, or trying Catalyst out.
Contributing to Catalyst
We welcome contributions — simply fork the Catalyst repository, and then make a pull
request containing your contribution.
We also encourage bug reports, suggestions for new features and enhancements.
Support
If you are having issues, please let us know by posting the issue on our GitHub issue tracker.
We also have a PennyLane discussion forum—come join the community
and chat with the PennyLane team.
Note that we are committed to providing a friendly, safe, and welcoming environment for all. Please
read and respect the Code of Conduct.
Authors
Catalyst is the work of many contributors.
If you are doing research using Catalyst, please cite our paper:
@article{
Ittah2024,
doi = {10.21105/joss.06720},
url = {https://doi.org/10.21105/joss.06720},
year = {2024},
publisher = {The Open Journal},
volume = {9},
number = {99},
pages = {6720},
author = {David Ittah and Ali Asadi and Erick Ochoa Lopez and Sergei Mironov and Samuel Banning and Romain Moyard and Mai Jacob Peng and Josh Izaac},
title = {Catalyst: a Python JIT compiler for auto-differentiable hybrid quantum programs},
journal = {Journal of Open Source Software}
}
License
Catalyst is free and open source, released under the Apache License, Version 2.0.
Acknowledgements
Catalyst makes use of the following libraries and tools, which are under their own respective
licenses:
About
A JIT compiler for hybrid quantum programs in PennyLane
docs.pennylane.ai/projects/catalyst
Resources
Readme
License
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages