diff --git a/Gruntfile.js b/Gruntfile.js
index 2f3a7d2..90697d9 100644
--- a/Gruntfile.js
+++ b/Gruntfile.js
@@ -90,7 +90,7 @@ module.exports = function(grunt) {
                 }
             },
             all: ["tests/all.html"],
-            single: ["tests/index.html"]
+            single: ["tests/single.html"]
         },
         copy: {
             qunit: {
diff --git a/src/editor/core/Arte.js b/src/editor/core/Arte.js
index b5aac5d..edac782 100644
--- a/src/editor/core/Arte.js
+++ b/src/editor/core/Arte.js
@@ -11,9 +11,12 @@
 (function($) {
     $.Arte = $.Arte || {};
     $.fn.Arte = function(options, args) {
-        var result = [];
         rangy.init();
-        this.each(function() {
+
+        if (!this.length) {
+            return this;
+        }
+        return this.map(function() {
             var $this = $(this);
             var editor = $this.data("Arte");
             if (options && typeof(options) === "string") {
@@ -28,7 +31,7 @@
                 }
 
                 var returnValue = editor[methodName].call(editor, args);
-                result.push(returnValue);
+                return returnValue;
             } else {
                 // If $this is not a rich text editor, construct the editor
                 if (!editor) {
@@ -37,9 +40,8 @@
                     editor = new $.Arte.TextArea(options);
                     $this.data("Arte", editor);
                 }
-                result.push(editor);
+                return editor;
             }
         });
-        return $(result);
     };
 })(jQuery);
diff --git a/src/new/arte-commands.js b/src/new/arte-commands.js
new file mode 100644
index 0000000..252e948
--- /dev/null
+++ b/src/new/arte-commands.js
@@ -0,0 +1,167 @@
+jQuery(function($) {
+    var commands = {
+        bold: function() {
+            var weight = this.element.css("fontWeight");
+
+            if (weight === "bold" || weight > 500) {
+                this.element.css("fontWeight", 400);
+            } else {
+                this.element.css("fontWeight", 700);
+            }
+        },
+        italic: function() {
+            var style = this.element.css("fontStyle");
+
+            if (style === "italic") {
+                this.element.css("fontStyle", "normal");
+            } else {
+                this.element.css("fontStyle", "italic");
+            }
+        },
+        underline: function() {
+            var decoration = this.element.css("textDecoration");
+
+            if (decoration === "underline") {
+                this.element.css("textDecoration", "none");
+            } else {
+                this.element.css("textDecoration", "underline");
+            }
+        },
+        fontSize: function(value) {
+            if (value) {
+                return this.element.css("fontSize", value);
+            } else {
+                return this.element.css("fontSize");
+            }
+        },
+        fontFamily: function(value) {
+            if (value) {
+                return this.element.css("fontFamily", value);
+            } else {
+                return this.element.css("fontFamily");
+            }
+        },
+        color: function(value) {
+            if (value) {
+                return this.element.css("color", value);
+            } else {
+                return this.element.css("color");
+            }
+        },
+        backgroundColor: function(value) {
+            if (value) {
+                return this.element.css("backgroundColor", value);
+            } else {
+                return this.element.css("backgroundColor");
+            }
+        },
+        textAlign: function(value) {
+            if (value) {
+                return this.element.css("textAlign", value);
+            } else {
+                return this.element.css("textAlign");
+            }
+        },
+        unorderedList: function() {
+            if (this.__type === "plainText") {
+                throw new Error("Can't create lists on plain text editors");
+            }
+        },
+        orderedList: function() {
+            if (this.__type === "plainText") {
+                throw new Error("Can't create lists on plain text editors");
+            }
+        },
+        blockquote: function() {
+            if (this.__type === "plainText") {
+                throw new Error("Can't create elements on plain text editor");
+            }
+        },
+        h1: function() {
+            if (this.__type === "plainText") {
+                throw new Error("Can't create elements on plain text editor");
+            }
+        },
+        h2: function() {
+            if (this.__type === "plainText") {
+                throw new Error("Can't create elements on plain text editor");
+            }
+        },
+        h3: function() {
+            if (this.__type === "plainText") {
+                throw new Error("Can't create elements on plain text editor");
+            }
+        },
+        h4: function() {
+            if (this.__type === "plainText") {
+                throw new Error("Can't create elements on plain text editor");
+            }
+        },
+        h5: function() {
+            if (this.__type === "plainText") {
+                throw new Error("Can't create elements on plain text editor");
+            }
+        },
+        h6: function() {
+            if (this.__type === "plainText") {
+                throw new Error("Can't create elements on plain text editor");
+            }
+        },
+        subscript: function() {
+            if (this.__type === "plainText") {
+                throw new Error("Can't create elements on plain text editor");
+            }
+        },
+        superscript: function() {
+            if (this.__type === "plainText") {
+                throw new Error("Can't create elements on plain text editor");
+            }
+        }
+    };
+
+    $.each([
+            "bold", "italic", "underline",
+            "fontSize", "fontFamily",
+            "color", "backgroundColor",
+            "unorderedList", "orderedList",
+            "textAlign"
+        ], function() {
+            var command = this;
+            Arte.prototype[command] = function(options) {
+                return this.exec(command, options);
+            };
+        });
+
+    $.each([
+            "blockquote",
+            "h1", "h2", "h3", "h4", "h5", "h6",
+            "subscript", "superscript",
+        ], function() {
+            var command = this;
+            Arte.prototype[command] = function() {
+                return this.exec(command);
+            };
+        });
+
+    $.extend(Arte.prototype, {
+        exec: function(command, options) {
+            var result;
+
+            this.triggerEvent({
+                type: "arte-beforecommand",
+                options: options,
+                command: command
+            });
+
+            result = commands[command].call(this, options);
+
+            this.triggerEvent({
+                type: "arte-command",
+                options: options,
+                command: command
+            });
+
+            return result;
+        }
+    });
+});
diff --git a/src/new/arte-configuration.js b/src/new/arte-configuration.js
new file mode 100644
index 0000000..e69de29
diff --git a/src/new/arte-core.js b/src/new/arte-core.js
new file mode 100644
index 0000000..5c2eab2
--- /dev/null
+++ b/src/new/arte-core.js
@@ -0,0 +1,156 @@
+/**
+ * @fileoverview Rich text editor
+ * Usage:
+ *  1) var arte = Arte(element);
+ *     Converts the first matched element into a rich text editor using default options and returns an existing instance
+ * @returns {an Arte object}
+ *  2) var arte = Arte(element, { options });
+ *     Converts the first matched elements into a rich text editor using the options supplied and returns an existing instance
+ * @returns {an Arte object}
+ *
+ */
+
+jQuery(function($) {
+    function Arte(element, options) {
+        if (!(this instanceof Arte)) {
+            return new Arte(element, options);
+        }
+
+        this.container = $(element).first();
+        this.options = $.extend({
+                editorType: "plainText",
+                styles: {
+                    "min-height": "200px",
+                    "height": "inherit"
+                },
+                classes: [],
+                value: "Please enter text ..."
+                // TODO: set all default values here
+            }, options);
+
+        if (!this.container.length) {
+            throw "Arte requires a DOM element";
+        }
+
+        // NEW: replace element reference to the new made element
+        // after it's initialized
+        this.element = this.__initialize();
+
+        this.__initEvents();
+
+        this.__type = this.options.editorType;
+
+        return this;
+    }
+
+    // Export Arte
+    window.Arte = Arte;
+
+    Arte.prototype = {
+        __initialize: function() {
+            var newElement;
+
+            if (this.options.editorType === "richText") {
+                newElement = $("<div/>", {
+                        class: "arte-richtext",
+                        contenteditable: true
+                    })
+                    .html(this.options.value);
+            } else {
+                newElement = $("<textarea/>", {
+                        class: "arte-plaintext",
+                        style: {
+                            height: "100%",
+                            width: "100%",
+                            padding: 0,
+                            border: 0
+                        }
+                    })
+                    .val(this.options.value);
+            }
+
+            newElement
+                // Apply default style
+                .css(this.options.styles)
+                // add custom classes
+                .addClass(this.options.classes.join(" "))
+                // insert newElement to the element container
+                .appendTo(this.container);
+
+            return newElement;
+        },
+
+        /* Methods */
+
+        /**
+         * Get or Set content of the element
+         * @params {string} value string to set content of element
+         * @returns {string} returns 'innerHTML' of the contentEditable element
+         * if in rich text mode or 'value' of the element if in plaintext mode
+         */
+        value: function() {
+            if (this.__type === "plainText") {
+                return $.fn.val.apply(this.element, arguments);
+            } else {
+                return $.fn.html.apply(this.element, arguments);
+            }
+        },
+
+        /**
+         * Gets outerHtml of the element
+         * @returns {string} returns 'outerHTML' of the element
+         */
+        outerValue: function() {
+            return this.element.get(0).outerHTML;
+        },
+
+        /**
+         * Calls a focus event on the contentEditable element, moves the cursor
+         * to the end of that element, and fires an onselectionchange event
+         */
+        focus: function() {
+            var elem = this.element[0];
+            var range;
+            var sel;
+
+            this.element.trigger("focus");
+
+            // Moves the cursor to the end of the element
+            if (elem.selectionStart >= 0) {
+                // Works only on textarea elements
+                elem.selectionStart = elem.selectionEnd = elem.value.length;
+            } else if (typeof elem.createTextRange !== "undefined") {
+                // Fallback for textarea elements without support to selectionStart
+                range = elem.createTextRange();
+                range.collapse(false);
+                range.select();
+            } else if (this.__type === "richText" && document.createRange && window.getSelection) {
+                // Works only on contenteditable
+                range = document.createRange();
+                sel = window.getSelection();
+
+                while (elem.lastChild) {
+                    elem = elem.lastChild;
+                }
+                range.setStart(elem, elem.nodeValue.length);
+                range.collapse(true);
+
+                sel.removeAllRanges();
+                sel.addRange(range);
+            }
+
+            return this;
+        },
+
+        destroy: function(options) {
+            this.triggerEvent("arte-destroy");
+
+            if (options && options.removeContent) {
+                this.element.empty();
+            } else {
+                this.element.remove();
+            }
+        }
+    };
+
+});
diff --git a/src/new/arte-events.js b/src/new/arte-events.js
new file mode 100644
index 0000000..4decd5d
--- /dev/null
+++ b/src/new/arte-events.js
@@ -0,0 +1,58 @@
+jQuery(function($) {
+    $.extend(Arte.prototype, {
+        /**
+        * Triggers the event passed in on the contentEditable element with data provided
+        * @params {string} name - name of the event you want to trigger
+        * @params {object} data - extra parameters to pass into the event handler
+         */
+        triggerEvent: function() {
+            $.fn.trigger.apply(this.element, arguments);
+            return this;
+        },
+
+        on: function() {
+            $.fn.on.apply(this.element, arguments);
+        },
+
+        off: function() {
+            $.fn.off.apply(this.element, arguments);
+        },
+
+        __initEvents: function() {
+            var arte = this;
+
+            this.on("keydown keyup keypress focus", function(ev) {
+                arte.triggerEvent({
+                    type: "arte-" + ev.type,
+                    originalEvent: ev
+                });
+                ev.stopPropagation();
+            });
+
+            this.on("blur", function(ev) {
+                arte.triggerEvent("arte-selectionchange");
+                arte.triggerEvent({
+                    type: "arte-blur",
+                    originalEvent: ev
+                });
+
+                ev.stopPropagation();
+            });
+
+            this.on("mouseup", function(ev) {
+                arte.triggerEvent("arte-selectionchange");
+                arte.triggerEvent({
+                    type: "arte-mouseup",
+                    originalEvent: ev
+                });
+            });
+
+            arte.on("mousedown click paste", function(ev) {
+                arte.triggerEvent({
+                    type: "arte-" + ev.type,
+                    originalEvent: ev
+                });
+            });
+        }
+    });
+});
diff --git a/tests/all.html b/tests/all.html
index a29f9b3..4fd1e7d 100644
--- a/tests/all.html
+++ b/tests/all.html
@@ -12,9 +12,12 @@
 
     <script>
         QUnit.testSuites([
-            { name: "jQuery 1.9.1", path: "index.html?jquery=1.9.1" },
-            { name: "jQuery 1.8.3", path: "index.html?jquery=1.8.3" },
-            { name: "jQuery 1.8.3", path: "index.html?jquery=1.7.2" }
+            { name: "jQuery 2.1.3", path: "single.html?jquery=2.1.3" },
+            { name: "jQuery 1.11.2", path: "single.html?jquery=1.11.2" },
+            { name: "jQuery 1.10.2", path: "single.html?jquery=1.10.2" },
+            { name: "jQuery 1.9.1", path: "single.html?jquery=1.9.1" },
+            { name: "jQuery 1.8.3", path: "single.html?jquery=1.8.3" },
+            { name: "jQuery 1.8.3", path: "single.html?jquery=1.7.2" }
         ]);
     </script>
 </head>
diff --git a/tests/new/commands-plaintext.js b/tests/new/commands-plaintext.js
new file mode 100644
index 0000000..62e58ad
--- /dev/null
+++ b/tests/new/commands-plaintext.js
@@ -0,0 +1,209 @@
+QUnit.module("commands - plaintext", {
+    beforeEach: function() {
+        this.element = $("#test-element");
+        this.arte = new Arte(this.element);
+    }
+});
+
+QUnit.test("bold", function(t) {
+    var arte = this.arte;
+
+    arte.element.css("fontWeight", 400);
+
+    arte.bold();
+
+    // Crossbrowser support
+    var validBold = [
+        "bold", "700"
+    ];
+    t.ok(validBold.indexOf(arte.element.css("fontWeight")) >= 0);
+
+    arte.bold();
+    t.equal(arte.element.css("fontWeight"), "400");
+});
+
+QUnit.test("italic", function(t) {
+    var arte = this.arte;
+
+    arte.element.css("fontStyle", "normal");
+
+    arte.italic();
+    t.strictEqual(arte.element.css("fontStyle"), "italic");
+
+    arte.italic();
+    t.strictEqual(arte.element.css("fontStyle"), "normal");
+});
+
+QUnit.test("underline", function(t) {
+    var arte = this.arte;
+
+    arte.element.css("textDecoration", "none");
+
+    arte.underline();
+    t.strictEqual(arte.element.css("textDecoration"), "underline");
+
+    arte.underline();
+    t.strictEqual(arte.element.css("textDecoration"), "none");
+});
+
+QUnit.test("fontSize", function(t) {
+    var arte = this.arte;
+
+    arte.element.css("fontSize", "10px");
+
+    t.equal(arte.fontSize(), "10px");
+
+    arte.fontSize(20);
+    t.equal(arte.element.css("fontSize"), "20px");
+
+    arte.fontSize(15);
+    t.equal(arte.element.css("fontSize"), "15px");
+
+    t.equal(arte.fontSize(), "15px");
+});
+
+QUnit.test("fontFamily", function(t) {
+    var arte = this.arte;
+
+    arte.element.css("fontFamily", "Verdana");
+
+    t.strictEqual(arte.fontFamily(), "Verdana");
+
+    arte.fontFamily("Arial");
+    t.strictEqual(arte.element.css("fontFamily"), "Arial");
+});
+
+QUnit.test("color", function(t) {
+    var arte = this.arte;
+
+    arte.element.css("color", "#000");
+    t.strictEqual(arte.color(), "rgb(0, 0, 0)");
+
+    arte.color("#fff");
+    t.strictEqual(arte.element.css("color"), "rgb(255, 255, 255)");
+});
+
+QUnit.test("backgroundColor", function(t) {
+    var arte = this.arte;
+
+    arte.element.css("backgroundColor", "black");
+    t.strictEqual(arte.backgroundColor(), "rgb(0, 0, 0)");
+
+    arte.backgroundColor("#fff");
+    t.strictEqual(arte.element.css("backgroundColor"), "rgb(255, 255, 255)");
+});
+
+QUnit.test("unorderedList", function(t) {
+    var arte = this.arte;
+
+    t.throws(
+        function() {
+            arte.unorderedList();
+        },
+        /Can't create lists on plain text editors/,
+        "Throws and error after trying to create lists on plaintext editors"
+    );
+});
+
+QUnit.test("orderedList", function(t) {
+    var arte = this.arte;
+
+    t.throws(
+        function() {
+            arte.orderedList();
+        },
+        /Can't create lists on plain text editors/,
+        "Throws and error after trying to create lists on plaintext editors"
+    );
+});
+
+QUnit.test("textAlign", function(t) {
+    var arte = this.arte;
+
+    arte.element.css("textAlign", "center");
+    t.strictEqual(arte.textAlign(), "center");
+
+    arte.textAlign("left");
+    t.strictEqual(arte.element.css("textAlign"), "left");
+});
+
+QUnit.test("blockquote", function(t) {
+    t.throws(
+        function() {
+            this.arte.blockquote();
+        },
+        "arte.blockquote() throws an error on plain text editors"
+    );
+});
+
+QUnit.test("h1", function(t) {
+    t.throws(
+        function() {
+            this.arte.h1();
+        },
+        "arte.h1() throws an error on plain text editors"
+    );
+});
+
+QUnit.test("h2", function(t) {
+    t.throws(
+        function() {
+            this.arte.h2();
+        },
+        "arte.h2() throws an error on plain text editors"
+    );
+});
+
+QUnit.test("h3", function(t) {
+    t.throws(
+        function() {
+            this.arte.h3();
+        },
+        "arte.h3() throws an error on plain text editors"
+    );
+});
+
+QUnit.test("h4", function(t) {
+    t.throws(
+        function() {
+            this.arte.h4();
+        },
+        "arte.h4() throws an error on plain text editors"
+    );
+});
+
+QUnit.test("h5", function(t) {
+    t.throws(
+        function() {
+            this.arte.h5();
+        },
+        "arte.h5() throws an error on plain text editors"
+    );
+});
+
+QUnit.test("h6", function(t) {
+    t.throws(
+        function() {
+            this.arte.h6();
+        },
+        "arte.h6() throws an error on plain text editors"
+    );
+});
+
+QUnit.test("superscript", function(t) {
+    t.throws(
+        function() {
+            this.arte.superscript();
+        },
+        "arte.superscript() throws an error on plain text editors"
+    );
+});
+
+QUnit.test("subscript", function(t) {
+    t.throws(
+        function() {
+            this.arte.subscript();
+        },
+        "arte.subscript() throws an error on plain text editors"
+    );
+});
diff --git a/tests/new/commands-richtext.js b/tests/new/commands-richtext.js
new file mode 100644
index 0000000..9ee115b
--- /dev/null
+++ b/tests/new/commands-richtext.js
@@ -0,0 +1,149 @@
+QUnit.module("commands - richText", {
+    beforeEach: function() {
+        this.element = $("#test-element");
+        this.arte = new Arte(this.element, {
+            editorType: "richText"
+        });
+    }
+});
+
+// Commands that return tags
+var tagCommands = {
+        bold: "b",
+        italic: "i",
+        underline: "u",
+        blockquote: "blockquote",
+        h1: "h1",
+        h2: "h2",
+        h3: "h3",
+        h4: "h4",
+        h5: "h5",
+        h6: "h6"
+    };
+
+var spanCommands = {
+        fontSize: ["10px", "20px"],
+        fontFamily: ["Verdana", "monospace"],
+        color: ["rgb(0, 0, 0)", "rgb(255, 255, 255)"],
+        backgroundColor: ["rgb(255, 255, 255)", "rgb(0, 0, 0)"],
+        textAlign: ["center", "right"]
+    };
+
+$.each(tagCommands, function(command, tag) {
+    QUnit.test(command + " - no selection", function(t) {
+        var arte = this.arte;
+
+        t.expect(3);
+
+        arte.value("foo");
+
+        // TODO: set selection cursor on the last character.
+        arte[command]();
+        t.strictEqual(
+            arte.value(),
+            "foo<" + tag + "></" + tag + ">",
+            "creates " + command + " tags"
+        );
+
+        // TODO: assert cursor is inside <tag></tag>
+
+        arte[command]();
+        t.strictEqual(arte.value(), "foo", "revert " + command + " tags");
+    });
+
+    QUnit.test(command + " - selected text", function(t) {
+        var arte = this.arte;
+
+        t.expect(5);
+
+        arte.value("foo bar baz");
+
+        // TODO: select "bar "
+
+        arte[command]();
+        t.strictEqual(
+            arte.value(),
+            "foo <" + tag + ">bar </" + tag + ">baz",
+            "set " + command + " tags in selection"
+        );
+
+        // TODO: assert "<tag>bar </tag>" is now selected
+        // TODO: assert cursor position starts on previous "bar " started
+
+        // TODO: select "bar ba"
+        arte[command]();
+        t.strictEqual(
+            arte.value(),
+            "foo <" + tag + ">bar ba</" + tag + ">z",
+            "extend " + command + " tags to selection"
+        );
+
+        // expecting "<tag>bar ba</tag>" is now selected
+        arte[command]();
+        t.strictEqual(
+            arte.value(),
+            "foo bar baz",
+            "revert " + command + " tags"
+        );
+        // TODO: assert "bar ba" is now selected
+    });
+});
+
+$.each(spanCommands, function(command, values) {
+    QUnit.test(command + " - no selection", function(t) {
+        var arte = this.arte;
+
+        arte.value("foo");
+
+        arte.element.css(command, values[0]);
+        t.strictEqual(arte[command](), values[0], "return");
+
+        arte[command](values[1]);
+        t.strictEqual(arte.element.css(command), values[1], "set");
+    });
+
+    QUnit.test("fontFamily - selected text", function(t) {
+        var arte = this.arte;
+        var spanTag;
+
+        arte.value("foo bar baz");
+
+        // TODO: select "bar "
+
+        arte[command](values[0]);
+        spanTag = arte.element.find("span");
+        t.strictEqual(spanTag.length, 1, "sets a span tag");
+        t.strictEqual(spanTag.css(command), values[0]);
+        t.strictEqual(spanTag.html(), "bar ");
+
+        arte[command](values[1]);
+        spanTag = arte.element.find("span");
+        t.strictEqual(spanTag.length, 1, "keeps the span tag");
+        t.strictEqual(spanTag.css(command), values[1]);
+        t.strictEqual(spanTag.html(), "bar ");
+    });
+});
+
+QUnit.test("unorderedList", function() {
+    var arte = this.arte;
+
+    arte.unorderedList();
+});
+
+QUnit.test("orderedList", function() {
+    var arte = this.arte;
+
+    arte.orderedList();
+});
+
+QUnit.test("superscript", function() {
+    var arte = this.arte;
+
+    arte.superscript();
+});
+
+QUnit.test("subscript", function() {
+    var arte = this.arte;
+
+    arte.subscript();
+});
diff --git a/tests/new/core.js b/tests/new/core.js
new file mode 100644
index 0000000..1d42bcc
--- /dev/null
+++ b/tests/new/core.js
@@ -0,0 +1,80 @@
+QUnit.module("initialization", {
+    beforeEach: function() {
+        this.element = $("#test-element");
+    }
+});
+
+QUnit.test("basic", function(t) {
+    var arte = new Arte(this.element);
+
+    t.ok(arte.element.hasClass("arte-plaintext"));
+    t.strictEqual(arte.element.val(), "Please enter text ...", "sets default value");
+    t.strictEqual(arte.element.height(), 200, "sets basic height");
+});
+
+QUnit.test("without the new", function(t) {
+    var arte = Arte(this.element);
+
+    t.ok(arte instanceof Arte);
+});
+
+QUnit.test("multiple elements", function(t) {
+    var elem;
+    var multiple = $("<div/><div/>")
+            .addClass("foo")
+            // Appends the new elements so we get a proper height value
+            .appendTo(this.element);
+
+    var arte = Arte(multiple);
+
+    elem = multiple.first();
+
+    t.strictEqual(elem.children(arte.elem).length, 1, "Arte obj contains only the affected element");
+    t.strictEqual(arte.container.length, 1, "Arte obj contains only the affected element");
+
+    t.strictEqual(multiple.last().html(), $("<div.foo/>").html(), "Other elements than first are not affected");
+});
+
+QUnit.test("no element", function(t) {
+    var elem = $("#i-dont-exist");
+    t.throws(
+        function() {
+            Arte(elem);
+        },
+        /Arte requires a DOM element/,
+        "Arte will throw an error if it doesnt't receive an existing element"
+    );
+});
+
+QUnit.test("custom options", function(t) {
+    var arte = new Arte(this.element, {
+            styles: {
+                "height": "100px"
+            },
+
+            // Collection of classes applied to rich text editor
+            classes: ["foo"],
+
+            // Initial value of the text editor
+            value: "Custom text",
+
+            editorType: "richText"
+        });
+
+    t.ok(arte.element.attr("contenteditable"), "richText creates a contenteditable elem");
+    t.ok(arte.element.hasClass("arte-richtext"));
+    t.strictEqual(arte.element.text(), "Custom text", "sets custom text");
+    t.strictEqual(arte.element.height(), 100, "sets custom height");
+    t.ok(arte.element.hasClass("foo"), "Custom class");
+});
+
+QUnit.test("rich text initializes with a html content", function(t) {
+    var arte = new Arte(this.element, {
+            value: "<p>foo</p><div></div>",
+            editorType: "richText"
+        });
+
+    // catches <p> and <div>
+    t.strictEqual(arte.element.children().length, 2);
+    t.strictEqual(arte.element.children('p').text(), "foo");
+});
diff --git a/tests/new/events.js b/tests/new/events.js
new file mode 100644
index 0000000..f43f632
--- /dev/null
+++ b/tests/new/events.js
@@ -0,0 +1,185 @@
+QUnit.module("events", {
+    beforeEach: function() {
+        this.element = $("#test-element");
+    }
+});
+
+QUnit.test("keydown", function(t) {
+    var arte = new Arte(this.element);
+
+    t.expect(2);
+
+    arte.on("arte-keydown", function() {
+        t.ok(true, "triggered");
+    });
+
+    arte.on("keydown", function(ev) {
+        t.ok(ev.isPropagationStopped());
+    });
+
+    arte.element.trigger("keydown");
+});
+
+QUnit.test("keyup", function(t) {
+    var arte = new Arte(this.element);
+
+    t.expect(2);
+
+    arte.on("arte-keyup", function() {
+        t.ok(true, "triggered");
+    });
+
+    arte.on("keyup", function(ev) {
+        t.ok(ev.isPropagationStopped());
+    });
+
+    arte.element.trigger("keyup");
+});
+
+QUnit.test("keypress", function(t) {
+    var arte = new Arte(this.element);
+
+    t.expect(2);
+
+    arte.on("arte-keypress", function() {
+        t.ok(true, "triggered");
+    });
+
+    arte.on("keypress", function(ev) {
+        t.ok(ev.isPropagationStopped());
+    });
+
+    arte.element.trigger("keypress");
+});
+
+QUnit.test("focus", function(t) {
+    var arte = new Arte(this.element);
+
+    t.expect(2);
+
+    arte.on("arte-focus", function() {
+        t.ok(true, "triggered");
+    });
+
+    arte.on("focus", function(ev) {
+        t.ok(ev.isPropagationStopped());
+    });
+
+    arte.element.trigger("focus");
+});
+
+QUnit.test("blur", function(t) {
+    var arte = new Arte(this.element);
+
+    t.expect(3);
+
+    arte.on("arte-blur", function() {
+        t.ok(true, "triggered");
+    });
+
+    arte.on("blur", function(ev) {
+        t.ok(ev.isPropagationStopped());
+    });
+
+    arte.on("arte-selectionchange", function() {
+        t.ok(true, "triggered arte-selectionchange");
+    });
+
+    arte.element.trigger("blur");
+});
+
+QUnit.test("mouseup", function(t) {
+    var arte = new Arte(this.element);
+
+    t.expect(3);
+
+    arte.on("arte-mouseup", function() {
+        t.ok(true, "triggered");
+    });
+
+    arte.on("mouseup", function(ev) {
+        t.ok(!ev.isPropagationStopped());
+    });
+
+    arte.on("arte-selectionchange", function() {
+        t.ok(true, "triggered arte-selectionchange");
+    });
+
+    arte.element.trigger("mouseup");
+});
+
+QUnit.test("mousedown", function(t) {
+    var arte = new Arte(this.element);
+
+    t.expect(2);
+
+    arte.on("arte-mousedown", function() {
+        t.ok(true, "triggered");
+    });
+
+    arte.on("mousedown", function(ev) {
+        t.ok(!ev.isPropagationStopped());
+    });
+
+    arte.on("arte-selectionchange", function() {
+        t.ok(false, "can't trigger arte-selectionchange");
+    });
+
+    arte.element.trigger("mousedown");
+});
+
+QUnit.test("click", function(t) {
+    var arte = new Arte(this.element);
+
+    t.expect(2);
+
+    arte.on("arte-click", function() {
+        t.ok(true, "triggered");
+    });
+
+    arte.on("click", function(ev) {
+        t.ok(!ev.isPropagationStopped());
+    });
+
+    arte.on("arte-selectionchange", function() {
+        t.ok(false, "can't trigger arte-selectionchange");
+    });
+
+    arte.element.trigger("click");
+});
+
+QUnit.test("paste", function(t) {
+    var arte = new Arte(this.element);
+
+    t.expect(2);
+
+    arte.on("arte-paste", function() {
+        t.ok(true, "triggered");
+    });
+
+    arte.on("paste", function(ev) {
+        t.ok(!ev.isPropagationStopped());
+    });
+
+    arte.on("arte-selectionchange", function() {
+        t.ok(false, "can't trigger arte-selectionchange");
+    });
+
+    arte.element.trigger("paste");
+});
+
+QUnit.test("original events", function(t) {
+    var i;
+    var arte = new Arte(this.element);
+    var originalEvents = "keydown keyup keypress focus blur mouseup mousedown click paste".split(" ");
+    var event;
+    var eventCallback = function(ev) {
+            t.strictEqual(ev.originalEvent.type, event, "sends original event");
+        };
+
+    for (i = 0; i < originalEvents.length; i++) {
+        event = originalEvents[i];
+        arte.on("arte-" + event, eventCallback);
+        arte.triggerEvent(event);
+    }
+});
diff --git a/tests/new/methods.js b/tests/new/methods.js
new file mode 100644
index 0000000..9b23dfc
--- /dev/null
+++ b/tests/new/methods.js
@@ -0,0 +1,128 @@
+QUnit.module("methods", {
+    beforeEach: function() {
+        this.element = $("#test-element");
+    }
+});
+
+// value, outerValue, focus, triggerEvent, destroy, on, off
+
+QUnit.test("Arte.prototype.value - plainText", function(t) {
+    var arte = new Arte(this.element);
+
+    t.strictEqual(arte.value(), "Please enter text ...", "returns a value");
+
+    arte.value("<p><em>foo</em><span></span><br/></p>");
+
+    t.strictEqual(arte.value(), "<p><em>foo</em><span></span><br/></p>", "set a new value");
+});
+
+QUnit.test("Arte.prototype.value - richText", function(t) {
+    var arte = new Arte(this.element, {
+        editorType: "richText"
+    });
+
+    t.strictEqual(arte.value(), "Please enter text ...", "returns a value");
+
+    arte.value("<p><em>foo</em><span></span><br></p>");
+
+    t.strictEqual(arte.value(), "<p><em>foo</em><span></span><br></p>", "set a new value");
+});
+
+QUnit.test("Arte.prototype.outerValue", function(t) {
+    var arte = new Arte(this.element, {
+        editorType: "richText"
+    });
+
+    var outerHTML = arte.element[0].outerHTML;
+
+    t.strictEqual(arte.outerValue(), outerHTML, "returns an outer value");
+});
+
+QUnit.test("Arte.prototype.focus", function(t) {
+    var arte = new Arte(this.element, {
+        editorType: "richText"
+    });
+
+    arte.element
+        .blur()
+        .focus(function() {
+            t.ok(true, "focus");
+        });
+
+    t.expect(1);
+
+    arte.focus();
+
+    // TODO: test cursor position
+});
+
+QUnit.test("Arte.prototype.triggerEvent", function(t) {
+    var arte = new Arte(this.element);
+
+    t.expect(2);
+
+    arte.on("my-custom-event", function() {
+        t.ok(true, "triggered custom event");
+    });
+
+    arte.element.on("my-custom-event", function() {
+        t.ok(true, "triggered custom event on jQuery element");
+    });
+
+    arte.triggerEvent("my-custom-event");
+});
+
+QUnit.test("Arte.prototype.destroy", function(t) {
+    var arte = new Arte(this.element);
+
+    arte.on("after-destroy", function() {
+        t.ok(false, "can't trigger any event after destroying");
+    });
+
+    arte.destroy();
+
+    arte.triggerEvent("after-destroy");
+
+    t.strictEqual($(document).find(arte.element).length, 0);
+});
+
+QUnit.test("Arte.prototype.destroy - removeContent", function(t) {
+    var arte = new Arte(this.element);
+
+    t.expect(3);
+
+    arte.destroy({removeContent: true});
+
+    arte.on("after-destroy", function() {
+        t.ok(true, "just removed contents");
+    });
+
+    arte.triggerEvent("after-destroy");
+
+    t.strictEqual(this.element.find(arte.element).length, 1);
+    t.strictEqual(arte.element.html(), "");
+});
+
+QUnit.test("Arte.prototype.on", function(t) {
+    var arte = new Arte(this.element);
+
+    arte.on("custom-event", function() {
+        t.ok(true, "attachs a custom event on arte object");
+    });
+
+    arte.element.trigger("custom-event");
+});
+
+QUnit.test("Arte.prototype.off", function(t) {
+    var arte = new Arte(this.element);
+
+    t.expect(0);
+
+    arte.on("custom-event", function() {
+        t.ok(false, "dettachs a custom event on arte object");
+    });
+
+    arte.off("custom-event");
+
+    arte.element.trigger("custom-event");
+});
diff --git a/tests/single.html b/tests/single.html
new file mode 100644
index 0000000..56b1fd9
--- /dev/null
+++ b/tests/single.html
@@ -0,0 +1,76 @@
+<!doctype html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>Rich text commands unit test suite</title>
+
+    <script>
+        (function() {
+            var item, i, script,
+                source = "dependencies/jquery-1.11.2",
+                parts = location.search
+                    .substr(1)
+                    .split("&");
+
+            for (i = 0; i < parts.length; i++) {
+                item = parts[i].split("=");
+                if (item[0] === "jquery" && item[1]) {
+                    source = "dependencies/jquery-" + item[1];
+                    break;
+                }
+            }
+
+            source += ".js";
+
+            document.write( "<script src='" + source + "'><" + "/script>" );
+        })();
+    </script>
+
+    <!--Test Infrastructure-->
+    <link href="dependencies/QUnit/qunit.css" rel="stylesheet" type="text/css" />
+    <script src="dependencies/QUnit/qunit.js" type="text/javascript"></script>
+
+    <!--Files To Test-->
+    <script src="../src/new/arte-core.js"></script>
+    <script src="../src/new/arte-events.js"></script>
+    <script src="../src/new/arte-commands.js"></script>
+    <!--<script src="../src/new/arte-configuration.js"></script>-->
+
+    <!-- End of files being tested !-->
+
+    <script src="new/core.js"></script>
+    <script src="new/methods.js"></script>
+    <script src="new/events.js"></script>
+    <script src="new/commands-plaintext.js"></script>
+    <script src="new/commands-richtext.js"></script>
+
+    <!-- playground --><!--
+
+    <style>
+
+    .arte-plaintext:focus {
+        background:yellow;
+    }
+
+    </style>
+
+    <script>
+    $(function($) {
+    arte = Arte("#test-element", { editorType: "richText" });
+
+    arte.element.append("<div>foo</div>");
+    })
+    </script>
+
+    <a href="#" onclick="javascript:arte.focus();">click</a>-->
+
+</head>
+<body>
+    <div id="qunit"></div>
+
+    <div id="qunit-fixture">
+        <!-- If you need to do DOM manipulation, do it in this element !-->
+        <div id="test-element"></div>
+    </div>
+</body>
+</html>