A simple command-line arguments parsing library for Scala, written in spirit of Ruby's Trollop. Cross-built for Scala 2.10, 2.11 and latest 2.12 milestone.

Programming language: Scala
License: MIT License
Tags: Parsing     Tools     CLI    
Latest version: v4.0.2

Scallop alternatives and similar packages

Based on the "Parsing" category.
Alternatively, view Scallop alternatives based on common mentions on social networks and blogs.

Do you think we are missing an alternative of Scallop or a related project?

Add another 'Parsing' Package



Build Status

A simple command-line arguments parsing library for Scala. Cross-built for Scala 3.0, 2.13, 2.12, 2.11, 2.10, supports Scala Native and Scala JS.

Scallop supports:

  • flag, single-value and multiple value options
  • POSIX-style short option names (-a) with grouping (-abc)
  • GNU-style long option names (--opt, --opt=value)
  • unnamed integer options, like GNU tail (-42)
  • Property arguments (-Dkey=value, -D key1=value key2=value)
  • Non-string types of options and properties values (with extendable converters)
  • Powerful matching on trailing args
  • Subcommands

For more info and information on usage, you can look into the project wiki or consult the API docs.

Also, I wrote a blog post and another one about Scallop.


Add following to your build.sbt:

libraryDependencies += "org.rogach" %% "scallop" % "4.0.2"

For use with Scala Native and Scala.js, use %%%:

libraryDependencies += "org.rogach" %%% "scallop" % "4.0.2"

If you were using 3.x version or older, please see migration notes.

Quick example

import org.rogach.scallop._

class Conf(arguments: Seq[String]) extends ScallopConf(arguments) {
  val apples = opt[Int](required = true)
  val bananas = opt[Int]()
  val name = trailArg[String]()

object Main {
  def main(args: Array[String]) {
    val conf = new Conf(args)
    println("apples are: " + conf.apples())

This snippet above defined simple configuration that will parse argument lines like these:

--apples 4 --bananas 10 strangeTree
-a 4 appleTree

For more examples, you can look at Scallop's wiki and [test suite](./jvm/src/test/scala).

Fancy things

Scallop supports quite powerful matching on trailing arguments. For example:

object Conf extends ScallopConf(
       List("-Ekey1=value1", "key2=value2", "key3=value3",
            "first", "1","2","3","second","4","5","6")) {
  val properties = props[String]('E')
  val firstListName = trailArg[String]()
  val firstList = trailArg[List[Int]]()
  val secondListName = trailArg[String]()
  val secondList = trailArg[List[Double]]()
Conf.properties("key1") shouldBe "value1"
Conf.firstListName() shouldBe "first"
Conf.secondListName() shouldBe "second"
Conf.firstList() shouldBe List(1,2,3)
Conf.secondList() shouldBe List[Double](4,5,6)

In this case, Scallop's backtracking parser is clever enough to distinguish the boundaries of the arguments lists.

Also, Scallop supports parsing of subcommands. Not only subcommands, but nested subcommands!

object Conf extends ScallopConf(Seq("sub1", "sub2", "sub3", "sub4", "win!")) {
  object sub1 extends Subcommand("sub1") {
    object sub2 extends Subcommand("sub2") {
      object sub3 extends Subcommand("sub3") {
        object sub4 extends Subcommand("sub4") {
          val opts = trailArg[List[String]]()
Conf.subcommands shouldBe List(Conf.sub1, Conf.sub1.sub2, Conf.sub1.sub2.sub3, Conf.sub1.sub2.sub3.sub4)
Conf.sub1.sub2.sub3.sub4.opts() shouldBe List("win!")


... and the whole Scala community for help and explanations.


Scallop is distributed under [MIT license](./license.txt).

*Note that all licence references and agreements mentioned in the Scallop README section above are relevant to that project's source code only.