Scalus Intersect Budget Update - Milestone 6 Delivered

As part of our commitment to transparency in Cardano's decentralized governance, we're sharing progress on our Intersect-administrated project: Scalus - Smart contracts & dApps Development Platform (EC-0020-25).

Milestone 6, the final milestone of the project, focused on the accelerated end-to-end development cycle: shortening the feedback loop between writing a validator in Scala and running, testing, profiling, and deploying it on Cardano. It rounds out Scalus with a comprehensive command-line interface, a test-data management toolkit, a one-command contract deployment tool, and a full profiling & diagnostics suite, improving overall developer productivity across the whole workflow.

What We Delivered

Comprehensive CLI

Scalus leverages the Scala sbt tool to provide a comprehensive CLI that supports the full smart contract development cycle: initiation, testing, integration, and deployment. It reduces the manual work required during development and gives developers a repeatable workflow for moving from Scala source code to compiled Plutus artifacts and testable scripts. The full command reference is documented under Project Commands.

sbt new scalus3/validator
sbt test
SCALUS_TEST_ENV=yaci sbt test
sbt blueprint MyContract
sbt "deploy MyContract --network preprod --blockfrost-key <key> --mnemonic '<24 words>' --address <bech32-address>"
sbt clean

Test Data Management Toolset

The test data management toolset helps developers model realistic validator inputs and transaction datums without rebuilding the same fixtures for every scenario. It supports configurable datasets for test-library actors (alice, bob, …) or raw bech32 addresses, custom datums (inline, CBOR, hash hex), and deterministic validator inputs (tx_id, index).

Datasets are provided in a generic JSON format that integrates seamlessly with the Scalus testing utilities and the Cardano node emulator:

{
  "utxo": {
    "alice": [
      { "ada": 10000 },
      { "ada": 5, "datum": { "int": 42 } }
    ],
    "bob": [{ "ada": 5000, "datum_hash": "abcd..." }],
    "addr_test1qz...": [{ "ada": 100, "tx_id": "abcd...", "idx": 0 }]
  }
}

import scalus.testing.{ImmutableEmulator, Preconfiguration}

val emulator = ImmutableEmulator.fromJson(json)

Smart Contract Deployment Toolkit

The new deploy command is integrated into the Scalus CLI and creates a reference script UTxO from a Contract object. It extracts the compiled script, attaches it to a new UTxO, builds and signs the transaction, and submits it via Blockfrost:

sbt "deploy MyContract --network preprod --blockfrost-key <key> --mnemonic '<24 words>' --address <bech32-address>"

Using environment variables keeps secrets out of shell history:

export BLOCKFROST_API_KEY=preprodXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
export CARDANO_MNEMONIC="word1 word2 ... word24"
export CARDANO_NETWORK=preprod

sbt "deploy MyContract --address addr_test1q..."

Profiling & Diagnostics

The CEK profiler matured into a full diagnostic suite. EvaluatorReportConfig (env-overridable via SCALUS_DUMP / SCALUS_PROFILE*, or straight from the CLI with SCALUS_PROFILE=1 sbt test) produces text, CSV, and JSON output alongside a self-contained interactive HTML report — sortable tables, a by-source-location view, a call graph, a hot-paths tree, per-line annotated source, and a transition-matrix heatmap.

The by-source-location view ranks every source position by cost and expands into a hot-paths call tree, while the annotated-source view maps CPU, memory, evaluation count, and fee back onto each line of the original Scala contract — highlighting exactly where the budget is spent:

Evaluator debug dumps now use stable, overwriting filenames plus a manifest.json index instead of accumulating volatile per-txid files, making profiling runs reproducible and easy to diff.

Ongoing Platform Improvements

Driven by adopter feedback, releases 0.17.x and 0.18.x hardened the language, testing, and off-chain layers.

Smart contract syntax & capabilities — V3 == now routes to structural equality, with non-structural types (Rational, AssocMap) excluded from the Eq system in favour of explicit RationalEq / AssocMapEq. Opaque types are now supported in FromData / ToData and the compiler plugin, and new helpers landed: Map.singleton / Map.empty factories, List.unboxedNil, and Options.noWarn.

Testing library — a new agent-based testing model in scalus-testkit (ContractTestActor), dual-budget testing across evaluation modes (assertEvalWithBudgets, PlutusV3.withOptions), gated CEK diagnostic assertions that catch native-UC vs Data representation mismatches, and conformance vectors that now run inside cardano-ledger's Imp slot/epoch environment.

Transaction builder & emulator — CellValidator with a full UtxoCell lifecycle, hardened against known vulnerability patterns and shipped with an AuctionCell reference example; the UtxoFlow framework for multi-transaction off-chain flows with compile-time safety checks; emulator preconfiguration (JSON pre-init, custom datums, an extended JS API); and Conway certificate mutators for stake-pool and DRep/voting certificates in scalus-cardano-ledger.

Scala 3 cross-build — scalus-plugin and scalus-core now build on both 3.3.7 LTS and 3.8.x, isolating the diverging compiler API behind a PluginCompat trait so adopters can stay on the Scala version that suits them.

Public Releases

• 0.17.0 (2026-05-08) — release notes, announcement.
• 0.18.0 (2026-06-11) — release notes.
• 0.18.1 (2026-06-16) — release notes.
• 0.18.2 (2026-06-19) — release notes.

Every release is validated through automated CI pipelines that build the project and run the full unit and integration test suite on the latest stable Scala 3 and JDK, ensuring correctness, stability, and backwards compatibility across modules (CI evidence). Complete changelog: GitHub.

Community Engagement

The Scalus Club — our early adoption group of 30+ experienced Cardano developers — continues meeting every 4 weeks. The most recent session covered the DApp Starter Kit, the JS Emulator, and the Plutus V11 hard fork:

Why This Matters

With Milestone 6, the full Scalus workflow closes the loop. A developer can scaffold a project, write a validator in idiomatic Scala, seed realistic on-chain state from a JSON fixture, run it against the in-process emulator or a Yaci devnet, profile the exact source lines that burn budget, and deploy a reference script to preprod — all through a single sbt-based toolchain, without leaving the language. The shorter this loop, the faster teams ship correct contracts, which is the entire point of an end-to-end development platform.

Treasury reports can be found in the Intersect Treasury Dashboard.

What's Next

Milestone 6 completes EC-0020-25. Across six milestones the project delivered the smart contract compiler, the transaction builder and off-chain stack, ecosystem integrations, a full testing framework, advanced UPLC optimisation, and — with this milestone — the accelerated end-to-end development cycle we promised to close out on. Scalus is now the most complete development solution for building applications on Cardano in a single language.

Development doesn't stop here: Scalus remains actively maintained and open source, and we've laid out the next chapter — extending from development into runtime, chain access, and scaling — in our 2026 Treasury proposal.

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.