Skip to content
A static, type inferred and embeddable language written in Rust.
Rust Shell
Branch: master
Clone or download

Latest commit

bors and Marwes Merge #836
836: test: Add tests for #793 r=Marwes a=Marwes

Was presumably fixed in #696

Closes #793

Co-authored-by: Markus Westerlind <>
Latest commit 77652ab May 17, 2020


Type Name Latest commit message Commit time
Failed to load latest commit information.
base Merge #833 May 14, 2020
benches a Mar 15, 2020
book feat: Replace Compiler with the ThreadExt trait Oct 1, 2019
c-api Version 0.14.1 Apr 16, 2020
check fix alloc May 2, 2020
codegen Version 0.14.1 Apr 16, 2020
completion Version 0.14.1 Apr 16, 2020
doc Version 0.14.1 Apr 16, 2020
examples test: Verify that the standard library is formatted Apr 13, 2020
format test: Add tests for #793 May 17, 2020
parser Fix formatting by updating to lalrpop 0.19 May 13, 2020
repl fix alloc May 2, 2020
scripts Add back all projects to Apr 16, 2020
src Version 0.14.1 Apr 16, 2020
std Fix metadata parsing on recursive bindings May 4, 2020
tests fix: Allow bitoperations to be deserialized May 16, 2020
vm fix: Allow bitoperations to be deserialized May 16, 2020
.clog.toml Version 0.4.0 May 16, 2017
.gitignore Ignore .bak files Oct 9, 2018
.travis.yml Disable BSD as it fails on -lexecinfo Apr 16, 2020 Version 0.14.1 Apr 16, 2020 docs: Update Nov 4, 2017
Cargo.lock wip May 14, 2020
Cargo.toml Fix formatting by updating to lalrpop 0.19 May 13, 2020
Cross.toml chore: Pass the GIT_HASH variable through to cross Feb 3, 2018
LICENSE Added LICENSE and Aug 2, 2015 Version 0.14.1 Apr 16, 2020
appveyor.yml Update appveyor token Jul 2, 2018
bors.toml chore: Increase bors timeout to 2 hours Apr 22, 2018 feat: Replace Compiler with the ThreadExt trait Oct 1, 2019
rustfmt.toml feat: Update syn to 0.15 Sep 29, 2018


Build Status Gitter Documentation Book std

Gluon is a small, statically-typed, functional programming language designed for application embedding.


  • Statically typed - Static typing makes it easier to write safe and efficient interfaces between gluon and the host application.

  • Type inference - Type inference ensures that types rarely have to be written explicitly giving all the benefits of static types with none of the typing.

  • Simple embedding - Marshalling values to and from gluon requires next to no boilerplate, allowing functions defined in Rust to be directly passed to gluon.

  • UTF-8 by default - Gluon supports unicode out of the box with utf-8 encoded strings and unicode codepoints as characters.

  • Separate heaps - Gluon is a garbage-collected language but uses a separate heap for each executing gluon thread. This keeps each heap small, reducing the overhead of the garbage collector.

  • Thread safe - Gluon is written in Rust, which guarantees thread safety. Gluon keeps the same guarantees, allowing multiple gluon programs to run in parallel (example)*

* Parallel execution of gluon programs is a recent addition and may still have issues such as deadlocks.


Hello world

let io = import!
io.print "Hello world!"


let factorial n : Int -> Int =
    if n < 2
    then 1
    else n * factorial (n - 1)

factorial 10


// # 24
// From
// Write a program that randomly chooses and displays four digits, each from 1 ──► 9 (inclusive) with repetitions allowed.
// The program should prompt for the player to enter an arithmetic expression using just those, and all of those four digits, used exactly once each. The program should check then evaluate the expression.
// The goal is for the player to enter an expression that (numerically) evaluates to 24.
// * Only the following operators/functions are allowed: multiplication, division, addition, subtraction
// * Division should use floating point or rational arithmetic, etc, to preserve remainders.
// * Brackets are allowed, if using an infix expression evaluator.
// * Forming multiple digit numbers from the supplied digits is disallowed. (So an answer of 12+12 when given 1, 2, 2, and 1 is wrong).
// * The order of the digits when given does not have to be preserved.
// ## Notes
//     The type of expression evaluator used is not mandated. An RPN evaluator is equally acceptable for example.
//     The task is not for the program to generate the expression, or test whether an expression is even possible.

// The `import!` macro are used to load and refer to other modules.
// It gets replaced by the value returned by evaluating that module (cached of course, so that
// multiple `import!`s to the same module only evaluates the module once)
let io @ { ? } = import!
let prelude = import! std.prelude
let { Result } = import! std.result
let array @ { ? } = import! std.array
let int = import!
let string = import! std.string
let list @ { List, ? } = import! std.list
let random = import! std.random
let string = import! std.string

// Since imports in gluon returns regular values we can load specific parts of a module using pattern matches.
let char @ { ? } = import! std.char

let { (<>) } = import! std.semigroup
let { flat_map } = import! std.monad

let { (*>), (<*), wrap } = import! std.applicative

let { for } = import! std.traversable

type Op = | Add | Sub | Div | Mul
type Expr = | Int Int | Binop Expr Op Expr

