Denis G.’s Post

The biggest bottleneck in #QuantumComputing isn't just the hardware—it's the latency of the software trying to save it. I’m excited to share a major milestone from Korelis Labs LLC: We’ve just hit v0.4.0 of QSHL (Quantum Self-Healing Language), a zero-dependency, Rust-native compiler designed for the "Utility-Scale" era. While the industry targets 0.1% error rates, we decided to push the limits. In our latest stress tests, QSHL’s active Sparse Blossom Decoder achieved a 55.6% heal rate on hardware with a staggering 5% gate error rate. What makes QSHL different? ✅ Fast but Gentle: A Rust-based frontend with an "Ownership Model" for qubits—preventing decoherence at the compiler level. ✅ Real-Time Recovery: Repeated syndrome extraction and MWPM decoding that runs in sub-milliseconds—beating the decoherence clock. ✅ QIR & OpenQASM 3.0 Native: We’ve moved beyond Python. QSHL targets the QIR Adaptive Profile and emits ready-to-run AWS Braket code for IonQ and Rigetti. We’re building this to be the "Quantum Root of Trust" for our upcoming RegenX/OS security architecture. Quantum computing shouldn't just be a lab experiment; it needs to be stable, secure, and fast.

The April 13th edition covers a thermodynamic metric for magic in quantum systems, a benchmark for quantum code generation by LLM and a new quantum-classical compilation framework. Here is the daily selection: 1️⃣ Every Little Thing Heat Does Is Magic 🔗 https://lnkd.in/ecqjwaV2 👨👩 Rafael Macedo, Jonatan Bohr Brask, Rafael Chaves et al. 🔬 It is possible to detect whether a quantum state contains “magic” (a key resource for quantum advantage) using simple thermodynamic measurements, without reconstructing the full state. 2️⃣ QuanBench+: A Unified Multi-Framework Benchmark for LLM-Based Quantum Code Generation 🔗 https://lnkd.in/eXByYNCh 👨👩 Ali Slim, Haydar Hamieh, Jawad Kotaich, Yehya Ghosn, Mahdi Chehimi, Ammar Mohanna, PhD, Hassan Hammoud and Bernard Ghanem 🔬 A new paper introduces a benchmark to fairly evaluate how well LLMs generate quantum code across multiple frameworks (Qiskit, Cirq and Pennylane), separating true quantum understanding from framework-specific knowledge. 3️⃣ The MQT Compiler Collection: A Blueprint for a Future-Proof Quantum-Classical Compilation Framework 🔗https://lnkd.in/eevJwwv7 👨👩 Lukas Burgholzer, Daniel Haag, Yannick Stade, Damian Rovara, Patrick Hopf and Robert Wille 🔬 Future quantum programs are increasingly hybrid, so traditional “quantum-first” compilers are no longer sufficient. MQT Compiler Collection is built on the Multi-Level Intermediate Representation and can better handle full quantum-classical workflows. That’s it for the daily selection. If you enjoyed it, please consider giving us a like or reposting to support our content. Thanks!

Hybrid machine learning architectures are gaining traction. Recently, a GitHub repository demonstrated a system leveraging quantum circuits alongside classical algorithms to classify noisy signals. The project is still in early stages with only 3 commits, yet it already has 58 stars in a single day. The architecture compares a classical model against a quantum circuit-based model. There's a dedicated `noise_filter.py` module, which raises the question: Is noise filtering critical for quantum viability, or does it artificially inflate complexity? With just 8 core Python files, the proof-of-concept is intriguing. However, we need to discuss the performance gap. Does this trend represent sustainable quantum ML adoption or temporary hype? Let's analyze the Srivardhini-S repo. Link: https://lnkd.in/dzf4xT7D Thoughts?

I’ve started running a set of experiments with quantum computing applied to iGaming systems. Two parallel tracks. First: probabilistic modeling. Building a toy framework to estimate RTP and rare event probabilities using quantum techniques, then benchmarking it against classical Monte Carlo. My objective is to understand whether methods like amplitude estimation change anything in practice when it comes to expected value, variance, and edge-case modeling. Second: RNG architecture. Exploring a hybrid model where quantum-generated entropy feeds into a standard deterministic RNG pipeline. My focus is on entropy quality, conditioning, statistical validation, and whether this can integrate into systems that require auditability and certification. Stack is Python with Qiskit, starting on simulators and then pushing runs to real quantum hardware. This has nothing to do with predicting outcomes or reinventing gambling math. If there’s something real here, it will show up in measurable differences. I’ll share results once I have data worth looking at.

Excited to share the latest Microsoft Quantum Development Kit (QDK) release! 🚀 QDK v1.27.0 and QDK for Chemistry v1.1.0 are here.  🤖 AI meets quantum development. GitHub Copilot is deeply integrated into the QDK experience in VS Code: from code generation and circuit reasoning to debugging, resource estimation, and hardware submission. Quantum development just got a serious productivity boost. 🧩 Build quantum programs from building blocks. You can now dynamically compose algorithms from interchangeable subroutines across Q#, Python, OpenQASM, Qiskit, and Cirq. Write once, plug in anywhere.  🧪 Chemistry goes further. QDK for Chemistry v1.1.0 adds model Hamiltonians (Hubbard, Hückel, Ising, Heisenberg and more), arbitrary-order Trotter decompositions, and a strong classical pipeline, making practical quantum chemistry experimentation possible today. Read more in our blog post and hear directly from David and Stefan as they discuss the key updates in this release and what they unlock for practical quantum development.👇 https://lnkd.in/gPNK96M9 As always, please reach out—we’d love to hear how we can better support your quantum application development!  #QuantumComputing #Microsoft #QDK #QuantumDevelopment #GitHubCopilot #QuantumChemistry

