diff --git a/core/includes/common.inc b/core/includes/common.inc
index 77ea718..948d5db 100644
--- a/core/includes/common.inc
+++ b/core/includes/common.inc
@@ -1,6 +1,5 @@
 <?php
 
-use Drupal\Component\Utility\Crypt;
 use Drupal\Component\Utility\Json;
 use Drupal\Component\Utility\Settings;
 use Drupal\Component\Utility\SortArray;
@@ -21,6 +20,7 @@
 use Drupal\Core\Routing\GeneratorNotInitializedException;
 use Drupal\Core\SystemListingInfo;
 use Drupal\Core\Template\Attribute;
+use Drupal\Core\Render\Element;
 
 /**
  * @file
@@ -3857,7 +3857,7 @@ function drupal_render(&$elements) {
   }
 
   // Get the children of the element, sorted by weight.
-  $children = element_children($elements, TRUE);
+  $children = Element::children($elements, TRUE);
 
   // Initialize this element's #children, unless a #pre_render callback already
   // preset #children.
@@ -4484,21 +4484,21 @@ function drupal_sort_title($a, $b) {
  * Checks if the key is a property.
  */
 function element_property($key) {
-  return $key[0] == '#';
+  return Element::property($key);
 }
 
 /**
  * Gets properties of a structured array element (keys beginning with '#').
  */
 function element_properties($element) {
-  return array_filter(array_keys((array) $element), 'element_property');
+  return Element::properties($element);
 }
 
 /**
  * Checks if the key is a child.
  */
 function element_child($key) {
-  return !isset($key[0]) || $key[0] != '#';
+  return Element::child($key);
 }
 
 /**
@@ -4516,41 +4516,7 @@ function element_child($key) {
  *   The array keys of the element's children.
  */
 function element_children(&$elements, $sort = FALSE) {
-  // Do not attempt to sort elements which have already been sorted.
-  $sort = isset($elements['#sorted']) ? !$elements['#sorted'] : $sort;
-
-  // Filter out properties from the element, leaving only children.
-  $children = array();
-  $sortable = FALSE;
-  foreach ($elements as $key => $value) {
-    if ($key === '' || $key[0] !== '#') {
-      if (is_array($value)) {
-        $children[$key] = $value;
-        if (isset($value['#weight'])) {
-          $sortable = TRUE;
-        }
-      }
-      // Only trigger an error if the value is not null.
-      // @see http://drupal.org/node/1283892
-      elseif (isset($value)) {
-        trigger_error(t('"@key" is an invalid render array key', array('@key' => $key)), E_USER_ERROR);
-      }
-    }
-  }
-  // Sort the children if necessary.
-  if ($sort && $sortable) {
-    uasort($children, 'element_sort');
-    // Put the sorted children back into $elements in the correct order, to
-    // preserve sorting if the same element is passed through
-    // element_children() twice.
-    foreach ($children as $key => $child) {
-      unset($elements[$key]);
-      $elements[$key] = $child;
-    }
-    $elements['#sorted'] = TRUE;
-  }
-
-  return array_keys($children);
+  return Element::children($elements, $sort);
 }
 
 /**
@@ -4563,25 +4529,7 @@ function element_children(&$elements, $sort = FALSE) {
  *   The array keys of the element's visible children.
  */
 function element_get_visible_children(array $elements) {
-  $visible_children = array();
-
-  foreach (element_children($elements) as $key) {
-    $child = $elements[$key];
-
-    // Skip un-accessible children.
-    if (isset($child['#access']) && !$child['#access']) {
-      continue;
-    }
-
-    // Skip value and hidden elements, since they are not rendered.
-    if (isset($child['#type']) && in_array($child['#type'], array('value', 'hidden'))) {
-      continue;
-    }
-
-    $visible_children[$key] = $child;
-  }
-
-  return array_keys($visible_children);
+  return Element::getVisibleChildren($elements);
 }
 
 /**
@@ -4597,16 +4545,7 @@ function element_get_visible_children(array $elements) {
  *   no property name needs to be specified.
  */
 function element_set_attributes(array &$element, array $map) {
-  foreach ($map as $property => $attribute) {
-    // If the key is numeric, the attribute name needs to be taken over.
-    if (is_int($property)) {
-      $property = '#' . $attribute;
-    }
-    // Do not overwrite already existing attributes.
-    if (isset($element[$property]) && !isset($element['#attributes'][$attribute])) {
-      $element['#attributes'][$attribute] = $element[$property];
-    }
-  }
+  Element::setAttributes($element, $map);
 }
 
 /**
diff --git a/core/lib/Drupal/Core/Render/Element.php b/core/lib/Drupal/Core/Render/Element.php
new file mode 100644
index 0000000..ef5c696
--- /dev/null
+++ b/core/lib/Drupal/Core/Render/Element.php
@@ -0,0 +1,162 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Core\Render\Element.
+ */
+
+namespace Drupal\Core\Render;
+
+/**
+ * Deals with drupal render elements.
+ */
+class Element {
+
+  /**
+   * Checks if the key is a property.
+   *
+   * @param string $key
+   *   The key to check.
+   *
+   * @return bool
+   *   TRUE of the key is a property, FALSE otherwise.
+   */
+  public static function property($key) {
+    return $key[0] == '#';
+  }
+
+  /**
+   * Gets properties of a structured array element (keys beginning with '#').
+   *
+   * @param array $element
+   *   An element array to return properties for.
+   *
+   * @return array
+   *   An array of property keys for the element.
+   */
+  public static function properties(array $element) {
+    return array_filter(array_keys($element), 'static::property');
+  }
+
+  /**
+   * Checks if the key is a child.
+   *
+   * @param string $key
+   *   The key to check.
+   *
+   * @return bool
+   *    TRUE if the element is a child, FALSE otherwise.
+   */
+  public static function child($key) {
+    return !isset($key[0]) || $key[0] != '#';
+  }
+
+  /**
+   * Identifies the children of an element array, optionally sorted by weight.
+   *
+   * The children of a element array are those key/value pairs whose key does
+   * not start with a '#'. See drupal_render() for details.
+   *
+   * @param $elements
+   *   The element array whose children are to be identified.
+   * @param $sort
+   *   Boolean to indicate whether the children should be sorted by weight.
+   *
+   * @return
+   *   The array keys of the element's children.
+   */
+  public static function children(array &$elements, $sort = FALSE) {
+    // Do not attempt to sort elements which have already been sorted.
+    $sort = isset($elements['#sorted']) ? !$elements['#sorted'] : $sort;
+
+    // Filter out properties from the element, leaving only children.
+    $children = array();
+    $sortable = FALSE;
+    foreach ($elements as $key => $value) {
+      if ($key === '' || $key[0] !== '#') {
+        if (is_array($value)) {
+          $children[$key] = $value;
+          if (isset($value['#weight'])) {
+            $sortable = TRUE;
+          }
+        }
+        // Only trigger an error if the value is not null.
+        // @see http://drupal.org/node/1283892
+        elseif (isset($value)) {
+          trigger_error(t('"@key" is an invalid render array key', array('@key' => $key)), E_USER_ERROR);
+        }
+      }
+    }
+    // Sort the children if necessary.
+    if ($sort && $sortable) {
+      uasort($children, 'element_sort');
+      // Put the sorted children back into $elements in the correct order, to
+      // preserve sorting if the same element is passed through
+      // element_children() twice.
+      foreach ($children as $key => $child) {
+        unset($elements[$key]);
+        $elements[$key] = $child;
+      }
+      $elements['#sorted'] = TRUE;
+    }
+
+    return array_keys($children);
+  }
+
+  /**
+   * Returns the visible children of an element.
+   *
+   * @param $elements
+   *   The parent element.
+   *
+   * @return
+   *   The array keys of the element's visible children.
+   */
+  public static function getVisibleChildren(array $elements) {
+    $visible_children = array();
+
+    foreach (static::children($elements) as $key) {
+      $child = $elements[$key];
+
+      // Skip un-accessible children.
+      if (isset($child['#access']) && !$child['#access']) {
+        continue;
+      }
+
+      // Skip value and hidden elements, since they are not rendered.
+      if (isset($child['#type']) && in_array($child['#type'], array('value', 'hidden'))) {
+        continue;
+      }
+
+      $visible_children[$key] = $child;
+    }
+
+    return array_keys($visible_children);
+  }
+
+  /**
+   * Sets HTML attributes based on element properties.
+   *
+   * @param $element
+   *   The renderable element to process.
+   * @param $map
+   *   An associative array whose keys are element property names and whose values
+   *   are the HTML attribute names to set for corresponding the property; e.g.,
+   *   array('#propertyname' => 'attributename'). If both names are identical
+   *   except for the leading '#', then an attribute name value is sufficient and
+   *   no property name needs to be specified.
+   */
+  public static function setAttributes(array &$element, array $map) {
+    foreach ($map as $property => $attribute) {
+      // If the key is numeric, the attribute name needs to be taken over.
+      if (is_int($property)) {
+        $property = '#' . $attribute;
+      }
+      // Do not overwrite already existing attributes.
+      if (isset($element[$property]) && !isset($element['#attributes'][$attribute])) {
+        $element['#attributes'][$attribute] = $element[$property];
+      }
+    }
+  }
+
+}
diff --git a/core/tests/Drupal/Tests/Core/Render/ElementTest.php b/core/tests/Drupal/Tests/Core/Render/ElementTest.php
new file mode 100644
index 0000000..6148589
--- /dev/null
+++ b/core/tests/Drupal/Tests/Core/Render/ElementTest.php
@@ -0,0 +1,73 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Tests\Core\Render\ElementTest.
+ */
+
+namespace Drupal\Tests\Core\Render;
+
+use Drupal\Tests\UnitTestCase;
+use Drupal\Core\Render\Element;
+
+/**
+ * Tests the Element class
+ *
+ * @see \Drupal\Core\Render\Element
+ *
+ * @group Drupal
+ * @group Render
+ */
+class ElementTest extends UnitTestCase {
+
+  public static function getInfo() {
+    return array(
+      'name' => 'Element test',
+      'description' => 'Tests \Drupal\Core\Render\Element helper class.',
+      'group' => 'Render',
+    );
+  }
+
+  /**
+   * Tests the property() method.
+   */
+  public function testProperty() {
+    $this->assertTrue(Element::property('#property'));
+    $this->assertFalse(Element::property('property'));
+    $this->assertFalse(Element::property('property#'));
+  }
+
+  /**
+   * Tests the properties() method.
+   */
+  public function testProperties() {
+    $element = array(
+      '#property1' => 'property1',
+      '#property2' => 'property2',
+      'property3' => 'property3'
+    );
+
+    $properties = Element::properties($element);
+
+    $this->assertContains('#property1', $properties);
+    $this->assertContains('#property2', $properties);
+    $this->assertNotContains('property3', $properties);
+  }
+
+  /**
+   * Tests the child() method.
+   */
+  public function testChild() {
+    $this->assertFalse(Element::child('#property'));
+    $this->assertTrue(Element::child('property'));
+    $this->assertTrue(Element::child('property#'));
+  }
+
+  /**
+   * Tests the children() method.
+   */
+  public function testChildren() {
+
+  }
+
+}