Miden brings privacy to Ethereum. We've worked with the team for over a year and this post covers our work across the Miden ecosystem in Q2 2026.
Last quarter ended with a lot of work one release away from developers. End-to-end transaction debugging was about to land. Contract verification was about to move out of a single explorer and into something any tool could plug into. midenup was still early. Q2 is where most of it shipped.
The work spans four areas: the debugger and compiler, midenup, contract verification, and Miden Playground.
Debugger & Compiler
Why it matters: Last quarter debugger stopped at the edge of a full transaction. This quarter it runs end to end.
By the end of Q1, the debugger could step through Rust logic but stopped where execution crossed into kernel calls. End-to-end debugging, the piece we said would reach developers with the next releases, was the gap. It closed early in Q2. Full transaction debugging shipped across the client stack: developers can step through a complete transaction, against real account state, real note inputs, and the real kernel. It behaves like debugging an ordinary Rust binary, except what's being inspected is a ZK transaction. The workflow is documented in the Miden docs.
Two features make it practical day to day. REPL mode drops developers into an interactive session to poke at state and test assumptions. Variable reading prints what a named variable holds at any point in execution, with cleaner call-stack output alongside it.
Accurate variable inspection only works if the compiler and VM emit correct debug information, and a good part of our effort went into that. Source locations, call stacks, and typed values now line up more reliably with the Rust code developers are debugging.
Flamegraph support also landed in miden-debug v0.8.0, with a Rust API that generates them straight from tests, surfacing where execution time goes without leaving the test suite.
The next step is the editor. The same release added Debug Adapter Protocol (DAP) support, the standard editors speak to debuggers. The VS Code extension now does DAP-based debugging, with Zed close behind. The client-side integration those extensions build on came together at the end of the quarter, so editor-native debugging is what we’re focused on next.
midenup
Why it matters: Foundry made Ethereum development productive. Miden needs the same local toolchain, and midenup is how it gets there.
Q1 left midenup as early building blocks. Q2 is where that loop started to take shape: invoke a contract, test it, verify it.
The call path started in miden-client. The midenup work is to make it available as miden call once the compatible client release is ready. It runs a procedure on a local account and shows both what came back and how account state changed. A read-only call returns the values left on the stack. A state-changing call reports which storage slots moved. That covers the invoke step. The catch is output: miden call still prints raw field elements, so developers have to translate returned values themselves.
We’re working on typed output to close that gap. miden call will read compiler type info, print a real procedure signature, and decode common results instead of dumping raw stack values. A call would read like take-account-id(id: account-id) -> account-id, with the decoded result underneath. That will make local contract calls usable without manually translating field elements.
A local test layer is what we promised in Q1, and we filled it in across the quarter. The work centers on miden-testing, where we cut down the setup a test needs before it can assert anything. Developers can now test note lifecycles, expected failures, storage reads, and authenticated flows with less boilerplate.
miden verify closed the loop late in the quarter. It checks custom account components and notes against deployed code, from the same toolchain a developer already uses to call and test. That ties straight into the next section.
Contract Verification
Why it matters: Verification reduces blind trust in deployed code. Q1 shipped the first version inside MidenScan. This quarter it became infrastructure any tool can build on.
Last quarter, contract verification landed inside MidenScan. This quarter, we pulled that work into standalone Miden Source Code Verification, now used by Miden Playground, and miden verify from the command line.
Contract verification is now shared infrastructure any explorer, wallet, or developer tool can plug into: publish source once, let the ecosystem check what deployed code it matches.
We split the service around two integration points. One API recompiles submitted source and checks it against deployed accounts or notes. Another stores verified results behind an API that explorers, wallets, and developer tools can query, with developer docs in the Miden Source Code Verification repository.
Playground
Why it matters: The Playground is where many developers first try Miden. This quarter we kept it current with Miden's testnet, moved more of the project workflow into the browser, and connected it to shared verification infrastructure.
Q2 kept the Playground aligned with the rest of Miden. We moved it to testnet 0.14, updated the tutorials for the current wallet and SDK flow, and started bringing the Developer Console direction into the product. Developers can now load GitHub-backed examples like Counter Contract and Miden Bank, or import Rust projects from disk, instead of starting every session from an empty sandbox.
Verification now sits inside that loop. Contracts deployed through the Playground verify automatically. Imported contracts and notes can be checked by uploading source, with the Playground routing the request through the shared contract verification service. Once verified, components show their source, expose procedure names, and become callable from the Playground UI.
We moved the Playground closer to Miden's current web SDK stack. Transaction execution, history, and Next.js compatibility now depend less on custom glue, so future testnet upgrades should be easier to absorb.
Much of what we called close in Q1 is now either live or much closer to developers. End-to-end transaction debugging shipped, and editor-native debugging is next. midenup made good progress across calling, testing, and verifying contracts. Verification stands on its own as open infrastructure, a registry and a compilation API anyone can build on. The Playground runs on that same infrastructure. That's the base we carry into Q3 next.