Nova

Nova is a small, statically typed, object-oriented programming language that compiles high-level, class-based source code down to bytecode for execution on a dedicated virtual machine. Developed as an open-source project beginning around 2019-2020, it pairs a familiar, C-family syntax with a deliberately simple compile-and-run pipeline, making it a compact, readable example of how an object-oriented language can be implemented end to end.

A note on the name. “Nova” is a popular name, and several unrelated hobby and educational language projects have used it — including a Node.js-based pseudocode learning tool and a more recent minimal systems language. This page describes the object-oriented, statically typed Nova that compiles to bytecode, which most closely matches the encyclopedia’s metadata (object-oriented, first appearing around 2020). Because the language is a small independent project rather than a standardized or commercially backed one, some details below are documented only in its source repository, and claims are kept to what is verifiable there.

History & Origins

Public development of Nova began with the creation of its source repository in December 2019, led by an independent open-source developer who publishes under the handle Skinz3. The earliest commits on the main development branch date to December 2019, but the bulk of the language’s design and implementation took shape through 2020, which is why it is generally placed as first appearing around 2020.

Nova was conceived as a language “with a high level of abstraction” — an attempt to build a clean, modern object-oriented language together with the full machinery needed to run it. Rather than targeting an existing runtime, the project pairs a compiler with a purpose-built virtual machine, so the author controls the language from grammar all the way down to the executed instructions. This makes Nova as much a study in language implementation as it is a language in its own right.

Design Philosophy

Nova’s design reflects a small set of priorities that are visible directly in its toolchain and syntax:

• High-level abstraction with familiar syntax. Programs are organized around class and struct declarations with typed fields and methods, in a style that will be immediately legible to anyone who has written C#, Java, or C++.
• Static, strong typing. Types are checked at compile time, and the language gained an explicit type system (including primitive types) as it matured through 2020.
• Compile to bytecode, then interpret. Nova does not run source directly. A compiler translates .nv source into a compact .nov bytecode file, which a separate virtual machine then executes — a model conceptually similar to the JVM or the CLR, though far smaller in scope.
• Multi-paradigm, but object-first. The project describes itself as supporting structured, imperative, and functional styles, but its central organizing idea is the object-oriented pairing of data (struct/class members) with behavior (methods).

The implementation reinforces these goals: the front end is written in C# and uses the ANTLR4 parser generator to turn grammar rules into a lexer and parser, while the runtime is a C++ virtual machine. There is, by the author’s own note, no just-in-time compilation — the VM interprets bytecode directly.

Key Features

• Classes and structs. Both can declare typed fields and methods. The example below uses a struct to model a value type and a class to host the program’s entry point.
• Constructor syntax with ->. Constructors are written with a distinctive arrow form, e.g. -> Human(string name, int age), and objects are created with the same arrow operator at the call site.
• Built-in vectors. A Vector type supports list literals such as [7, 8, 9, 10] along with operations like Add and Print.
• A small standard library. Imported with using <nova>, it supplies built-ins such as Nova.PrintLine for console output.
• Namespaces and accessors. Added during 2020, these organize code and expose members in a structured way.
• A compact bytecode instruction set. The virtual machine implements a focused set of stack-based opcodes — including add, sub, mul, div, comp, jump, jumpIfFalse, load/store, loadGlobal/storeGlobal, pushConst, pushInt, pushNull, dup, call, return, nat (native calls), and a family of struct* and vect* operations for object and vector handling.

A representative Nova program, drawn from the project’s own documentation, looks like this:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

using <nova> // Nova std library

class MyClass
{
    public int Main()
    {
        Human human = -> Human("Freddy", 18)
        human.PrintAge()

        Vector myVect = [7, 8, 9, 10]
        myVect.Add(5)

        myVect.Print() // Print '7,8,9,10,5'
    }
}

struct Human
{
    public string Name
    public int Age

    -> Human(string name, int age) // Human constructor
    {
        Name = name
        Age = age
    }

    public void PrintAge()
    {
        Nova.PrintLine(Name + " is " + Age + " years old")
    }
}

(The block is highlighted as C# above only because Nova borrows that family’s syntax; Nova is its own language.)

Evolution

Nova’s recorded evolution is concentrated in a relatively short, intense period. After the repository was created in late 2019, development through 2020 assembled the pieces of a working language: the ANTLR4-based grammar and C# compiler front end, the bytecode format, and the C++ virtual machine, followed by the type system, control flow, namespaces, and accessors. The accompanying README documentation describing the two-stage build pipeline was maintained from the project’s earliest days and received its final updates in October 2020.

After the October 2020 work, the repository saw only a single further commit, in early 2022, after which it appears to have stopped. As of this writing there are no tagged releases or formal version numbers; the language exists as a development build in its source tree rather than as a packaged, versioned product.

Current Relevance

Nova is best understood as a small, experimental open-source language rather than a production tool. It has a modest following (a handful of stars on its repository) and no documented use in industry or in shipping software. Notably — despite some secondhand categorizations that associate the name with mobile development — the project’s own documentation makes no claim of mobile, iOS, or Android support, and its runtime targets a desktop-oriented C++ virtual machine. Readers should treat any “mobile language” framing with caution.

Where Nova remains genuinely interesting is as a teaching-sized reference implementation. It is compact enough to read in full yet complete enough to demonstrate the entire arc of language implementation: a grammar expressed in ANTLR4, a compiler that performs semantic and type validation, a defined bytecode format, and a stack-based virtual machine to execute it.

Why It Matters

Nova will not appear on any list of widely used languages, and it would be inaccurate to suggest otherwise. Its value is pedagogical and illustrative. The project shows, in one self-contained codebase, how the high-level conveniences of an object-oriented language — classes, structs, constructors, typed fields, a standard library — are reduced to a handful of bytecode instructions and then run by a small interpreter.

It is also a representative artifact of a broader phenomenon: the steady stream of independent, hobbyist programming languages that modern tooling makes possible. Parser generators like ANTLR4, accessible systems languages like C++, and open platforms like GitHub have lowered the barrier to designing and implementing a language to the point where a single developer can build a complete compiler-and-VM toolchain. Nova is one such effort — a reminder that the act of creating a language, not just using one, is now within reach of anyone curious enough to try.

Sources: the Nova.Compiler source repository and README (object-oriented, bytecode-compiled Nova), including its documented code example, type system, toolchain, and bytecode instruction set, with dates corroborated by the repository’s commit history. Other unrelated projects sharing the name “Nova” include dan-online/Nova and rxrbln/nova.