Skip to content
✏️ VSL: Volleyball Seem Laughable
JavaScript Nearley CSS Other
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
.github
libraries
misc
src
test
vslnative
.babelrc Specify corejs version Jul 30, 2019
.esdoc.json Move interpreter over to new toolchain Jul 20, 2019
.eslintignore
.eslintrc.js
.gitignore
.gitmodules cleanup: Move WASM into submodule. Mar 4, 2018
.npmignore
.tern-project
.travis.yml
CHANGELOG.md
CONTRIBUTING.md
README.md
TODO.md Add libvsl JS Sep 10, 2017
api.js
appveyor.yml
index.js Add backend names Jan 23, 2018
interop.js Add VSL interop Nov 25, 2018
package.json
vsl
wasm.js

README.md

VSL: Versatile Scripting Language

Build Status

Language DocumentationAPI Documentation

Versatile Scripting Language

VSL is a modern, powerful, fast, and easy to write programming language designed for the 21st century.

Download

You can either build from source (see Building) or installed a pre-compiled binary/executable:

Windows macOS Linux
Download Download Download

Changes

Git revision history is a mess but checkout CHANGELOG.md for detailed devleopment information.

Building

Building isn't too diffiult. Usually you'll want to install a pre-built binary but if you're feeling adventurous or just want to help build VSL (:D) building from source is simple:

$ git clone --recursive https://github.com/vsl-lang/VSL
$ npm install
$ npm run build

Do note, branch of the develop branch to make changes. All PRs go there. Other commands:

$ npm run coverage # Generates testing coverage reports
$ npm test         # Runs all tests
$ npm run dev      # Development build
$ npm run docs     # Make docs
$ npm run lint     # Lint code and make sure not crap

Do note you don't need to generate docs unless you want them for yourself because the CI will automatically generate docs.

Development Info

  • Docs are located here.
  • A bunch of READMEs are located in the dirs which do more complex things

Problem

Today they are quite a few languages, some popular ones you may of heard of are:

  • Python
  • Java
  • JavaScript
  • C/C++

and while these are all great and well (and have worked). Here are the things one wants from a programming language:

  • Portability (C/C++ lack here)
  • Ease of Use (Java & C/C++ lack here, but arguable)
  • Rapid prototyping (Java, C/C++, and even JS ES2015+)
  • Saftey: type, memory, etc. (JS & Python lack)
  • Bare-metal speed (yeah...)
  • Powerful and close-to-hardware (JS, Python, and Java lack)

So VSL aims to solve all of these problems

  • Portability: By leveraging the LLVM bytecode engine VSL can compile to almost all targets and is designed for simple compatibility with existing C projects.

  • Fast: Due to careful design and implementation choices, VSL compiles to very similar ASM to what something written in a low-level language such as C would produce.

  • Safe: By using syntax sugar, and powerful type-negotiation, VSL has one of the best type deduction algorithms. Combined with low compilation overhead, VSL can generate code with bare minimum boilerplate and guarunteed saftey at compile-time.

  • Powerful: VSL uses high-level syntax to be able to write code that works for all types of programmers, whether you are functional, OO, scripting, or low-level engineer. Through both high-level interfaces for low-level functions, you can use VSL for tasks low-level such as read/writing bits from a serial port to running a server.

  • Reliability: through bindings of reliable, trusted, and industry-standard libraries such as libcurl, and libc backends, VSL has powerful low-level pointer interopability and the power of full OO-classes.

Examples

VSL functions both as a scripting and a full-blown language so two alterntaives are given for all programs. That said, they are many more ways to write many of these programs, neither more correct than the other.

Hello, World!

print("Hello, World")
func main(args: String[]) {
  print("Hello, World!")
}

Fizzbuzz

let fizzbuzz :: (of: Int) -> String
fizzbuzz(i where i % 3, i % 5) -> "FizzBuzz"
fizzbuzz(i where i % 3) -> "Fizz"
fizzbuzz(i where i % 5) -> "Buzz"
fizzbuzz(i) -> String(for: i)

Using the JS interface

To interface with the compiler the easiest way is to use the VSLToolchain class. For more specific behavior you'd need to interact directly with the CompilationIndex and CompilationGroups. See the documentation for information on that:

import { Toolchain } from 'vsl';

const toolchain = new Toolchain.VSLToolchain();

const file = {
    type: Toolchain.VSLToolchainDataSourceType.file,
    data: './main.vsl'
};

const compilationInstance = await toolchain.executeFiles([ file ]);
const emissionInstance = await result.compile();

// Get byte-code
const byteCode = await emissionInstance.emitRaw(result);

// To obtain an executable
await compiledInstance.emitExecutable('main.out', { /* See object options below */ });

// To obtain a shared object
await compiledInstance.emitSharedObject('main.dylib', { /* See object options below */ });

// To obtain a linked object file
await compiledInstance.emitObject('main.o', { optimizationLevel: 3, objects: [...], libraries: [...] })

// Otherwise to optimize and get bytecode
await compiledInstance.emitBitcode('main.bc', { optimizationLevel: 3 });

// To obtain assembly
await compiledInstance.emitAsm('main.s', { optimizationLevel: 3 });
You can’t perform that action at this time.