Scala Online Compiler | Free Online Compiler

Code

object Main extends App {
    println("Hello, Scala!")
    if (args.nonEmpty) {
        println("First arg: " + args(0))
    }
}

STDIN (optional)

Args (space separated)

Output

What Is the Scala Online Compiler?

This tool lets you compile and run Scala programs directly in your browser without installing the Scala toolchain or JVM on your machine. Whether you are learning Scala for the first time or quickly testing functional programming patterns and case classes, this compiler provides a fast way to write and execute Scala code online.

Your code must include an entry point, typically an object extending App or containing a def main(args: Array[String]) method. You can use println() to print output, define case classes, use pattern matching, and leverage the full Scala collections library.

All code executes on a remote sandboxed server powered by the Piston API. Your browser sends the source code to the server, which compiles it with the Scala compiler and runs the resulting bytecode inside an isolated container. Scala's type system, pattern matching, and functional programming features are fully available.

How It Works

Write your Scala code in the editor panel. The editor starts with a simple "Hello, Scala!" example using object Main extends App, but you can replace it with any valid Scala program.
Provide input in the STDIN field if your program reads from standard input using scala.io.StdIn.readLine(). Leave this field empty if your program does not require input.
Add command-line arguments in the Args field if your program reads from the args array. Enter arguments separated by spaces.
Click the Run button to send your code to the Piston execution server. The server first compiles your Scala source code, then runs the resulting program and captures all output.
View the results in the Output panel. You will see everything your program prints to standard output, along with any compiler errors including type mismatches, missing implicits, or runtime exceptions.

Step-by-Step Example

Suppose you want to write a program that demonstrates pattern matching with case classes. Here is how you would do it:

First, type the following code into the editor panel:

sealed trait Shape
case class Circle(radius: Double) extends Shape
case class Rectangle(width: Double, height: Double) extends Shape
case class Triangle(base: Double, height: Double) extends Shape

object Main extends App {
    val shapes: List[Shape] = List(
        Circle(5.0),
        Rectangle(4.0, 6.0),
        Triangle(3.0, 8.0)
    )

    shapes.foreach { shape =>
        val area = shape match {
            case Circle(r)       => math.Pi * r * r
            case Rectangle(w, h) => w * h
            case Triangle(b, h)  => 0.5 * b * h
        }
        println(f"$shape: area = $area%.2f")
    }
}

This example demonstrates several Scala features: sealed traits for algebraic data types, case classes with automatic pattern matching support, a List collection, the foreach higher-order function, match expressions with destructuring, and formatted string output with f interpolation.

Click the Run button. The compiler builds and executes your Scala program. After a moment, the Output panel displays the result:

Circle(5.0): area = 78.54
Rectangle(4.0,6.0): area = 24.00
Triangle(3.0,8.0): area = 12.00

Try adding new shape types to the sealed trait or modifying the match expression. The Scala compiler will warn you about non-exhaustive matches if you forget a case, which helps catch bugs at compile time.

Use Cases

Learning Scala fundamentals. Beginners can experiment with vals, vars, functions, classes, objects, and traits in a zero-setup environment.
Testing functional programming patterns. Quickly verify how map, flatMap, filter, fold, pattern matching, and for-comprehensions work with different data types.
Exploring case classes and algebraic data types. Define sealed traits, case classes, and case objects to build type-safe domain models with pattern matching.
Practicing algorithms and data structures. Implement sorting algorithms, tree traversals, graph searches, and other problems using Scala's rich collections library.
Preparing for coding interviews. Many interview questions can be solved elegantly in Scala. Use this compiler to practice problems and test solutions quickly.

Limitations and Notes

Single file execution only. This compiler runs a single Scala file (main.scala). Multi-file projects and separate source files are not supported.
No SBT or build tools. The SBT build system and other build tools are not available. You cannot use build.sbt or manage dependencies.
No external library imports. Third-party libraries from Maven Central or other repositories cannot be imported. Only the Scala standard library and basic Java standard library are available.
Limited Java interop. Basic Java standard library classes are accessible, but adding external JARs or Java dependencies is not supported.
No file system access. The sandboxed environment does not allow reading from or writing to the filesystem. File operations will fail at runtime.
Execution timeout applies. Programs that take too long or enter infinite loops are terminated automatically to prevent resource exhaustion.
Compilation may be slower. Scala compilation involves multiple phases and can take longer than simpler languages. Larger programs may need extra time to compile.

Frequently Asked Questions

What Scala version does this compiler use?

It uses the latest Scala version available through the Piston execution engine.

Can I use Java libraries from Scala?

Java interop is limited. Basic Java standard library classes are accessible, but adding external Java dependencies or JARs is not supported.

Is SBT available for building projects?

No, SBT and other build tools are not available. This compiler runs a single Scala file directly without a build system.

Do case classes work?

Yes, case classes work fully including automatic equals, hashCode, toString, copy methods, and pattern matching support.

Does pattern matching work?

Yes, Scala pattern matching works fully including match expressions, case classes, guards, wildcards, and nested patterns.

Can I use traits?

Yes, traits are fully supported. You can define traits with abstract and concrete methods, and mix them into classes and objects.

Is the Scala collections library available?

Yes, the full Scala collections library is available including List, Map, Set, Vector, Seq, and all collection operations like map, filter, and fold.

Do implicit conversions work?

Yes, implicit conversions and implicit parameters are supported, though behavior may depend on the specific Scala version provided by the execution engine.

Scala Compiler