Skip to content


Repository files navigation

Lasca Language

Build Status Join the chat at

Lasca is Scala shifted towards Haskell.

Lasca is a LLVM-based statically or dynamically typed strict functional programming language. Simplified OCaml if you will.

It has a 'dynamic' compilation mode, meaning instant code generation without compile time type checking/inference, allowing instant compilation/execution cycle, and more freedom dynamic languages give.

It has a full type inference, parametric polymorphism, GC, algebraic data types, pattern matching, and type classes are coming soon.


  • Scala with fast compilation/start time, optional dynamic typing, and without null
  • Go with ADTs, global type inference, and parametric polymorphism
  • Haskell with decent records syntax, runtime polymorphism, and string interpolation
  • OCaml with typeclasses, overloaded +-*/ for ints and floats, and do-notation
  • Rust with garbage collector without <::>!?
  • Erlang with types and fast execution
  • Python with multithreading, pattern matching, and multiline lambdas
  • TypeScript with indentation significant syntax, and LLVM
  • Julia with static type checking, and zero-based indexing

Inspired by:

  • Scala
  • Haskell, Liquid Haskell, Linear Haskell, Idris
  • OCaml/SML/F#/1ML
  • Clojure (persisted data structures, HAMT/CHAMP)
  • Go (CSP)
  • Erlang (actors, immutability, minimalism)
  • Python (docstrings, doctests, syntax)
  • Julia
  • Swift
  • Nim
  • Pony
  • Koka (algebraic effects)


  • light, non-symbol-polluted syntax (Python)
  • indentation-based
  • readability first
  • fast development cycle
  • presentation compiler for IDE integration
  • IDE-friendly (intellisence 'dot-autocomplete', auto-formatting, compiler API)
  • type-safe
  • strict functional
  • expression-based
  • practical first, but as clean and concise as possible
  • prefer things done one way
  • LLVM backend
  • JavaScript/WebAssembly backend (native or via LLVM/emscripten)
  • GraalVM backend?
  • no OOP and data subclassing/inheritance?
  • syntactic sugar is ok
  • no null
  • annotations (Java/Python-style)
  • annotation-based extensions
  • macros based metaprogramming (like Scala Macros, Template Haskell)
  • Concurrency Oriented Programming (Erlang). Objects are out. Concurrency is in.
  • Gradual Typing
  • Deferred Type Errors (runtime compilation mode, Haskell)
  • Linear/affine types (Rust, Linear Haskell)?
  • Liquid Type system (refinement types, Leon, Liquid Haskell) and Z3/CVC4 as proof assistant.
  • Algebraic Subtyping for module system
  • import features (Scala-like)
  • compile-time and runtime reflection
  • save/distribute AST (Scala TASTY). Full program optimization/reflection
  • important things must be greppable and googlable, call it searchability :)
  • compiler as a service: Language Server Protocol
  • markdown/rst comments/docs, doctest (Julia, Python)
  • CPS/Actors/π-calculus/STM?, non-blocking IO, reactive


Current implementation uses braces and semicolons, but I consider adding indentation-based syntax, or semicolon inference.

-- Algebraic data type a la Haskell
data JValue
    = JNull
    | JNum(n: Float)
    | JString(s: String)
    | JBool(v: Bool)
    | JArray(v: [JValue])
    | JObject(v: Map String JValue)

-- function argument type annotations are optional, compiler infers those
def jsonToString(js: JValue) = match js {
    JObject(m) ->
        if Map.isEmpty(m) then "{}" else {
            res = Array.makeArray(m.size, "");
            var idx = 0;
            Map.foreachWithKey(m, { k, v ->
                setIndex(res, idx.readVar, "\"${k}\": ${jsonToString(v)}");
                idx := idx.readVar + 1;
            s = String.join(", ", res);
            "{ ${s} }"
    JNull -> "null"
    JNum(n) -> toString(n)
    JBool(v) -> toString(v)
    JString(v) -> "\"${v}\""
    JArray(v) -> {
        values =, jsonToString);

What Works Right Now

  • JIT and AOT compilation and execution (via LLVM OrcJIT)
    • lasca -e hello.lasca to execute
    • lasca hello.lasca to create a binary
  • type inference
  • dynamic typing mode (lasca -e --mode dynamic hello.lasca)
  • ADTs, inner functions, out of order function definitions
  • pattern matching
  • calling external C functions
  • string interpolation, UTF8 encoded immutable strings
  • builtin types: String, Bool, Int, Byte, Int16, Int32, Float, Array, ByteArray, Var, FileHandle
  • implemented List, Option, Either, Map, ArrayBuffer
  • regular expressions with PCRE-2
  • overloaded + - * / operators

Package System

Consider Nix as package manager

Compiler Modes

  • Dynamic Mode, aka Prototype Mode. Syntax is checked. All types are dynamically checked.
  • Static Mode. Syntax is checked. Typechecking/inference, faster execution.
  • Hardcore Liquid types enabled. (See Liquid Haskell) Proves checked. Array bounds checks eliminated.

Type System

  • Hindley-Milner by default, dependent types if needed
  • traits, kind of type classes
  • Liquid types as in Liquid Haskell

Memory Management

GC, concurrent mark and sweep per actor/green thread GC Consider MultiCore Ocaml GC

for now, use Boehm conservative GC


  • indentation significant (i.e. Python, Haskell)
  • uppercase Typenames, lowercase idents and type arguments (Haskell/Scala style)
  • pattern-matching
  • ADT, traits, type classes
  • easy C interoperability
  • no exceptions (Go/Rust panic style errors)
  • don't overuse `'~!@#$%^&* symbols
  • default immutability
  • string interpolation: "${ident} = ${expression}"
  • multiline strings
  • Uniform Function Call Syntax (Rust, D). For example, any function can be a method for its first argument:
    def toString(s: String) = ...
    def plus(l: Num, r: Num)
  • uniform select principle. Use (.) for record field selection, func calls, package name resolution etc
  • UTF-8 strings
  • Haskell-like application for type functions: Option Int, Either Int String, etc

Install on Mac OS using Homebrew

brew install boehmgc pcre2
brew install nau/lasca/lasca-compiler

Setup LASCAPATH environment variable. Add this to your .bash_profile

export LASCAPATH="$(brew --prefix lasca-compiler)/src"

Try it!

echo 'def main() = println("Hello Lasca!")' > hello.lasca
lasca -e hello.lasca
> Hello Lasca!

Add bash completion config for lasca compiler options:

lasca --bash-completion-script lasca > $(brew --prefix)/etc/bash_completion.d/lasca

Build on Mac OS

You need LLVM 6.0 installed, and latest Haskell Stack.

brew install cmake boehmgc pcre2

brew install llvm-hs/llvm/llvm-6.0 # this compiles llvm from sources, make take some time

brew install haskell-stack

stack setup

Setup LASCAPATH environment variable. Add this to your .bash_profile

export LASCAPATH="${lasca-compiler-src-dir}/libs/base"

Add your ~/.local/bin directory to your PATH

export PATH=$PATH:~/.local/bin

Build and install lasca compiler

make install

Add bash completion config for lasca compiler options:

lasca --bash-completion-script lasca > $(brew --prefix)/etc/bash_completion.d/lasca

Run hello.lasca

lasca --exec examples/hello.lasca

Build on Ubuntu

Requirements: Haskell Stack > 1.6, Cabal > 2.0, LLVM 6, CMake

Don't install Haskell Stack from apt. It's likely to be older than 1.6 and won't be able to upgrade

Do this instead:

curl -sSL | sh

sudo apt install llvm-6.0-dev libgc-dev zlib1g-dev cmake
sudo add-apt-repository universe
sudo apt install libpcre2-dev
export LASCAPATH="${lasca-compiler-src-dir}/libs/base"
export PATH=$PATH:~/.local/bin
stack setup
make install
lasca -e examples/hello.lasca

Current n-body run

There are several implementation of n-body problem Currently it's quite slow due to boxing.

$ time lasca -e -O2 examples/nbody.lasca -- 50000000

real      7m13.261s
user      7m39.476s
sys       0m38.716s

find src -name "*.hs"  | xargs cat | wc -l

cat rts/runtime.c rts/builtin.c rts/lasca.h | wc -l