diff --git a/entity_example/entity_example.info b/entity_example/entity_example.info
new file mode 100644
index 0000000..f6e00a6
--- /dev/null
+++ b/entity_example/entity_example.info
@@ -0,0 +1,5 @@
+name = Entity Example
+description = A simple entity example showing the main steps required to set up your own entity.
+core = 7.x
+package = Example modules
+dependencies[] = devel
\ No newline at end of file
diff --git a/entity_example/entity_example.install b/entity_example/entity_example.install
new file mode 100644
index 0000000..ed18973
--- /dev/null
+++ b/entity_example/entity_example.install
@@ -0,0 +1,67 @@
+<?php
+/**
+ * @file
+ * Install for a basic entity - need to create the base table for our entity.
+ * This table can have as many columns as you need to keep track of
+ * entity-specific data that will not be added via attached fields.
+ * The minimum information for the entity to work is an id and an entity name.
+ */
+
+/**
+ * Implements hook_schema()
+ */
+function entity_example_schema() {
+  $schema = array();
+
+  // The name of the table can be any name we choose. However, namespacing the
+  // table with the module name is best practice.
+  $schema['entity_example_basic'] = array(
+    'description' => 'The base table for our basic entity.',
+      'fields' => array(
+        'basic_id' => array(
+          'description' => 'Primary key of the basic entity.',
+          'type' => 'serial',
+          'unsigned' => TRUE,
+          'not null' => TRUE,
+        ),
+        // If we allow multiple bundles, then the schema must handle that;
+        // We'll put it in the 'bundle_type' field to avoid confusion with the
+        // entity type.
+        'bundle_type' => array(
+          'description' => 'The bundle type',
+          'type' => 'text',
+          'size' => 'medium',
+          'not null' => TRUE
+        ),
+        // Additional properties are just things that are common to all
+        // entities and don't require field storage.
+        'title' => array(
+          'description' => 'A not-so-creative title property',
+          'type' => 'varchar',
+          'length' => 255,
+          'not null' => TRUE,
+          'default' => '',
+        ),
+        'created' => array(
+          'description' => 'The Unix timestamp when the node was created.',
+          'type' => 'int',
+          'not null' => TRUE,
+          'default' => 0,
+        ),
+      ),
+    'primary key' => array('basic_id'),
+  );
+
+  return $schema;
+}
+
+
+/*
+ * Implements hook_uninstall().
+ *
+ * At uninstall time we'll notify field.module that the entity was deleted
+ * so that attached fields can be cleaned up.
+ */
+function entity_example_uninstall(){
+  field_attach_delete_bundle( 'entity_example_basic' , 'first_example_bundle' );
+}
diff --git a/entity_example/entity_example.module b/entity_example/entity_example.module
new file mode 100644
index 0000000..a617355
--- /dev/null
+++ b/entity_example/entity_example.module
@@ -0,0 +1,393 @@
+<?php
+
+/**
+ *@file
+ * Implements the basic functionality required to create and display an entity.
+ *
+ * @todo: Provide an edit page.
+ * @todo: Make the extra_fields work correctly on display.
+ */
+
+
+/**
+ * Implements hook_entity_info()
+ *
+ * This is the fundamental description of the entity.
+ *
+ * It provides a single entity with a single bundle and without revision
+ * support.
+ */
+function entity_example_entity_info() {
+  $info['entity_example_basic'] = array(
+    // A human readable label to identify our entity.
+    'label' => t('Example Basic Entity'),
+
+    // The controller for our Entity, extending the Drupal core controller.
+    'controller class' => 'EntityExampleBasicController',
+
+    // The table for this entity defined in hook_schema()
+    'base table' => 'entity_example_basic',
+
+    // Returns the uri elements of an entity
+    'uri callback' => 'entity_example_basic_uri',
+
+    // IF fieldable == FALSE, we can't attach fields.
+    'fieldable' => TRUE,
+
+    // entity_keys tells the controller what database fields are used for key
+    // functions. It is not required if we don't have bundles or revisions.
+    // Here we do not support a revision, so that entity key is omitted.
+    'entity keys' => array(
+      'id' => 'basic_id' , // The 'id' (basic_id here) is the unique id.
+      'bundle' => 'bundle_type' // Bundle will be determined by the 'bundle_type' field
+    ),
+    'bundle keys' => array(
+      'bundle' => 'bundle_type',
+    ),
+
+    // FALSE disables caching. Caching functionality is handled by Drupal core.
+    'static cache' => TRUE,
+
+    // Bundles are alternative groups of fields or configuration
+    // associated with a base entity type.
+    'bundles' => array(
+      'first_example_bundle' => array(
+        'label' => 'First example bundle',
+        // 'admin' key is used by the Field UI to provide field and
+        // display UI pages.
+        'admin' => array(
+          'path' => 'admin/structure/entity_example_basic/manage',
+          'access arguments' => array('administer entity_example_basic entities'),
+        ),
+      ),
+    ),
+    // View modes allow entities to be displayed differently based on context.
+    // As a demonstration we'll support "Tweaky", but we could have and support
+    // multiple display modes.
+    'view modes' => array(
+      'tweaky' => array(
+        'label' => t('Tweaky'),
+        'custom settings' =>  FALSE,
+      ),
+    )
+  );
+
+  return $info;
+}
+
+/**
+ * Fetch a basic object. Make sure that the wildcard you choose
+ * in the basic entity definition fits the function name here.
+ *
+ * @param $basic_id
+ *   Integer specifying the basic entity id.
+ * @param $reset
+ *   A boolean indicating that the internal cache should be reset.
+ * @return
+ *   A fully-loaded $basic object or FALSE if it cannot be loaded.
+ *
+ * @see basic_load_multiple()
+ */
+function entity_example_basic_load($basic_id = NULL, $reset = FALSE) {
+  $basic_ids = (isset($basic_id) ? array($basic_id) : array());
+  $basic = entity_example_basic_load_multiple($basic_ids, $reset);
+  return $basic ? reset($basic) : FALSE;
+}
+
+
+/**
+ * Loads multiple basic entities based on certain conditions
+ */
+function entity_example_basic_load_multiple($basic_ids = FALSE, $conditions = array(), $reset = FALSE) {
+  return entity_load('entity_example_basic', $basic_ids, $conditions, $reset);
+}
+
+
+
+/**
+ * Implements the uri callback.
+ */
+function entity_example_basic_uri($basic) {
+  return array(
+    'path' => 'examples/entity_example/basic/' . $basic->basic_id,
+  );
+}
+
+
+/**
+ * Implements hook_menu()
+ */
+function entity_example_menu() {
+  $items['examples/entity_example'] = array(
+    'title' => 'Entity Example',
+    'page callback' => 'entity_example_info_page',
+    'access callback' => TRUE,
+  );
+  // This provides a place for Field API to hang its own
+  // interface and has to be the same as what was defined
+  // in basic_entity_info() above.
+  $items['admin/structure/entity_example_basic/manage'] = array(
+    'title' => 'Administer entity_example_basic entity type',
+    'page callback' => 'entity_example_basic_admin_page',
+    'access arguments' => array('administer entity_example_basic entities'),
+  );
+
+  // The page to view our entities - needs to follow what
+  // is defined in basic_uri and will use load_basic to retrieve
+  // the necessary entity info.
+  $items['examples/entity_example/basic/%entity_example_basic'] = array(
+    'title callback' => 'entity_example_basic_title',
+    'title arguments' => array(3),
+    'page callback' => 'entity_example_basic_view',
+    'page arguments' => array(3),
+    'access arguments' => array('view entity_example_basic entities'),
+    'type' => MENU_CALLBACK,
+  );
+
+  // Add example entities.
+  $items['examples/entity_example/basic/add'] = array(
+    'title' => 'Add an Entity Example Basic Entity',
+    'page callback' => 'entity_example_basic_add',
+    'access arguments' => array('create entity_example_basic entities'),
+  );
+
+  $items['examples/entity_example/basic/%entity_example_basic/edit'] = array(
+    'title' => 'Add an Entity Example Basic Entity',
+    'page callback' => 'drupal_get_form',
+    'page arguments' => array('entity_example_basic_form', 3),
+    'access arguments' => array('edit entity_example_basic entities'),
+  );
+
+  return $items;
+}
+
+/**
+ * Basic information for the page.
+ * @todo: Give links to admin pages, etc.
+ */
+function entity_example_info_page() {
+  return array(
+    '#markup' => t('The entity example provides a simple example entity.'),
+  );
+}
+
+/**
+ * Implements hook_permission()
+ */
+function example_entity_permission() {
+    return array(
+    'administer entity_example_basic entities' =>  array(
+      'title' => t('Administer entity_example_basic entities'),
+      'restrict access' => TRUE,
+    ),
+    'view entity_example_basic entities' => array(
+      'title' => t('View Entity Example Basic Entities'),
+    ),
+    'create entity_example_basic entities' => array(
+      'title' => t('Create Entity Example Basic Entities'),
+    ),
+  );
+}
+
+
+/**
+ * Just provide some basic info for the entity administration page.
+ * This can be expanded to add a list of all created entities, etc.
+ * @todo: Provide a list of existing entities.
+ */
+function entity_example_basic_admin_page() {
+  $output = 'Welcome to the administration page for your Entity Example Basic Entities.<br/>';
+
+  $output .= l(t('Add an entity example basic entity'), 'examples/entity_example/basic/add');
+
+  dpm(entity_example_basic_load_multiple());
+
+  return $output;
+}
+
+/**
+ * Callback for a page title when this entity is displayed.
+ */
+function entity_example_basic_title($entity) {
+  return t('Entity Example Basic (title=@title)', array('@title' => $entity->title));
+}
+
+/**
+ * Function to display the entity.
+ */
+function entity_example_basic_view($entity, $view_mode = 'tweaky') {
+
+  $entity->content = array();
+
+  // Build fields content - this where the FieldAPI really comes in to play.
+  // The task has very little code here because it all gets taken care of by
+  // field module.
+  field_attach_prepare_view('entity_example_basic', array($entity->basic_id => $entity), $view_mode);
+  entity_prepare_view('entity_example_basic', array($entity->basic_id => $entity));
+  $entity->content += field_attach_view('entity_example_basic', $entity, $view_mode);
+
+  $entity->content['created'] = array(
+    '#type' => 'item',
+    '#title' => t('Created date'),
+    '#markup' => format_date($entity->created),
+  );
+  $entity->content['title'] = array(
+    '#type' => 'item',
+    '#title' => t('Actual title'),
+    '#markup' => $entity->title,
+  );
+
+  $type = 'entity_example_basic';
+  drupal_alter(array('entity_example_basic_view', 'entity_view'), $entity->content, $type);
+
+  return $entity->content;
+}
+
+
+
+/**
+ * Implements hook_field_extra_fields()
+ *
+ * This exposes the "extra fields" (usually properties that can be configured
+ * as if they were fields) of the entity as pseudo-fields
+ * so that they get handled by the Entity and Field core functionality.
+ * Node titles get treated in a similar manner.
+ */
+function entity_example_field_extra_fields() {
+  $form_elements['title'] = array(
+    'label' => t('Title'),
+    'description' => t('Title (an extra field)'),
+    'weight' => -5,
+  );
+  $display_elements['created'] = array(
+    'label' => t('Created date'),
+    'description' => t('Created date (an extra field)'),
+    'weight' => 0,
+  );
+  $display_elements['title'] = array(
+    'label' => t('Cool title'),
+    'description' => t('Really just the title'),
+    'weight' => 0,
+  );
+
+  // Since we have only one bundle type, we'll just provide the extra_fields
+  // for it here.
+  $extra_fields['entity_example_basic']['first_example_bundle']['form'] = $form_elements;
+  $extra_fields['entity_example_basic']['first_example_bundle']['display'] = $display_elements;
+
+  return $extra_fields;
+}
+
+function entity_example_basic_add() {
+  // Create a basic entity structure to be used and passed to the validation
+  // and submission functions.
+  $entity = new stdClass();
+  $entity->type = 'entity_example_basic';
+  $entity->basic_id = 0;
+  $entity->bundle_type = 'first_example_bundle';
+  $entity->title = '';
+  return drupal_get_form('entity_example_basic_form', $entity);
+}
+
+/**
+ * Form function to create an entity_example_basic entity.
+ *
+ * The pattern is:
+ * - Set up the form for the data that is specific to your
+ *   entity: the columns of your base table.
+ * - Call on the Field API to pull in the form elements
+ *   for fields attached to the entity.
+ */
+function entity_example_basic_form($form, &$form_state, $entity) {
+  $form['title'] = array(
+    '#type' => 'textfield',
+    '#title' => t('Title'),
+    '#required' => TRUE,
+    '#default_value' => $entity->title,
+  );
+
+  $form['basic_entity'] = array(
+    '#type' => 'value',
+    '#value' => $entity,
+  );
+
+  field_attach_form('entity_example_basic', $entity, $form, $form_state);
+
+  $form['submit'] = array(
+    '#type' => 'submit',
+    '#value' => t('Save'),
+    '#weight' => 100,
+  );
+
+  return $form;
+}
+
+
+/**
+ * Validation handler for entity_example_basic_add_form form.
+ * We pass things straight through to the Field API to handle validation
+ * of the attached fields.
+ */
+function entity_example_basic_form_validate($form, &$form_state) {
+  field_attach_form_validate('entity_example_basic', $form_state['values']['basic_entity'], $form, $form_state);
+}
+
+
+/**
+ * Form callback: submits basic_add_form information
+ */
+function entity_example_basic_form_submit($form, &$form_state) {
+  $entity = $form_state['values']['basic_entity'];
+  $entity->title = $form_state['values']['title'];
+  field_attach_submit('entity_example_basic', $entity, $form, $form_state);
+  $entity = entity_example_basic_save($entity);
+  $form_state['redirect'] = 'examples/entity_example/basic/' . $entity->basic_id;
+}
+
+
+/**
+ * We save the entity by calling the controller.
+ */
+function entity_example_basic_save(&$entity) {
+  return entity_get_controller('entity_example_basic')->save($entity);
+}
+
+
+/**
+ * BasicController extends the DrupalDefaultEntityController by adding
+ * an extra function to handle saving of entities.
+ */
+class EntityExampleBasicController extends DrupalDefaultEntityController{
+
+ /**
+  * Saves the custom fields using drupal_write_record()
+  */
+  public function save($entity) {
+    $entity->created = time();
+    // 'primary_keys' argument determines whether this will be an insert or an
+    // update. So if entity already has an ID, we'll specify basic_id as the
+    // key.
+    $primary_keys = $entity->basic_id ? 'basic_id' : array();
+    drupal_write_record('entity_example_basic', $entity, $primary_keys);
+    if (empty($primary_keys)) {
+      field_attach_insert('entity_example_basic', $entity);
+    }
+    else {
+      field_attach_update('entity_example_basic', $entity);
+    }
+    module_invoke_all('entity_insert', 'entity_example_basic', $entity);
+    return $entity;
+  }
+}
+
+
+
+/**
+ * Implements hook_help().
+ */
+function entity_example_help($path, $arg) {
+  switch ($path) {
+    case 'admin/help#entity_example':
+      return "<p>" . t('Once you have activated the module you can configure your entity bundle by visiting "admin/structure/basic/manage"') . "</p>";
+  }
+}