Releases: varundubey-dev/nova
Release list
NOVA v1.1.0 (LTS)
The first Long-Term Support (LTS) release of NOVA.
NOVA v1.1 focuses on improving the developer experience without changing the language itself. This release introduces semantic highlighting support for editors, improves syntax highlighting reliability by allowing token generation even in the presence of syntax errors, fixes input provider behavior for API integrations, and expands the language with string concatenation.
As the first LTS release, v1.1 provides a stable foundation for tooling, editor integrations, educational use, and long-term projects.
Highlights
- First Long-Term Support (LTS) release
- Semantic token generation
- Tolerant lexer mode
- Improved editor integration
- API input provider fix
- String concatenation
Documentation
Complete language documentation:
Language
Standard Library
Built-in Functions
Runnable examples:
Compatibility
Fully backward compatible with:
- NOVA v1.0
What's New in v1.1
Semantic Highlighting
The lexer can now generate semantic tokens alongside lexical tokens, enabling semantic syntax highlighting in editors and language tooling. This provides more accurate highlighting based on the meaning of identifiers rather than only their lexical form.
Tolerant Lexer Mode
A new tolerant lexer mode allows tokenization to continue even when lexical errors are encountered. Instead of stopping at the first error, the lexer produces as many valid tokens as possible, making it suitable for live editor features such as syntax highlighting while code is still being written.
API Input Provider Fix
The input provider no longer defaults to Python's standard input when running through the API. Input is now resolved correctly through the configured provider, ensuring consistent behavior across editor integrations and remote execution environments.
String Concatenation
Strings can now be concatenated using the + operator, making text construction more natural and improving readability for formatted output and dynamic string generation.
Long-Term Support
NOVA v1.1 is designated as the first Long-Term Support (LTS) release. It is intended to serve as the recommended stable version for projects, documentation, educational material, and tooling while future feature development continues in subsequent releases.
NOVA v1.0.0
The first stable public release of NOVA.
NOVA v1.0 completes the first generation of the language by expanding the Standard Library built upon NOVA's module system. In addition to the math module introduced in v0.9, the Standard Library now includes modules for arrays, randomness, statistics, and time, providing reusable functionality through explicit imports.
Programs can now organize code across multiple files, build reusable modules, and access a growing ecosystem of Standard Library modules while preserving NOVA's predictable execution model, strong runtime type checking, and explicit import semantics.
Highlights
- First stable NOVA release
- Expanded Standard Library
- Array Standard Library
- Mathematics Standard Library
- Random Standard Library
- Statistics Standard Library
- Time Standard Library
- Runtime intrinsics
- Explicit Standard Library imports
Documentation
Complete language documentation:
Language
Standard Library
Built-in Functions
Runnable examples:
Compatibility
Fully backward compatible with:
- NOVA v0.1
- NOVA v0.2
- NOVA v0.3
- NOVA v0.4
- NOVA v0.5
- NOVA v0.6
- NOVA v0.7
- NOVA v0.8
- NOVA v0.9
What's New in v1.0
Expanded Standard Library
The Standard Library now provides five official modules:
matharrayrandomstatstime
Each module is imported explicitly and exposes reusable functionality through a clean, documented API.
Runtime Intrinsics
Standard Library modules are implemented using runtime intrinsics that remain inaccessible to user programs. Low-level runtime operations are reserved for the Standard Library while user code interacts only with the public module interfaces.
Improved Project Organization
Projects can now be structured using:
- User-defined modules
- Standard Library modules
- Selective imports
- Module aliases
- Exported declarations
- Circular import detection
NOVA v0.9.0
The ninth public release of NOVA.
NOVA v0.9 introduces NOVA's first module system, enabling programs to be organized across multiple source files through imports and exports. This release also introduces NOVA's first importable Standard Library module, math, establishing the foundation for reusable libraries distributed with the language.
Programs can now import user-defined modules, selectively import exported declarations, assign import aliases, organize projects using hierarchical module paths, and access Standard Library functionality through explicit imports. Module resolution, export visibility, and circular dependency detection are performed before program execution begins.
Highlights
- Module imports
- Module exports
- Selective imports
- Import aliases
- Hierarchical module paths
- Standard Library modules
mathStandard Library- Module resolution
- Circular import detection
Documentation
Complete language documentation:
Language
Standard Library
Runnable examples:
Compatibility
Fully backward compatible with:
- NOVA v0.1
- NOVA v0.2
- NOVA v0.3
- NOVA v0.4
- NOVA v0.5
- NOVA v0.6
- NOVA v0.7
- NOVA v0.8
Next Release
Planned for v1.0:
- Additional Standard Library modules
- Expanded mathematical library
- Time module
- Random module
- JSON module
- Improved module ecosystem
NOVA v1.0 will continue expanding the Standard Library while preserving the explicit import model introduced in v0.9.
NOVA v0.8.0
The eighth public release of NOVA.
NOVA v0.8 introduces NOVA's first collection of built-in functions, providing common functionality for arrays, strings, type conversion, and user input. These functions are available globally without requiring imports.
Programs can now manipulate arrays and strings, perform mathematical operations, convert between primitive datatypes, and read user input through globally available built-in functions. These functions integrate with NOVA's existing function call semantics, type system, and runtime diagnostics.
Highlights
- Array built-in functions
- String built-in functions
- Type conversion built-in functions
- Input built-in functions
- Built-in function dispatch
- Built-in argument validation
- Playground-ready input abstraction
Documentation
Complete language documentation:
Language
Built-in Functions
Runnable examples:
Compatibility
Fully backward compatible with:
- NOVA v0.1
- NOVA v0.2
- NOVA v0.3
- NOVA v0.4
- NOVA v0.5
- NOVA v0.6
- NOVA v0.7
Next Release
Planned for v0.9:
- Module imports
- Multi-file programs
- Module resolution
- Exported declarations
- Migration of built-in functions into importable standard library modules
- Circular import detection
The next release will introduce NOVA's module system, allowing programs to be organized across multiple source files through explicit imports while maintaining predictable name resolution, lexical scoping, and compile-time diagnostics.
NOVA v0.7.0
The seventh public release of NOVA.
NOVA v0.7 introduces user-defined functions, enabling reusable program logic through function declarations, parameters, return values, recursion, and isolated function execution environments.
Programs can now organize behavior into reusable components while preserving lexical scope, runtime type safety, and source-aware diagnostics.
Highlights
- Function declarations
- Function calls
- Parameters
- Arguments
- Return values
- Return type enforcement
- Early returns
- Function-local scope
- Global scope access
- Variable shadowing
- Recursive functions
- Function resolution before declaration
Documentation
Complete language documentation:
Runnable examples:
Compatibility
Fully backward compatible with:
- NOVA v0.1
- NOVA v0.2
- NOVA v0.3
- NOVA v0.4
- NOVA v0.5
- NOVA v0.6
Next Release
Planned for v0.8:
- Standard library
- Built-in functions
- Input functions
- Type conversion functions
- String functions
- Array functions
- Map functions
- Mathematical functions
These additions will introduce NOVA's first standard library, providing reusable built-in functionality while preserving the language's simple and consistent function model.
NOVA v0.6.1
Patch release for NOVA v0.6.
NOVA v0.6.1 completes the loop execution model by introducing loop control statements and runtime validation.
Programs may now terminate the nearest enclosing loop using break or skip the current iteration using continue, with compile-time validation preventing their use outside of loops.
Highlights
breakstatementcontinuestatement- Loop control validation
- Runtime loop control handling
Documentation
Complete language documentation:
Runnable examples:
Compatibility
Fully backward compatible with NOVA v0.6.0.
Next Release
Planned for v0.7:
- Function declarations
- Function calls
- Parameters
- Arguments
- Return values
- Return type enforcement
- Local function scope
- Global scope access
- Variable shadowing
- Recursive functions
- Early returns
These additions will introduce reusable program logic through user-defined functions, enabling abstraction, recursion, and modular software development.
NOVA v0.6.0
The sixth public release of NOVA.
NOVA v0.6 introduces structured iteration through while loops, range loops, array iteration, and loop-scoped execution.
This release completes NOVA's foundational control-flow system, allowing programs to repeatedly execute code, iterate over numeric ranges and collections, and process data using structured loops while preserving lexical scope and runtime type safety.
Highlights
- While loops
- Range loops
- Inclusive ranges (
...) - Exclusive ranges (
..) - Descending ranges
- Array iteration
- Nested loops
- Loop variables
- Loop scope
Documentation
Complete language documentation:
Runnable examples:
Compatibility
Fully backward compatible with:
- NOVA v0.1
- NOVA v0.2
- NOVA v0.3
- NOVA v0.4
- NOVA v0.5
Next Release
Planned for v0.6.1:
breakstatementcontinuestatement- Loop control validation
- Runtime loop control handling
This patch release will complete NOVA's loop control system by introducing early loop termination and iteration skipping.
NOVA v0.5.1
Patch release for NOVA v0.5.
This release improves the print() statement by allowing multiple expressions to be printed in a single call.
Highlights
- Multiple expressions in
print() - Comma-separated output arguments
Example:
name: S = "Nova"
age: N = 1
print(name, age)
Output:
Nova 1
Output values are separated by a single space.
Documentation
Complete language documentation:
Runnable examples:
Compatibility
Fully backward compatible with NOVA v0.5.0.
Next Release
Planned for v0.6:
- While loops
- Range loops
- Array iteration
- Loop scope
- Enhanced control flow
NOVA v0.5.0
The fifth public release of NOVA.
NOVA v0.5 introduces the language's first control-flow system through conditional execution, block scope, and ternary expressions.
Programs can now execute different code paths based on runtime conditions while maintaining lexical scoping and runtime type safety.
Highlights
- Conditional execution
- If statements
- Else statements
- Else-if chains
- Nested conditionals
- Ternary expressions
- Block scope
- Variable shadowing
- Parent scope resolution
- Unary minus
Documentation
Complete language documentation:
Runnable examples:
Compatibility
Fully backward compatible with:
- NOVA v0.1
- NOVA v0.2
- NOVA v0.3
- NOVA v0.4
Next Release
Planned for v0.6:
- While loops
- Range loops
- Inclusive ranges
- Exclusive ranges
- Descending ranges
- Array iteration
- Nested loops
- Loop variables
- Loop scope
breakcontinue
These additions will complete NOVA's foundational control-flow system by introducing structured iteration and repeated execution over ranges and collections.
NOVA v0.4.0
The fourth public release of NOVA.
NOVA v0.4 introduces structured data through schema maps and strongly typed map instances.
Schemas allow programs to define reusable object layouts with runtime validation, optional properties, nested schemas, arrays of maps, and property-based access while preserving NOVA's runtime type safety.
Highlights
- Schema maps (
M) - Map instances
- Schema-based type validation
- Optional properties
- Nested schemas
- Arrays of maps
- Schemas containing arrays
- Property access
- Property mutation
- Deep collection traversal
Documentation
Complete language documentation:
Runnable examples:
Compatibility
Fully backward compatible with:
- NOVA v0.1
- NOVA v0.2
- NOVA v0.3
Next Release
Planned for v0.5:
- If statements
- Else statements
- Else-if chains
- Ternary expressions
- Block scope
- Variable shadowing
- Parent scope resolution
- Unary minus
These additions will introduce NOVA's first control-flow system, enabling programs to execute different code paths while establishing lexical block scoping for future loop and function support.