Additional information

• Images
• Videos
• Documents
• Books
• Articles

History

JS++ first appeared on October 8, 2011.¹²³ The modern implementation was announced at DeveloperWeek 2016⁴ and released on May 31, 2016.⁵⁶⁷⁸ The language is designed by Roger Poon and Anton Rapetov.

Features

Sound gradual type system

Since JS++ is a superset of JavaScript, declaring data types for variables is optional. However, when types are declared, the types are enforced at both compile time and runtime.

Type annotations in JS++ use the traditional C syntax:

int x = 1; var y = 2; bool z = true;

Notably, this differs from TypeScript and ActionScript, which use a more verbose style:

var x : number = 1; var y : any = 2; var z : boolean = true;

The type system in JS++ is sound for ECMAScript and DOM API corner cases, including host objects, dynamic key-value pairs, Comet, JScript conditional compilation, dynamic return types, ActiveX, ECMAScript for XML, web browser garbage collector and cyclic reference counting bugs, conditional logic, and other corner cases.⁹¹⁰ This differs from other JavaScript supersets where types are optional and discarded at runtime via type erasure, such as in TypeScript.¹¹¹²

Importing JavaScript libraries

JS++ can use JavaScript libraries using the one-line external statement as in the following example from the homepage of JS++:

import System; // Import JavaScript libraries in one line of code external jQuery, $; class Example { public Example() { // Nearly NO learning curve // You can keep writing regular JavaScript var a = 0, random = Math.random(); // Integer types and other primitives // ... enable fast (optimized) and clear code byte[] rgbColors = [ 0xFF, 0xFA, 0xFF ]; } public void showMessage(int id, string text) { // 100% compatible with regular JavaScript jQuery("#msgbox").show(); $("#msgbox").text(id.toString() + text); } }

Object-oriented programming

While classes in JavaScript (ECMAScript 6) are syntactic sugar for prototypes under the hood,¹³ JS++ classes resemble the classes found in classical programming languages such as C++, Java, and C# in terms of memory layout, performance, and semantics. For example, private methods are private at both compile time and runtime, and external JavaScript objects cannot access private JS++ fields or methods.

Example: object-oriented sorting

The following source code illustrates object-oriented sorting in JS++ using the IComparable<T> interface and Comparison enumeration for type-safe and readable comparisons.¹⁴ The custom sorting logic is one line of code in the overridden compare method below:

