Nova Implementations

Categorization

Some Nova implementations run Nova rules directly. These are called interpreters, and they run on a single language.

Other Nova implementations generate Nova code to be run by another program. These are called compilers. They run on a single language, but some can create Nova programs in different languages.

Myte

The current main Javascript (aka Web Browser) Nova implementation.

Syntax: January
Type: Compiler
Runs on: Nodejs, Web browsers, ES5+ JS Runtimes
Output targets: Nodejs, Web browsers, ES5+ JS Runtimes
Notable uses: Nova Playground, Archipelago

Pyra

Lua powered implementation uses more modes in the syntax to require less configurable delimiters.

Syntax: Bespoke
Type: Compiler
Runs on: Lua
Output targets: Lua, Love2D, Ruby, Javascript, Graphviz
Notable uses: eevie.dev, axowotw

Serpens

The OG Nova prototype, rough around the edges

Syntax: January
Type: Interpreter
Runs on: Python

The syntax used in the Introduction to Nova is called January, shortned to jan casually. As of right now, it's more of a set of guidelines than a formalized thing, but the Nova core devs are working to change that.

For a brief description: It's a two-level configurable delimiter syntax. The first non-whitespace character in a file is the rule-side delimiter.

After each rule-side delimiter, the next non-whitespace character is a stack-label delimiter.

$ is used to make a symbol as a variable. If the same variable name is used twice in a cause, Nova makes sure that both symbols are the same value.

| :cause stack name: symbol $variable | 
  :effect stack name: seen $variable

January Shorthands

We'll start with an example with some repetition written out:

| :do: one thing :do: second thing |
  :done: one :done: second

., if it's the first symbol after a stack label, allows you to write multiple facts without repeating the whole label. Using that, we can shorten things like so:

| :do: . one thing . second thing |
  :done: . one . second

If a fact begins with the symbol ( and ends with the symbol ), then each symbol between the parens is treated as a single-symbol fact. This allows us to rewrite things like so:

| :do: . one thing . second thing |
  :done: ( one second )