https://github.com/joaaoverona/venusscript
A dynamic, interpreted, scripting language written in Java.
https://github.com/joaaoverona/venusscript
ast async asynchronous compiler cryptography dynamic extensible java java-8 java-library java8 language runtime-injections script scripting scripting-engine scripting-language scripting-languages
Last synced: 8 months ago
JSON representation
A dynamic, interpreted, scripting language written in Java.
- Host: GitHub
- URL: https://github.com/joaaoverona/venusscript
- Owner: JoaaoVerona
- License: agpl-3.0
- Created: 2016-05-09T00:06:01.000Z (over 9 years ago)
- Default Branch: master
- Last Pushed: 2024-08-19T02:40:00.000Z (over 1 year ago)
- Last Synced: 2025-03-28T02:46:15.502Z (9 months ago)
- Topics: ast, async, asynchronous, compiler, cryptography, dynamic, extensible, java, java-8, java-library, java8, language, runtime-injections, script, scripting, scripting-engine, scripting-language, scripting-languages
- Language: Java
- Homepage:
- Size: 1.05 MB
- Stars: 18
- Watchers: 5
- Forks: 1
- Open Issues: 9
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
### 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](https://github.com/BloodShura/VenusScript/tree/master/examples) 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 |
- Object-oriented features (classes, attributes, methods, maybe polymorphism, etc)
- Java interoperability
- Lists
- Dictionaries/Maps
- Heterogeneous arrays |
- Functional features
- Enumerations
- Debugging utilities and breakpoints |
- Improved performance
- Own bytecode compiler and interpreter |
## How to use
##### With Gradle:
```
dependencies {
compile 'com.github.bloodshura:venusscript:2.0.0'
}
```##### With Maven:
```
com.github.bloodshura
venusscript
2.0.0```
##### 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...](https://github.com/BloodShura/VenusScript/issues?q=is%3Aissue+is%3Aopen+-label%3Abug)## Documentation
*Work in progress.*
| **1.x** | **current** |
| 2.x | planned |
| ? | planned |