Scalus Intersect Budget Update - Milestone 5 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 5 focused on advanced UPLC optimisation, giving Cardano developers fine-grained control over the entire compilation pipeline (Scala source → SIR → UPLC → Plutus Script) to reduce script size, execution costs, and transaction fees. As well as introducing the new Typed UPLC Expression Builder (equivalent of Plutarch in the Haskell ecosystem) for hand-crafting UPLC & deep optimisation capabilities.

What We Delivered

Advanced Smart Contract Optimisations — End-to-End Guide

A new Advanced Smart Contract Optimisations section was rewritten end-to-end to give Cardano developers a complete, structured guide for reducing script size, execution costs, and fees.

The section walks through every layer of the Scalus compilation pipeline and shows exactly where and how to intervene at each stage:

• Measuring Performance — end-to-end cost measurement (CPU steps, memory units, flat-encoded script size, total transaction fee) computed via the Scalus in-memory Node Emulator.
• Algorithmic Optimisations — backend-agnostic patterns that give the biggest wins: Withdraw-Zero (O(N) instead of O(N²)), UTxO Indexer, Transaction-Level Minting, Merkelised Validators.
• Scala Metaprogramming — using Scala 3 inline, inline if, and compile-time evaluation to optimise Plutus scripts, with measured fee comparisons.
• Direct Builtins Usage — manual control over Data access with 1:1 mapping to UPLC builtins for maximum on-chain efficiency.
• Lowering Backends — choosing between V3 Lowering, Scott Encoding, and Sum of Products, plus controlling type-to-UPLC representation with @UplcRepr annotations.
• UPLC Term DSL — a Scala-based DSL for hand-crafting UPLC validators directly, analogous to Plutarch in Haskell.
• UPLC Optimiser Pipeline — the optimisation passes Scalus delivers (EtaReduce, Inliner, StrictIf, ForcedBuiltinsExtractor, CaseConstrApply), applicable individually for fine-grained control.

New SIR-to-UPLC Lowering Algorithm

The Scalus compiler ships with three backends for lowering SIR (Scalus Intermediate Representation) to UPLC. Each makes a different trade-off between code size, execution cost, and Plutus protocol-version compatibility.

Scala Metaprogramming for UPLC Code Generation

Scala 3 introduces inline and inline if as first-class metaprogramming primitives. The Scala compiler evaluates these expressions at compile time, before the Scalus compiler plugin sees the code, giving developers full control over what reaches UPLC. Bodies can be substituted at call sites, values embedded as constants, and entire computations folded away during compilation.

Supported patterns:

• Function inlining — inline def eliminates let-bindings and per-call lambda overhead
• Constant inlining — embeds compile-time values (public key hashes, configuration, parameters) directly into the generated UPLC, eliminating parameter-passing cost entirely.
• Loop unrolling — inline def combined with inline if and a compile-time-known iteration count produces straight-line code with no recursion.
• Compile-time evaluation of closed functions — fib(100) collapses to a single Const Integer 354224848179261915075 in the compiled script.
• Conditional code generation — inline if over a compile-time Boolean produces separate debug and release scripts from one source.

Typed UPLC Expression Builder

Scalus delivers the typed UPLC expression builder as a Scala-embedded DSL for constructing Plutus Core scripts directly, with the Scala type system enforcing structural correctness. It is Scalus' equivalent of Plutarch in the Haskell ecosystem.

All 100+ Plutus builtins from scalus.uplc.DefaultFun are available via implicit conversion — just import TermDSL.given and write the builtin name directly.

Example: Factorial

A simple example to show the DSL mechanics — computing factorial using a fixpoint combinator:

import scalus.uplc.Term, scalus.uplc.Term.{asTerm, λ, vr}
import scalus.uplc.TermDSL.given
import scalus.uplc.DefaultFun.*
 
// Y-combinator (strict fixpoint)
def pfix(f: Term => Term): Term =
    λ { r => r $ r } $ λ { r => f(r $ r) }
 
