» Integer and Primitive Types in VL
This site relies heavily on Javascript. You should enable it if you want the full experience. Learn more.

Integer and Primitive Types in VL


The latest VL comes with a revised 'Primitive' category in the nodebrowser. This category holds the most basic data types which the system has build in. As amazing as it sounds all other types are made out of them.

There are:

  • Integer and floating point numeric types for calculations
  • Boolean for logic
  • Char and String for text
  • A few system types like Exception and Object

In this article we will focus on the numeric types and which operations VL ships for them.


Primitive numeric types come in two flavors: integer and floating point. The number after the type name is the size of the type in bits. The number of bits also defines the value range that the type can hold.

The VL default types are Integer32 and Float32.

Operators and Types

Numeric Unary Numeric Binary Bit Unary Bit Binary Bit Shift Bool Unary Bool Binary
~ &
! ==

You should know most of them from math class but there are a few computer specific ones:

Division for integers is called DIV and it outputs an integer again. The "/" operator on integer types returns a floating point number.

The "%" operator is called MOD in VL and returns the remainder of a division.

For integers there is a combination of DIV and MOD called DIVMOD which outputs both the result of the division and the remainder. A practical usage is 2D column/row index calculation.

"~" is the ones complement, it inverts all bits of a value.

">>", "<<" are the bit shift operators, they move all bits of a type to the left or right. New bits are padded with zeroes.

The following table gives an overview of all types and their operators:

VL Name Bits Unary Binary C# Name
Integer8 8 num/bit num/bit/shift sbyte
Byte 8 num/bit num/bit/shift byte
Char 16 num/bit num/bit/shift char
Integer16 16 num/bit num/bit/shift short
Integer16 (Unsigned) 16 num/bit num/bit/shift ushort
Integer32 32 num/bit num/bit/shift int
Integer32 (Unsigned) 32 num/bit num/bit/shift uint
Integer64 64 num/bit num/bit/shift long
Integer64 (Unsigned) 64 +, ~ num/bit/shift ulong
Float32 32 num num float
Float64 64 num num double
Boolean 1 bool bool bool

Value Range

Integer types

Type Range Size
Integer8 -128 to 127 Signed 8-bit integer
Byte 0 to 255 Unsigned 8-bit integer
Char U+0000 to U+ffff Unicode 16-bit character
Integer16 -32,768 to 32,767 Signed 16-bit integer
Integer16 (Unsigned) 0 to 65,535 Unsigned 16-bit integer
Integer32 -2,147,483,648 to 2,147,483,647 Signed 32-bit integer
Integer32 (Unsigned) 0 to 4,294,967,295 Unsigned 32-bit integer
Integer64 -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 Signed 64-bit integer
Integer64 (Unsigned) 0 to 18,446,744,073,709,551,615 Unsigned 64-bit integer

Floating point types

Type Approximate range Precision Size
Float32 ±1.5 * E45 to ±3.4 * E38 7 digits 32-bit float
Float64 ±5.0 * E−324 to ±1.7 * E308 15-16 digits 64-bit float
Floating point numbers have an insane value range, but its important to understand that there is only a certain number of digits of precision.
This also means that the maximum consecutive integer that can be represented is 2^24 = 16,777,216 for Float32 and 2^54 = 9,007,199,254,740,992 for Float64, keep that in mind when connecting integers to float inputs.


Between Numeric Types

Smaller integer types can directly be connected to bigger integer types that can hold the range of the smaller type and to floating point types.
For all other conversions a node is required since information might get lost.
However, sometimes you want to trick the VL type inference system or you explicitly want a specific type and therefore the complete list of conversion nodes are available.


Checked conversions throw an error if the value to convert exceeds the range of the target type. This can be helpful if you want to make sure to assign correct values to bytes.

The naming scheme of the nodes is ToTargetType and they are located in the category of the source type. For example a conversion from Integer32 to Byte is called ToByte (Integer32). Unsigned types are abbreviated with an 'U', so a conversion from Float32 to Integer32 (Unsigned) is called ToUInt32 (Float32).


Unchecked conversions do not throw errors and just copy appropriate bits from the source type to the target type. This results in value wrapping. For example converting an Integer32 with value 256 to a Byte will result in a value of 0, an integer with value 257 in a value of 1 and so on...

