Knight is a minimalistic programming language designed to be easily implementable in a variety of languages. While it is a fully-functional programming language, it's main purpose is to be a somewhat-easy-to-implement language.

Unofficial Tag-line: "Knight: Runs everywhere. Not because it's cross-platform, but because it works in any almost any language you have."

Checkout the community, and join us on discord: https://discord.gg/SE3TjsewDk.

I've implemented Knight in quite a few languages over the years. Some of the implementations only implement older versions of the spec (eg Knight 1.0, which was before lists); my eventual plan is to upgrade them all. There are three implementations of special note:

• go: The exemplar implementation, intentionally written without any fancy tricks or optimizations, and is thoroughly documented. If you don't know how to get started writing a Knight program, take a look at this one!
• rust: The fully-functional implementation. It has all the suggested extensions (and a few of its own) implemented (--features=all-extensions), and has the ability to check for all forms of undefined behaviour (--features=strict-compliance). If you're not sure if a piece of Knight code is spec compliant, you can run it with cargo run --no-default-features --features=strict-compliance -- -e ...!
• c: The fastest, currently. When compiled with -DKN_RECKLESS, it will assume that every input program is 100% spec-compliant (and won't ever error).

The following is the list of all languages that I've written it in:

I love language design, and have written quite a few programming languages. I generally try to get the languages fleshed out enough so that I can write a fully compliant Knight interpreter in it.

In addition, the following is a list of languages which I want to write an implementation in at some point.

NOTE: These are outdated. I no longer own the computer I tested them on, and the timeit file doesn't actually work. I'll be updating them in the future. The following able describes how fast each implementation (in user time) was at running examples/fizzbuzz.kn in knight.kn in knight.kn in their implementation, on my machine. You can test it yourself via the timeit script provided.

Note that these are simply benchmarks of my implementations of Knight, and not a reflection of the efficiency of the languages themselves.

Here's some examples of the syntax to give you a feel for it:

; = max 100                                   # max = 100
; = secret + 1 (% RAND max)                   # secret = rand(1, max)
; = nguess 0                                  # nguess = 0
; = guess 0                                   # guess = 0
; OUTPUT (+ 'guess 1-' max)                   # print('pick from 1-' + m)
; WHILE (| (< guess secret) (> guess secret)) # while guess != s:
  ; OUTPUT '> \'                              #   print('> ', end='')
  ; = guess (+ 0 PROMPT)                      #   guess = int(prompt())
  ; = nguess (+ nguess 1)                     #   nguess += 1
  : OUTPUT (                                  #   print(
     IF (< guess secret) 'too low'            #     if guess < secret: 'too low'
     IF (> guess secret) 'too high'           #     if guess > secret: 'too high'
                         'correct')           #     else: 'correct')
: OUTPUT (+ 'tries: ' nguess)                 # print('tries: ' + n)

; = fib BLOCK                           # function fib:
    ; = a 0                             #    a = 0
    ; = b 1                             #    b = 1
    ; WHILE n                           #    while n != 0:
        ; = b + a (= tmp b              #       b = a + (tmp = b)
        ; = a tmp                       #       a = tmp
        : = n - n 1                     #       n -= 1
    : a                                 #    return a
; = n 10                                # n = 10
: OUTPUT +++ 'fib(' n ')=' CALL fib     # print "fib(" + n + ")=" + fib()
# => fib(10)=55

The following is just a rough overview, and is not to be taken as authoritative; for exact details please see specs.md.

Every Knight program is a single expression. (The ; function can be used to write more than one expression, sequentially.) Because of this, parsing is extremely simple: Parse a token, then parse as many arguments as that expression dictates.

Non-symbol functions are defined by their first character: additional uppercase characters following it are ignored. Because of this, OUTPUT is the same as OUT, which is the same as OFOOBARBAZ.

Tokens may follow directly one after another (eg 1a is parsed as 1 and then a), except in the following four cases (which must have whitespace or comments):

1. Between two "word" keywords, such as IF PROMPT
2. Between two numbers, such as + 1 2
3. Between two identifiers, such as * a b
4. Between an identifier and a number, such as + a 3.

Additionally, while not technically whitesapce, (, ), and : can be safely interpreted as whitespace as well. As such, expressions such as OUTPUT * a (IF b 3 b) can be written as O*aIb 3b.

Knight's ENBF is as follows:

program := expr ;
expr := integer-literal
      | string-literal
      | identifier
      | nullary
      | unary      expr
      | binary     expr expr
      | ternary    expr expr expr
      | quaternary expr expr expr expr ;

integer-literal := DIGIT {DIGIT} ;
string-literal  := `'` {NON_SINGLE} `'` | `"` {NON_DOUBLE} `"` ;
identifier      := LOWER {LOWER | DIGIT} ;

nullary := '@'
         | ('T' | 'F' | 'N' | 'P' | 'R') {UPPER} ;

unary := ':' | '!' | '~' | ',' | '[' | ']'
       | ('B' | 'C' | 'Q' | 'D' | 'O' | 'L' | 'A') {UPPER} ;

binary := '+' | '-' | '*' | '/' | '%' | '^'
        | '<' | '>' | '?' | '&' | '|' | ';' | '='
        | 'W' {UPPER} ;

ternary := ('I' | 'G') {UPPER} ;

quaternary := 'S' {UPPER} ;

UPPER := [A-Z] | '_' ;
LOWER := [a-z] | '_' ;
DIGIT := [0-9] ;
NON_SINGLE := (? any character except single quote (`'`) *) ;
NON_DOUBLE := (? any character except double quote (`"`) *) ;