flix/flix

---

flix/flix.json

{
  "createdAt": "2015-06-12T03:20:35Z",
  "defaultBranch": "master",
  "description": "The Flix Programming Language",
  "fullName": "flix/flix",
  "homepage": "https://flix.dev/",
  "language": "Flix",
  "name": "flix",
  "pushedAt": "2025-11-25T10:07:17Z",
  "stargazersCount": 2538,
  "topics": [
    "flix",
    "functional",
    "hacktoberfest",
    "imperative",
    "jvm",
    "language",
    "logic",
    "programming-language"
  ],
  "updatedAt": "2025-11-25T10:07:20Z",
  "url": "https://github.com/flix/flix"
}

Flix is a statically typed functional, imperative, and logic programming language.

We refer you to the official Flix website (flix.dev) for more information about Flix.

Example

///
/// The expressions of the lambda calculus are: variables, lambda abstractions, and applications.
///
enum Expression {
    // A variable expression. A variable is represented by an integer.
    case Var(Int23),

    // A lambda abstracation expression. A variable is represented by an integer.
    case Abs(Int32, Expression),

    // A function application expression.
    case App(Expression, Expression),
}

///
/// Performs alpha conversion by introducing fresh variables for all variables in the given expression `e0`.
///
def alpha(e0: Expression, m: Map[Int32, Int32]): Expression = match e0 {
    case Var(x) =>
        // Check if we need to rename the variable.
        match Map.get(x, m) {
            case None => Var(x)
            case Some(y) => Var(y)
        }

    case Abs(x, e) =>
        // Generate a fresh variable name for `x`.
        let y = freshVar();
        Abs(y, alpha(e, Map.insert(x, y, m)))

    case App(e1, e2) =>
        // Recursively perform alpha conversion on each expression.
        App(alpha(e1, m), alpha(e2, m))
}

Building

See [docs/BUILD.md]!(docs/BUILD.md).

License

Flix is available under the Apache 2.0 license.

Sponsors

We kindly thank EJ Technologies for providing us with JProfiler and JetBrains for providing us with IntelliJ IDEA.