A general-purpose programming language coming to life through a custom one-pass compiler and a stack-based virtual machine.

👉️ The language is currently being developed, but the implemented features can be seen in Milestones. This README is also in development.

• Playground
• Language
  • Characteristics
  • Syntax
• Milestones
  • Milestone 1 - Expressions
  • Milestone 2 - Variables and Control Flow
  • Milestone 3 - Interactive Playground
  • Milestone 4 - First-Class Functions
  • Example Input
• Getting Started
  • Prerequisites
  • Building the Project
  • Running Code
• License

Try out Thusly in the interactive playground.

• General-purpose
• Interpreted
• Dynamically typed
• Imperative
• Garbage collected

The development of both the language and the surrounding documentation is currently on-going, but the following is a subset of the language:

Whitespace:

Whitespace is semantically insignificant except for newline characters on non-blank lines.

• The terminals in the initial grammar can be identified from user input via a multi-line file or single-line REPL input and then tokenized.
• Arithmetic expressions using number (double) can be evaluated.
  • Addition (+)
  • Subtraction (-)
  • Multiplication (*)
  • Division (/)
  • Modulo (mod)
  • Unary negation (-)
  • Precedence altering (())
• Comparison expressions using number can be evaluated.
  • Greater than (>)
  • Greater than or equal to (>=)
  • Less than (<)
  • Less than or equal to (<=)
• Equality and logical negation expressions using number, boolean, text (string), and none can be evaluated.
  • Equal to (=)
  • Not equal to (!=)
  • Logical not (not)
• Concatenation of text literals using + can be evaluated.

• Temporary @out statement can be executed.
• Global and local variables can be defined and used.
  • Declaration and initialization (var <name> : <expression>)
  • Assignment expression (<name> : <expression>)
• Variables adhere to lexical scope.
  • Standalone block

    block
      <statements>
    end
    

• Logical operators can be evaluated.
  • Conjunction (and)
  • Disjunction (or)
• Control flow statements can be executed.

  • Selection

    • if
    • elseif
    • else

    if <condition>
      <statements>
    elseif <condition>
      <statements>
    else
      <statements>
    end
    

  • Loops

    • Bounded (foreach)

    foreach <name> in <start>..<end> step <change>
      <statements>
    end
    

    Example 1

    // `<change>` expression is implicitly 1
    foreach value in 0..10
      @out value
    end
    

    Example 2

    var a: 0
    var b: 10
    var c: 2
    foreach value in a..b step c
      @out value
    end
    

    • Unbounded (while)

    while <condition> { <change> }
      <statements>
    end
    

    Example

    // `{ <change> }` expression is optional
    var i: 0
    while i < 10 {i +: 1}
      @out i
    end
    

• Augmented assignment expressions can be evaluated.
  • Addition and assignment (+:)
  • Subtraction and assignment (-:)
  • Multiplication and assignment (*:)
  • Division and assignment (/:)
  • Modulo and assignment (mod:)
• Range comparison expression can be evaluated (<value> in <min>..<max>)
• TODO (more milestones will be added here)

• A Thusly VM can run and execute code in the browser via an interactive playground.

• Functions can be defined and invoked.
• Closures are supported.
• Functions are first-class citizens.
• TODO (more milestones will be added here)

This section is for briefly demonstrating implemented functionality thus far and expected behavior when running your code.

By inputting code from either a file or via the REPL, the VM will interpret it and output the result if an @out statement is used.

Table 1: Valid user input (expressions)

Table 2: Valid user input (statements)

Table 3: Invalid user input

• A C compiler (e.g. Clang or GCC)
• CMake version 3.20 or later

Run the below command to make Thusly come to life. It will create a top-level bin directory where the configured and compiled project will be located along with the executable binary cthusly.

./build.sh

If permission is denied, first add executable permission to the build script by running: chmod +x build.sh.

Once you have built the project you can go ahead and feed it some code to interpret thusly (..get it?):

Usage example:

$ ./bin/cthusly --help

Usage: ./bin/cthusly [options] [path]

    The REPL (interactive prompt) starts if no [path] is provided

    -h,     --help           Show usage
    -d,     --debug          Enable all debug flags below
    -dcomp, --debug-comp     Show compiler output (bytecode)
    -dexec, --debug-exec     Show VM execution trace

Flags:

Currently, only 1 flag may be provided.

Interpret code from a file:

./bin/cthusly path/to/your/file

Start the REPL (interactive prompt):

./bin/cthusly

Exit REPL:

Press Cmd + D (Mac) or Ctrl + D (Windows).

Example:

$ ./bin/cthusly

> @out "he" + "llo" = "hello"
true
> @out (1 + 2) * 3 / 4
2.25
> 

Enable/disable debug:

For the debug flags to have an effect, the following macro in src/common.h need to be defined.

• DEBUG_MODE

You may comment or uncomment it to disable or enable support for the flags (then rebuild the project).

This software is licensed under the terms of the MIT license.