Built by Lantr Engineering · in continuous development since 2024

Scalus is a production-ready Smart contract & dApps development platform for Cardano built in Scala 3. It covers the full development journey: build, test, debug, optimise, integrate, deploy, and operate a protocol/application in one integrated stack.

It's built for teams shipping L2s, bridges, DEXs, and other systems where the contract is only one part of what has to be correct.

Scalus covers the full Cardano development lifecycle: write validators, compile and optimize UPLC, test and debug locally, build transactions, generate blueprints, deploy scripts, and run tooling across JVM, JavaScript/TypeScript, and Native targets.

Scalus is not just a Scala-to-UPLC compiler. It is an integrated Cardano development stack.

Scalus is designed so the same core Cardano model can be used across the parts of an application that usually drift apart: on-chain validators, backend services, browser or Node.js tooling, transaction builders, and local test infrastructure.

On JVM, Scalus provides the full Scala developer experience: compiler plugin, transaction builder, ledger/emulator APIs, testing, profiling, and integration with JVM Cardano tooling. On JavaScript/TypeScript, the scalus npm package exposes the emulator, Plutus script evaluation, cost calculation, and related Cardano utilities for Node.js and browser-oriented workflows. Native support keeps the evaluator and low-level tooling available where embedding or performance-sensitive execution matters.

Aiken is a focused Cardano smart-contract language. Plutarch gives Haskell teams low-level control over generated Plutus code. Yaci DevKit provides a local Cardano devnet. Balius explores headless Cardano application runtimes.

Scalus has a different center of gravity: it aims to be a full JVM-based Cardano development platform, built around Scala 3 and available across JVM, JavaScript/TypeScript, and Native targets. It combines smart-contract development, the compiler pipeline, optimization controls, transaction building, ledger/emulator workflows, testing, debugging, profiling, CIP-57 blueprints, example contracts, and multiplatform tooling in one stack.

That matters for teams building non-trivial protocols, because the hard part is rarely only writing a validator. The hard part is keeping contracts, off-chain code, tests, transaction flows, deployment artifacts, and long-term operations coherent as the protocol evolves.

Read more: How Scalus Differs.

Create a minimal Scalus validator project:

sbt new scalus3/hello.g8
cd hello-cardano
sbt test

This generates a Plutus V3 spending validator, unit tests, integration tests, and a compiled contract wrapper.

For a fuller dApp-ready starter with CIP-57 blueprint generation and deployment tasks:

sbt new scalus3/validator.g8

Next steps:

• Getting Started — setup and first validator
• First Smart Contract — write, compile, and test validators
• Transactions — build and submit Cardano transactions
• Testing — unit tests, emulator, debugging, and profiling

Use the latest published Scalus version. Maven Central currently lists 0.18.2.

project/plugins.sbt:

addSbtPlugin("org.scalus" % "scalus-sbt-plugin" % "0.18.2")

build.sbt:

scalaVersion := "3.3.8"

val scalusVersion = "0.18.2"

addCompilerPlugin(
  "org.scalus" % "scalus-plugin" % scalusVersion cross CrossVersion.full
)

libraryDependencies ++= Seq(
  "org.scalus" %% "scalus" % scalusVersion,
  "org.scalus" %% "scalus-cardano-ledger" % scalusVersion,
  "org.scalus" %% "scalus-testkit" % scalusVersion % Test
)

Use scalus for on-chain validators and UPLC compilation, scalus-cardano-ledger for transaction building and ledger/emulator APIs, and scalus-testkit for validator and transaction tests.

npm install scalus

import { Emulator, SlotConfig, Scalus } from "scalus";

The JS/TS package provides the in-memory Cardano emulator, Plutus script evaluation, cost calculation, and related Cardano tooling.

Here's a real validator, checking a signature and a redeemer, compiled to production UPLC:

@Compile
object HelloCardano extends Validator {
    inline override def spend(
        datum: Option[Data],
        redeemer: Data,
        tx: TxInfo,
        ownRef: TxOutRef
    ): Unit = {
        val owner = datum.getOrFail("Datum not found").to[PubKeyHash]
        val signed = tx.signatories.contains(owner)
        require(signed, "Must be signed")
        val saysHello = redeemer.to[String] == "Hello, World!"
        require(saysHello, "Invalid redeemer")
    }
}

// compile to Untyped Plutus Core (UPLC)
val compiled = PlutusV3.compile(HelloCardano.validate)
// HEX encoded Plutus script, ready to be used with cardano-cli or Blockfrost
val plutusScript = compiled.program.doubleCborHex

The examples project contains Contract objects with CIP-57 blueprint definitions. Generate the catalogue locally with:

sbt scalusExamplesJVM/blueprint

The ScalusSbtPlugin also embeds generated JSON files in packaged JARs under META-INF/scalus/blueprints/<ContractName>.json.

Script evaluation & cost calculation utilities for JVM.

In-memory Cardano node emulator, script evaluation & cost calculation utilities for JS/TS.

• Milestone 2
• Milestone 3
• Milestone 4
• Milestone 5
• Milestone 6

See CONTRIBUTING.md for the full contributor guide.

The default contributor workflow expects Java 11+ and sbt. The recommended full toolchain setup is:

nix develop

Then use sbtn or sbt from the repository root.

The public documentation site lives in scalus-site and uses pnpm:

cd scalus-site
pnpm install
pnpm dev

Follow our progress on X (@Scalus3) and X (@lantr_io).

Join Scalus Club for early access and to shape the roadmap.

Questions or feedback? Reach out on Discord or email us at [email protected].