Java Developers Already Know How to Build on Cardano

Many Java developers believe the same thing about blockchain: it is a separate world, one with new languages, new tools and a new way of thinking. They assume they'd have to start from zero in order to get in, but that's not really accurate. At least not on Cardano.

Let's run a simple three-question test:

1. Can you add a dependency to a pom.xml?
2. Can you write a @Test method?
3. Can you call a REST endpoint?

If so, then you already have the skills that matter most. Of course some ideas will be new, like how a UTXO ledger works or what a validator script does, but you can learn them slowly while you build with tools you already know. You won't have to fight a new language, build system and test framework all at the same time.

Most of what people regard as the pain of developing on blockchain comes from having to learn several new things at once. Remove the majority of them, and suddenly everything becomes much easier than expected.

This post will show how Java developers build on Cardano today using the open-source BloxBean tools. It will also provide an early look at three experimental projects setting the future for blockchain.

The basics of Cardano's transaction architecture

Cardano uses the extended UTXO (EUTXO) model, which has some key differences from the account-based model you may have encountered before. Instead of updating a shared account balance, with EUTXO each transaction spends existing outputs and creates new ones. Every output can also define the conditions under which it can be spent. When building a transaction on Cardano, you need to make sure those conditions are met. If they are, the transaction succeeds. If they are not, it fails. Because those conditions are known before submitting the transaction, you can predict the outcome in advance. Fees work the same clear way: they are fixed by a formula, so you are not guessing or bidding in a busy fee market. If you have spent years caring about systems that behave the same way every time, this will feel familiar.

The EUTXO model is also good for running things in parallel. Independent transactions use independent outputs, so they do not fight over the same shared state. And with regulations like MiCA now shaping how companies handle digital assets, Cardano's focus on security and predictability makes it a strong choice for supply chains, finance, the public sector, manufacturing and many other industries.

Best of all, none of this asks you to leave the JVM. In fact, Cardano has a robust Java ecosystem and BloxBean will help you hit the ground running.

A toolkit Java developers can use today

BloxBean is a group of open-source, Java-first libraries for Cardano. It features familiar APIs, a clean build setup and a local development stack that lets Java developers start fast.

The main parts work together like this:

• Cardano Client Lib sets the base. It is a pure-Java library. You use it to build and sign transactions, manage keys and addresses, and talk to the network. Its API uses a clear, builder-style that reads the way any good Java tool should read.
• Yaci is a Java version of Cardano's node protocols. It establishes the low-level layer that lets your app speak directly to the node.
• Yaci Store is a chain indexer built on top of Yaci. It reads and stores on-chain data, then provides it through Spring Boot event listeners. So reading blockchain events feels like reading any other event stream in your app.
• Yaci DevKit starts a private, throw-away Cardano network on your machine in seconds, using Docker. You can test against a real ledger without touching a public testnet.

You add these the same way you add anything else:

<dependency>
    <groupId>com.bloxbean.cardano</groupId>
    <artifactId>cardano-client-lib</artifactId>
    <version>0.7.2</version>
</dependency>
Copy

No new package manager, and no new command-line tool to learn before you can print a "hello world."

What the workflow looks like

First you start a local network. The Yaci DevKit will produce a full local Cardano network in seconds, providing not just test accounts with funds but also fast feedback. Just like with test containers, you can create it and delete it as often as you want.

Then you build a transaction with an API that reads like Java, so that sending funds is just one clear, chained call, without any need for a long list of protocol details:

