Scalus — Smart contract & dApps Development Platform for Cardano

Built by Lantr Engineering · in continuous development since 2024

Vision

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.

---

What Scalus includes

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.

---

Platform at a glance

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

---

Multiplatform support

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.

---

Versioning and stability

Starting with 1.0.0-M1, scalus-core, scalus-cardano-ledger, and scalus-bloxbean-cardano-client-lib form the stable API surface, checked with MiMa on every build. Most APIs will remain binary compatible across the 1.x line; some parts will likely still see breaking changes in 1.x releases, always following a deprecation cycle. scalus-testkit is best-effort, and *.internal packages and compiler internals carry no compatibility promise (concretely: scalus.compiler.sir.lowering, scalus.compiler.sir.linking, scalus.compiler.intrinsics, scalus.uplc.builtin.internal and scalus.uplc.internal are exempt from the MiMa check; see mimaBinaryIssueFilters in build.sbt). Upgrading from 0.18.x? See the migration guide.

---

How Scalus differs

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.

---

Quickstart

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

---

Learning paths

---

Installation

Scala / sbt

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

project/plugins.sbt:

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

build.sbt:

scalaVersion := "3.3.8"

val scalusVersion = "1.0.0"

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.

JavaScript / TypeScript

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.

---

Quick Look

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

Compilation pipeline

---

Repository map

---

Blueprint catalogue

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.

---

Used by

Protocol & application development

Integrating Scalus Components

JVM

Script evaluation & cost calculation utilities for JVM.

JavaScript / TypeScript

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

---

Previous funding

Reports 2025

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

---

Contributing

See CONTRIBUTING.md for the full contributor guide.

Local setup

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.

Useful commands

Website docs

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

cd scalus-site
pnpm install
pnpm dev

---

Contact

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 contact@lantr.io.