diff --git a/corresponding_node_references.admin.inc b/corresponding_node_references.admin.inc
index af5c96a..abdf2b5 100644
--- a/corresponding_node_references.admin.inc
+++ b/corresponding_node_references.admin.inc
@@ -10,22 +10,27 @@
 function corresponding_node_references_settings_form() {
   $form['intro'] = array('#markup' => t('Check which node references should listen to each other. When checking a check box a reference on node type A to node B will automatically update the node reference field on node B adding an entrie which points to node A.'));
 
-  $result = db_query("SELECT field_name, data FROM {field_config} WHERE type = :type AND deleted = 0", array(':type' => 'node_reference'));
+  $result = db_query("SELECT field_name, data FROM {field_config} WHERE (type = :type OR type = 'user_reference') AND deleted = 0", array(':type' => 'node_reference'));
   foreach ($result as $row) {
     $data = unserialize($row->data);
-    foreach ($data['settings']['referenceable_types'] as $reference) {
-      if ($reference != '0') {
-        $references[$row->field_name][] = $reference;
+    if (!isset($data['settings']['referenceable_types'])) {
+      $references[$row->field_name][] = 'user';
+    }
+    else {
+      foreach ($data['settings']['referenceable_types'] as $reference) {
+        if ($reference != '0') {
+          $references[$row->field_name][] = $reference;
+        }
       }
     }
   }
 
-  $result = db_query("SELECT fci.field_name, fci.entity_type, fci.bundle FROM {field_config_instance} fci INNER JOIN {field_config} fc ON fc.field_name = fci.field_name WHERE fc.type = :type", array(':type' => 'node_reference'));
+  $result = db_query("SELECT fci.field_name, fci.entity_type, fci.bundle FROM {field_config_instance} fci INNER JOIN {field_config} fc ON fc.field_name = fci.field_name WHERE (fc.type = :type OR fc.type = 'user_reference')", array(':type' => 'node_reference'));
 
   foreach ($result as $row) {
     if (!empty($references[$row->field_name])) {
       foreach ($references[$row->field_name] as $reference) {
-        if ($row->entity_type == 'node') {
+        if ($row->entity_type == 'node' || $row->entity_type == 'user') {
           $fields_to_compare[] = array('field_type' => $row->field_name, 'bundle' => $row->bundle, 'reference' => $reference);
         }
       }
diff --git a/corresponding_node_references.crud.inc b/corresponding_node_references.crud.inc
index 88d9da3..e1071dc 100644
--- a/corresponding_node_references.crud.inc
+++ b/corresponding_node_references.crud.inc
@@ -16,41 +16,85 @@
  *        the home node.
  */
 function corresponding_node_references_insert($home_node, $home_field, $away_node_type, $away_field) {
-  $old_node = node_load($home_node->nid, NULL, TRUE);
+
+  if ($away_node_type == "user"){   //If the referenced node is a user object, references to "uid" has to be checked, not "nid"
+    $id = "uid";
+  }
+  else {
+    $id = "nid";
+  }
+  if (!isset($home_node->nid)) {    //If the node is called using user_load, not node_load.
+    $id2 = "uid";
+    $home_id = $home_node->uid;
+    $old_node = user_load($home_node->uid, FALSE);
+  }
+  else {
+    $id2 = "nid";
+    $home_id = $home_node->nid;
+    $old_node = node_load($home_node->nid, NULL, TRUE);
+  }
 
   // Determine the nodereference values after the insert.
   if (isset($home_node->$home_field) && is_array($home_node->$home_field)) {
     foreach ($home_node->$home_field as  $fields) {
       foreach ($fields as $reference) {
-        if (!empty($reference['nid'])) {
-          // Load the referenced node if it is of the specified away type.
-          // TODO: Do this with EntityFieldQuery
-          // See http://api.drupal.org/api/drupal/modules--node--node.module/function/node_load_multiple/7
-          if ($referenced_node = node_load($reference['nid'], NULL, FALSE)) {
-            if ($referenced_node->type == $away_node_type) {
+        if (!empty($reference[$id])) {
+          if ($id == "uid") {
+            if (empty($referenced_node->language)) {
+            // Users may not have a language set: in which case, set it to be "und", which is what is needed.
+              $language = 'und';
+            }
+            else {
+              $language = $referenced_node->language;
+            }
+            if ($referenced_node = user_load($reference['uid'], FALSE)) {
               $away_field_language = field_language('node', $referenced_node, $away_field);
               // Add the new reference.
-              // If there are no other references, we need to make sure this
-              // is delta 0
-              if (array_key_exists($away_field_language, $referenced_node->{$away_field}) == FALSE || $referenced_node->{$away_field}[$away_field_language][0]['nid'] == NULL) {
-                $referenced_node->{$away_field}[$away_field_language][0]['nid'] = $home_node->nid;
+              // Check for doubles, could happen when nodes of same type are
+              // referenced.
+              $exists = FALSE;
+              foreach ($referenced_node->{$away_field}[$language] as $key => $value) {
+                if ($value['uid'] == $home_node->uid) {
+                  $exists = TRUE;
+                  break;
+                }
               }
-              else {
+              if (!$exists) {
+                $edit = array($away_field => $referenced_node->{$away_field});
+                $edit{$away_field}[$language][] = array($id2 => $home_id);
+                _corresponding_node_references_update_user($referenced_node, $edit);
+              }
+            }
+          }
+          else if ($id == "nid") {
+            // Load the referenced node if it is of the specified away type.
+            // TODO: Do this with EntityFieldQuery
+            // See http://api.drupal.org/api/drupal/modules--node--node.module/function/node_load_multiple/7
+            if ($referenced_node = node_load($reference['nid'], NULL, FALSE)) {
+              if ($referenced_node->type == $away_node_type) {
                 // Add the new reference.
-                // Check for doubles, could happen when nodes of same type are
-                // referenced.
-                $exists = FALSE;
-                foreach ($referenced_node->{$away_field}[$away_field_language] as $key => $value) {
-                  if ($value['nid'] == $home_node->nid) {
-                    $exists = TRUE;
-                    break;
+                // If there are no other references, we need to make sure this
+                // is delta 0
+                if (array_key_exists($referenced_node->language, $referenced_node->{$away_field}) == FALSE || $referenced_node->{$away_field}[$referenced_node->language][0][$id2] == NULL) {
+                  $referenced_node->{$away_field}[$referenced_node->language][0][$id2] = $home_id;
+                }
+                else {
+                  // Add the new reference.
+                  // Check for doubles, could happen when nodes of same type are
+                  // referenced.
+                  $exists = FALSE;
+                  foreach ($referenced_node->{$away_field}[$referenced_node->language] as $key => $value) {
+                    if ($value[$id2] == $home_id) {
+                      $exists = TRUE;
+                      break;
+                    }
+                  }
+                  if (!$exists) {
+                    $referenced_node->{$away_field}[$referenced_node->language][] = array($id2 => $home_id);
                   }
                 }
-
-                if (!$exists) {
-                  $referenced_node->{$away_field}[$away_field_language][] = array('nid' => $home_node->nid);                }
-              }
               _corresponding_node_references_update($referenced_node);
+              }
             }
           }
         }
@@ -76,16 +120,35 @@ function corresponding_node_references_insert($home_node, $home_field, $away_nod
  *        reference fields that don't match up.
  */
 function corresponding_node_references_update($home_node, $home_field, $away_node_type, $away_field, $process_unchanged = FALSE) {
-  // Since home_node is just beeing saved, $old_node and $home_node are different!
-  $old_node = node_load($home_node->nid, NULL, FALSE);
+
+  if ($away_node_type == "user"){   //If the referenced node is a user object, references to "uid" has to be checked, not "nid"
+    $id = "uid";
+  }
+  else {
+    $id = "nid";
+  }
+
+  if (!isset($home_node->nid)) {    //If the home node is a user object, again "uid" is used, not "nid". The node is called using user_load, not node_load.
+    $id2 = "uid";
+    $home_id = $home_node->uid;
+    $old_node = user_load($home_node->uid, FALSE);
+  }
+  else {
+    $id2 = "nid";
+    $home_id = $home_node->nid;
+    $old_node = node_load($home_node->nid, NULL, FALSE);
+  }
+
+  // Since home_node is just being saved, $old_node and $home_node are different!
+  //$old_node = node_load($home_node->nid, NULL, FALSE);
   $old = $new = array();
 
   // Determine the nodereference values before the update.
   if (isset($old_node->$home_field) && is_array($old_node->$home_field)) {
     foreach ($old_node->$home_field as $lang => $fields) {
       foreach ($fields as $reference) {
-        if (!empty($reference['nid'])) {
-          $old[] = $reference['nid'];
+        if (!empty($reference[$nid])) {
+          $old[] = $reference[$nid];
         }
       }
     }
@@ -101,8 +164,8 @@ function corresponding_node_references_update($home_node, $home_field, $away_nod
   if (isset($home_node->$home_field) && is_array($home_node->$home_field)) {
     foreach ($home_node->$home_field as $lang => $fields) {
       foreach ($fields as $reference) {
-        if (!empty($reference['nid'])) {
-          $new[] = $reference['nid'];
+        if (!empty($reference[$nid])) {
+          $new[] = $reference[$nid];
         }
       }
     }
@@ -113,24 +176,49 @@ function corresponding_node_references_update($home_node, $home_field, $away_nod
     foreach ($old as $data) {
       if ($removed = array_diff($old, $new)) {
         foreach ($removed as $nid) {
-          // Load the referenced node if it is of the specified away type.
-          if ($referenced_node = node_load($nid, NULL, FALSE)) {
-            // Self-references are handled by the node_reference module anyway.
-            if ($referenced_node->type == $away_node_type && $nid != $home_node->nid) {
-              $away_field_language = field_language('node', $referenced_node, $away_field);
-              if (isset($referenced_node->{$away_field}[$away_field_language]) && is_array($referenced_node->{$away_field}[$away_field_language])) {
+          if ($id == "uid") {
+            // Load the referenced node if it is of the specified away type.
+            if ($referenced_node = user_load($nid, FALSE)) {
+              if (empty($referenced_node->language)) {
+                // Users may not have a language set: in which case, set it to be "und" which is what is needed.
+                  $language = 'und';
+              }
+              else {
+              $language = $referenced_node->language;
+              }
+              if (isset($referenced_node->{$away_field}[$language]) && is_array($referenced_node->{$away_field}[$language])) {
                 // Iterate through the away node's references.
-                foreach ($referenced_node->{$away_field}[$away_field_language] as $key => $value) {
+                foreach ($referenced_node->{$away_field}[$language] as $key => $value) {
                   // Remove references to the deleted node.
-                  if ($value['nid'] && $value['nid'] == $home_node->nid) {
-                    unset($referenced_node->{$away_field}[$away_field_language][$key]);
-                    _corresponding_node_references_update($referenced_node);
+                  if ($value[$id2] && $value[$id2] == $home_id) {
+                    $edit = array($away_field => $referenced_node->{$away_field});
+                    unset($edit{$away_field}[$language][$key]);
+                    _corresponding_node_references_update_user($referenced_node, $edit);
                     break;
                   }
                 }
               }
             }
           }
+          else if ($id == "nid"){
+            // Load the referenced node if it is of the specified away type.
+            if ($referenced_node = node_load($nid, NULL, FALSE)) {
+              // Self-references are handled by the node_reference module anyway.
+              if ($referenced_node->type == $away_node_type && $nid != $home_id) {
+                if (isset($referenced_node->{$away_field}[$referenced_node->language]) && is_array($referenced_node->{$away_field}[$referenced_node->language])) {
+                  // Iterate through the away node's references.
+                  foreach ($referenced_node->{$away_field}[$referenced_node->language] as $key => $value) {
+                    // Remove references to the deleted node.
+                    if ($value[$id2] && $value[$id2] == $home_id) {
+                      unset($referenced_node->{$away_field}[$referenced_node->language][$key]);
+                      _corresponding_node_references_update($referenced_node);
+                      break;
+                    }
+                  }
+                }
+              }
+            }
+          }
         }
       }
     }
@@ -139,68 +227,91 @@ function corresponding_node_references_update($home_node, $home_field, $away_nod
   // No array diff a reference overload could of happend or a mass update.
   if ($added = $new) {
     foreach ($added as $nid) {
-      // Load the referenced node if it is of the specified away type.
-      if ($referenced_node = node_load($nid, NULL, FALSE)) {
-        $away_field_language = field_language('node', $referenced_node, $away_field);
-        // Self-references are handled by the node_reference module anyway.
-        if ($referenced_node->type == $away_node_type && $nid != $home_node->nid) {
+      if ($id == "uid") {
+        $referenced_node = user_load($nid, FALSE);
+      }
+      else {
+        $referenced_node = node_load($nid, NULL, FALSE);
+      }
+      // Load the referenced node.
+      if ($referenced_node) {
+          if (empty($referenced_node->language)) {
+          // Users may not have a language set: in which case, set it to be "und", which is what is needed.
+            $language = 'und';
+          }
+          else {
+            $language = $referenced_node->language;
+          }
           // Detect whether the reference already exists.
           $exists = FALSE;
-          if (isset($referenced_node->{$away_field}[$away_field_language]) && !empty($referenced_node->{$away_field}[$away_field_language])) {
-            foreach ($referenced_node->{$away_field}[$away_field_language] as $data) {
-              if ($data['nid'] == $home_node->nid) {
-                $exists = TRUE;
-                break;
-              }
+          if (isset($referenced_node->{$away_field}[$language]) && !empty($referenced_node->{$away_field}[$language])) {
+          foreach ($referenced_node->{$away_field}[$language] as $data) {
+            if ($data[$id2] == $home_id) {
+              $exists = TRUE;
+              break;
             }
           }
-
-          // Empty places are removed.
-          // Yes this means the deltas change on the away node when a
-          // reference is made on the home node.
-          $values = array();
-          if (isset($referenced_node->{$away_field}[$away_field_language])) {
-            foreach ($referenced_node->{$away_field}[$away_field_language] as $value) {
-              if (!empty($value['nid'])) {
-                $values[] = $value;
-              }
+        }
+        // Empty places are removed.
+        // Yes this means the deltas change on the away node when a
+        // reference is made on the home node.
+        $values = array();
+        if (isset($referenced_node->{$away_field}[$language])) {
+          foreach ($referenced_node->{$away_field}[$language] as $value) {
+            if (!empty($value[$id2])) {
+              $values[] = $value;
             }
           }
-          $referenced_node->{$away_field}[$away_field_language] = $values;
-          // Add the new reference. Don't create a duplicate.
-          if (!$exists) {
-            // Get the allowed values.
-            $unlimited = FALSE;
-            $field = field_info_field($away_field);
-            if ($field) {
-              if ($field['cardinality'] == -1) {
-                $unlimited = TRUE;
-                $allowed_references = 0;
+        }
+        $referenced_node->{$away_field}[$language] = $values;
+        // Add the new reference. Don't create a duplicate.
+        if (!$exists) {
+          // Get the allowed values.
+          $unlimited = FALSE;
+          $field = field_info_field($away_field);
+          if ($field) {
+            if ($field['cardinality'] == -1) {
+              $unlimited = TRUE;
+              $allowed_references = 0;
+            }
+            else {
+              $allowed_references = $field['cardinality'];
+            }
+            // Check for reference overloading.
+            $references = count($referenced_node->{$away_field}[$language]) + 1;
+            if (($allowed_references >= $references) || $unlimited) {
+              // If referenced node is a user, we need to use user_save();
+              if ($id == "uid") {
+                $edit = array($away_field => $referenced_node->{$away_field});
+                $edit{$away_field}[$language][] = array($id2 => $home_id);
+                _corresponding_node_references_update_user($referenced_node, $edit);
               }
               else {
-                $allowed_references = $field['cardinality'];
-              }
-              // Check for reference overloading.
-              $references = count($referenced_node->{$away_field}[$away_field_language]) + 1;
-              if (($allowed_references >= $references) || $unlimited) {
-                $referenced_node->{$away_field}[$away_field_language][] = array('nid' => $home_node->nid);
+                $referenced_node->{$away_field}[$referenced_node->language][] = array($id2 => $home_id);
                 _corresponding_node_references_update($referenced_node);
               }
+            }
+            else {
+              $t_reference = format_plural($references, '1 reference', '@count references');
+              $t_allowed = format_plural($allowed_references, '1 reference is', '@count references are');
+              if ($id == "uid") {
+                $replacements = array(
+                  '@title' => $referenced_node->name,
+                  '@url' => url('node/' . $referenced_node->uid),
+                  '@t_reference' => $t_reference,
+                  '@t_allowed' => $t_allowed,);
+              }
               else {
-                $t_reference = format_plural($references, '1 reference', '@count references');
-                $t_allowed = format_plural($allowed_references, '1 reference is', '@count references are');
-                drupal_set_message(
-                  t('Reference overloading: @title would of had @t_reference and only @t_allowed permitted. Before adding a reference, you would need to <a href="@url">edit</a> @title to remove an existing reference and resave this node to have make it correspond. Or you could allow this reference instance to have more references, go to the cck field settings of the instance',
-                    array(
-                      '@title' => $referenced_node->title,
-                      '@url' => url('node/' . $referenced_node->nid),
-                      '@t_reference' => $t_reference,
-                      '@t_allowed' => $t_allowed,
-                    )
-                  ),
-                  'error'
-                );
+                $replacements = array(
+                  '@title' => $referenced_node->title,
+                  '@url' => url('node/' . $referenced_node->nid),
+                  '@t_reference' => $t_reference,
+                  '@t_allowed' => $t_allowed,);
               }
+              drupal_set_message(
+                t('Reference overloading: @title would of had @t_reference and only @t_allowed permitted. Before adding a reference, you would need to edit @title to remove an existing reference and resave this node to have make it correspond. Or you could allow this reference instance to have more references, go to the cck field settings of the instance',$replacements),
+              'error'
+              );
             }
           }
         }
@@ -220,24 +331,58 @@ function corresponding_node_references_update($home_node, $home_field, $away_nod
  *        the home node.
  */
 function corresponding_node_references_delete($home_node, $home_field, $away_node_type, $away_field) {
+
+  if ($away_node_type == "user"){   //If the referenced node is a user object, references to "uid" has to be checked, not "nid"
+    $id = "uid";
+  }
+  else {
+    $id = "nid";
+  }
+  if (!isset($home_node->nid)) {    //If the node is called using user_load, not node_load.
+    $id2 = "uid";
+    $home_id = $home_node->uid;
+    $old_node = user_load($home_node->uid, FALSE);
+  }
+  else {
+    $id2 = "nid";
+    $home_id = $home_node->nid;
+    $old_node = node_load($home_node->nid, NULL, TRUE);
+  }
+
   // Iterate through the field's references.
   foreach ($home_node->$home_field as $lang => $langdata) {
     foreach ($langdata as $reference) {
-      if (!empty($reference['nid'])) {
-        // Load the referenced node if it is of the specified away type.
-        if ($referenced_node = node_load($reference['nid'], NULL, FALSE)) {
-          if ($referenced_node->type == $away_node_type) {
+      if (!empty($reference[$id])) {
+        if ($id == "uid") {
+           if ($referenced_node = user_load($reference['uid'], FALSE)) {
             // Iterate through the away node's references.
-            foreach ($referenced_node->{$away_field}[$lang] as $key => $value) {
+            foreach ($referenced_node->{$away_field}["und"] as $key => $value) {
               // Remove references to the deleted node.
-              if ($value['nid'] && $value['nid'] == $home_node->nid) {
-                unset($referenced_node->{$away_field}[$lang][$key]);
-                _corresponding_node_references_update($referenced_node);
+              if ($value[$id2] && $value[$id2] == $home_id) {
+                $edit = array($away_field => $referenced_node->{$away_field});
+                unset($edit{$away_field}["und"][$key]);
+                _corresponding_node_references_update_user($referenced_node, $edit);
                 break;
               }
             }
           }
         }
+        else {
+          // Load the referenced node if it is of the specified away type.
+          if ($referenced_node = node_load($reference['nid'], NULL, FALSE)) {
+            if ($referenced_node->type == $away_node_type) {
+              // Iterate through the away node's references.
+              foreach ($referenced_node->{$away_field}[$lang] as $key => $value) {
+                // Remove references to the deleted node.
+                if ($value[$id2] && $value[$id2] == $home_id) {
+                  unset($referenced_node->{$away_field}[$lang][$key]);
+                  _corresponding_node_references_update($referenced_node);
+                  break;
+                }
+              }
+            }
+          }
+        }
       }
     }
   }
@@ -252,3 +397,6 @@ function _corresponding_node_references_update(&$node) {
   field_attach_presave('node', $node);
   field_attach_update('node', $node);
 }
+function _corresponding_node_references_update_user($user, $edit) {
+  user_save($user, $edit);
+}
\ No newline at end of file
diff --git a/corresponding_node_references.module b/corresponding_node_references.module
index 2b96661..b4b7e68 100644
--- a/corresponding_node_references.module
+++ b/corresponding_node_references.module
@@ -69,6 +69,13 @@ function corresponding_node_references_node_insert($node) {
 }
 
 /**
+ * Implements hook_user_insert().
+ */
+function corresponding_node_references_user_insert(&$edit, $account, $category) {
+  corresponding_node_references_processing_node('insert', $account);
+}
+
+/**
  * Implements hook_node_update().
  */
 function corresponding_node_references_node_update($node) {
@@ -76,6 +83,13 @@ function corresponding_node_references_node_update($node) {
 }
 
 /**
+ * Implements hook_user_update().
+ */
+function corresponding_node_references_user_update(&$edit, $account, $category) {
+  corresponding_node_references_processing_node('update', $account);
+}
+
+/**
  * Implements hook_node_delete().
  */
 function corresponding_node_references_node_delete($node) {
@@ -83,6 +97,13 @@ function corresponding_node_references_node_delete($node) {
 }
 
 /**
+ * Implements hook_user_delete().
+ */
+function corresponding_node_references_user_delete($account) {
+  corresponding_node_references_processing_node('delete', $account);
+}
+
+/**
  * Load enabled CNR presets.
  */
 function corresponding_node_references_preset_load_enabled() {
@@ -120,8 +141,13 @@ function corresponding_node_references_processing_node($op, $node, $process_unch
   $result = corresponding_node_references_preset_load_enabled();
   while ($row = array_shift($result)) {
     $key = explode('*', $row->node_types_content_fields);
-
-    switch ($node->type) {
+    if (!isset($node->type)) {    //If the node doesn't have a "type" element, i.e. it's a user object.
+      $type = "user";
+    }
+    else {
+      $type = $node->type;
+    }
+    switch ($type) {
       case $key[0]:
         $args = array($node, $key[1], $key[2], $key[3], $process_unchanged);
         $function = 'corresponding_node_references_' . $op;