Tx tx = new Tx()
    .payToAddress(receiverAddress, Amount.[ada](https://cardanofoundation.org/glossary?search=ada)(10))
    .from(senderAddress);

Result<String> result = new QuickTxBuilder(backendService)
    .compose(tx)
    .withSigner(SignerProviders.signerFrom(senderAccount))
    .completeAndWait();
Copy

If you have ever written a builder in your own code, none of this is new. The library handles the fee, picks the inputs and does the rest behind that clean surface.

Monitoring and reacting to on-chain events also happens as in any other event stream. Just open Yaci Store and use Spring Boot code to watch the chain:

@Component
public class TransferListener {

    @EventListener
    public void onTransaction(TxEvent event) {
        // Handle new transactions the same way you
        // handle any other application event
    }
}
Copy

Finally, test the way you test everything else. The local network is real and always behaves the same, so your integration tests are true ones.

Implementing blockchain solutions with Java

Teams already run full blockchain projects, solutions and systems on Java.

Reeve, for instance, is a platform for financial record integrity. It uses Cardano to store trusted financial data. Built in Java, it uses Spring Boot and a Spring Modulith architecture, with its reporting core, blockchain publisher and reader, and ERP adapters operating as independent modules. Reeve is currently available under the Apache 2.0 license.

OriginateNavio brings supply chain verification on-chain, giving products a record of origin that cannot be altered. It captures supply chain and certification data at the source, links each product to a unique identifier and makes its history accessible through a QR code. Verified information is permanently recorded on Cardano, enabling provenance to be checked instantly by anyone.

USDM, a fiat-backed stablecoin, is built on Cardano Client Lib for its off-chain work.

Different fields, all using Java tools to build serious things on Cardano.

Three preview projects at the edge of Java for blockchain

Everything above is stable and used in production today. What comes next are three open-sourced projects, not yet ready for production. Their APIs and storage formats might still change between releases, so this section is just a glimpse into the future, not a base to build a product.

Yano: a Cardano data node written in Java

Status: still in active development

Yano is a Cardano data node written in Java and built on Yaci and Cardano Client Lib. It stores ledger state in RocksDB. In addition, it runs both as a standalone Quarkus app and as a library you can put inside your own Java program.

This means Yano can run a Cardano node inside your own processes, allowing you to do away with extra outside servers when building in-process indexers, wallets, validation tools or even research setups. Yano keeps full ledger state, including the UTXO set, accounts, stakes, delegations and rewards, epoch snapshots and Conway-era governance such as DReps and proposals, with full rollback support.

For testing, Yano offers some ideal features: it can produce blocks in a fixed, repeatable way from genesis, and it can even time travel into the past. To do so, just start a local network in the past, replay blocks the same way every time, and then catch up to the real clock. This gives Java integration tests a real, repeatable network that produces blocks and supports replay.

@RegisterExtension
static YanoDevnetExtension yano = YanoDevnetExtension.devnet()
        .startNode()
        .blockTimeMillis(200)
        .epochLength(60);

@Test
@DisplayName("A real devnet boots inside the test JVM and produces blocks")
void devnetBootsAndProducesBlocks(YanoDevnetTestKit kit) {
    kit.await().untilReady();
    kit.await().untilBlockAtLeast(2);

    var tip = kit.queries().tip();
    System.out.printf("  tip: [slot](https://cardanofoundation.org/glossary?search=Slot)=%d block=%d epoch=%d%n",
            tip.getSlot(), tip.getBlockNumber(), kit.queries().currentEpoch());

    assertThat(tip.getBlockNumber()).isGreaterThanOrEqualTo(2);
    kit.assertions().nodeIsRunning().runtimeNotDegraded();
}
Copy

JuLC: write Plutus smart contracts in Java

Status: experimental research project; not for production

JuLC, pronounced "jool-see," is an experimental Java-to-UPLC compiler. You write Cardano smart contracts in a subset of Java and it turns them into Plutus V3 UPLC bytecode (the on-chain form that Cardano validators actually run).

The goal is to write validators in the language you already use. It supports records, sealed interfaces and pattern matching, as well as lambdas and higher-order functions, generic tuples and multi-validator setups. A spending validator looks like a small, easy-to-read Java class:

@SpendingValidator
public class MultiSigTreasury {

    record TreasuryDatum(byte[] signer1, byte[] signer2) {}

    @Entrypoint
    public static boolean validate(TreasuryDatum datum, BigInteger [redeemer](https://cardanofoundation.org/glossary?search=Redeemer), ScriptContext ctx) {
        TxInfo txInfo = ctx.txInfo();
        ContextsLib.trace("Checking signers");
        return checkBothSigners(txInfo, datum.signer1(), datum.signer2());
    }

    static boolean checkBothSigners(TxInfo txInfo, byte[] s1, byte[] s2) {
        var sigs = txInfo.signatories();
        boolean hasSigner1 = sigs.contains(PubKeyHash.of(s1));
        boolean hasSigner2 = sigs.contains(PubKeyHash.of(s2));
        return hasSigner1 && hasSigner2;
    }
}
Copy

It also comes with a standard library for areas such as math, lists, cryptography and more. Moreover, JuLC has a pluggable VM for local testing that uses Scalus (a Scala-based Plutus VM) as the backend for cost estimates and testing. It ships with a testkit so you can run validators locally without a node, and it works closely with Cardano Client Lib for deployment.

ZeroJ: zero-knowledge proofs in pure Java and checked on-chain

Status: experimental; only for research and learning, not for production

ZeroJ is an experimental Java toolkit for creating, proving and checking zero-knowledge proofs, including on-chain checks on Cardano.

It does cryptography in pure Java without any native libraries. You define circuits in a Java DSL, then generate proofs with a pure-Java prover that supports Groth16 on the BLS12-381 curve, check them locally, and finally check them on-chain with Plutus V3 validators.

ZeroJ has a built-in library with primitives like Poseidon hashing and Merkle trees. It also allows optional backends (a gnark native prover, snarkjs CLI support), and its Cardano integration runs through JuLC for the on-chain part.

A circuit reads like normal Java:

@ZKCircuit(name = "secret-multiplier", version = 1)
public class SecretMultiplier {

    @Prove
    ZkBool prove(
            ZkContext zk,
            @Public ZkField a,
            @Public ZkField product,
            @Secret ZkField b) {
        return a.mul(b).isEqual(product);
    }
}
Copy

The same warnings apply: ZeroJ is at an experimental stage and not suitable for production yet. It is, however, already available for research purposes. It ultimately aims to provide full zero-knowledge from a Java-defined circuit to a proof checked by a Cardano smart contract, all without leaving the JVM.

Today, Java developers can build, test and ship real Cardano apps using only Java, all the while keeping to the same build tools and the same tests they're already accustomed to. Tomorrow, they might just use Java to write smart contracts and verify zero-knowledge proofs on-chain.

So try out the preview projects. Give them a spin, experiment, and tell us what worked and what didn't. Every issue you report, every suggestion or contribution you share, makes building on blockchain with Java easier and faster. It will also help to shape what comes next.

Key Links

• Cardano Client Lib: GitHub
• Yaci DevKit: GitHub | Documentation
• Yaci: GitHub
• Yaci Store: GitHub
• Yano: GitHub
• JuLC: Tool Page
• ZeroJ: GitHub
• CF Java Rewards Calculation: GitHub
• Reeve: Product Page | GitHub
• OriginateNavio: Product Page
• USDM by Moneta: Product Page
• Cardano Developer Portal: Website