Because they directly copy the bits, the naming scheme of the nodes is BitsToTargetType in the category of the source type. For example a conversion from Integer32 to Integer64 (Unsigned) is called BitsToUint64 (Integer32) or a Byte to Char BitsToChar (Byte).

Type -> String

The conversion form machine representation to human readable string is of course essential for programming. There is a general node ToString (Object) which tries to convert everything plugged in to it to a string. This node works for all numeric types and Char because the system knows what to do.

However if you want your value in a specific string representation you have three more advanced nodes for all numeric types:

ToString (Format)

This is the most powerful node. It allows to input a format string which acts as template for the output string of the value. See these two documentation pages for the vast amount of possibilities (thanks microsoft!).
Standard Format Strings
Custom Format Strings

ToString (Binary)

Quite helpful when working with low level device protocols and other bitwise operations. Nerds ahoi!

ToString (Hex)

Hexadecimal is a compact representation of the bits where one digit can represent 16 values from '0' to 'F' which is 4 bits. You know this probably from html colors. Medium nerdy.

String -> Type

Parsing strings to a numeric type is also often required. When getting user input from or reading data from a text file for example. Since the parsing can go wrong quite easily the nodes are called TryParse and have a boolean output 'Success' which indicates whether the input string could be parsed into a numeric value that makes sense.

TryParse (Hex)

Version to parse hexadecimal strings into a numeric type.

TryParse (Binary)

My personal favorite, parsing binary strings. (Didn't you ever want to just type ones and zeroes into your computer?).


This might be some heavy detailed stuff for the average user, but it gives us a solid core library that is ready for all tasks and can solve even the problems on the lowest level.

And rest assured, most of the time you will just deal with the standard types Integer32 and Float32 and don't have to worry about the others. But in the 1% case when you need to shuffle the bits its all there for you.


tonfilm, Wednesday, Mar 23rd 2016 Digg | Tweet | Delicious 1 comments  
tonfilm 24/03/2016 - 20:06

this chapter didn't made it into the article, but for the interested here it is as a comment:

Bit Layout


Integer types only store whole numbers and have a direct bit to value layout which makes them very fast. Let's have a look at the unsigned 8-bit Byte type and a few value representations in bits:

0000 0000 = 0
0000 0001 = 1
0000 0011 = 3
0111 1111 = 127
1000 0000 = 128
1000 1000 = 136
1111 1110 = 254
1111 1111 = 255

Signed integer types use the first bit to indicate the sign. Hence the same bits can have a different meaning for signed types:

0000 0000 = 0
0000 0001 = 1
0000 0011 = 3
0111 1111 = 127
1000 0000 = -128
1000 1000 = -120
1111 1110 = -2
1111 1111 = -1

The interesting thing here is that 1111 1111 is -1, so in a sense -1 is the highest value in binary. The reason for this is that the values wrap in a nice way when an overflow occurs.

Floating Point

Floating point numbers have a more complicated layout in memory. Simplified, they store there significant digits, the sign and the place of the decimal mark (aka dot or comma, depending on where you live). Also see IEEE Float for details.

  • 1

anonymous user login


~6min ago

joreg: Please help yourself to the latest #vvvv gamma 2020.2: vvvv-gamma-2020.2-release

~3d ago

nodeforum: E-mail invitations for NODE20’s Festival Hub have been sent out yesterday. In case of trouble let us know via help@nodeforum.org

~4d ago

david: @neuston: email is going out very soon!!!

~4d ago

neuston: @sunep Thx, but I have checked the spam folder but could not fine any

~5d ago

sunep: @neustron have you checked your spam folder? Mine went to spam.

~5d ago

neuston: I've not received any activation email for Talque, after purchased tickets of NODE20 last week. Is it normal? just want to confirm.

~5d ago

boplbopl: @tonfilm nice!

~5d ago

tonfilm: The first #vl #stride screenshots are here! vl.stride-earlyaccess-screenshots #visualprogramming #dotnet @stride3d #creativecoding #vvvv #gamedev

~6d ago

udo2013: @systray27 thank you :)

~7d ago

systray27: @Udo2013> Wow that's beautiful!