diff --git a/includes/modules/entityreference.inc b/includes/modules/entityreference.inc
new file mode 100644
index 0000000..3c7ee6a
--- /dev/null
+++ b/includes/modules/entityreference.inc
@@ -0,0 +1,90 @@
+<?php
+
+/**
+ * Implements hook_uuid_node_features_export_render_alter().
+ *
+ * @param $export
+ * @param $node
+ * @param $module
+ */
+function entityreference_uuid_node_features_export_render_alter(&$export, &$node, $module) {
+  $fields = uuid_features_get_field_items_iterator($export, 'node', 'entityreference');
+  _entity_reference_uuid_entity_features_export_set_uuid_references($fields);
+}
+
+/**
+ * Implements hook_uuid_user_features_export_render_alter().
+ *
+ * @param $export
+ * @param $node
+ * @param $module
+ */
+function entityreference_uuid_user_features_export_render_alter(&$export, &$user, $module) {
+  $fields = uuid_features_get_field_items_iterator($export, 'user', 'entityreference');
+  _entity_reference_uuid_entity_features_export_set_uuid_references($fields);
+}
+
+/**
+ * Implements hook_uuid_node_features_rebuild_alter().
+ *
+ * @param $node
+ * @param $module
+ */
+function entityreference_uuid_node_features_rebuild_alter(&$node, $module) {
+  $fields = uuid_features_get_field_items_iterator($node, 'node', 'entityreference');
+  _entity_reference_uuid_entity_features_rebuild_fetch_uuid_references($fields);
+}
+
+/**
+ * Implements hook_uuid_user_features_rebuild_alter().
+ *
+ * @param $node
+ * @param $module
+ */
+function entityreference_uuid_user_features_rebuild_alter(&$user, $module) {
+  $fields = uuid_features_get_field_items_iterator($user, 'user', 'entityreference');
+  _entity_reference_uuid_entity_features_rebuild_fetch_uuid_references($fields);
+}
+
+/**
+ * Helper function to fetch uuid references in case of different fields types.
+ *
+ * @param $fields
+ */
+function _entity_reference_uuid_entity_features_rebuild_fetch_uuid_references(&$fields) {
+  // Entityreference fields may have different targets (nodes, users, etc.).
+  // So we process them one by one.
+  foreach ($fields as $field_name => $field) {
+    $field_info = field_info_field($field_name);
+    $entity_info = entity_get_info($field_info['settings']['target_type']);
+
+    // uuid_features_fetch_uuid_references accepts only references to array as the first parameter.
+    $tmp_fields = array(
+      $field_name => &$field,
+    );
+
+    uuid_features_fetch_uuid_references($tmp_fields, $field_info['settings']['target_type'], array(
+      $entity_info['entity keys']['id'] => 'target_id',
+    ));
+  }
+}
+
+/**
+ * Helper function to set uuid references in case of different fields types.
+ *
+ * @param $fields
+ */
+function _entity_reference_uuid_entity_features_export_set_uuid_references(&$fields) {
+  // Entityreference fields may have different targets (nodes, users, etc.).
+  // So we process them one by one.
+  foreach ($fields as $field_name => &$field) {
+    $field_info = field_info_field($field_name);
+
+    // uuid_features_fetch_uuid_references accepts only references to array as the first parameter.
+    $tmp_fields = array(
+      $field_name => &$field,
+    );
+
+    uuid_features_set_uuid_references($tmp_fields, $field_info['settings']['target_type']);
+  }
+}
diff --git a/includes/modules/field_collection.inc b/includes/modules/field_collection.inc
new file mode 100644
index 0000000..622046f
--- /dev/null
+++ b/includes/modules/field_collection.inc
@@ -0,0 +1,54 @@
+<?php
+
+
+/**
+ * Implements hook_uuid_node_features_export_render_alter().
+ *
+ * @param $export
+ * @param $node
+ * @param $module
+ */
+function field_collection_uuid_node_features_export_render_alter(&$export, &$node, $module) {
+  $fields = uuid_features_get_field_items_iterator($export, 'node', 'field_collection');
+  uuid_features_set_uuid_references($fields, 'field_collection_item');
+}
+
+/**
+ * Implements hook_uuid_user_features_export_render_alter().
+ *
+ * @param $export
+ * @param $node
+ * @param $module
+ */
+function field_collection_uuid_user_features_export_render_alter(&$export, &$user, $module) {
+  $fields = uuid_features_get_field_items_iterator($export, 'user', 'field_collection');
+  uuid_features_set_uuid_references($fields, 'field_collection_item');
+}
+
+/**
+ * Implements hook_uuid_node_features_rebuild_alter().
+ *
+ * @param $node
+ * @param $module
+ */
+function field_collection_uuid_node_features_rebuild_alter(&$node, $module) {
+  $fields = uuid_features_get_field_items_iterator($node, 'node', 'field_collection');
+  uuid_features_fetch_uuid_references($fields, 'field_collection_item', array(
+    'item_id' => 'value',
+    'revision_id' => 'revision_id',
+  ));
+}
+
+/**
+ * Implements hook_uuid_user_features_rebuild_alter().
+ *
+ * @param $node
+ * @param $module
+ */
+function field_collection_uuid_user_features_rebuild_alter(&$user, $module) {
+  $fields = uuid_features_get_field_items_iterator($user, 'user', 'field_collection');
+  uuid_features_fetch_uuid_references($fields, 'field_collection_item', array(
+    'item_id' => 'value',
+    'revision_id' => 'revision_id',
+  ));
+}
diff --git a/includes/modules/taxonomy.inc b/includes/modules/taxonomy.inc
index d7fdd7e..2a440f5 100644
--- a/includes/modules/taxonomy.inc
+++ b/includes/modules/taxonomy.inc
@@ -22,40 +22,48 @@ function taxonomy_uuid_node_features_export_alter(&$export, &$pipe, $node) {
 
 /**
  * Implements hook_uuid_node_features_export_render_alter().
+ *
+ * @param $export
+ * @param $node
+ * @param $module
  */
 function taxonomy_uuid_node_features_export_render_alter(&$export, &$node, $module) {
-  if (!empty($node->taxonomy)) {
-    $export->uuid_term = array();
-    foreach ($node->taxonomy as $term) {
-      $export->uuid_term[] = $term->uuid;
-    }
-  }
+  $fields = uuid_features_get_field_items_iterator($export, 'node', 'taxonomy_term_reference');
+  uuid_features_set_uuid_references($fields, 'taxonomy_term');
 }
 
 /**
+ * Implements hook_uuid_user_features_export_render_alter().
+ *
+ * @param $export
+ * @param $node
+ * @param $module
+ */
+function taxonomy_uuid_user_features_export_render_alter(&$export, &$user, $module) {
+  $fields = uuid_features_get_field_items_iterator($export, 'user', 'taxonomy_term_reference');
+  uuid_features_set_uuid_references($fields, 'taxonomy_term');
+}
+
+
+/**
  * Implements hook_uuid_node_features_rebuild_alter().
- * Build a taxonomy array suitable for node_save() from the uuid_term array.
  */
 function taxonomy_uuid_node_features_rebuild_alter(&$node, $module) {
-  if (!empty($node->uuid_term)) {
-    $node->taxonomy = array();
-    foreach ($node->uuid_term as $uuid) {
-      $tid = uuid_taxonomy_term_find($uuid);
-      if (empty($tid)) {
-        // If no tid was found, then the term doesn't exist, and most likely
-        // the uuid_term rebuild needs to run first.
-        // TODO: figure out how to weight feature components.
-        uuid_term_features_rebuild($module);
-
-        // Now try again.
-        $tid = uuid_taxonomy_term_find($uuid);
-        if (empty($tid)) {
-          watchdog('uuid_features', 'The term specified by %uuid could not be found.', array('%uuid' => $uuid));
-          continue;
-        }
-      }
+  $fields = uuid_features_get_field_items_iterator($node, 'node', 'taxonomy_term_reference');
+  uuid_features_fetch_uuid_references($fields, 'taxonomy_term', array(
+    'tid' => 'tid',
+  ));
+}
 
-      $node->taxonomy[] = $tid;
-    }
-  }
+/**
+ * Implements hook_uuid_user_features_rebuild_alter().
+ *
+ * @param $node
+ * @param $module
+ */
+function taxonomy_uuid_user_features_rebuild_alter(&$user, $module) {
+  $fields = uuid_features_get_field_items_iterator($user, 'user', 'taxonomy_term_reference');
+  uuid_features_fetch_uuid_references($fields, 'taxonomy_term', array(
+    'tid' => 'tid',
+  ));
 }
diff --git a/includes/modules/user.inc b/includes/modules/user.inc
new file mode 100644
index 0000000..d128682
--- /dev/null
+++ b/includes/modules/user.inc
@@ -0,0 +1,34 @@
+<?php
+
+/**
+ * Implements hook_uuid_node_features_export_render_alter().
+ *
+ * @param $export
+ * @param $node
+ * @param $module
+ */
+function user_uuid_node_features_export_render_alter(&$export, &$node, $module) {
+  $uuid = reset(entity_get_uuid_by_id('user', array($node->uid)));
+  if ($uuid) {
+    $export->user_uuid = $uuid;
+  }
+}
+
+/**
+ * Implements hook_uuid_node_features_rebuild_alter().
+ *
+ * @param $node
+ * @param $module
+ */
+function user_uuid_node_features_rebuild_alter(&$node, $module) {
+  if (isset($node->user_uuid) && uuid_is_valid($node->user_uuid)) {
+    $uid = reset(entity_get_id_by_uuid('user', array($node->user_uuid)));
+    if ($uid) {
+      $node->uid = $uid;
+    } else {
+      $node->uid = 1;
+    }
+  } else {
+    $node->uid = 1;
+  }
+}
diff --git a/includes/uuid_field_collection.features.inc b/includes/uuid_field_collection.features.inc
new file mode 100644
index 0000000..4ee49a7
--- /dev/null
+++ b/includes/uuid_field_collection.features.inc
@@ -0,0 +1,143 @@
+<?php
+/**
+ * @file
+ * Features hooks for the uuid_field_collection features component.
+ */
+
+/**
+ * Implements hook_features_export_options().
+ */
+function uuid_field_collection_features_export_options() {
+  $options = array();
+
+  $all_ids = array();
+
+  $efq_field_collection_items = new EntityFieldQuery();
+  $efq_field_collection_items->entityCondition('entity_type', 'field_collection_item');
+  $result = $efq_field_collection_items->execute();
+
+  if (!empty($result['field_collection_item'])) {
+    $all_ids = array_keys($result['field_collection_item']);
+  }
+
+  $items = entity_load('field_collection_item', $all_ids);
+
+  foreach($items as $item){
+    $options[$item->uuid] = $item->uuid;
+  }
+
+  drupal_alter('uuid_field_collection_features_export_options', $options);
+
+  return $options;
+}
+
+/**
+ * Implements hook_features_export().
+ */
+function uuid_field_collection_features_export($data, &$export, $module_name = '') {
+  $export['dependencies']['field_collection'] = 'field_collection';
+  $export['dependencies']['uuid'] = 'uuid';
+  $export['dependencies']['uuid_features'] = 'uuid_features';
+
+  foreach ($data as $uuid) {
+    $export['features']['uuid_field_collection'][$uuid] = $uuid;
+  }
+  return array();
+}
+
+/**
+ * Implements hook_features_export_render().
+ */
+function uuid_field_collection_features_export_render($module = 'foo', $data) {
+  $translatables = $code = array();
+
+  $code[] = '  $field_collections = array();';
+  $code[] = '';
+  foreach ($data as $uuid) {
+    $field_collections = entity_uuid_load('field_collection_item', array($uuid), array(), TRUE);
+    if (!count($field_collections)) {
+      continue;
+    }
+
+    $export = reset($field_collections);
+
+    // Do not export ids.
+    unset($export->item_id);
+    unset($export->revision_id);
+
+    $export_output = features_var_export($export, '  ');
+    $export_output = str_replace("entity_import('field_collection_item', '", "", $export_output);
+    $export_output = str_replace("}')", "}", $export_output);
+    $export_output = json_decode($export_output, TRUE);
+
+    $code[] = '  $field_collections[] = ' . features_var_export($export_output, '  ') . ';';
+  }
+
+  if (!empty($translatables)) {
+    $code[] = features_translatables_export($translatables, '  ');
+  }
+  $code[] = '  return $field_collections;';
+  $code = implode("\n", $code);
+  return array('uuid_features_default_field_collections' => $code);
+}
+
+/**
+ * Implements hook_features_revert().
+ */
+function uuid_field_collection_features_revert($module) {
+  uuid_field_collection_features_rebuild($module);
+}
+
+/**
+ * Implements hook_features_rebuild().
+ */
+function uuid_field_collection_features_rebuild($module) {
+  // Make sure all referenced entities exist.
+  taxonomy_features_rebuild($module);
+  field_features_rebuild($module);
+  uuid_node_features_rebuild($module);
+  cache_clear_all();
+
+  $field_collections = module_invoke($module, 'uuid_features_default_field_collections');
+  if (!empty($field_collections)) {
+    foreach ($field_collections as $field_collection_item) {
+      try {
+        foreach ($field_collection_item as $key => $value) {
+          if (is_array($value) && strpos($key, 'field_') !== FALSE) {
+            foreach ($value as $lang => $field_data) {
+              if (is_array($field_data)) {
+                foreach ($field_data as $i => $field_entry) {
+                  if (isset($field_entry['nid'])) {
+                    $nid = reset(entity_get_id_by_uuid('node', array($field_entry['nid'])));
+                    if ($nid) {
+                      $field_collection_item[$key][$lang][$i]['nid'] = $nid;
+                    }
+                  }  elseif (isset($field_entry['target_id'])) {
+                    $nid = reset(entity_get_id_by_uuid('node', array($field_entry['target_id'])));
+                    if ($nid) {
+                      $field_collection_item[$key][$lang][$i]['target_id'] = $nid;
+                    }
+                  } elseif (isset($field_entry['tid'])) {
+                    $tid = reset(entity_get_id_by_uuid('taxonomy_term', array($field_entry['tid'])));
+                    if ($tid) {
+                      $field_collection_item[$key][$lang][$i]['tid'] = $tid;
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        $field_collection_item['original'] = TRUE;
+        $entity = entity_import('field_collection_item', json_encode($field_collection_item));
+        /* @var FieldCollectionItemEntity $entity */
+        $entity->is_new = FALSE; // Hack to ignore missing host entities.
+        $entity->save(TRUE);
+      } catch (Exception $e) {
+
+      }
+    }
+  }
+  uuid_node_features_rebuild($module);
+}
diff --git a/includes/uuid_node.features.inc b/includes/uuid_node.features.inc
index 17f931b..151dc07 100755
--- a/includes/uuid_node.features.inc
+++ b/includes/uuid_node.features.inc
@@ -10,18 +10,27 @@
 function uuid_node_features_export_options() {
   $options = array();
 
-  $types = node_type_get_names();
+  $types = variable_get('uuid_features_entity_node_types', array_keys(node_type_get_types()));
+  if (empty($types)) {
+    return $options;
+  }
+
+  $query = db_select('node', 'n');
+  $query->fields('n', array('nid', 'title', 'type', 'uuid'))
+    ->condition('type', $types)
+    ->orderBy('type')
+    ->orderBy('title');
+  $nodes = $query->execute()->fetchAll();
 
-  $query = 'SELECT n.nid, n.title, n.type, n.uuid
-    FROM {node} n ORDER BY n.type, n.title ASC';
-  $results = db_query($query);
-  foreach ($results as $node) {
+  foreach ($nodes as $node) {
     $options[$node->uuid] = t('@type: @title', array(
       '@type' => $types[$node->type],
       '@title' => $node->title,
     ));
   }
 
+  drupal_alter('uuid_node_features_export_options', $options);
+
   return $options;
 }
 
@@ -86,16 +95,24 @@ function uuid_node_features_export_render($module, $data) {
     $export->date = format_date($export->created, 'custom', 'Y-m-d H:i:s O');
 
     // Don't cause conflicts with nid/vid/revision_timestamp/changed fields.
-    unset($export->nid);
-    unset($export->vid);
-    unset($export->revision_timestamp);
-    unset($export->changed);
-    unset($export->last_comment_timestamp);
     uuid_features_file_field_export($export, 'node');
     // The hook_alter signature is:
     // hook_uuid_node_features_export_render_alter(&$export, $node, $module);
+
     drupal_alter('uuid_node_features_export_render', $export, $node, $module);
 
+    unset($export->revision_uid);
+    unset($export->revision_timestamp);
+    unset($export->nid);
+    unset($export->vid);
+    unset($export->vuuid);
+    unset($export->changed);
+    unset($export->last_comment_timestamp);
+    unset($export->last_comment_id);
+    unset($export->last_comment_name);
+    unset($export->cid);
+    unset($node->name);
+
     $code[] = '  $nodes[] = ' . features_var_export($export) . ';';
   }
 
@@ -123,28 +140,43 @@ function uuid_node_features_rebuild($module) {
   if (!empty($nodes)) {
     module_load_include('inc', 'node', 'node.pages');
 
-    foreach ($nodes as $data) {
-      $node = (object) $data;
-      node_object_prepare($node);
-
-      // Find the matching UUID, with a fresh cache.
-      $nids = entity_get_id_by_uuid('node', array($node->uuid));
-      if (isset($nids[$node->uuid])) {
-          $nid = array_key_exists($node->uuid, $nids) ? $nids[$node->uuid] : FALSE;
-          $existing = node_load($nid, NULL, TRUE);
-          if (!empty($existing)) {
-            $node->nid = $existing->nid;
-            $node->vid = $existing->vid;
-          }
+    $rebuild = FALSE;
+    foreach ($nodes as $key => $data) {
+      if (isset($data['og_group_ref'])) {
+        $tmp = $nodes[$key];
+        unset($nodes[$key]);
+        $nodes[$key] = $tmp;
       }
+    }
 
-      // The hook_alter signature is:
-      // hook_uuid_node_features_rebuild_alter(&node, $module);
-      drupal_alter('uuid_node_features_rebuild', $node, $module);
+    try {
+      foreach ($nodes as $data) {
+        $node = (object) $data;
+        $node->uid = 0;
+        node_object_prepare($node);
+
+        // Find the matching UUID, with a fresh cache.
+        $nids = entity_get_id_by_uuid('node', array($node->uuid));
+        if (isset($nids[$node->uuid])) {
+            $nid = array_key_exists($node->uuid, $nids) ? $nids[$node->uuid] : FALSE;
+            $existing = node_load($nid, NULL, TRUE);
+            if (!empty($existing)) {
+              $node->nid = $existing->nid;
+              $node->vid = $existing->vid;
+            }
+        }
+
+        // The hook_alter signature is:
+        // hook_uuid_node_features_rebuild_alter(&node, $module);
+        drupal_alter('uuid_node_features_rebuild', $node, $module);
+
+        $node = node_submit($node);
+        uuid_features_file_field_import($node, 'node');
+        node_save($node);
+      }
+    } catch (Exception $e) {
 
-      $node = node_submit($node);
-      uuid_features_file_field_import($node, 'node');
-      node_save($node);
     }
   }
+  return TRUE;
 }
diff --git a/includes/uuid_nodequeue_item.features.inc b/includes/uuid_nodequeue_item.features.inc
new file mode 100644
index 0000000..821e4ad
--- /dev/null
+++ b/includes/uuid_nodequeue_item.features.inc
@@ -0,0 +1,116 @@
+<?php
+/**
+ * @file
+ * Features hooks for the uuid_nodequeue_item features component.
+ */
+
+/**
+ * Implements hook_features_export_options().
+ */
+function uuid_nodequeue_item_features_export_options() {
+  $options = array();
+  $result = db_select('nodequeue_nodes', 'qn')
+    ->fields('qn', array('qid', 'sqid', 'nid', 'position', ))
+    ->orderBy('position', 'ASC')
+    ->execute();
+  while ($row = $result->fetchAssoc()) {
+    $queue = nodequeue_load($row['qid']);
+    $uuid = reset(entity_get_uuid_by_id('node', array($row['nid'], )));
+    if ($uuid) {
+      $item_name = $queue->name . ' - ' . $uuid;
+      $options[$item_name] = $item_name;
+    }
+  }
+  return $options;
+}
+
+/**
+ * Implements hook_features_export().
+ */
+function uuid_nodequeue_item_features_export($data, &$export, $module_name = '') {
+  $export['dependencies']['nodequeue'] = 'nodequeue';
+  $export['dependencies']['uuid'] = 'uuid';
+  $export['dependencies']['uuid_features'] = 'uuid_features';
+
+  foreach ($data as $item_id) {
+    $export['features']['uuid_nodequeue_item'][$item_id] = $item_id;
+  }
+  return array();
+}
+
+/**
+ * Implements hook_features_export_render().
+ */
+function uuid_nodequeue_item_features_export_render($module = 'foo', $data) {
+  $translatables = $code = array();
+  $code[] = '  $nodequeue_items = array();';
+  $code[] = '';
+
+  if (!empty($data)) {
+    foreach ($data as $item_id) {
+      list($queue_name, $uuid) = explode(' - ', $item_id);
+      $nodequeue = nodequeue_load_queue_by_name($queue_name);
+      if ($nodequeue) {
+
+        $nid = reset(entity_get_id_by_uuid('node', array($uuid)));
+        if ($nid) {
+          // We need to check if record exists to perform overriden state check.
+          $result = db_select('nodequeue_nodes', 'qn')
+            ->fields('qn', array('qid', 'sqid', 'nid'))
+            ->condition('qn.nid', $nid)
+            ->condition('qn.qid', $nodequeue->qid)
+            ->range(0, 1)
+            ->execute()
+            ->rowCount();
+
+          if (!$result) {
+            continue;
+          }
+        } else {
+          continue;
+        }
+
+        $uuid = reset(entity_get_uuid_by_id('node', array($nid)));
+        if ($uuid) {
+          $export = array(
+            'queue_name' => $queue_name,
+            'node_uuid' => $uuid,
+          );
+          $code[] = '  $nodequeue_items[] = ' . features_var_export($export, '  ') . ';';
+        }
+      }
+    }
+  }
+  if (!empty($translatables)) {
+    $code[] = features_translatables_export($translatables, '  ');
+  }
+  $code[] = '  return $nodequeue_items;';
+  $code = implode("\n", $code);
+
+  return array('uuid_features_default_nodequeue_items' => $code);
+
+}
+
+/**
+ * Implements hook_features_revert().
+ */
+function uuid_nodequeue_item_features_revert($module) {
+  uuid_nodequeue_item_features_rebuild($module);
+}
+
+/**
+ * Implements hook_features_rebuild().
+ */
+function uuid_nodequeue_item_features_rebuild($module) {
+  $nodequeue_items = module_invoke($module, 'uuid_features_default_nodequeue_items');
+  if (!empty($nodequeue_items)) {
+    foreach ($nodequeue_items as $nodequeue_item) {
+      $queue = nodequeue_load_queue_by_name($nodequeue_item['queue_name']);
+      $subqueue = reset(nodequeue_load_subqueues_by_queue($queue->qid));
+      $nid = reset(entity_get_id_by_uuid('node', array($nodequeue_item['node_uuid'])));
+      if ($nid) {
+        nodequeue_subqueue_add($queue, $subqueue, $nid);
+      }
+    }
+  }
+}
diff --git a/includes/uuid_term.features.inc b/includes/uuid_term.features.inc
index 40acb13..bf28d9c 100644
--- a/includes/uuid_term.features.inc
+++ b/includes/uuid_term.features.inc
@@ -10,15 +10,26 @@
 function uuid_term_features_export_options() {
   $options = array();
 
-  $query = 'SELECT t.tid, t.name, v.name AS vname, t.uuid
-    FROM {taxonomy_term_data} t
-    INNER JOIN {taxonomy_vocabulary} v ON t.vid = v.vid
-    ORDER BY v.name ASC, t.name ASC';
-  $results = db_query($query);
+  $vocabs = variable_get('uuid_features_entity_taxonomy_term_vocabularies', array_keys(taxonomy_vocabulary_get_names()));
+  if (empty($vocabs)) {
+    return $options;
+  }
+
+  $query = db_select('taxonomy_term_data', 't');
+  $query->innerJoin('taxonomy_vocabulary', 'v', 't.vid = v.vid');
+  $query->condition('v.machine_name', $vocabs)
+    ->fields('t', array('tid', 'name', 'uuid'))
+    ->addField('v', 'name', 'vname');
+  $query->orderBy('v.name', 'ASC');
+  $query->orderBy('t.name', 'ASC');
+  $results = $query->execute()->fetchAll();
+
   foreach ($results as $term) {
     $options[$term->uuid] = $term->vname . ' - ' . $term->name;
   }
 
+  drupal_alter('uuid_term_features_export_options', $options);
+
   return $options;
 }
 
diff --git a/includes/uuid_user.features.inc b/includes/uuid_user.features.inc
new file mode 100644
index 0000000..845f482
--- /dev/null
+++ b/includes/uuid_user.features.inc
@@ -0,0 +1,159 @@
+<?php
+
+/**
+ * Implements hook_features_export_options().
+ */
+function uuid_user_features_export_options() {
+  $options = array();
+
+  $query = 'SELECT u.uid, u.name, u.mail, u.uuid
+    FROM {users} u WHERE uid > 0 ORDER BY u.name ASC';
+  $results = db_query($query);
+  foreach ($results as $user) {
+    $options[$user->uuid] = t('@name: @mail', array(
+      '@name' => $user->name,
+      '@mail' => $user->mail,
+    ));
+  }
+
+  return $options;
+}
+
+/**
+ * Implements hook_features_export().
+ */
+function uuid_user_features_export($data, &$export, $module_name = '') {
+  $pipe = array();
+
+  $export['dependencies']['uuid_features'] = 'uuid_features';
+
+  uuid_features_load_module_includes();
+
+  $uids = entity_get_id_by_uuid('user', $data);
+  foreach ($uids as $uuid => $uid) {
+    // Load the existing user, with a fresh cache.
+    $node = user_load($uid, TRUE);
+
+    $export['features']['uuid_user'][$uuid] = $uuid;
+
+    $data = &$export;
+    drupal_alter('uuid_user_features_export', $data, $user);
+  }
+
+  return $pipe;
+}
+
+/**
+ * Implements hook_features_export_render().
+ */
+function uuid_user_features_export_render($module, $data) {
+  $translatables = $code = array();
+
+  uuid_features_load_module_includes();
+
+  $code[] = '  $users = array();';
+  $code[] = '';
+  $uids = entity_get_id_by_uuid('user', $data);
+  foreach ($uids as $uuid => $uid) {
+    // Only export the user if it exists.
+    if ($uid === FALSE) {
+      continue;
+    }
+    // Attempt to load the user, using a fresh cache.
+    $account = user_load($uid, TRUE);
+    if (empty($account)) {
+      continue;
+    }
+    $export = $account;
+
+    // Use date instead of created, in the same format used by node_object_prepare.
+    $export->date = format_date($export->created, 'custom', 'Y-m-d H:i:s O');
+    unset($export->uid);
+    $export->pass = user_password(10);
+
+    // The hook_alter signature is:
+    // hook_uuid_node_features_export_render_alter(&$export, $user, $module);
+    drupal_alter('uuid_user_features_export_render', $export, $user, $module);
+
+    $code[] = '  $users[] = ' . features_var_export($export) . ';';
+  }
+
+  if (!empty($translatables)) {
+    $code[] = features_translatables_export($translatables, '  ');
+  }
+
+  $code[] = '  return $users;';
+  $code = implode("\n", $code);
+  return array('uuid_features_default_users' => $code);
+}
+
+/**
+ * Implements hook_features_revert().
+ */
+function uuid_user_features_revert($module) {
+  uuid_user_features_rebuild($module);
+}
+
+/**
+ * Implements hook_features_rebuild().
+ * Rebuilds users based on UUID from code defaults.
+ */
+function uuid_user_features_rebuild($module) {
+  $users = module_invoke($module, 'uuid_features_default_users');
+  uuid_node_features_rebuild($module);
+  cache_clear_all();
+
+  if (!empty($users)) {
+    module_load_include('inc', 'user', 'user.pages');
+
+    foreach ($users as $data) {
+      $account = (object) $data;
+      $existing = new stdClass();
+
+      // Find the matching uid
+      $efq = new EntityFieldQuery();
+      $efq->entityCondition('entity_type', 'user');
+      $efq->propertyCondition('name', $account->name);
+      $result = $efq->execute();
+
+      if (isset($result['user'])) {
+        $uid = reset(array_keys($result['user']));
+      }
+
+      if (!empty($uid)) {
+        if ($uid == 1) {
+          global $user;
+          if (!empty($user->uid) && $user->uid == 1) {
+            $existing = $user;
+          } else {
+            $existing = user_load(1);
+          }
+        } else {
+          // Find the matching user by name with a fresh cache
+          $existing = user_load($uid, TRUE);
+          $existing->uid = $uid;
+        }
+        $account->uid = $uid;
+      }
+      else {
+        $existing->uid = NULL;
+      }
+
+      // The hook_alter signature is:
+      // hook_uuid_user_features_rebuild_alter(&user, $module);
+      drupal_alter('uuid_user_features_rebuild', $account, $module);
+
+      if($existing->uid === NULL) {
+        $account = user_save(NULL, (array) $account);
+      }
+      else {
+        // Dont' reset password.
+        unset($account->pass);
+        $account = user_save($existing, (array) $account);
+      }
+      // Clear out previously loaded user account if one was found
+      unset($existing);
+    }
+  }
+  uuid_node_features_rebuild($module);
+}
\ No newline at end of file
diff --git a/uuid_features.info b/uuid_features.info
index c3b4fbc..e89e9b9 100644
--- a/uuid_features.info
+++ b/uuid_features.info
@@ -17,3 +17,10 @@ files[] = modules/filefield.inc
 files[] = modules/nodereference.inc
 files[] = modules/taxonomy.inc
 files[] = modules/userreference.inc
+
+
+; Information added by drush on 2013-04-15
+version = "i2i_uuid_features-dev"
+project = "uuid_features"
+datestamp = "1366010233"
+
diff --git a/uuid_features.module b/uuid_features.module
index 1ac359c..bcca2b2 100644
--- a/uuid_features.module
+++ b/uuid_features.module
@@ -1,5 +1,7 @@
 <?php
 
+define ('UUID_FEATURES_DEFAULT_FALLBACK_ID', 1);
+
 /**
  * Implements hook_menu().
  */
@@ -28,6 +30,14 @@ function uuid_features_features_api() {
     'file' => drupal_get_path('module', 'uuid_features') . '/includes/uuid_node.features.inc',
   );
 
+  $components['uuid_user'] = array(
+    'name' => t('Users'),
+    'feature_source' => TRUE,
+    'default_hook' => 'uuid_features_default_users',
+    'default_file' => FEATURES_DEFAULTS_INCLUDED,
+    'file' => drupal_get_path('module', 'uuid_features') . '/includes/uuid_user.features.inc',
+  );
+
   if (module_exists('taxonomy')) {
     $components['uuid_term'] = array(
       'name' => t('Taxonomy Term'),
@@ -48,6 +58,26 @@ function uuid_features_features_api() {
     );
   }
 
+  if (module_exists('field_collection')) {
+    $components['uuid_field_collection'] = array(
+      'name' => t('Field collection'),
+      'feature_source' => TRUE,
+      'default_hook' => 'uuid_features_default_field_collections',
+      'default_file' => FEATURES_DEFAULTS_INCLUDED,
+      'file' => drupal_get_path('module', 'uuid_features') . '/includes/uuid_field_collection.features.inc',
+    );
+  }
+
+  if (module_exists('nodequeue')) {
+    $components['uuid_nodequeue_item'] = array(
+      'name' => t('Nodequeue item'),
+      'feature_source' => TRUE,
+      'default_hook' => 'uuid_features_default_nodequeue_items',
+      'default_file' => FEATURES_DEFAULTS_INCLUDED,
+      'file' => drupal_get_path('module', 'uuid_features') . '/includes/uuid_nodequeue_item.features.inc',
+    );
+  }
+
   return $components;
 }
 
@@ -76,12 +106,22 @@ function uuid_features_load_module_includes() {
  * When exporting a vocabulary, include its terms.
  */
 function uuid_features_features_pipe_taxonomy_alter(&$pipe, $data, $export) {
-  if ($vocab = taxonomy_vocabulary_machine_name_load($data)) {
-    $export['features']['uuid_term'] = array();
-    foreach (taxonomy_get_tree($vocab->vid) as $term) {
-      uuid_term_features_get_dependencies($export, $term->uuid);
+  if (variable_get('uuid_features_vocabulary_terms', FALSE) == TRUE) {
+    if (!is_array($data)) {
+      $data = array($data);
+    }
+    if (empty($pipe['uuid_term'])) {
+      $pipe['uuid_term'] = array();
+    }
+    foreach ($data as $machine_name) {
+      if ($vocab = taxonomy_vocabulary_machine_name_load($machine_name)) {
+        $export['features']['uuid_term'] = array();
+        foreach (taxonomy_get_tree($vocab->vid) as $term) {
+          uuid_term_features_get_dependencies($export, $term->uuid);
+        }
+        $pipe['uuid_term'] = array_merge($pipe['uuid_term'], $export['features']['uuid_term']);
+      }
     }
-    $pipe['uuid_term'] = $export['features']['uuid_term'];
   }
 }
 
@@ -96,6 +136,22 @@ function uuid_features_settings($form, &$form_state) {
     }
   }
 
+  $form['entity']['uuid_features_entity_node_types'] = array(
+    '#type' => 'checkboxes',
+    '#title' => t('Exportable node types'),
+    '#description' => t('Which content types should be exportable?'),
+    '#default_value' => variable_get('uuid_features_entity_node_types', array()),
+    '#options' => $bundles['node'],
+  );
+
+  $form['entity']['uuid_features_entity_taxonomy_term_vocabularies'] = array(
+    '#type' => 'checkboxes',
+    '#title' => t('Exportable term vocabularies'),
+    '#description' => t("Which taxonomy vocabulary's terms should be exportable?"),
+    '#default_value' => variable_get('uuid_features_entity_taxonomy_term_vocabularies', array()),
+    '#options' => $bundles['taxonomy_term'],
+  );
+
   $form['file']['uuid_features_file_node_types'] = array(
     '#type' => 'checkboxes',
     '#title' => t('Files exported for nodes'),
@@ -154,6 +210,13 @@ function uuid_features_settings($form, &$form_state) {
     '#description' => t('Comma seperated list of file field types to detect for export/import.'),
   );
 
+  $form['settings']['uuid_features_vocabulary_terms'] = array(
+    '#type' => 'checkbox',
+    '#title' => t('Auto detect uuid terms'),
+    '#description' => t('When exporting a vocabulary, include its terms.'),
+    '#default_value' => variable_get('uuid_features_vocabulary_terms', FALSE),
+  );
+
   return system_settings_form($form);
 }
 
@@ -446,3 +509,107 @@ function _uuid_features_file_field_import_file(&$file) {
 
   return TRUE;
 }
+
+/**
+ * Helper function to get a filtered list of fields of the same type.
+ *
+ * @param $export
+ *   Example: node object
+ * @param $bundle_type
+ *   Example: 'node'
+ * @param $field_type
+ *   Example: 'field_collection', 'taxonomy_term_reference'
+ *
+ * @return array
+ *   A filtered list of fields of the same type.
+ */
+function uuid_features_get_field_items_iterator(&$export, $bundle_type, $field_type) {
+  $fields = field_info_instances($bundle_type, isset($export->type) ? $export->type : NULL);
+  if (!isset($export->type)) {
+    $fields = reset($fields);
+  }
+  $return = array();
+  foreach ($fields as $field_instance) {
+    $info = field_info_field($field_instance['field_name']);
+    $field = &$export->{$info['field_name']};
+    if ($info['type'] == $field_type) {
+      foreach ($field as $language => &$field_items) {
+        $return[$field_instance['field_name']] = array(
+          $language => &$field_items,
+        );
+      }
+    }
+  }
+  return $return;
+}
+
+/**
+ * Walks through a filtered list of fields and sets UUID property using entities' ids.
+ *
+ * @param $fields
+ *   Filtered array of fields of the same type.
+ * @param $entity_type
+ */
+function uuid_features_set_uuid_references(&$fields, $entity_type) {
+  foreach ($fields as $field_name => &$field_languages) {
+    foreach ($field_languages as &$field_values) {
+      foreach ($field_values as &$field_value) {
+        $field_info = field_info_field($field_name);
+        $columns = array_keys($field_info['columns']);
+        $id_column = $columns[0];
+        $field_reference_uuid = reset(entity_get_uuid_by_id($entity_type, array(
+          $field_value[$id_column],
+        )));
+
+        if ($field_reference_uuid) {
+          $field_value['uuid'] = $field_reference_uuid;
+          foreach ($columns as $column) {
+            $field_value[$column] = $field_reference_uuid;
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Walks through a filtered list of fields and updates entity references using UUID property.
+ *
+ * @param $fields
+ *   Filtered array of fields of the same type.
+ * @param $entity_type
+ * @param $map
+ *   Mapping from entity to reference fields properties.
+ *   Example:
+ *     Taxonomy term:
+ *     array(
+ *       'tid' => 'tid',
+ *     )
+ *
+ *     Field collection:
+ *     array(
+ *       'item_id' => 'value',
+ *       'revision_id' => 'revision_id',
+ *     )
+ */
+function uuid_features_fetch_uuid_references(&$fields, $entity_type, $map) {
+  foreach ($fields as $field_name => &$field_languages) {
+    foreach ($field_languages as &$field_values) {
+      if (is_array($field_values)) {
+        foreach ($field_values as &$field_value) {
+          $referenced_entity = reset(entity_uuid_load($entity_type, array(
+            $field_value['uuid'],
+          ), array(), TRUE));
+          foreach ($map as $source => $destination) {
+            if ($referenced_entity) {
+              $field_value[$destination] = $referenced_entity->{$source};
+            } else {
+              // fallback
+              $field_value[$destination] = UUID_FEATURES_DEFAULT_FALLBACK_ID;
+            }
+          }
+        }
+      }
+    }
+  }
+}