let parse : String -> Result String Expr =
    // Gluon has a small parser combinator library which makes it easy to define an expression parser
    let parser @ {
        ? } = import! std.parser
    let { (<|>) } = import! std.alternative

    let lex x = x <* spaces

    let integer =
        // `do` expression provide a way to write monads in a way similiar to procedural code
        do i = lex (recognize (skip_many1 digit))
        match int.parse i with
        | Ok x -> wrap x
        | Err _ -> "Unable to parse integer"

    let operator =
        satisfy_map (\c ->
            match c with
            | '*' -> Some Mul
            | '+' -> Some Add
            | '-' -> Some Sub
            | '/' -> Some Div
            | _ -> None)
            <?> "operator"

    let atom _ = Int integer
            <|> between (lex (token '(')) (lex (token ')')) (lazy_parser expr)

    let binop _ =
        let op_parser =
            do op = lex operator
            wrap (\l r -> Binop l op r)
        chainl1 (atom ()) op_parser

    let expr _ = binop ()

    // Gluon makes it possible to partially apply functions which we use here to scope all parser functions
    // inside the `let parse` binding above.
    let parse : String -> Result String Expr = parser.parse (expr () <* spaces)

/// Validates that `expr` contains exactly the same integers as `digits`
let validate digits expr : Array Int -> Expr -> Bool =
    let integers xs expr : List Int -> Expr -> List Int =
        match expr with
        | Int i -> Cons i xs
        | Binop l _ r -> integers (integers xs l) r
    let ints = integers Nil expr

    list.sort (list.of digits) == list.sort ints

let eval expr : Expr -> Int =
    match expr with
    | Int i -> i
    | Binop l op r ->
        let f =
            // Operators are just functions and can be referred to like any other identifier
            // by wrapping them in parentheses
            match op with
            | Add -> (+)
            | Sub -> (-)
            | Div -> (/)
            | Mul -> (*)
        f (eval l) (eval r)

do digits =
    let gen_digit = random.thread_rng.gen_int_range 1 10
    do a = gen_digit
    do b = gen_digit
    do c = gen_digit
    do d = gen_digit
    wrap [a, b, c, d]

let print_digits = for digits (\d ->
        seq io.print " "
        io.print (show d))
seq io.print "Four digits:" *> print_digits *> io.println ""

let guess_loop _ =
    do line = io.read_line
    // Exit the program if the line is just whitespace
    if string.is_empty (string.trim line) then
        wrap ()
        match parse line with
        | Err err -> io.println err *> guess_loop ()
        | Ok expr ->
            if validate digits expr then
                let result = eval expr
                if result == 24
                then io.println "Correct!"
                else io.println ("Incorrect, " <> result <> " != 24") *> guess_loop ()
                    "Expression is not valid, you must use each of the four numbers exactly once!"
                    *> guess_loop ()

guess_loop ()


Getting started

Try online

You can try gluon in your browser at (Github)


Gluon can be installed by using one of the prebuilt executables at Github or you can use Cargo in order to install the gluon_repl crate:

cargo install gluon_repl


Gluon has a small executable which can be used to run gluon programs directly or in a small REPL. The REPL can be started by passing the -i flag to the built repl executable which can be run with cargo run -p gluon_repl -- -i.

REPL features:

  • Evaluating expressions (expressions of type IO will be evaluated in the IO context).

  • Bind variables by writing let <pattern> <identifier>* = <expr> (omitting in <expr> from a normal let binding) Example:

       let f x = x + 1
       let { x, y = z } = { x = 1, y = 2 }
       f z
  • Printing help about available commands with :h

  • Loading files with :l path_to_file the result of evaluating the expression in the loaded file is stored in a variable named after the filename without an extension.

  • Checking the types of expressions with :t expression

  • Printing information about a name with :i name.

    :i std.prelude.List
    type std.prelude.List a = | Nil | Cons a (std.prelude.List a)
    /// A linked list type
  • Tab-completion of identifiers and record fields repl completion

  • Exit the REPL by writing :q


Language server

Gluon has a language server which provides code completion and formatting support. Installation is done with cargo install gluon_language-server.

Visual Studio Code Extension

The gluon extension for Visual Studio Code provides syntax highlighting and completion. To install it, search for gluon among the extensions. (Github)


Vim plugin

vim-gluon provides syntax highlighting and indentation.

The gluon language server has been tested to work with and

Example configuration (autozimu/LanguageClient-neovim)

let g:LanguageClient_serverCommands = {
    \ 'gluon': ['gluon_language-server'],
    \ }

" Automatically start language servers.
let g:LanguageClient_autoStart = 1

nnoremap <silent> K :call LanguageClient_textDocument_hover()<CR>
nnoremap <silent> gd :call LanguageClient_textDocument_definition()<CR>


The Gluon Book

Gluon Standard Library API Reference

Rust API Docs



Gluon requires a recent Rust compiler to build (1.9.0 or later) and is available at It can easily be included in a Cargo project by adding the lines below.

gluon = "0.14.1"

Other languages

Currently the easiest way to interact with the gluon virtual machine is through Rust but a rudimentary C api exists which will be extended in the future to bring it closer to the Rust api.


There are many ways to contribute to gluon. The two simplest ways are opening issues or working on issues marked as beginner. For more extensive information about contributing, you can look at Contributing also has details on running/getting-started-with tests for gluon.


These goals may change or be refined over time as I experiment with what is possible with the language.

  • Embeddable - Similiar to Lua - it is meant to be included in another program which may use the virtual machine to extend its own functionality.

  • Statically typed - The language uses a Hindley-Milner based type system with some extensions, allowing simple and general type inference.

  • Tiny - By being tiny, the language is easy to learn and has a small implementation footprint.

  • Strict - Strict languages are usually easier to reason about, especially considering that it is what most people are accustomed to. For cases where laziness is desired, an explict type is provided.

  • Modular - The library is split into its parser, typechecker, and virtual machine + compiler. Each of these components can be used independently of each other, allowing applications to pick and choose exactly what they need.


This language takes its primary inspiration from Lua, Haskell and OCaml.

You can’t perform that action at this time.