Neuron Language Reference

Objects and Functions

Objects and functions can be integrated. Neuronic Objects can hold both properties and methods accessable to itself and to other objects, providing it with a dynamic foundation for script execution. Objects and functions are defined in the following syntax:

myObject {
  property: value;

Objects can hold both properties and methods, accessible to itself and to other objects:

myObject {
  width: 1px;
  height: 1px;
  position: 10px 10px;


Objects containing HTML- and CSS-specific properties should be invoked as such:


Functions can be called as methods:


Functions with return values can be called as inline functions:

[myObject => parameters]

Functions can also take parameters, prefixed with # and followed by their parameter number:

absoluteValue {
  return([math.abs => #0]); // #0 defines the first parameter passed

log([absoluteValue => 0]);
// logs '0'

Functions can be executed with the following syntax as well:

add {
  log(#0 + #1 is [#0 + #1]);

add(0, 1);
// logs '0 + 1 is 1'

Bracket Notation

Groupings, literals, and inline functions are all preceded by and followed by brackets. Bracket notation is defined by the following syntax:

[function => parameters]
[function parameters]

Bracket notation can be embedded in parameters or values:

log([function => parameters]px, [grouping]px)


Parameters are seperated by commas or spaces. Bracket notation can escape parameter seperators, and pass a single parameter.

log(Hello, World!) // The parameter seperator is not escaped
// logs 'Hello' and 'World!' in 'Hello World!'
log([Hello, World!]) // Bracket notation
// logs 'Hello, World!'


Literals evaluate its contents.

log(0 + 1) // Evaluated as a string
// logs '0 + 1'
log([0 + 1]) // Evaluated as a literal
// logs '1'

Inline Functions

Inline functions can pass parameters to a function with a return value, seperated by spaces.

[function => parameters]
log([math.sqrt => 1]px);

Variables and Assignments

Variables can be defined with the following syntax:

#myVar = value

Variables can then be referenced or reassigned:

#myVar = value;

Object properties can be referenced and reassigned as well:

myObject.position = value;


Conditionals can be defined with the following syntax:

if (condition) {
  // contents

The conditional will execute if the condition returns true. Conditionals are capable of being embedded in executable objects.


Iterators can be defined with the following syntax:

for (var in/=> value) {
  // contents

The iterator will iterate through the value, executing its contents. The variable can then be used with the prefixed # notation.

for (var => value) {

Iterators are capable of being embedded in executable objects.


Arithmetic Operators

+ Addition operator

- Subtraction operator

/ Division operator

* Multiplication operator

% Remainder operator

** Exponentiation operator

Relational Operators

< Less than operator

> Greater than operator

<= Less than or equal to operator

>= Greater than or equal to operator

== Equality operator

!= Inequality operator

=== Identity operator

!== Nonidentity operator

Logical Operators

&& Logical AND

|| Logical OR

! Logical NOT operator

Assignment Operators

= Assignment operator


Expressions preceded by a tilde ~ are recognized as inheritance. Inheritance can be defined with the following syntax: