Skip to content
Comparison

Mesh SDK vs Evolution SDK: Which off-chain library?

  • Beginner
  • Conway era
  • Settled
  • Updated Nov 2025
Mesh SDK or Evolution SDK

I'm building Cardano off-chain code in TypeScript. Should I use Mesh or Evolution SDK?

TL;DR

Mesh for DApp builders, Evolution for wallet/exchange/infrastructure builders. Mesh prioritises developer experience with high-level helpers and React components; Evolution prioritises composability and control. They're not competitors — they target different layers. Most projects only need Mesh.

Quick pick

If you needChooseWhy
NFT marketplace frontendMeshReact components + minting helpers
DEX trading interfaceMeshWallet UX matters most
Custodial exchange integrationEvolutionNeed control over signing and UTxO management
Mobile wallet appEvolutionDesigned for wallet-grade reliability
Hackathon demoMeshShip the demo in hours
On-chain indexer / data pipelineEvolutionBetter provider abstraction
Tutorial / learning Cardano devMeshLower friction, more examples
Mesh SDK or Evolution SDK

Mesh SDK and Evolution SDK are the two TypeScript-first off-chain libraries that most new Cardano DApp teams pick between in 2026. They cover roughly the same surface (transaction building, wallet integration, multi-provider support, Plutus and Aiken interop, Conway-era governance) but they make very different architectural bets. The right call depends on your runtime targets, your team’s preferred coding style, and whether you want batteries-included frontend tooling or a pure TypeScript core you can compose your own way.

Why this comparison matters

For a long stretch, the Cardano off-chain story was fragmented. You picked Lucid for ergonomics, hand-rolled serialisation-lib bindings if you wanted control, or reached for IOG’s heavier cardano-js-sdk if you were building wallet-grade infrastructure. The picture in 2026 is much cleaner. Two community-funded, TypeScript-first SDKs have emerged as the practical defaults for new DApp builders: MeshJS and Evolution SDK.

Both auto-handle UTxO selection, fee calculation, and change. Both work with Blockfrost, Koios, Maestro, Ogmios, and Kupo. Both target Conway features, including DReps, voting, treasury actions, Plutus V3, and reference scripts. The real differences sit in API design, runtime profile, frontend tooling, and lineage.

Origins

MeshJS started as a community-led open-source project and grew into a Catalyst-funded ecosystem library that now powers NFT marketplaces, DEXs, and a large share of new Cardano DApps. It wraps the underlying serialisation stacks (CSL via @meshsdk/core-csl, CML via @meshsdk/core-cst) and ships a deep set of helpers, React and Svelte components, production-grade smart contract templates, Hydra and Midnight integrations, and Agent Skills for AI coding tools.

Evolution SDK is the next-generation rewrite of Lucid. The lineage runs from Lucid (created by Alessandro Konrad at Spacebudz in 2022), to Lucid Evolution (taken over by Anastasia Labs in late 2023 to keep the library alive), to today’s Evolution SDK from No Witness Labs (co-founded by Jonathan Rodriguez and Mladen Lamesevic). In 2025, Evolution SDK became the first project accepted into Intersect’s Incubation Program. It is pure TypeScript with no WASM, CML, CSL, or libsodium dependencies, built on the Effect library for composable error handling and dependency injection.

Quick framing

If you’re building…Use
A React DApp with wallet connectionMesh
A DApp deploying to Cloudflare Workers, Vercel Edge, or other WASM-hostile runtimesEvolution
An NFT mint or marketplace using ready-made smart contractsMesh
A type-safe DApp using Effect or a functional styleEvolution
A Hydra Layer 2 appMesh
Conway governance toolingEither, both fully support DReps and voting
A migration from Lucid or Lucid EvolutionEvolution (direct successor)
A hackathon projectWhichever your team already knows

Decision tree

  1. Do you need first-party React, Svelte, or wallet UI components? Mesh ships them. Evolution does not.
  2. Are you targeting edge runtimes, Cloudflare Workers, or other environments where WASM is awkward? Evolution is pure TypeScript with zero WASM.
  3. Do you want production-ready smart contract templates (vesting, escrow, NFT mints, marketplaces)? Mesh has the largest contract library in the ecosystem.
  4. Do you prefer Effect-style functional composition, typed errors, and maximum type safety? Evolution is built on Effect end-to-end.
  5. Are you using an AI coding agent (Claude Code, Cursor, Codex)? Mesh ships Agent Skills that teach your tooling the API patterns.
  6. Are you migrating from Lucid or Lucid Evolution? Evolution is the direct successor and the shortest path.

What each makes easier

Mesh strengths

  • First-party React components, including <CardanoWallet /> with a built-in wallet selection modal, hooks like useWallet, useAssets, useLovelace, and dark/light theming out of the box
  • Svelte components for non-React frontends
  • Production-ready smart contract library with full docs and live demos (NFT marketplace, vesting, escrow, content ownership, payment splitter, and more)
  • Hydra Layer 2, Yaci local devnet, and Midnight Network setup in one SDK
  • Mesh CLI for scaffolding new projects with a single command
  • Agent Skills for AI coding tools, with documented patterns, recipes, and common error fixes
  • Long Catalyst funding history and an established community presence