val factorial = pfix { recur =>
    λ { n =>
        // Force(Force(IfThenElse) $ condition $ ~thenBranch $ ~elseBranch)
        !(!IfThenElse
            $ (LessThanEqualsInteger $ n $ 0.asTerm)
            $ ~(1.asTerm)
            $ ~(MultiplyInteger $ n $ (recur $ (SubtractInteger $ n $ 1.asTerm))))
    }
}
 
// Wrap as a Plutus program and evaluate
import scalus.uplc.eval.PlutusVM
given PlutusVM = PlutusVM.makePlutusV3VM()
val result = (factorial $ 10.asTerm).plutusV3.deBruijnedProgram.evaluateDebug
// Result: 3628800

Scalus allows combining hand-crafted UPLC fragments with compiler-generated code. For example, you can write a simple validator in Scala, then drop into the UPLC Term DSL or apply targeted Scala 3 macros exactly where the budget pressure is.

import scalus.*, scalus.compiler.compile
import scalus.uplc.Term, scalus.uplc.Term.{asTerm, λ}
import scalus.uplc.TermDSL.given
import scalus.uplc.DefaultFun.*
 
// Compile part of the logic with the plugin
val compiledFragment = compile {
    (x: BigInt, y: BigInt) => x + y
}.toUplcOptimized()
 
// Use it in a hand-crafted validator
val validator = λ { datum =>
    λ { redeemer =>
        λ { ctx =>
            compiledFragment $ datum $ redeemer
        }
    }
}

Performance Optimisations

Six weeks of representation-level optimisations targeting the SIR-to-UPLC lowering pipeline, progressing through five phases:

• opaque-typed Queue;
• list representation parameterisation (SumBuiltinList/SumPairBuiltinList);
• pair representation parameterisation (ProdBuiltinPair);
• @UplcRepr(UplcConstr) type-level annotations;
• @UplcRepr lambda-param plumbing with native intrinsics (appendedAll, Option).

Cumulative impact on real workloads:

SortedMap operations (Mar 13 baseline → Apr 28)

Value arithmetic

Benchmarks (Knights — biggest gain on Apr 15-28)

Validators

Smart Contracts Syntax Tuning

Compile-time partial evaluation in the UPLC optimiser with occurrence analysis for smarter inlining; source positions in UPLC Term and CEK error reporting for precise diagnostics; DebugScript API for diagnostic replay of release scripts (re-evaluating stripped scripts with full traces); strip trace/log statements for release builds; -> operator support in the Scalus compiler plugin; builtin totality annotations for improved dead-code elimination.

Notable fixes: Force(Delay) elimination after inner optimisation in Inliner, free-variable tracking in substitute to avoid name capture, unsaturated builtin applications recognised as WHNF, and inlinedFrom propagation in compileThrowException for inline require.

Public Releases

• 0.16.0 (2026-02-13) — release notes, announcement.

Complete changelog: GitHub.

Community Engagement

The Scalus Club — our early adoption group of 30+ experienced Cardano developers — continues meeting every 4 weeks. Recent session covered dApp development & the van Rossem Hard Fork:

Why This Matters

With Milestone 5, Scalus delivers something the Cardano ecosystem has lacked: a complete spectrum of optimisation control, from idiomatic Scala 3 down to a hand-tuned UPLC AST, all within a single toolchain. Developers no longer have to choose between high-level expressiveness and low-level efficiency. They can write the bulk of a validator in clear Scala, then drop into the UPLC Term DSL or apply targeted Scala 3 macros exactly where the budget pressure is.

The milestone was reviewed and approved by No Witness Labs as third-party assurer, confirming deliverables align with scope and demonstrating that Intersect's milestone-based funding model works.

Treasury reports can be found in the Intersect Treasury Dashboard.

What's Next

Milestone 6 will close out the project with a focus on test data management and end-to-end developer flow — completing Scalus' position as the most complete development solution for smart contract development on Cardano.

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.