Symsyn is a simple syntax, back-to-basics, minimalist programming language which resembles a sort of assembly language for a Pascal Virtual Machine (PVM).  Assemblers provide a one to one relationship between a mneumonic instruction and a hardware opcode. Similarly, Symsyn establishes a one to one relationship between an instruction and a Pascal procedure.  The instruction set is, therefore, open ended and can grow into any operating environment.

It is implemented by a compiler, SSL which generates version specific PVM code from a text file; and a runtime executive/emulator, SSX which processes the code. Both are written in Pascal.  SSX has program (prog) monitoring and log functions. It is capable of running 99 progs concurrently.  Multitasking is enhanced with several inter-program communication instructions which provide synchronization and data passing functions.

The single task runtime SSS is simpler, smaller, and faster than SSX.  It runs from the command line, has no window, no commands, and no log file.  It runs a single prog to completion and then ends.

The intended user is a novice programmer or a non programmer who doesn't have the time or interest to learn the conceptual niceties and abstract concepts of a more advanced and rigorous language, but needs to accomplish a given task. Symsyn's simplicity and potential could provide much of the functionality of Pascal without all of Pascal's discipline and could be an on ramp to learning Pascal.


A compiler and emulator were written for the PC under DOS to enable it to run multitasking software originally written for a minicomputer. The software drove legacy data communications protocols, code translation, encryption support, and transaction flow control for a real time banking application involving ATM's, teller terminals, and regional switches. This front end and a host computer were capable of controlling hundreds of devices.  While Symsyn is decidedly different from that source code, major portions of that compiler and emulator were used here.


  • Real time multitasking operating environment running up to 99 progs concurrently.
  • Program security - re-assignable version specific opcodes to inhibit reverse engineering.
  • Extensible architecture designed to accommodate new instructions.
  • Fast - each instruction variant is hard coded for the current software release.
  • Tight - average instruction size is 6 bytes.
  • Interprogram communication (synchronization and data passing) instructions.
  • Access to Free Pascal run time functions. 
  • Capable of running on any platform supported by Free Pascal
  • Bit, character, and word manipulation.
  • Data Encryption Standard (DES) encryption instructions.
  • TCP/IP support.
  • Small footprint.
  • Any algorithm can be reduced to an instruction.


As much as possible examples will be used to explain the syntax.  But first, some basic principles.
  • A prog consists of one or more instructions.
  • One instruction or data declaration per line.
  • All data declarations precede instructions.
  • Labels start in column one.
  • Data and instructions are free form after column one.
  • Data items may be declared or just used in instructions.
  • Instructions consist of a command (opcode) followed by zero or more operands.
  • If the first item after the optional label is not a valid command, MOVE is assumed.
  • Items are separated by one or more spaces.
  • Action flows from left to right, rightmost item usually receives result.
  • Arithmetic is 64 bit.
  • Text after '|' on a line is comment.
  • The prefix '#' means size of.
  • The prefix '@' means address of.

There are three data types.
  • Word - a 64 bit binary object residing in the program space which can be an Integer or a Real (floating point) variable.  The Integer can be declared as a data item or just used in an instruction.   Bits can be addressed by number.  They are numbered 63 to 0, left to right (msb to lsb).  The Real must be declared by giving it a value with a decimal point.  Either Integer or Real array index begins at 0.
  • Character String - an unstructured list of one or more characters residing in the program space.  It can be declared as a data item or just used in an instruction as a literal string.  Index begins at 0.
  • Ansi String - a structured list of characters of any length residing outside the program space. It is never declared. All Ansi String identifiers begin with a '$'.  Index begins at 1.


In the following examples, identifiers starting with

  • C, D, E, are character strings 
  • X, Y, Z, are words
  • I, J, K, are index words
  • N is a count word (number of characters)
  • $R, $S, $T, are ansi strings

C  : 'This is a character string'
D  : 40 '  '                | character string of 40 spaces
C2 : X'ABCD1234567890'      | string of hexadecimal digits
X  : 3 1000                 | three word integer array with a value of 1000
X1 : 0XABCDEF               | integer with a hexadecimal value of ABCDEF
X2 : 0b100101               | integer with a binary value of 100101
RX : 0.0                    | real with a value of 0
Y  : @C                     | integer with a value equal to the address of C
Y1 : #C                     | integer with a value equal to the size of C
CEQ = X                     | CEQ points to X as a character string

  X                         | set X to zero
  + X                       | increment X by 1
  + 0XA9822B Y              | add hex value to Y
  X Y                       | move X to Y
  X:3:4 Y                   | move 4 bits starting with bit number 3 to Y
  C $S                      | move the character string C to the ansi string $S
  $S C #C                   | move (size of C) characters from ansi string $S to C  
  C D N                     | move N characters from C to D
  + 'ABC' $S                | add character string 'ABC' to the end of ansi string $S
  #$S X                     | move the size of string $S to X
  X.I Z                     | move the Ith word in array X to Z

| the if clause

   if i LT 1000

| becomes a 'while' clause with the addition of a 'goif' instruction

   if i LT 1000

| and becomes an iterative 'for' loop with the addition of an index variable

   if i LT 1000
        + i

|  the prog (T1) will cause 99 progs to run in SSX
    symsyn 'R T1'        | command to Symsyn to run T1
    delay 100            | sleep for 100 milliseconds
    go loop 

| time a loop and display the result on the console

 datetime strt                | system date and time to strt
 if I < 100000000
    + I
 datetime stopp               | system date and time to stopp
 msbetween strt stopp rslt    | milliseconds between strt and stopp
 ~ rslt $s                    | convert binary to decimal string
 $s []                        | display result

| read a text file and display it on the console

 opentext 'sorttext.txt' fid   
 if ioresult eq 0             | ioresult = -1 at end of file
     [fid] $s                 | move a record from the file to the string
     $s []                    | display string on the console

| the square root of the sum of the squares

x : 2 0                   | array (vector) x ( 2 members each a value of 0 )
 3 x.0                    | first member = 3
 4 x.1                    | second member = 4
 vmul x x x               | multiply each member of array x by same in x, store in x
 vsum x y                 | add all the members of array x place total in word y
 sqrt y z                 | square root of y in z (rounded) = 5

| DES encryption

key :  x'0e329232ea6d0d73'
data : x'8787878787878787'

 edes key data             | encrypt data with key 
 data $s                   | move data to string
 unpackhex $s $s           | unpack
 $s []                     | output result - 0000000000000000


Copyright 2015 - 2020 Symsyn Group

symsyn @