1. Very exciting things coming down the pike for QDK/Chemistry. We’d love for you to kick the tires and tell us everything that’s broken, confusing, or just plain wrong (we promise we have thick skin 😂). File issues, roast our design choices, and don’t hold back; the most brutal feedback makes the best code. 2. There may or may not be a fun video at the end of this blog post of me and another Microsoft engineer discussing the release. Let us know if that medium “clicks” for you relative to reading a lengthy blog post!

This stopped me mid-scroll. Anthropic just published how they built a fully functional C compiler capable of compiling the Linux kernel — using a team of 16 parallel Claude agents, with almost zero human intervention. 100,000 lines of Rust code. 2,000 Claude Code sessions. ~$20,000 in API costs. Two weeks. The result? A compiler that builds Linux 6.9 on x86, ARM, and RISC-V. It compiles QEMU, FFmpeg, SQLite, Postgres, Redis. It passes 99% of GCC torture tests. But here's what hit me as a builder: The researcher, Nicholas Carlini, didn't just ship a cool demo — he documented exactly how the harness works. The infinite agent loop. Task locking via git. How to write tests FOR Claude (not for yourself). Context window management. Parallel specialization. This is the engineering playbook for autonomous AI systems that we've all been waiting for. Think about what this actually means: → Agents don't just assist — they architect, test, and iterate. → The bottleneck is no longer talent. It's system design. → The teams who learn to orchestrate agents will outbuild everyone else. At CloudNate, we've been thinking deeply about where agentic AI fits in cloud-native infrastructure — structured, testable, and built to scale. This work validates exactly the direction we're heading. The part that Carlini himself admits made him uneasy: "I did not expect this to be anywhere near possible so early in 2026." Neither did I. We are not approaching an AI-augmented future. We are already in it. The question now is: are you designing systems that can work WITH autonomous agents — or ones that will be left behind? Full write-up from Anthropic's engineering blog in the comments. #AI #CloudNative #AgenticAI #LLMs #ClaudeAI #Builders #Anthropic #FutureOfWork #CloudNate #Thasaamah

Quantum error correction shouldn’t be manual. But today, it is. Most quantum stacks like Qiskit and Q# push error correction into libraries, forcing developers to hand-build syndrome circuits with no compile-time guarantees. So I built something different: QSHL (Quantum Self-Healing Language) A programming language where error correction is built in—not bolted on. What’s different: → Heal Blocks Define error correction once. The compiler generates the full syndrome + correction loop automatically. → Linear Qubit Ownership Prevents use-after-measurement and invalid quantum states at compile time. → Coherence-Aware Compilation If your program exceeds the hardware’s coherence window, it fails before it runs. → Rust-native pipeline No Python overhead. Low-latency classical control for real-time decoding. Results: In simulation, QSHL achieved a 55.6% error “heal rate” at a 5% gate error, completing correction cycles within the coherence window using a Sparse Blossom decoder. We’ve filed a provisional patent on the architecture at Korelis Labs. I’m currently exploring QIR / OpenQASM 3.0 integrations and early pilot opportunities with teams working on real quantum systems. If you’re in the quantum space—let’s talk. #QuantumComputing #QEC #RustLang #DeepTech #KorelisLabs

Quantum computers don’t run code. They run circuits. That’s the first mental shift you need to make. In classical computing, we write programs step by step instructions executed sequentially in languages like Python or C++. Quantum computing works differently. Instead of code, you design a quantum circuit a sequence of quantum gates applied to qubits. Each gate doesn’t “compute” in the classical sense. It transforms the state of a qubit shaping probabilities, not flipping bits. You’re not telling the computer what to do step by step. You’re constructing a system that evolves according to quantum mechanics. And at the end of the circuit? You measure. That’s when probabilities collapse into an actual result. This is why quantum programming feels less like coding… and more like designing an experiment. From instructions → to transformations From logic → to physics This is Day 2 of understanding how quantum computers actually compute. Next: What exactly is a quantum gate? #QuantumComputing #QuantumAlgorithms #QuantumCircuits #DeepTech #FutureOfComputing #EmergingTech #day2 #computation

Anthropic's Claude agents made 501 commits. Built thousands of files. Couldn't compile "Hello World." This wasn't a model failure. It was an orchestration failure. 16 Claude agents tried to build a full C compiler in Rust. A senior researcher did 2,000+ interactive turns babysitting them. Still didn't reach a functional state. The community dug in found broken ARM instruction encoding, busted x86 conditional processing, no real optimization pipeline. Classic multi-agent trap: more agents, more chaos, no coordination layer that actually works. Then Blitzy stepped in. Same task. Different approach. - Ingested the broken repo, fixed all 13 critical regressions - Built a new compiler (BCC) from scratch - 230,000 lines of Rust. 129 source files. - 2 human prompts. Not 2,000. The result boots the Linux kernel. Compiles SQLite. Compiles Redis. What did they do differently? Not better models. Better orchestration. - Mapped the entire codebase into a knowledge graph before writing a single line - 3,600 specialized agents running in parallel for 600+ hours - Built-in QA agents validating code continuously — no human in the loop The honest takeaway no one wants to say out loud: The LLM is the least interesting part. Claude, GPT, Gemini they're roughly in the same ballpark now. What separates a demo from a working system is the harness. The coordination layer. The validation loops. The context architecture. That's the actual moat. That's what we should be building. We keep evaluating AI by "which model is smarter." We should be asking "which orchestration survives contact with a real problem." 501 commits that can't say Hello World is the most honest benchmark I've seen all year. #AgenticAI #AIEngineering #LLMOrchestration #BuildingWithAI #ClaudeCode #MultiAgent #SoftwareEngineering