Built on Cardano Client Lib · fully offline
One mature Cardano codebase,
exported to four languages.
Cardano Client Lib — the Java SDK behind production Cardano systems — compiled to a plain native library. Offline key derivation, transaction building, signing, Plutus, and governance from Python, Go, Rust, and JavaScript. Nothing extra to install, no JVM anywhere in your stack.
Where this fits
Cardano already has excellent native libraries — pycardano, MeshJS and Lucid Evolution, pallas, gOuroboros, Apollo, and more. If one of them serves you well, use it. These bindings shine when it doesn't quite: when a native library is missing a capability you need, or its API doesn't fit how you work, you get Cardano Client Lib's exact, well-tested semantics — identically in four languages — without leaving your stack. Being offline and stateless, they slot in alongside an existing library for just the missing pieces: no rewrite, no migration. It may feel less idiomatic than your native library — and if a native implementation catches up later, swapping back out is just as easy. The point is that you keep moving in the meantime.
Choose these bindings when…
- your native library is missing functionality you need — e.g. Conway governance operations, offline Plutus costing, HD-wallet or DRep key derivation — use these bindings for just those pieces, alongside it
- you're not happy with an API and prefer CCL's model — declarative TxPlan YAML instead of imperative builders
- you want identical transaction-building behavior across several languages or services, or already use CCL on the JVM
- you want offline building backed by CCL's test suite and devnet-verified intent shapes, and insurance against a library going unmaintained
Choose a native library when…
- you prefer a pure-language dependency — these bindings ship a ~50 MB native binary
- you need node protocols / chain sync — deliberately out of scope here
- your platform isn't covered (e.g. macOS Intel)
- an idiomatic library already fits your stack — no need to switch
Same semantics in every language
Same API groups, same error codes, same TxPlan YAML — kept at parity and enforced by CI.
import { Mesmo, TESTNET } from '@bloxbean/mesmo';
const Mesmo = new Mesmo();
using account = lib.accounts.create(TESTNET);
const result = lib.quicktx.build(yaml, utxos, params);
const signed = account.signTx(result.tx_cbor);
// fully offline — submit signed cbor with any HTTP clientlib, _ := mesmo.New()
defer lib.Close()
account, _ := lib.Accounts.Create(mesmo.Testnet)
defer account.Close()
result, _ := lib.QuickTx.Build(yaml, utxos, params)
signed, _ := account.SignTx(result.TxCbor, mesmo.RolePayment)
// cross-compiles: pure Go, no C toolchainlet Mesmo = mesmo::Mesmo::new()?;
let account = lib.account().create(mesmo::network::TESTNET)?;
let result = lib.quicktx().build(&yaml, &utxos, ¶ms)?;
let signed = lib.account()
.sign_tx(&mnemonic, mesmo::network::TESTNET, 0, 0, &result.tx_cbor)?;
// native lib fetched once at first build, then cachedfrom mesmo import Mesmo, Network
with Mesmo() as lib, lib.accounts.create(Network.TESTNET) as account:
result = lib.quicktx.build(yaml, utxos, params)
signed = account.sign_tx(result["tx_cbor"])
# wheels bundle the native library — pip install and goWhy these bindings
Nothing extra to install
Ships as a plain native library with a C ABI, compiled ahead of time — native startup, small footprint, and no JVM anywhere in your stack.
Fully offline by design
Key derivation, transaction building, signing, Plutus data — no network calls, no submission, no secrets in the library. You bring chain data; optional providers fetch it for you.
One YAML transaction format
Describe payments, staking, governance, minting, and Plutus operations as TxPlan YAML — identical across all four languages, with a verified intent catalog.
Offline Plutus costing
The embedded Scalus UPLC evaluator computes execution units in-process. Override with explicit units or a remote evaluator when you want node-backed costing.
Four first-class wrappers
Python, Go, Rust, and JavaScript (Bun) are kept at strict parity — same API groups, same error codes, enforced by CI. No second-class language.
AI-friendly from day one
llms.txt, a full-docs dump, and an AI Starter Pack distilled for agents: point Claude Code or Cursor at one URL and generate correct code immediately.
Proven engine, new bindings
Most ecosystem libraries are maintained by small teams in their spare time, so after a hard fork some features can lag. The Java Cardano stack is maintained full-time and has a track record of picking up new protocol features quickly. These bindings are brand new — nobody runs them in production yet. What is proven is the engine inside them: Cardano Client Lib has powered production Cardano systems — exchange integrations, governance platforms, indexers — for years. The bindings compile and export that same library, with the same code, tests, and maintainers. Only the calling language changes.
Bring your AI agent
The docsite ships llms.txt, a full-docs dump, and a distilled
Starter Pack. One curl and Claude Code, Cursor, or any agent
writes correct code against the bindings.
$ curl -o CLAUDE.md https://getmesmo.dev/ai/starter-pack.md