This was a project made by the author while in university, in 2016, and is no longer maintained. Still, feel free to explore and fork it. :)

---

venusscript

Welcome to the official GitHub repository of the dynamic, injectable, scripting language VenusScript. See the examples directory to get a closer look in how the language works.

using std

ver = "2.0.0"
println("Hi from VenusScript! Version = " + ver)

def sum(int a, int b) {
    return a + b
}

newestSum = 0

async {
    for i in (1, 10) {
        newestSum = sum(i, i)
        println(newestSum)
    }
}

wait(newestSum == 20)
println("Ok!")

Version Planning

Version	State	Description
0.x	done	Definitions Functions Function references Standard library Loop containers Branching components Variable references Initial dynamic injection Runtime interpretation Asynchronous features Synchronous features Homogeneous arrays
1.x	current	Object-oriented features (classes, attributes, methods, maybe polymorphism, etc) Java interoperability Lists Dictionaries/Maps Heterogeneous arrays
2.x	planned	Functional features Enumerations Debugging utilities and breakpoints
?	planned	Improved performance Own bytecode compiler and interpreter

How to use

With Gradle:

dependencies {
	compile 'com.github.bloodshura:venusscript:2.0.0'
}

With Maven:

<dependency>
	<groupId>com.github.bloodshura</groupId>
	<artifactId>venusscript</artifactId>
	<version>2.0.0</version>
</dependency>

With other build systems:

If your build system supports fetching dependencies from the Maven central repository, then just include a dependency with group com.github.bloodshura, artifact venusscript and version 2.0.0.

Tech

VenusScript is meant to be used within any Java or JVM-built (Kotlin, Scala, Groovy, etc) application. It is required Java 8+.

Definition

• Highly extensible
• Dynamic typing
• Context/scope manipulation
• No 'null' type/value
• Simple syntax
• Runtime injections (of libraries, function overriding, function definition, etc)
• Multithreaded
• Extremely easy syntax

Already implemented

• Asynchronous features: async scopes
• Synchronous features: monitor locks (produce, consume), value waiting (e.g. wait(i == 5))
• Value types
• Function references
• Variable references
• Top-level functions
• Higher-order functions
• Dynamic include statements
• Dynamic using statements
• Exporting variables to global context (so multiple scripts within the same application can access them)
• While, do-while containers
• Break, continue statements
• Ranged foreach container (e.g. for i in (0, n))
• Strongly typed function definitions (e.g. def print(string name) {...)
• Basic standard libraries (random, input, output, cryptography, dialogs, math, runtime injection)
• Interpret source code at runtime (e.g. interpret("println(3 + 5 + 2 - 1)"))
• Binary, decimal and hexadecimal literals
• Execute other scripts, asynchronously or synchronously (e.g. async run("../basic.vs"))
• Homogeneous arrays

To be implemented

• Object-oriented programming (classes, attributes, methods, maybe polymorphism, etc)
• Functional programming (lambdas, data immutability, etc)
• Collections (heterogeneous arrays, lists, maps, sets)
• Easier interoperability with Java
• User-defined value types
• Debugging features (including, but not limited to, breakpoints)
• Expand standard libraries
• Enumerations
• Simple exception handling?
• ... and many more...

Documentation

Work in progress.