Evolution SDK strengths

  • Pure TypeScript, zero WASM. Runs on Node.js, Bun, Deno, browsers, edge functions, and serverless without native binary friction
  • Tree-shakeable modules, so you ship only what you use
  • Built on Effect for typed errors, retries, dependency injection, and composable async flows
  • Modular package layout: @evolution-sdk/evolution for the core, plus /plutus, /blueprint for Aiken, /message-signing for CIP-8, and /uplc
  • Backed by Intersect’s Incubation Program with structured governance, technical validation, and longevity commitments
  • Cleanest migration path from Lucid or Lucid Evolution codebases
  • Full CDDL spec coverage with round-trip CBOR support across all Cardano types

Common misconceptions

“Mesh is for beginners, Evolution is for advanced devs.” Not really. Both are production-grade. Mesh has more abstraction layers and a larger surface area, which is great when you want to ship fast. Evolution has a smaller core API and pushes you toward Effect patterns that experienced TypeScript devs love but newcomers will need to learn.

“Evolution is just Lucid with a new name.” It is the lineage, but Evolution SDK is a rewrite, not a rebrand. It moves away from CML entirely, adopts Effect throughout the codebase, and reorganises the API around composable clients rather than a single monolithic Lucid object.

“You should use both.” Possible, but rarely a good idea. They overlap in concept (transaction builders, providers, wallet abstractions) with different APIs that do not interop cleanly. Pick one and stick with it. If you genuinely need a feature from the other, write a small adapter at the boundary and isolate it.

“Mesh is heavier because it bundles more.” Mesh is tree-shakable too, and its core package is under 60kB. The bundle size differences in practice are smaller than the marketing implies. Evolution does win on edge and serverless cold starts thanks to having no WASM payload.

Migration path

Moving between the two is mostly a transaction-builder rewrite. Validators, on-chain code, and Aiken contracts do not change. Provider configuration (Blockfrost project ID, Maestro key, Koios endpoint) carries over directly. Wallet handling and signing logic translate cleanly enough.

If you are coming from Lucid or Lucid Evolution, Evolution SDK is the natural destination and the migration is shortest. If you are coming from cardano-js-sdk and want a more DApp-focused SDK, either works, with Mesh offering the gentler on-ramp thanks to its abstraction helpers and React tooling.

Budget roughly 1 to 2 weeks per developer for a moderate codebase, less if your transaction patterns are simple.

When to revisit this decision

  • Your deployment target changes and you suddenly need edge or serverless: consider Evolution
  • You start building a React frontend and want to stop rolling your own wallet UI: consider Mesh
  • Your team standardises on Effect across the wider codebase: Evolution aligns more naturally
  • You need a specific smart contract template Mesh already ships: Mesh saves you weeks
  • A breaking change in your chosen SDK lands awkwardly for your stack: the other is now a real option given how much they overlap

Other comparisons worth reading alongside

  • Aiken vs Plutus vs Plutarch (validator language choice, independent of off-chain SDK)
  • Blockfrost vs Koios vs Maestro vs Ogmios (provider choice, applies to either SDK)
  • Mesh vs cardano-js-sdk (if you specifically need wallet-grade infrastructure with chain-following and PersonalWallet abstractions, which is a different question to this one)

Sources

The options

Mesh SDK

Community-maintained TypeScript SDK with high-level helpers, React components, and opinionated defaults. Optimised for getting DApps shipped quickly.

Pros

  • High-level API — minting, sending, validators in a few lines
  • @meshsdk/react ships ready-made wallet components (CardanoWallet, useWallet)
  • Great documentation and tutorials
  • Large community on Discord, fast issue response
  • Works for 95% of DApp use cases out of the box

Cons

  • Opinionated — harder to customise UTxO selection or fee calculation deeply
  • Fewer escape hatches when you need raw transaction control
  • Version churn historically faster than Evolution

Pick it when: You're building a DApp frontend, a tutorial, a hackathon project, or anything where shipping speed matters more than fine-grained control.

Website

Evolution SDK

Cardano Foundation / IOG-backed monorepo formerly known as cardano-js-sdk. Lower-level, composable primitives. Designed for wallets, exchanges, and infrastructure.

Pros

  • Composable — pluggable UTxO selection, signing, providers
  • Mature, used by production wallets (Lace internally)
  • Better for high-throughput backends or non-DApp use cases
  • More granular control over transaction construction
  • Provider abstraction lets you swap Blockfrost ↔ Ogmios ↔ Kupo cleanly

Cons

  • Steeper learning curve — more boilerplate for simple operations
  • No React components — you wire everything yourself
  • Documentation skews toward wallet/exchange use cases, not DApps
  • Monorepo version pinning can be fiddly (peer-dependency mismatches)

Pick it when: You're building a wallet, exchange integration, indexer, or anything where you need direct control over transaction construction and signing.

Website

About Learn Crypto

Hi, I'm Peter, I've been podcasting since 2013

After years of trading and learning about crypto, I decided that Cardano was my chain of choice and put all my efforts into understanding everything about Cardano and the broader crypto and blockchain space. Learn Crypto is where I share all that I learn with you.

Follow & contact Peter (opens Chatsoon in a new tab)

Peter Bui
ADAOZ Stake Pool

Support Our Content

Delegate to Our Stake Pool ADAOZ

Delegate to our stake pool and help us continue to create content for the Cardano ecosystem.

Pool ID: 6658713e2cbfa4e347691a0435953f5acbe9f03d330e94caa3a0cfb4

Stake Your ADA

Keep Up To Date!

Sign up for our newsletter. Latest crypto news, airdrops, courses and everything you need to know about Cardano, Midnight and the wider crypto space.