import System; class Employee : IComparable<Employee> { private string firstName; private string lastName; public Employee(string firstName, string lastName) { this.firstName = firstName; this.lastName = lastName; } public override Comparison compare(Employee that) { // Sort by employee surname return this.lastName.compare(that.lastName); } public override string toString() { return this.firstName + " " + this.lastName; } } Employee zig = new Employee("Zig", "Ziglar"); Employee john = new Employee("John", "Smith"); Employee abe = new Employee("Abe", "Lincoln"); Employee[] employees = [ zig, john, abe ]; employees.sort(); Console.log(employees.join(", ")); // Output: // Abe Lincoln, John Smith, Zig Ziglar

Thus, in the code above, the custom sorting logic provided is:

return this.lastName.compare(that.lastName);

Likewise, to call the sort:

employees.sort();

For printing the sorted results:

Console.log(employees.join(", "));

The join method will call the overridden toString method on each individual object, which concatenates the employee's first and last names.

Example: encapsulation by default

JS++ provides encapsulation by default. In the following example, the fields x and y are private by default, even if no access modifier is specified. The methods getX() and getY() are public by default. This enables a more concise class definition syntax, as illustrated in the Point class below:¹⁵

class Point { int x, y; Point(int x, int y) { this.x = x; this.y = y; } int getX() { return this.x; } int getY() { return this.y; } }

Out-of-bounds analysis

An out-of-bounds access usually occurs with arrays. For example, when we access the 100th element of a 3-element array, we have an out-of-bounds access:

int[] arr = [ 1, 2, 3 ]; Console.log(arr[100]); // out-of-bounds access, 'arr' does not have an element at index 100

In Java and C#, this can result in an exception and program termination. In C, this can result in buffer overflows or segmentation faults. C++ has varying semantics, such as default initialization, exceptions, segmentation faults, or buffer overflows.¹⁶¹⁷

JS++ can efficiently analyze out-of-bounds errors at compile time.¹⁸¹⁹²⁰

JavaScript has the notion of null and undefined values, where null means a value is present but it's an empty value, and undefined means there isn't a value there at all. JS++ extends this intuition further to differentiate between empty values and out-of-bounds accesses.²¹

Consider the following code, with a nullable int type represented with int?:

int[] a = [ 1, 2 ]; int? value1 = a[2]; if (value1 == null) { Console.log("Definitely out of bounds"); } int?[] b = [ 1, null ]; int? value2 = b[2]; if (value2 == null) { Console.log("Might be out of bounds, might just be an access of a null element"); }

While nullable types can represent an out-of-bounds access, it falls apart when the array might contain nullable values as illustrated above. Instead, JS++ introduces an additional concept in addition to null values: undefined values. Recall that JS++ extends the JavaScript notion that null means a value is present but is an empty value, while an undefined value means a value does not exist at all. JS++ uses the concept of "a value does not exist at all" to mean an out-of-bounds access has occurred, and this concept is known in JS++ as "existent types."²²

Therefore, the previous example can be amended. The existent type int+ means "int or out of bounds" and int?+ means "int, null, or out of bounds":

int[] a = [ 1, 2 ]; int? value1 = a[2]; if (value1 == undefined) { Console.log("Definitely out of bounds"); } int?[] b = [ 1, null ]; int?+ value2 = b[2]; if (value2 == undefined) { Console.log("Definitely out of bounds"); }

Intuitively, this means existent types cannot be used as the underlying type for array elements. JS++ enforces this at compile time:

int+[] arr = []; // ERROR [ ERROR ] JSPPE5204: Existent type `int+' cannot be used as the element type for arrays

Development tools

Compiler

The JS++ compiler is available for Windows, macOS, and Linux. It is a source-to-source compiler which emits JavaScript source code as an intermediate representation.

Editor integration

JS++ integrates with various code editors including Visual Studio Code, Atom, and Sublime Text.²³²⁴²⁵

Build tools

JS++ can be integrated with third-party build tools like Webpack.²⁶

Release history

Version number	Release date	Changes
0.01	8 October 2011 (2011-10-08)	Alpha version, initial release
0.011	10 October 2011 (2011-10-10)	Alpha version
0.012	25 October 2011 (2011-10-25)	Alpha version
0.013	29 January 2012 (2012-01-29)	Alpha version
0.014.1	15 August 2012 (2012-08-15)	Alpha version
0.4.1	31 May 2016 (2016-05-31)	Beta version, array and callback types, character literals, integral suffixes, removed ECMAScript ASI
0.4.2	18 October 2016 (2016-10-18)	Modules, function overloading, dead code elimination, editor integrations
0.4.2.1	24 October 2016 (2016-10-24)	Bug fixes
0.4.2.2	17 November 2016 (2016-11-17)	Source map debugging
0.4.2.4	25 December 2016 (2016-12-25)	Support for Mac OS X, C-style casts, callback and array conversions
0.5.0	13 March 2017 (2017-03-13)	Classes
0.5.1	26 March 2017 (2017-03-26)	'foreach' loops
0.5.2	27 July 2017 (2017-07-27)	BSD License, Interfaces, Abstract Classes, Virtual Methods, Auto-boxing
0.7.0	27 October 2017 (2017-10-27)	All ECMAScript 3 features via Array<T> and Standard Library
0.8.0	15 March 2018 (2018-03-15)	Generic programming, Dictionary<T>, multi-line strings, .js++ file extension
0.8.1	27 March 2018 (2018-03-27)	auto, catch-all clauses, standard library modules for handling time, bug fixes
0.8.4	23 May 2018 (2018-05-23)	New string functions, advanced generics, bug fixes, standard library expansion
0.8.5	2 June 2018 (2018-06-02)	Bug fixes
0.8.10	24 November 2018 (2018-11-24)	Faster compile times, stacks, queues, Unicode, Base64, generic default constraint rules
0.9.0	11 January 2019 (2019-01-11)	Efficient compile time out-of-bounds error analysis
0.9.1	1 July 2019 (2019-07-01)	Bug fixes
0.9.2	18 October 2019 (2019-10-18)	Final (immutable) variables and default to 64-bit for macOS Catalina

See also

• TypeScript
• PureScript

References

1. "JavaScript++: New, Powerful Language for Better Web Development". 17 October 2011. Archived from the original on 17 October 2011. https://web.archive.org/web/20111017221312/http://jspp.javascript.am/ ↩

2. "C++ et Javascript = Javascript++". La ferme du web. 12 October 2011. Archived from the original on 12 October 2011. https://web.archive.org/web/20111012143226/http://www.lafermeduweb.net/veille/c-et-javascript-javascript-123284133702156289.html ↩

3. "Index of /downloads". 18 October 2011. Archived from the original on 18 October 2011. https://web.archive.org/web/20111018172906/http://jspp.javascript.am/downloads/ ↩

4. "JavaScript Conference - DeveloperWeek 2016 - February 12–18". 13 February 2016. Archived from the original on 13 February 2016. https://web.archive.org/web/20160213204925/http://www.developerweek.com/javascript-conference/ ↩

5. Poon, Roger (May 31, 2016). "JS++ Goes Into Public Beta". Onux.com. https://www.onux.com/jspp/blog/jspp-goes-into-public-beta/ ↩

6. Handy, Alex (June 1, 2016). "Onux seeks to fix JavaScript's lack of type safety". SD Times. http://sdtimes.com/onux-seeks-fix-javascripts-lack-type-safety/ ↩

7. Krill, Paul (June 6, 2016). "New compiler tackles JavaScript's weak typing". InfoWorld. https://www.infoworld.com/article/3079092/javascript/new-compiler-tackles-javascripts-weak-typing.html ↩

8. Cimpanu, Catalin (June 9, 2016). "jQuery 3.0 Released and Other JavaScript News". Softpedia. https://news.softpedia.com/news/jquery-3-0-released-and-other-javascript-news-505064.shtml ↩

9. "The JS++ Type System, Appendix B: Problems (Why was this hard to solve?)". Retrieved 10 February 2020. https://www.onux.com/jspp/tutorials/type-system#Appendix-B ↩

10. US patent 10296313, Roger Poon, "Safely consuming dynamically-typed code from a statically-typed programming language", published 2019-05-21 http://patft1.uspto.gov/netacgi/nph-Parser?patentnumber=10296313 ↩

11. Bridgwater, Adrian (June 13, 2016). "Onux JS++, an answer to JavaScript 'brittle' type safety?". Computer Weekly. Archived from the original on 2016-07-22. https://web.archive.org/web/20160722151154/http://www.computerweekly.com/blog/Open-Source-Insider/Onux-JS-an-answer-to-JavaScript-brittle-type-safety ↩

12. "The JS++ Type System". Onux.com. https://www.onux.com/jspp/tutorials/type-system ↩

13. "Classes". MDN Web Docs. Retrieved 2025-06-20. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes ↩

14. Poon, Roger (May 28, 2019). "Tips & Tricks: Object-oriented Sorting in JS++ with IComparable". Retrieved June 20, 2025. https://www.onux.com/jspp/blog/tips-tricks-object-oriented-sorting-in-jspp-with-icomparable-t/ ↩

15. Poon, Roger (June 10, 2018). "Tips & Tricks: Only Fields are 'private' by Default". Retrieved June 20, 2025. https://www.onux.com/jspp/blog/tips-tricks-only-fields-are-private-by-default/ ↩

16. "std::unordered_map::operator[] - cppreference.com". en.cppreference.com. Retrieved June 20, 2025. https://en.cppreference.com/w/cpp/container/unordered_map/operator_at.html ↩

17. "std::unordered_map::at - cppreference.com". en.cppreference.com. Retrieved June 20, 2025. https://en.cppreference.com/w/cpp/container/unordered_map/at.html ↩

18. Díaz, Fabio (January 23, 2019). "JS++, the JavaScript superset, is getting rid of out-of-bounds errors". Akuaroworld. https://www.akuaroworld.com/js-the-javascript-superset-is-getting-rid-of-out-of-bounds-errors/ ↩

19. Cardoza, Christina (January 16, 2019). "JS++ programming language looks to solve out-of-bounds errors". SD Times. https://sdtimes.com/softwaredev/js-programming-language-looks-to-solve-out-of-bounds-errors/ ↩

20. Poon, Roger (January 11, 2019). "JS++ 0.9.0: Efficient Compile Time Analysis of Out-of-Bounds Errors". Onux.com. https://www.onux.com/jspp/blog/jspp-0-9-0-efficient-compile-time-analysis-of-out-of-bounds-errors/ ↩

21. Poon, Roger (January 11, 2019). "JS++ 0.9.0: Efficient Compile Time Analysis of Out-of-Bounds Errors". Onux.com. https://www.onux.com/jspp/blog/jspp-0-9-0-efficient-compile-time-analysis-of-out-of-bounds-errors/ ↩

22. Poon, Roger (January 11, 2019). "JS++ 0.9.0: Efficient Compile Time Analysis of Out-of-Bounds Errors". Onux.com. https://www.onux.com/jspp/blog/jspp-0-9-0-efficient-compile-time-analysis-of-out-of-bounds-errors/ ↩

23. "JavaScript superset JS++ adds dead code elimination and more". Computerworld. October 19, 2016. http://www.computerworld.com/article/3132920/application-development/javascript-superset-js-adds-dead-code-elimination-and-more.html ↩

24. Cardoza, Christina (October 19, 2016). "JS++ 0.4.2 released with code editor integrations, modules and dead code elimination". SD Times. http://sdtimes.com/js-0-4-2-released-code-editor-integrations-modules-dead-code-elimination/ ↩

25. Clark, Geneva (October 20, 2016). "JS++ 0.4.2 Release - Upgraded With Modular Design, Dead Code Elimination, and Multiple Code Editors". Zeomag. https://www.zeolearn.com/magazine/jspp-0.4.2-release-with-upgrades ↩

26. Phoenix, Ingwie (7 December 2018). "Proof of Concept: Using JS++ with WebPack". GitHub. Ingwie Phoenix. https://github.com/IngwiePhoenix/jspp-webpack-poc ↩