Skip to content
Mesmo

Overview

Mesmo compiles Cardano Client Lib (CCL) into a native shared library (libmesmo.so / libmesmo.dylib / libmesmo.dll) using GraalVM native-image. Any language can call CCL’s offline Cardano operations via FFI — no JVM required at runtime.

Where this fits in the ecosystem

Section titled “Where this fits in the ecosystem”

To be clear about what this is not: Cardano has excellent native libraries in all four of these languages — pycardano (Python), MeshJS and Lucid Evolution (TypeScript), pallas (Rust), gOuroboros and Apollo (Go), among others. If one of them serves your needs, use it — these bindings are not trying to replace them.

The bindings exist for the cases where a native library doesn’t quite fit:

  • Filling functionality gaps. When your library is missing a capability — Conway-era governance operations, offline Plutus execution-unit costing, DRep/committee key derivation, HD wallets — the bindings give you CCL’s full offline surface for exactly those pieces. Because they’re offline and stateless, they slot in alongside your existing library; no rip-and-replace.
  • A different API model. If you’re not happy with an imperative builder API, CCL’s declarative TxPlan YAML — describe the transaction, let the library select UTXOs, compute fees, and handle change — may fit you better.
  • One behavior, four languages. When the same transaction-building semantics must hold across polyglot services, a single core beats four independent implementations that can drift.
  • CCL semantics outside the JVM. Teams already using Cardano Client Lib get the same behavior — same test suite, same edge cases — in their non-JVM code.
  • A maintained fallback. Native libraries have occasionally gone unmaintained; these bindings ride on CCL’s active maintenance.

The honest costs of this approach: a ~50 MB platform-specific native binary in your dependency tree, no node-protocol/chain-sync support (offline operations only, by design), and platform gaps a pure-language library wouldn’t have.

Why?

Section titled “Why?”

Cardano Client Lib is a mature, feature-rich Cardano SDK covering key derivation, transaction building, Plutus data handling, governance, and more. Mesmo makes selected CCL modules available as a native shared library with a C ABI, so Python, Go, Rust, and JavaScript reuse CCL’s exact, well-tested behavior — whether as the foundation for a wrapper library, a transaction builder, or for individual functions like crypto, address parsing, and CBOR serialization.

What’s included

Section titled “What’s included”

The bindings expose CCL’s offline/local operations:

AreaOperations
AccountCreate accounts, derive keys, export public/private keys, sign transactions
AddressParse, validate, convert between bech32 and bytes
CryptoBlake2b hashing, mnemonic generation/validation, Ed25519 sign/verify
TransactionSerialize, deserialize, hash, sign transactions
PlutusPlutusData CBOR/JSON conversion, datum hashing
ScriptNative script parsing, script hashing
GovernanceDRep, committee cold/hot key derivation
HD WalletCreate wallets, derive addresses
QuickTxTxPlan YAML-driven offline transaction builder: payments, staking, governance, Plutus scripts, multi-party compose

Backend/HTTP modules (Blockfrost, Koios, Ogmios) are intentionally excluded from the native library — every language has good HTTP clients, and each wrapper ships optional provider helpers instead.

The four wrappers

Section titled “The four wrappers”

All four wrappers are first-class and kept at strict parity — same API groups, same error codes, same TxPlan format — differing only in language idiom:

LanguageGuidePackage
JavaScript (Bun)docs@bloxbean/mesmo (npm)
Godocsgithub.com/bloxbean/mesmo/wrappers/go
Rustdocsmesmo (crate, imported as mesmo)
Pythondocsmesmo (PyPI, imported as mesmo)

How big is it?

Section titled “How big is it?”

The native library is a ~50–60 MB platform-specific binary (the embedded Scalus UPLC evaluator for offline Plutus costing accounts for ~12 MB of that). Wrapper packages that bundle it (Python wheels, npm platform packages) are correspondingly large; Go and Rust fetch it once and cache it. See Platforms & Packages for the full story, and Caveats & Limitations before relying on specific functions.

Where to next

Section titled “Where to next”