This year marks our fifth annual unitaryHACK hackathon (check out our post-event wrap-up blog)! It’s also the very first year Unitary Foundation’s new open-source quantum compiler UCC has been a part of the event. In this blog, we’re going to let three of the UCC unitaryHACK Bounty winners tell you about their projects.

We created UCC to be a quantum compiler that’s genuinely community-driven — that’s part of our mission to make quantum computing more accessible and beneficial to the most people — and so we did something a little different from the typical unitaryHACK bounties. We put out an open call for new quantum compiler passes, and the community delivered! Let’s hear from them:

Verifying logical equivalence of quantum circuits

Hacker	Bounty Amount	Description
WingCode	$200	In order to complete this issue, you should aim to demonstrate the use of one of these tools to verify the logical equivalence of a raw quantum circuit of O(100) qubits and O(1000) gates with its UCC compiled equivalent with a runtime <1 hr, excluding compilation time.

My name is Gregory Varghese, I have a Undergraduate degree in Computer Science & Engineering, and I work as a Senior Backend Expert, currently focused on QML methods for chemical simulations.

I wanted to work on this issue because I am fascinated by this as a fundamental problem at the intersection of quantum computing and computational complexity.

I faced two main challenges: first, developing a solid understanding of how compute time and memory requirements grow with circuit size; second, working across multiple frameworks—such as PyZX and the Munich‑Quantum‑Toolkit/QCEC—that use differing definitions of circuit equivalence. By tackling these, I clarified scaling behaviors in my equivalence tests and identified which frameworks are best suited to our needs for establishing logical equivalence within UCC.

Verifying circuit properties for benchmarking

Hacker	Bounty Amount	Description
WingCode	$75	For this issue, the completion criteria is to check that the compiled circuits in the benchmarks only use Rx, Ry, Rz, H and CX gates. This check should not be included in the measured compilation time.

I was drawn in by the compelling opportunity to enhance benchmarking reliability through direct gate‑set verification. Because the issue was clearly described, I was able to proceed smoothly, encountering minimal difficulty. As a result, I enabled robust checks for gate‑set‑specific compilations, strengthening benchmarking accuracy within UCC.

In the future, I am interested in researching additional transpilation passes within the UCC framework, particularly by leveraging large language models (LLMs). Additionally, I aim to design scalable and predictive models capable of evaluating the logical equivalence of black-box quantum circuits, focusing on metrics such as compute time and memory usage.

Introducing an approximate compilation module

Hacker	Bounty Amount	Description
ACE07-Sev	$500	Sequential MPS encoding [[1]] is a way to approximately encode a matrix product state up to arbitrary fidelity in $O(N)$ circuit depth where $N$ is the number of qubits. The cap fidelity is based on the bond dimension $\chi$ which trades off memory and runtime with potential for squeezing more fidelity from the encoding.

Greetings! I am Amir Ali Malekani Nezhad, a Quantum Compilation Researcher and Developer currently pursuing MPS/MPO (Matrix Product State/Operator) utilization for approximate compilation of arbitrary statevectors and operators in O(N) depth.

What drew me to this issue or to UCC? During unitaryHACK 2025, I had the pleasure of contributing to UCC, a Quantum Compilation library maintained by Jordan Sullivan and Brad Chase. Given my current obsession with anything related to Quantum Compilation, the issue immediately intrigued me. Upon reading about the premise of the issue, and the creative freedom provided by UCC’s supportive team, I proposed an approximate quantum compilation module. This was intended to complement the current compilation pipeline present within UCC to tradeoff slight infidelity with exponential depth reduction for certain class of states known as area-law entangled states.

Challenges I faced in hacking on this issue: While developing the open-source qmprs project for compression and compilation of quantum circuits using tensor networks, I had become familiar with the side-effects of approximation in state encoding. However, it was through UCC’s suggestion to benchmark the compiler using their suite that a critical limitation came to light—random Clifford circuits revealed themselves as a particular weakness of MPS-based approaches. Digging into the entanglement properties of both the benchmark circuits and the typical states I had used, I realized the circuits exhibited volume-law entanglement, whereas the states I had relied on were coincidentally area-law entangled. This contrast helped explain the discrepancy and highlighted both an opportunity and a constraint for the proposed compiler.
I spent time during and after the event exploring ways to reconcile this, eventually incorporating a method to ensure consistency for volume-law circuits via variational fine-tuning.

The experience was deeply instructive, and I was fortunate to contribute to the project, though it was UCC’s benchmarking approach that uncovered the limitation in the first place—a contribution I remain genuinely thankful for. Additionally, UCC’s infrastructure emphasized the importance of compatibility between approximate and exact compilation methods. To support this, I introduced a fallback mechanism that checks fidelity and cost metrics, defaulting to UCC’s exact compiler when approximation underperforms. It was a straightforward solution, but in hindsight, one that proved to be quite practical.

Future projects I’m interested in working on: My current focus is on finishing qmprs. Given the approximate compilation module making it to production, I will be looking forward to integrating qmprs once it reaches a minimum mature stage in UCC with the help of the supportive maintainers. Feel free to reach out to me via LinkedIn, or Discord, or email should you have any questions or would like to collaborate.

Porting over a BQSKit compiler pass

Hacker	Bounty Amount	Description
WolfLink	$500	I plan to integrate BQSKit into a UCC compiler pass. BQSKit offers a suite of techniques, but for the circuits in the UCC-bench suite, partitioning and resynthesis by LEAP will likely be most effective.

Hi, I’m Marc Davis, currently pursuing a PhD at MIT researching quantum compiling techniques.

What drew me to UCC: In the course of my research, I work with a variety of quantum circuit compilation, transpilation, and optimization tools, and a common problem is interfacing between different tools, which often rely on different underlying circuit formats, sometimes with different sets of features. UCC’s goal of making a wrapper that allows the interplay of many different tools is a worthy one.

Challenges I faced: My idea was to combine UCC and BQSKit. BQSKit is a quantum compiling tool I have previously worked on that provides a suite of optimization techniques. By implementing BQSKit as a UCC pass, I enabled many powerful circuit optimization tools to be used with the UCC ecosystem. However, many of BQSKit’s tools are focused on providing highly efficient circuits at the cost of runtime on the order of hours. UCC has strict runtime limits on the order of less than a second. Since these compilers have different underlying goals, for this issue, we made the design decision to make BQSkit an optional pass rather than a core part of the UCC workflow. This way users can easily import the pass, but the benchmarks for UCC won’t be affected by extended runtimes.

Another difficulty in implementing BQSKit was encountering the limitations of the Qiskit TransformationPass that UCC uses as the base class for its compiler passes. This class does not maintain information about the target hardware, such as the coupling map, which prevents UCC passes from taking advantage of this information.

Future Projects: I am currently working on compiler passes working on T-count minimization. If UCC targets fault tolerant circuit optimization in the future, I hope to include my T-count minimization tools.

Get involved

Did you get inspired by something you read here? Tell us about it! Comment on this blog post, reach out in the #ucc channel on Discord for casual or time sensitive questions — or create a GitHub discussion for code, repo, or theory stuff :]

About UCC

The Unitary Compiler Collection (UCC) is a Python library for frontend-agnostic, high performance compilation of quantum circuits. UCC’s goal is to gather together the best of open source compilation to make quantum programming simpler, faster, and more scalable.

GitHub Repos:
ucc - our main Unitary Compiler Collection source code repo
ucc-bench - our quantum compiler benchmarking suite
ucc-ft - our prototype Fault Tolerance checker for quantum circuits

Want to know more?

• Read the launch announcement to get a feel for UCC’s design philosophy.
• Watch our introductory video on UCC from FOSDEM 2025 by @natestemen.
• Explore research publications that utilize UCC.