diff --git a/lib/defaultValue.js b/lib/defaultValue.js
new file mode 100644
index 00000000..a521aa85
--- /dev/null
+++ b/lib/defaultValue.js
@@ -0,0 +1,152 @@
+var genFunc = require('generate-function');
+var genObj = require('generate-object-property');
+var util = require(__dirname+'/util.js');
+
+function schemaTreeHasDefault(schema, isVirtual) {
+    var nodeType, subSchema;
+    var schemaKeys = Object.keys(schema);
+
+    for (var i=0;i<schemaKeys.length;i++) {
+        var key = schemaKeys[i];
+        var node = schema[key];
+
+        nodeType = util.getType(node);
+        if ((nodeType === "virtual") === isVirtual && node.default !== undefined) {
+            return true;
+        }
+        else if (nodeType === Array || Array.isArray(node)) {
+            subSchema = util.getSchema(node);
+            if (subSchema) {
+                return schemaTreeHasDefault(subSchema, isVirtual);
+            }
+        }
+        else if (nodeType === Object || util.isSchema(node)) {
+            subSchema = util.getSchema(node);
+            if (subSchema) {
+                return schemaTreeHasDefault(subSchema, isVirtual);
+            }
+        }
+    }
+    return false;
+}
+
+function visit(fill, key, node, path, isVirtual, fillContext) {
+    var nodeType = util.getType(node);
+    path = key === "[i]" ? path + key : genObj(path, key);
+    var field = "doc" + path;
+    var subSchema;
+
+    if ((nodeType === "virtual") === isVirtual && (node._type !== undefined)) {
+        if (node.default !== undefined) {
+            if (!isVirtual) {
+                fill("if (%s === undefined) {", field);
+            }
+
+            var defaultValue = node.default;
+            var defaultType = typeof defaultValue;
+
+            if (defaultType === "number" || defaultType === "boolean") {
+                fill("%s = %s;", field, defaultValue.toString());
+            }
+            else if (defaultType === "function") {
+                fillContext.defaults[path] = defaultValue;
+                if (node.default._r === undefined) {
+                    fill('%s = defaults["%s"].apply(doc);', field, path);
+                }
+                else {
+                    fill('%s = defaults["%s"];', field, path);
+                }
+            }
+            else if (defaultType === "string") {
+                fillContext.defaults[path] = defaultValue;
+                fill('%s = defaults["%s"];', field, path);
+            }
+            else {
+                fillContext.defaults[path] = defaultValue;
+                fill('%s = util.deepCopy(defaults["%s"])', field, path);
+            }
+
+            if (!isVirtual) {
+                fill("}");
+            }
+        }
+        else if (isVirtual) {
+            fill("if (util.isPlainObject(virtuals) && (%s !== undefined)) %s = %s",
+                genObj("virtuals", key),
+                field,
+                genObj("virtuals", key));
+        }
+    }
+
+    if (nodeType === Array || Array.isArray(node)) {
+        subSchema = util.getSchema(node);
+        if (subSchema && schemaTreeHasDefault(subSchema, isVirtual)) {
+            if (isVirtual) {
+                fill("virtuals = util.isPlainObject(virtuals) ? %s : undefined;", genObj("virtuals", key));
+                fill("virtualStack.push(virtuals);");
+            }
+
+            fill("if (Array.isArray(%s)) {", field);
+            fill("for (var i=0;i<%s.length;i++) {", field);
+            visit(fill, "[i]", subSchema, path, isVirtual, fillContext);
+            fill("}");
+            fill("}");
+
+            if (isVirtual) {
+                fill("virtualStack.pop();");
+                fill("virtuals = virtualStack[virtualStack.length - 1];");
+            }
+        }
+    }
+    else if (nodeType === Object || util.isSchema(node)) {
+        subSchema = util.getSchema(node);
+        if (subSchema && schemaTreeHasDefault(subSchema, isVirtual)) {
+            if (isVirtual) {
+                fill("virtuals = util.isPlainObject(virtuals) ? %s : undefined;", genObj("virtuals", key));
+                fill("virtualStack.push(virtuals);");
+            }
+
+            fill("if (util.isPlainObject(%s)) {", field);
+            var subKeys = Object.keys(subSchema);
+            for (var i=0;i<subKeys.length;i++) {
+                var subKey = subKeys[i];
+                var subNode = subSchema[subKey];
+
+                visit(fill, subKey, subNode, path, isVirtual, fillContext);
+            }
+            fill("}");
+
+            if (isVirtual) {
+                fill("virtualStack.pop();");
+                fill("virtuals = virtualStack[virtualStack.length - 1];");
+            }
+        }
+    }
+}
+
+var compile = module.exports = function (name, schema, isVirtual) {
+    if (isVirtual) {
+        var fill =  genFunc()("function _fillVirtualValue_%s(doc, virtuals) {",  name)
+        ("var virtualStack = [virtuals];");
+    }
+    else {
+        var fill = genFunc()("function _fillDefaultValue_%s(doc) {", name);
+    }
+
+    var schemaKeys = Object.keys(schema);
+    var fillContext = {
+        util: util,
+        defaults: {}
+    };
+
+    for (var i=0;i<schemaKeys.length;i++) {
+        var key = schemaKeys[i];
+        var node = schema[key];
+
+        visit(fill, key, node, "", isVirtual, fillContext);
+    }
+
+    fill("}");
+
+    return fill.toFunction(fillContext);
+};
diff --git a/lib/document.js b/lib/document.js
index 17949024..0cdfea3e 100644
--- a/lib/document.js
+++ b/lib/document.js
@@ -122,162 +122,16 @@ Document.prototype._getVirtual = function() {
 // Generate the virtual values
 // This should be called AFTER _generateDefault
 Document.prototype.generateVirtualValues = function() {
-    var self = this;
-    var doc = self;
-    var schema = self._getModel()._schema;
-    var options = self._getModel().getOptions();
-
-    self._generateVirtualValues(self, schema, self, self._getVirtual());
+    this._getModel().__fillVirtual(this, this._getVirtual());
 }
 
-
-Document.prototype._generateVirtualValues = function(doc, schema, originalDoc, virtual) {
-    var nextVirtual;
-    // We need this check because the document may not be defined while the schema is
-    if (util.isPlainObject(doc)) {
-
-        for(var key in schema) {
-            if (util.isPlainObject(schema[key]) && (schema[key]._type === 'virtual')) {
-                if (typeof schema[key].default === "function") {
-                    if (schema[key].default._r === undefined) {
-                        doc[key] = schema[key].default.apply(originalDoc);
-                    }
-                    else {
-                        // TODO Improve this condition?
-                        // This is a ReQL term
-                        doc[key] = schema[key].default;
-                    }
-                }
-                else if (schema[key].default !== undefined) {
-                    doc[key] = util.deepCopy(schema[key].default);
-                }
-                else if (util.isPlainObject(virtual) && (virtual[key] !== undefined)) {
-                    doc[key] = virtual[key];
-                }
-            }
-
-            // Recurse in objects and array
-            if ((util.isPlainObject(schema[key])) && (schema[key]._type === undefined)) {
-                nextVirtual = util.isPlainObject(virtual) ? virtual[key] : undefined;
-                Document.prototype._generateVirtualValues(doc[key], schema[key], originalDoc, nextVirtual)
-            }
-            else if ((util.isPlainObject(schema[key])) && (schema[key]._type === Object)) {
-                if (util.isPlainObject(doc[key])) {
-                    nextVirtual = util.isPlainObject(virtual) ? virtual[key] : undefined;
-                    Document.prototype._generateVirtualValues(doc[key], schema[key].schema, originalDoc, nextVirtual)
-                }
-            }
-            else if ((util.isPlainObject(schema[key])) && (schema[key]._type === Array)) {
-                for(var i = 0; i<doc[key].length; i++) {
-                    if ((util.isPlainObject(virtual)) && (Array.isArray(virtual[key]))) {
-                        nextVirtual = virtual[key][i];
-                    }
-                    else {
-                        nextVirtual = undefined;
-                    }
-
-                    if ((util.isPlainObject(schema[key].schema)) && (schema[key].schema._type === undefined)) {
-                        Document.prototype._generateVirtualValues(doc[key][i], schema[key].schema, originalDoc, nextVirtual)
-                    }
-                    else if ((util.isPlainObject(schema[key].schema)) && (schema[key].schema._type === Object)) {
-                        Document.prototype._generateVirtualValues(doc[key][i], schema[key].schema.schema, originalDoc, nextVirtual)
-                    }
-                }
-            }
-            else if (Array.isArray(schema[key])) {
-                if (Array.isArray(doc[key])) {
-                    for(var i = 0; i<doc[key].length; i++) {
-                        if ((util.isPlainObject(virtual)) && (Array.isArray(virtual[key]))) {
-                            nextVirtual = virtual[key][i];
-                        }
-                        else {
-                            nextVirtual = undefined;
-                        }
-
-                        if ((util.isPlainObject(schema[key][0])) && (schema[key][0]._type === undefined)) {
-                            Document.prototype._generateVirtualValues(doc[key][i], schema[key][0], originalDoc, nextVirtual)
-                        }
-                        else if ((util.isPlainObject(schema[key][0])) && (schema[key][0]._type === Object)) {
-                            Document.prototype._generateVirtualValues(doc[key][i], schema[key][0].schema, originalDoc, nextVirtual)
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return doc;
-}
-
-
 // Generate the default values for all the fields, except virtual ones
 // Virtual fields are generated by `Document.prototype.generateVirtualValues`
 Document.prototype._generateDefault = function() {
-    var schema = this._getModel()._schema;
-
-    this.__generateDefault(this, schema, this);
+    this._getModel().__fillDefault(this);
     this.generateVirtualValues();
 }
 
-Document.prototype.__generateDefault = function(doc, schema, originalDoc) {
-    // We need this check because the document may not be defined while the schema is
-    if (util.isPlainObject(doc)) {
-
-        for(var key in schema) {
-            // Generate values for undefined fields
-            if (doc[key] === undefined) {
-                // virtual are generated later by generateDefault
-                if (util.isPlainObject(schema[key]) && (schema[key]._type !== undefined) && ((schema[key]._type !== 'virtual'))) {
-                    if (typeof schema[key].default === "function") {
-                        if (schema[key].default._r === undefined) {
-                            doc[key] = schema[key].default.apply(originalDoc);
-                        }
-                        else {
-                            doc[key] = schema[key].default;
-                        }
-                    }
-                    else if (schema[key].default !== undefined) {
-                        doc[key] = util.deepCopy(schema[key].default);
-                    }
-                }
-            }
-
-            // Recurse in objects and array
-            if ((util.isPlainObject(schema[key])) && (schema[key]._type === undefined)) {
-                Document.prototype.__generateDefault(doc[key], schema[key], originalDoc)
-            }
-            else if ((util.isPlainObject(schema[key])) && (schema[key]._type === Object)) {
-                if (util.isPlainObject(doc[key])) {
-                    Document.prototype.__generateDefault(doc[key], schema[key].schema, originalDoc)
-                }
-            }
-            else if ((util.isPlainObject(schema[key])) && (schema[key]._type === Array)) {
-                for(var i = 0; i<doc[key].length; i++) {
-                    if ((util.isPlainObject(schema[key].schema)) && (schema[key].schema._type === undefined)) {
-                        Document.prototype.__generateDefault(doc[key][i], schema[key].schema, originalDoc)
-                    }
-                    else if ((util.isPlainObject(schema[key].schema)) && (schema[key].schema._type === Object)) {
-                        Document.prototype.__generateDefault(doc[key][i], schema[key].schema.schema, originalDoc)
-                    }
-                }
-            }
-            else if (Array.isArray(schema[key])) {
-                if (Array.isArray(doc[key])) {
-                    for(var i = 0; i<doc[key].length; i++) {
-                        if ((util.isPlainObject(schema[key][0])) && (schema[key][0]._type === undefined)) {
-                            Document.prototype.__generateDefault(doc[key][i], schema[key][0], originalDoc)
-                        }
-                        else if ((util.isPlainObject(schema[key][0])) && (schema[key][0]._type === Object)) {
-                            Document.prototype.__generateDefault(doc[key][i], schema[key][0].schema, originalDoc)
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return doc;
-}
-
-
 /*
  * Validate the schema
  * 
@@ -323,7 +177,7 @@ Document.prototype._validate = function(options, modelToValidate, validateAll, v
 
             // Validate this document
             util.tryCatch(function() {
-                self.__validate(self, schema, prefix, docOptions, self);
+                self._getModel().__doc_validator(self, prefix, docOptions);
             }, function(err) {
                 error = err;
             });
@@ -395,358 +249,6 @@ Document.prototype._validate = function(options, modelToValidate, validateAll, v
     })
 }
 
-var types = [
-    ['string', String],
-    ['number', Number],
-    ['boolean', Boolean]
-]
-
-// The schema doesn't contain joined docs
-Document.prototype.__validate = function(doc, schema, prefix, options, originalDoc) {
-    //TODO: Why do we pass doc here?
-
-    var typeOf, className, key
-
-    // We need a deepcopy because we are going to pass the options around and overwrite them
-    var localOptions = util.deepCopy(options)
-
-    /*
-    // An element in an array can never be undefined because RethinkDB doesn't support such type
-    */
-    var fieldChecked = false;
-    
-    // Set the local settings
-    if (util.isPlainObject(schema) && (schema._type !== undefined) && (util.isPlainObject(schema.options))) {
-        localOptions.enforce_missing = (schema.options.enforce_missing != null) ? schema.options.enforce_missing : localOptions.enforce_missing;
-        localOptions.enforce_type = (schema.options.enforce_type != null) ? schema.options.enforce_type : localOptions.enforce_type;
-        localOptions.enforce_extra = (schema.options.enforce_extra != null) ? schema.options.enforce_extra : localOptions.enforce_extra;
-    }
-    else {
-        localOptions.enforce_missing = localOptions.enforce_missing;
-        localOptions.enforce_type = localOptions.enforce_type;
-        localOptions.enforce_extra = localOptions.enforce_extra;
-    }
-
-    // Check for primitives - bool, number, string
-    for(var i=0; i<types.length; i++) {
-        if (fieldChecked) break;
-
-        typeOf = types[i][0]; // "string", "number", "boolean"
-        className = types[i][1]; // String, Number, Boolean
-
-        if (schema === className) {
-            fieldChecked = true;
-
-            if (doc === undefined) {
-                if (localOptions.enforce_missing === true) {
-                    util.undefinedField(prefix);
-                }
-            }
-            else if (doc === null) {
-                if (localOptions.enforce_type === "strict") {
-                    util.strictType(prefix, typeOf);
-                }
-            }
-            else if (typeof doc !== typeOf) { // doc is not null/undefined
-                if (localOptions.enforce_type === "strict") {
-                    util.strictType(prefix, typeOf);
-                }
-                else if (localOptions.enforce_type === "loose") {
-                    util.looseType(prefix, typeOf);
-                }
-            }
-        }
-        else if (util.isPlainObject(schema) && (schema._type === className)) {
-            fieldChecked = true;
-            if (typeof schema.validator === 'function') {
-                if (schema.validator(doc) === false) {
-                    throw new Error("Validator for the field "+prefix+" returned `false`.");
-                }
-            }
-            if (doc === undefined) {
-                if (localOptions.enforce_missing === true) {
-                    util.undefinedField(prefix);
-                }
-            }
-            else if (doc === null) {
-                if (localOptions.enforce_type === "strict") {
-                    util.strictType(prefix, typeOf);
-                }
-            }
-            else if (typeof doc !== typeOf) {
-                if (localOptions.enforce_type === "strict") {
-                    util.strictType(prefix, typeOf);
-                }
-                else if (localOptions.enforce_type === "loose") {
-                    util.looseType(prefix, typeOf);
-                }
-
-            }
-            else if (Array.isArray(schema.enum) && (util.isPlainObject(schema._enum))) {
-                if (schema._enum[doc] !== true) {
-                    var validValues = Object.keys(schema._enum);
-                    var message = "The field "+prefix+" must be one of these values: "
-
-                    for(var i=0; i<validValues.length; i++) {
-                        if (i === 10) { break; }
-                        if ((i === validValues.length-1) || (i === 9)) {
-                            message = message+validValues[i]
-                        }
-                        else {
-                            message = message+validValues[i]+", "
-                        }
-                    }
-                    if (validValues.length > 10) {
-                        message = message+"..."
-                    }
-                    else {
-                        message = message+"."
-                    }
-
-                    throw new Error(message);
-                }
-            }
-        }
-    }
-    if (fieldChecked === false) { // The field is not a primitive, let's keep looking
-        if ((schema === Date) || (util.isPlainObject(schema) && schema._type === Date)) {
-            if ((util.isPlainObject(schema)) && (typeof schema.validator === 'function')) {
-                if (schema.validator(doc) === false) {
-                    throw new Error("Validator for the field "+prefix+"[key] returned `false`.")
-                }
-            }
-
-            if (doc === undefined) {
-                if (localOptions.enforce_missing === true) {
-                    util.undefinedField(prefix);
-                }
-            }
-            else if (doc === null) {
-                if (localOptions.enforce_type === "strict") {
-                    util.strictType(prefix, "date");
-                }
-            }
-            else if (localOptions.enforce_type !== "none") {
-                if (util.isPlainObject(doc) && (doc["$reql_type$"] === "TIME")) {
-                    if (doc.epoch_time === undefined) {
-                        util.pseudoTypeError("date", "epoch_time", prefix);
-                    }
-                    else if (doc.timezone === undefined) {
-                        util.pseudoTypeError("date", "timezone", prefix);
-                    }
-                }
-                else if ((typeof doc === 'function') && (Array.isArray(doc._query))) {
-                    // TOIMPROvE -- we currently just check if it's a term from the driver
-                    // We suppose for now that this is enough and we don't throw an error
-                }
-                else if (typeof doc === 'string') {
-                    var date = new Date(doc);
-                    if (date.getTime() !== date.getTime()) {
-                        if (localOptions.enforce_type === "strict") {
-                            util.strictType(prefix, "date or a valid string");
-                        }
-                        else if (localOptions.enforce_type !== "none") {
-                            util.looseType(prefix, "date or a valid string");
-                        }
-                    }
-                }
-                else if ((doc instanceof Date) === false)  {
-                    if (localOptions.enforce_type === "strict") {
-                        util.strictType(prefix, "date");
-                    }
-                    else if (localOptions.enforce_type !== "none") {
-                        util.looseType(prefix, "date");
-                    }
-                }
-            }
-        }
-        else if ((schema === 'Point') || (util.isPlainObject(schema) && schema._type === 'Point')) {
-            if ((util.isPlainObject(schema)) && (typeof schema.validator === 'function')) {
-                if (schema.validator(doc) === false) {
-                    throw new Error("Validator for the field "+prefix+"[key] returned `false`.")
-                }
-            }
-
-            if (doc === undefined) {
-                if (localOptions.enforce_missing === true) {
-                    util.undefinedField(prefix);
-                }
-            }
-            else if (doc === null) {
-                if (localOptions.enforce_type === "strict") {
-                    util.strictType(prefix, "date");
-                }
-            }
-            else if (localOptions.enforce_type !== "none") {
-                if (util.isPlainObject(doc) && (doc["$reql_type$"] === "GEOMETRY")) {
-                    if (doc.type === undefined) {
-                        util.pseudoTypeError("Point", "type", prefix);
-                    }
-                    else if (doc.type !== "Point") {
-                        throw new Error("The field `type` for "+prefix+" must be `'Point'`.")
-                    }
-                    else if (doc.coordinates === undefined) {
-                        util.pseudoTypeError("date", "coordinates", prefix);
-                    }
-                    else if ((!Array.isArray(doc.coordinates)) || (doc.coordinates.length !== 2)) {
-                        throw new Error("The field `coordinates` for "+prefix+" must be an Array of two numbers.")
-                    }
-                }
-                else if (util.isPlainObject(doc) && (doc.type === "Point") && (Array.isArray(doc.coordinates)) && (doc.coordinates.length === 2)) { // Geojson
-                    // Geojson format
-                }
-                else if ((typeof doc === 'function') && (Array.isArray(doc._query))) {
-                    // TOIMPROvE -- we currently just check if it's a term from the driver
-                    // We suppose for now that this is enough and we don't throw an error
-                }
-                else if (util.isPlainObject(doc)) {
-                    var keys = Object.keys(doc).sort();
-                    if (((keys.length !== 2) || keys[0] !== 'latitude') || (keys[1] !== 'longitude') || (typeof doc.latitude !== "number") || (typeof doc.longitude !== "number")) {
-                        throw new Error("The value for "+prefix+" must be a ReQL Point (`r.point(<longitude>, <latitude>)`), an object `{longitude: <number>, latitude: <number>}`, or an array [<longitude>, <latitude>].")
-                    }
-                    else if ((typeof doc.latitude !== 'number') || (typeof doc.latitude !== 'number')) {
-                        throw new Error("The value for "+prefix+" must be a ReQL Point (`r.point(<longitude>, <latitude>)`), an object `{longitude: <number>, latitude: <number>}`, or an array [<longitude>, <latitude>].")
-                    }
-                }
-                else if (Array.isArray(doc)) {
-                    if ((doc.length !== 2) || (typeof doc[0] !== "number") || (typeof doc[1] !== "number")) {
-                        throw new Error("The value for "+prefix+" must be a ReQL Point (`r.point(<longitude>, <latitude>)`), an object `{longitude: <number>, latitude: <number>}`, or an array [<longitude>, <latitude>].")
-                    }
-                }
-            }
-        }
-
-        else if ((schema === Buffer) || (util.isPlainObject(schema) && schema._type === Buffer)) {
-            if ((util.isPlainObject(schema)) && (typeof schema.validator === 'function')) {
-                if (schema.validator(doc) === false) {
-                    throw new Error("Validator for the field "+prefix+"[key] returned `false`.")
-                }
-            }
-
-            if (doc === undefined) {
-                if (localOptions.enforce_missing === true) {
-                    util.undefinedField(prefix);
-                }
-            }
-            else if (doc === null) {
-                if (localOptions.enforce_type === "strict") {
-                    util.strictType(prefix, "date");
-                }
-            }
-            else if (util.isPlainObject(doc) && (doc["$reql_type$"] === "BINARY")) {
-                if (doc.data === undefined) {
-                    util.pseudoTypeError("binary", "data", prefix);
-                }
-            }
-            else if ((typeof doc === 'function') && (Array.isArray(doc._query))) {
-                // TOIMPROvE -- we currently just check if it's a term from the driver
-                // We suppose for now that this is enough and we don't throw an error
-            }
-            else if ((doc instanceof Buffer) === false)  {
-                if (localOptions.enforce_type === "strict") {
-                    util.strictType(prefix, "buffer");
-                }
-                else if (localOptions.enforce_type !== "none") {
-                    util.looseType(prefix, "buffer");
-                }
-            }
-        }
-        else if (Array.isArray(schema) || (util.isPlainObject(schema) && schema._type === Array)) {
-            if (doc === undefined) {
-                if (localOptions.enforce_missing === true) {
-                    util.undefinedField(prefix);
-                }
-            }
-            else if (doc === null) {
-                if (localOptions.enforce_type === "strict") {
-                    util.strictType(prefix, "array");
-                }
-            }
-            else if (Array.isArray(doc)) {
-                for(var i=0; i<doc.length; i++) {
-                    if (doc[i] === undefined) {
-                        throw new Error("The element in the array "+prefix+" (position "+i+") cannot be `undefined`.");
-                    }
-
-                    if (Array.isArray(schema)) {
-                        Document.prototype.__validate(doc[i], schema[0], prefix+'['+i+']', localOptions, originalDoc)
-                    }
-                    else {
-                        Document.prototype.__validate(doc[i], schema.schema, prefix+'['+i+']', localOptions, originalDoc)
-                    }
-                }
-            }
-            else {
-                if (localOptions.enforce_type === "strict") {
-                    util.strictType(prefix, "array");
-                }
-                else if (localOptions.enforce_type === "loose") {
-                    util.looseType(prefix, "array");
-                }
-            }
-        }
-        else if (util.isPlainObject(schema) && schema._type === 'virtual') {
-            // Since virtual fields are not saved, we do not enforce anything here
-        }
-        else if (util.isPlainObject(schema)) {
-            if (typeof schema.validator === 'function') {
-                if (schema.validator(doc) === false) {
-                    throw new Error("Validator for the field "+prefix+"[key] returned `false`.")
-                }
-            }
-
-            if (doc === undefined) {
-                if (localOptions.enforce_missing === true) {
-                    util.undefinedField(prefix);
-                }
-            }
-            else if (doc === null) {
-                if (localOptions.enforce_type === "strict") {
-                    util.strictType(prefix, "object");
-                }
-            }
-            else if (util.isPlainObject(doc)) {
-                if (schema._type !== undefined) {
-                    for(var key in schema.schema) {
-                        Document.prototype.__validate(doc[key], schema.schema[key], prefix+'['+key+']', localOptions, originalDoc)
-                    }
-                }
-                else {
-                    for(var key in schema) {
-                        Document.prototype.__validate(doc[key], schema[key], prefix+'['+key+']', localOptions, originalDoc)
-                    }
-                }
-            }
-            else {
-                if (localOptions.enforce_type === "strict") {
-                    util.strictType(prefix, "object");
-                }
-                else if (localOptions.enforce_type === "loose") {
-                    util.looseType(prefix, "object");
-                }
-            }
-        }
-    }
-
-
-    //if localOptions.enforce_extra is true or "remove", we may have work to do
-    if ((localOptions.enforce_extra !== "none")) {
-        for(var key in doc) {
-            if (((doc._getModel == null) || (doc._getModel()._joins.hasOwnProperty(key) === false)) && (doc.hasOwnProperty(key)) &&
-                (util.isPlainObject(schema) && (schema._type === undefined) && (schema.hasOwnProperty(key) === false))
-                || (util.isPlainObject(schema) && (schema._type === Object) && (util.isPlainObject(schema.schema)) && (schema.schema.hasOwnProperty(key) === false))) {
-
-                if (localOptions.enforce_extra === 'remove') {
-                    delete doc[key]
-                }
-                else if (localOptions.enforce_extra === 'strict') {
-                    util.extraField(prefix, key);
-                }
-            }
-        }
-    }
-}
-
 Document.prototype.save = function(callback) {
     var self = this;
 
diff --git a/lib/model.js b/lib/model.js
index ec8e86ff..99585209 100644
--- a/lib/model.js
+++ b/lib/model.js
@@ -3,6 +3,8 @@ var Document = require(__dirname+'/document.js');
 var EventEmitter = require('events').EventEmitter;
 var Query = require(__dirname+'/query.js');
 var Promise = require('bluebird');
+var validator = require(__dirname+'/validator.js');
+var fillDefault = require(__dirname+'/defaultValue.js');
 
 /*
  * document -> {} -> Document.prototype <-cp- model -> Model.prototype
@@ -191,8 +193,11 @@ Model.new = function(name, schema, options, thinky) {
         })(key)
     }
 
+    proto.__doc_validator = validator(name, schema);
+    proto.__fillDefault = fillDefault(name, schema, false);
+    proto.__fillVirtual = fillDefault(name, schema, true);
 
-    return model
+    return model;
 }
 
 Model.prototype.isReady = function() {
diff --git a/lib/util.js b/lib/util.js
index 5120d43c..db0cad3a 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -265,4 +265,30 @@ function _hook(options) {
 }
 util.hook = hook;
 
+util.getType = function (schema) {
+    if (util.isPlainObject(schema) && schema._type){
+        return schema._type;
+    }
+    else {
+        return schema;
+    }
+}
+
+util.isSchema = function (object) {
+    return util.isPlainObject(object) && object._type === undefined;
+}
+
+util.getSchema = function (node) {
+    if (util.getType(node) === Object || util.getType(node) === Array) {
+        return node.schema;
+    }
+    else if (Array.isArray(node)) {
+        return util.getSchema(node[0]);
+    }
+    else {
+        return node;
+    }
+}
+
+
 module.exports = util;
diff --git a/lib/validator.js b/lib/validator.js
new file mode 100644
index 00000000..1fd8bce4
--- /dev/null
+++ b/lib/validator.js
@@ -0,0 +1,402 @@
+var genFunc = require('generate-function');
+var genObj = require('generate-object-property');
+var util = require(__dirname+'/util.js');
+
+
+function validatePrimitive(doc, localOptions, typeOf, prefix, Enum, _Enum) {
+    if (doc === undefined) {
+        if (localOptions.enforce_missing === true) {
+            util.undefinedField(prefix);
+        }
+    }
+    else if (doc === null) {
+        if (localOptions.enforce_type === "strict") {
+            util.strictType(prefix, typeOf);
+        }
+    }
+    else if (typeof doc !== typeOf) { // doc is not null/undefined
+        if (localOptions.enforce_type === "strict") {
+            util.strictType(prefix, typeOf);
+        }
+        else if (localOptions.enforce_type === "loose") {
+            util.looseType(prefix, typeOf);
+        }
+    }
+    else if (Enum && _Enum) {
+        if (_Enum[doc] !== true) {
+            var validValues = Object.keys(_Enum);
+            var message = "The field "+prefix+" must be one of these values: ";
+
+            for(var i=0; i<validValues.length; i++) {
+                if (i === 10) { break; }
+                if ((i === validValues.length-1) || (i === 9)) {
+                    message = message+validValues[i];
+                }
+                else {
+                    message = message+validValues[i]+", ";
+                }
+            }
+            if (validValues.length > 10) {
+                message = message+"...";
+            }
+            else {
+                message = message+".";
+            }
+
+            throw new Error(message);
+        }
+    }
+}
+
+function validateDate(doc, localOptions, prefix) {
+    if (doc === undefined) {
+        if (localOptions.enforce_missing === true) {
+            util.undefinedField(prefix);
+        }
+    }
+    else if (doc === null) {
+        if (localOptions.enforce_type === "strict") {
+            util.strictType(prefix, "date");
+        }
+    }
+    else if (localOptions.enforce_type !== "none") {
+        if (util.isPlainObject(doc) && (doc["$reql_type$"] === "TIME")) {
+            if (doc.epoch_time === undefined) {
+                util.pseudoTypeError("date", "epoch_time", prefix);
+            }
+            else if (doc.timezone === undefined) {
+                util.pseudoTypeError("date", "timezone", prefix);
+            }
+        }
+        else if ((typeof doc === 'function') && (Array.isArray(doc._query))) {
+            // TOIMPROvE -- we currently just check if it's a term from the driver
+            // We suppose for now that this is enough and we don't throw an error
+        }
+        else if (typeof doc === 'string') {
+            var date = new Date(doc);
+            if (date.getTime() !== date.getTime()) {
+                if (localOptions.enforce_type === "strict") {
+                    util.strictType(prefix, "date or a valid string");
+                }
+                else if (localOptions.enforce_type !== "none") {
+                    util.looseType(prefix, "date or a valid string");
+                }
+            }
+        }
+        else if ((doc instanceof Date) === false)  {
+            if (localOptions.enforce_type === "strict") {
+                util.strictType(prefix, "date");
+            }
+            else if (localOptions.enforce_type !== "none") {
+                util.looseType(prefix, "date");
+            }
+        }
+    }
+}
+
+function validateBuffer(doc, localOptions, prefix) {
+    if (doc === undefined) {
+        if (localOptions.enforce_missing === true) {
+            util.undefinedField(prefix);
+        }
+    }
+    else if (doc === null) {
+        if (localOptions.enforce_type === "strict") {
+            util.strictType(prefix, "date");
+        }
+    }
+    else if (util.isPlainObject(doc) && (doc["$reql_type$"] === "BINARY")) {
+        if (doc.data === undefined) {
+            util.pseudoTypeError("binary", "data", prefix);
+        }
+    }
+    else if ((typeof doc === 'function') && (Array.isArray(doc._query))) {
+        // TOIMPROvE -- we currently just check if it's a term from the driver
+        // We suppose for now that this is enough and we don't throw an error
+    }
+    else if ((doc instanceof Buffer) === false)  {
+        if (localOptions.enforce_type === "strict") {
+            util.strictType(prefix, "buffer");
+        }
+        else if (localOptions.enforce_type !== "none") {
+            util.looseType(prefix, "buffer");
+        }
+    }
+}
+
+function validatePoint(doc, localOptions, prefix) {
+    if (doc === undefined) {
+        if (localOptions.enforce_missing === true) {
+            util.undefinedField(prefix);
+        }
+    }
+    else if (doc === null) {
+        if (localOptions.enforce_type === "strict") {
+            util.strictType(prefix, "date");
+        }
+    }
+    else if (localOptions.enforce_type !== "none") {
+        if (util.isPlainObject(doc) && (doc["$reql_type$"] === "GEOMETRY")) {
+            if (doc.type === undefined) {
+                util.pseudoTypeError("Point", "type", prefix);
+            }
+            else if (doc.type !== "Point") {
+                throw new Error("The field `type` for "+prefix+" must be `'Point'`.");
+            }
+            else if (doc.coordinates === undefined) {
+                util.pseudoTypeError("date", "coordinates", prefix);
+            }
+            else if ((!Array.isArray(doc.coordinates)) || (doc.coordinates.length !== 2)) {
+                throw new Error("The field `coordinates` for "+prefix+" must be an Array of two numbers.");
+            }
+        }
+        else if (util.isPlainObject(doc) && (doc.type === "Point") && (Array.isArray(doc.coordinates)) && (doc.coordinates.length === 2)) { // Geojson
+            // Geojson format
+        }
+        else if ((typeof doc === 'function') && (Array.isArray(doc._query))) {
+            // TOIMPROvE -- we currently just check if it's a term from the driver
+            // We suppose for now that this is enough and we don't throw an error
+        }
+        else if (util.isPlainObject(doc)) {
+            var keys = Object.keys(doc).sort();
+            if (((keys.length !== 2) || keys[0] !== 'latitude') || (keys[1] !== 'longitude') || (typeof doc.latitude !== "number") || (typeof doc.longitude !== "number")) {
+                throw new Error("The value for "+prefix+" must be a ReQL Point (`r.point(<longitude>, <latitude>)`), an object `{longitude: <number>, latitude: <number>}`, or an array [<longitude>, <latitude>].")
+            }
+            else if ((typeof doc.latitude !== 'number') || (typeof doc.latitude !== 'number')) {
+                throw new Error("The value for "+prefix+" must be a ReQL Point (`r.point(<longitude>, <latitude>)`), an object `{longitude: <number>, latitude: <number>}`, or an array [<longitude>, <latitude>].")
+            }
+        }
+        else if (Array.isArray(doc)) {
+            if ((doc.length !== 2) || (typeof doc[0] !== "number") || (typeof doc[1] !== "number")) {
+                throw new Error("The value for "+prefix+" must be a ReQL Point (`r.point(<longitude>, <latitude>)`), an object `{longitude: <number>, latitude: <number>}`, or an array [<longitude>, <latitude>].")
+            }
+        }
+    }
+}
+
+function validateDocNotNull(doc, localOptions, prefix) {
+    if (doc === undefined) {
+        if (localOptions.enforce_missing === true) {
+            util.undefinedField(prefix);
+        }
+    }
+    else if (doc === null) {
+        if (localOptions.enforce_type === "strict") {
+            util.strictType(prefix, "object");
+        }
+    }
+    else if (!util.isPlainObject(doc)) {
+        if (localOptions.enforce_type === "strict") {
+            util.strictType(prefix, "object");
+        }
+        else if (localOptions.enforce_type === "loose") {
+            util.looseType(prefix, "object");
+        }
+    }
+}
+
+function validateDocIsArray(doc, localOptions, prefix) {
+    if (doc === undefined) {
+        if (localOptions.enforce_missing === true) {
+            util.undefinedField(prefix);
+        }
+    }
+    else if (doc === null) {
+        if (localOptions.enforce_type === "strict") {
+            util.strictType(prefix, "array");
+        }
+    }
+    else if (!Array.isArray(doc)) {
+        if (localOptions.enforce_type === "strict") {
+            util.strictType(prefix, "array");
+        }
+        else if (localOptions.enforce_type === "loose") {
+            util.looseType(prefix, "array");
+        }
+    }
+}
+
+function validateExtraFields(doc, schema, localOptions, prefix) {
+    if ((localOptions.enforce_extra !== "none")) {
+        for(var key in doc) {
+            if (((doc._getModel == null) || (doc._getModel()._joins.hasOwnProperty(key) === false)) && (doc.hasOwnProperty(key)) &&
+                (util.isPlainObject(schema) && (schema._type === undefined) && (schema.hasOwnProperty(key) === false))
+                || (util.isPlainObject(schema) && (schema._type === Object) && (util.isPlainObject(schema.schema)) && (schema.schema.hasOwnProperty(key) === false))) {
+
+                if (localOptions.enforce_extra === 'remove') {
+                    delete doc[key];
+                }
+                else if (localOptions.enforce_extra === 'strict') {
+                    util.extraField(prefix, key);
+                }
+            }
+        }
+    }
+}
+
+function mergeSchemaOption(base, local) {
+    if (local) {
+        base = util.deepCopy(base);
+        base.enforce_missing = local.enforce_missing == null ? base.enforce_missing : local.enforce_missing;
+        base.enforce_extra = local.enforce_extra == null ? base.enforce_extra : local.enforce_extra;
+        base.enforce_type = local.enforce_type == null ? base.enforce_type : local.enforce_type;
+    }
+    return base;
+}
+
+function visit(validate, key, node, path, validateContext) {
+    var nodeType = util.getType(node);
+    path = key === "[i]" ? path + key : genObj(path, key);
+    var field = "doc" + path;
+    var subSchema;
+
+    if (node && (typeof node.validator === 'function')) {
+        validateContext.schemas[path] = node;
+        validate("if (%s.validator(%s) === false) throw new Error(\"Validator for the field %s returned `false`.\")",
+            genObj("schemas", path), field, path);
+    }
+
+    if (nodeType === Number) {
+        var Enum, _Enum;
+        if (Array.isArray(node.enum) && (util.isPlainObject(node._enum))) {
+            Enum = node.enum;
+            _Enum = node._enum;
+        }
+        validate("validatePrimitive(%s, %s, 'number', prefix+'%s', %s, %s);",
+            field,
+            node.options ? "mergeSchemaOption(options, " + JSON.stringify(node.options) + ")" : 'options',
+            path,
+            Enum ? JSON.stringify(Enum) : 'undefined',
+            _Enum ? JSON.stringify(_Enum) : 'undefined'
+        );
+    }
+    else if (nodeType === String) {
+        var Enum, _Enum;
+        if (Array.isArray(node.enum) && (util.isPlainObject(node._enum))) {
+            Enum = node.enum;
+            _Enum = node._enum;
+        }
+        validate("validatePrimitive(%s, %s, 'string', prefix+'%s', %s, %s);",
+            field,
+            node.options ? "mergeSchemaOption(options, " + JSON.stringify(node.options) + ")" : 'options',
+            path,
+            Enum ? JSON.stringify(Enum) : 'undefined',
+            _Enum ? JSON.stringify(_Enum) : 'undefined'
+        );
+    }
+    else if (nodeType === Boolean) {
+        var Enum, _Enum;
+        if (Array.isArray(node.enum) && (util.isPlainObject(node._enum))) {
+            Enum = node.enum;
+            _Enum = node._enum;
+        }
+        validate("validatePrimitive(%s, %s, 'boolean', prefix+'%s', %s, %s);",
+            field,
+            node.options ? "mergeSchemaOption(options, " + JSON.stringify(node.options) + ")" : 'options',
+            path,
+            Enum ? JSON.stringify(Enum) : 'undefined',
+            _Enum ? JSON.stringify(_Enum) : 'undefined'
+        );
+    }
+    else if (nodeType === Date) {
+        validate("validateDate(%s, %s, prefix+'%s');",
+            field,
+            node.options ? "mergeSchemaOption(options, " + JSON.stringify(node.options) + ")" : 'options',
+            path);
+    }
+    else if (nodeType === Buffer) {
+        validate("validateBuffer(%s, %s, prefix+'%s');",
+            field,
+            node.options ? "mergeSchemaOption(options, " + JSON.stringify(node.options) + ")" : 'options',
+            path);
+    }
+    else if (nodeType === "Point") {
+        validate("validatePoint(%s, %s, prefix+'%s');",
+            field,
+            node.options ? "mergeSchemaOption(options, " + JSON.stringify(node.options) + ")" : 'options',
+            path);
+    }
+    else if (nodeType === Array || Array.isArray(node)) {
+        validate("validateDocIsArray(%s, options, prefix+'%s');", field, path);
+        subSchema = util.getSchema(node);
+        if (subSchema) {
+            if (node.options) {
+                validate("optionStack.push(mergeSchemaOption(options, " + JSON.stringify(node.options) + ");");
+                validate("options = optionStack[optionStack.length - 1];");
+            }
+            validate("if (Array.isArray(%s)) {", field);
+            validate("for (var i=0;i<%s.length;i++) {", field);
+            validate('if (%s === undefined) throw new Error("The element in the array %s (position "+i+") cannot be `undefined`.");', field + "[i]", path);
+            visit(validate, "[i]", subSchema, path, validateContext);
+            validate("}");
+            validate("}");
+            if (node.options) {
+                validate("optionStack.pop();");
+                validate("options = optionStack[optionStack.length - 1];");
+            }
+        }
+    }
+    else if (nodeType === Object || util.isSchema(node)) {
+        validate("validateDocNotNull(%s, options, prefix+'%s');", field, path);
+        subSchema = util.getSchema(node);
+        if (subSchema) {
+            if (node.options) {
+                validate("optionStack.push(mergeSchemaOption(options, " + JSON.stringify(node.options) + "));");
+                validate("options = optionStack[optionStack.length - 1];");
+            }
+            validate("if (util.isPlainObject(%s)) {", field);
+            var subKeys = Object.keys(subSchema);
+            for (var i=0;i<subKeys.length;i++) {
+                var subKey = subKeys[i];
+                var subNode = subSchema[subKey];
+
+                visit(validate, subKey, subNode, path, validateContext);
+            }
+            validate("}");
+            validateContext.schemas[path] = subSchema;
+            validate('validateExtraFields(%s, schemas["%s"], %s, prefix+"%s");',
+                field,
+                path,
+                node.options ? "mergeSchemaOption(options, " + JSON.stringify(node.options) + ")" : 'options',
+                path);
+            if (node.options) {
+                validate("optionStack.pop();");
+                validate("options = optionStack[optionStack.length - 1];");
+            }
+        }
+    }
+    else if (nodeType === "virtual") {
+    }
+}
+
+var compile = module.exports = function (name, schema) {
+    var validate =  genFunc()("function _validate_%s(doc, prefix, options) {", name)
+    ("var optionStack = [options];");
+    var schemaKeys = Object.keys(schema);
+    var validateContext = {
+        validatePrimitive: validatePrimitive,
+        validateDate: validateDate,
+        validatePoint: validatePoint,
+        validateBuffer: validateBuffer,
+        validateDocNotNull: validateDocNotNull,
+        validateDocIsArray: validateDocIsArray,
+        validateExtraFields: validateExtraFields,
+
+        mergeSchemaOption: mergeSchemaOption,
+        util: util,
+        schemas: {"root": schema}
+    };
+
+    for (var i=0;i<schemaKeys.length;i++) {
+        var key = schemaKeys[i];
+        var node = schema[key];
+
+        visit(validate, key, node, "", validateContext);
+    }
+
+    validate('validateExtraFields(doc, schemas.root, options, prefix);');
+
+    validate("}");
+
+    return validate.toFunction(validateContext);
+};
diff --git a/package.json b/package.json
index aa74d963..23f38cfa 100644
--- a/package.json
+++ b/package.json
@@ -24,6 +24,8 @@
     "url": "https://github.com/neumino/thinky/issues"
   },
   "dependencies":{
+    "generate-object-property": "latest",
+    "generate-function": "latest",
     "rethinkdbdash": "~1.15.0",
     "bluebird": "~ 2.1.3"
   },
diff --git a/test/document.js b/test/document.js
index d6cd90be..eb1bdf98 100644
--- a/test/document.js
+++ b/test/document.js
@@ -2577,7 +2577,7 @@ describe('hooks', function() {
                 Model.get(1).run().then(function(result) {
                     done(new Error("Was expecting an error"))
                 }).error(function(err) {
-                    assert.equal(err.message, "Value for [id] must be a string or null.");
+                    assert.equal(err.message, "Value for .id must be a string or null.");
                     done();
                 });
             }).error(done);
diff --git a/test/model.js b/test/model.js
index 1f2039ae..c6728f87 100644
--- a/test/model.js
+++ b/test/model.js
@@ -157,7 +157,7 @@ describe("Batch insert", function() {
     });
     it('Batch insert should validate fields before saving', function(done) {
         Model.save([{id: 4}]).error(function(err) {
-            assert.equal(err.message, "Value for [id] must be a string or null.")
+            assert.equal(err.message, "Value for .id must be a string or null.")
             done();
         });
     });
diff --git a/test/schema.js b/test/schema.js
index d1537202..60792a23 100644
--- a/test/schema.js
+++ b/test/schema.js
@@ -412,7 +412,7 @@ describe('generateDefault', function(){
                 schema: {
                     field: {_type: Number, default: defaultValue}
                 },
-                default: defaultArray 
+                default: defaultArray
             }
         }, {init: false})
 
@@ -435,11 +435,11 @@ describe('generateDefault', function(){
                 _type: Array,
                 schema: {
                     field: {
-                        _type: Object, 
+                        _type: Object,
                         schema: {value: {_type: Number, default: defaultValue} }
                     }
                 },
-                default: defaultArray 
+                default: defaultArray
             }
         }, {init: false})
 
@@ -467,7 +467,7 @@ describe('generateDefault', function(){
                         field: {_type: Number, default: defaultValue}
                     }
                 },
-                default: defaultArray 
+                default: defaultArray
             }
         }, {init: false})
 
@@ -659,7 +659,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be a string.")
+            return (error instanceof Error) && (error.message === "Value for .field must be a string.")
         });
     });
     it('String - wrong type  - type: "loose"', function(){
@@ -679,7 +679,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be a string or null.")
+            return (error instanceof Error) && (error.message === "Value for .field must be a string or null.")
         });
 
     });
@@ -763,7 +763,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be defined.")
+            return (error instanceof Error) && (error.message === "Value for .field must be defined.")
         });
 
     });
@@ -778,13 +778,13 @@ describe('validate', function(){
 
         doc = new Model({
             id: str,
-            field: null 
+            field: null
         })
 
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be a string.")
+            return (error instanceof Error) && (error.message === "Value for .field must be a string.")
         });
     });
     it('String - null  - type: "loose"', function(){
@@ -798,7 +798,7 @@ describe('validate', function(){
 
         doc = new Model({
             id: str,
-            field: null 
+            field: null
         })
 
         doc.validate();
@@ -836,7 +836,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be a number.")
+            return (error instanceof Error) && (error.message === "Value for .field must be a number.")
         });
     });
     it('Number - wrong type  - type: "loose"', function(){
@@ -845,7 +845,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: Number 
+            field: Number
         }, {init: false, enforce_type: 'loose'})
 
         doc = new Model({
@@ -856,7 +856,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be a number or null.")
+            return (error instanceof Error) && (error.message === "Value for .field must be a number or null.")
         });
 
     });
@@ -893,7 +893,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be a boolean.")
+            return (error instanceof Error) && (error.message === "Value for .field must be a boolean.")
         });
     });
     it('Boolean - wrong type  - type: "loose"', function(){
@@ -902,7 +902,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: Boolean 
+            field: Boolean
         }, {init: false, enforce_type: 'loose'})
 
         doc = new Model({
@@ -913,7 +913,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be a boolean or null.")
+            return (error instanceof Error) && (error.message === "Value for .field must be a boolean or null.")
         });
 
     });
@@ -939,7 +939,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: Date 
+            field: Date
         }, {init: false, enforce_type: 'strict'})
 
         doc = new Model({
@@ -955,7 +955,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: Date 
+            field: Date
         }, {init: false, enforce_type: 'strict'})
 
         doc = new Model({
@@ -966,7 +966,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be a date or a valid string.")
+            return (error instanceof Error) && (error.message === "Value for .field must be a date or a valid string.")
         });
     });
     it('Date - wrong type  - type: "loose"', function(){
@@ -986,7 +986,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be a date or a valid string or null.")
+            return (error instanceof Error) && (error.message === "Value for .field must be a date or a valid string or null.")
         });
     });
     it('Date - string type - type: "loose"', function(){
@@ -995,7 +995,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: Date 
+            field: Date
         }, {init: false, enforce_type: 'loose'})
 
         doc = new Model({
@@ -1027,7 +1027,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: Date 
+            field: Date
         }, {init: false, enforce_type: 'strict'})
 
         doc = new Model({
@@ -1043,7 +1043,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: Date 
+            field: Date
         }, {init: false, enforce_type: 'strict'})
 
         doc = new Model({
@@ -1053,7 +1053,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "The raw date object for [field] is missing the required field timezone.")
+            return (error instanceof Error) && (error.message === "The raw date object for .field is missing the required field timezone.")
         });
     });
     it('Date - raw type - missing epoch_time - type: "strict"', function(){
@@ -1062,7 +1062,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: Date 
+            field: Date
         }, {init: false, enforce_type: 'strict'})
 
         doc = new Model({
@@ -1072,7 +1072,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "The raw date object for [field] is missing the required field epoch_time.")
+            return (error instanceof Error) && (error.message === "The raw date object for .field is missing the required field epoch_time.")
         });
     });
     it('Date - r.now', function(){
@@ -1081,7 +1081,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: Date 
+            field: Date
         }, {init: false})
 
         doc = new Model({
@@ -1096,7 +1096,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: Date 
+            field: Date
         }, {init: false, enforce_missing: true})
 
         doc = new Model({
@@ -1105,7 +1105,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be defined.")
+            return (error instanceof Error) && (error.message === "Value for .field must be defined.")
         });
     });
     it('Date - undefined - enforce_missing: false', function(){
@@ -1114,7 +1114,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: Date 
+            field: Date
         }, {init: false, enforce_missing: false})
 
         doc = new Model({
@@ -1159,7 +1159,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be a buffer.")
+            return (error instanceof Error) && (error.message === "Value for .field must be a buffer.")
         });
     });
     it('Buffer - wrong type  - type: "loose"', function(){
@@ -1179,7 +1179,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be a buffer or null.")
+            return (error instanceof Error) && (error.message === "Value for .field must be a buffer or null.")
         });
     });
 
@@ -1231,7 +1231,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "The raw binary object for [field] is missing the required field data.")
+            return (error instanceof Error) && (error.message === "The raw binary object for .field is missing the required field data.")
         });
     });
     it('Buffer - r.http', function(){
@@ -1264,7 +1264,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be defined.")
+            return (error instanceof Error) && (error.message === "Value for .field must be defined.")
         });
     });
     it('Buffer - undefined - enforce_missing: false', function(){
@@ -1292,7 +1292,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: [Number] 
+            field: [Number]
         }, {init: false, enforce_missing: true})
 
         doc = new Model({
@@ -1302,7 +1302,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be defined.")
+            return (error instanceof Error) && (error.message === "Value for .field must be defined.")
         });
     });
     it('Array - undefined - enforce_missing: true', function(){
@@ -1311,7 +1311,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: [Number] 
+            field: [Number]
         }, {init: false, enforce_missing: true})
 
         doc = new Model({
@@ -1321,7 +1321,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be defined.")
+            return (error instanceof Error) && (error.message === "Value for .field must be defined.")
         });
     });
     it('Array - undefined - enforce_missing: false', function(){
@@ -1330,7 +1330,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: [Number] 
+            field: [Number]
         }, {init: false, enforce_missing: false})
 
         doc = new Model({
@@ -1345,7 +1345,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: [Number] 
+            field: [Number]
         }, {init: false, enforce_type: 'loose'})
 
         doc = new Model({
@@ -1356,7 +1356,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be a array or null.")
+            return (error instanceof Error) && (error.message === "Value for .field must be a array or null.")
         });
     });
     it('Array - wrong type - enforce_type: "loose"', function(){
@@ -1365,7 +1365,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: [Number] 
+            field: [Number]
         }, {init: false, enforce_type: 'loose'})
 
         doc = new Model({
@@ -1376,7 +1376,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be a array or null.")
+            return (error instanceof Error) && (error.message === "Value for .field must be a array or null.")
         });
     });
     it('Array - wrong type - enforce_type: "none"', function(){
@@ -1385,7 +1385,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: [Number] 
+            field: [Number]
         }, {init: false, enforce_type: 'none'})
 
         doc = new Model({
@@ -1400,7 +1400,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: [Number] 
+            field: [Number]
         }, {init: false, enforce_type: 'strict'})
 
         doc = new Model({
@@ -1411,7 +1411,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field][0] must be a number.")
+            return (error instanceof Error) && (error.message === "Value for .field[i] must be a number.")
         });
     });
     it('Array - wrong type inside - enforce_type: "loose"', function(){
@@ -1420,7 +1420,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: [Number] 
+            field: [Number]
         }, {init: false, enforce_type: 'loose'})
 
         doc = new Model({
@@ -1431,7 +1431,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field][0] must be a number or null.")
+            return (error instanceof Error) && (error.message === "Value for .field[i] must be a number or null.")
         });
     });
     it('Array - wrong type inside - enforce_type: "none"', function(){
@@ -1440,7 +1440,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: [Number] 
+            field: [Number]
         }, {init: false, enforce_type: 'none'})
 
         doc = new Model({
@@ -1456,7 +1456,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: [Number] 
+            field: [Number]
         }, {init: false, enforce_type: 'strict'})
 
         doc = new Model({
@@ -1467,7 +1467,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field][3] must be a number.")
+            return (error instanceof Error) && (error.message === "Value for .field[i] must be a number.")
         });
     });
     it('Array - wrong type inside - not first - enforce_type: "strict"', function(){
@@ -1476,7 +1476,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: [Number] 
+            field: [Number]
         }, {init: false, enforce_type: 'strict'})
 
         doc = new Model({
@@ -1487,7 +1487,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "The element in the array [field] (position 3) cannot be `undefined`.")
+            return (error instanceof Error) && (error.message === "The element in the array .field (position 3) cannot be `undefined`.")
         });
 
     });
@@ -1497,7 +1497,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: [Number] 
+            field: [Number]
         }, {init: false, enforce_type: 'loose'})
 
         doc = new Model({
@@ -1508,7 +1508,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "The element in the array [field] (position 3) cannot be `undefined`.")
+            return (error instanceof Error) && (error.message === "The element in the array .field (position 3) cannot be `undefined`.")
         });
 
 
@@ -1519,7 +1519,7 @@ describe('validate', function(){
 
         var Model = thinky.createModel(name, {
             id: String,
-            field: [Number] 
+            field: [Number]
         }, {init: false, enforce_type: 'loose'})
 
         doc = new Model({
@@ -1545,7 +1545,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be defined.")
+            return (error instanceof Error) && (error.message === "Value for .field must be defined.")
         });
     });
     it('Object - undefined - enforce_missing: false', function(){
@@ -1580,7 +1580,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be a object or null.")
+            return (error instanceof Error) && (error.message === "Value for .field must be a object or null.")
         });
     });
     it('Object - undefined - enforce_type: "none"', function(){
@@ -1632,7 +1632,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be a object.")
+            return (error instanceof Error) && (error.message === "Value for .field must be a object.")
         });
     });
     it('Object - nested wrong type - enforce_type: "strict"', function(){
@@ -1654,7 +1654,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be a object.")
+            return (error instanceof Error) && (error.message === "Value for .field must be a object.")
         });
     });
     it('Object - nested wrong type - enforce_type: "strict" - 2', function(){
@@ -1678,7 +1678,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field][foo] must be a number.")
+            return (error instanceof Error) && (error.message === "Value for .field.foo must be a number.")
         });
     });
     it('Object - nested wrong type - enforce_type: "loose"', function(){
@@ -1702,7 +1702,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field][foo] must be a number or null.")
+            return (error instanceof Error) && (error.message === "Value for .field.foo must be a number or null.")
         });
     });
     it('Object - Empty - enforce_type: "strict"', function(){
@@ -1737,7 +1737,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field][foo] must be defined.")
+            return (error instanceof Error) && (error.message === "Value for .field.foo must be defined.")
         });
     });
     it('Object - undefined - enforce_type: "loose"', function(){
@@ -1777,7 +1777,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field][foo] must be a number or null.")
+            return (error instanceof Error) && (error.message === "Value for .field.foo must be a number or null.")
         });
     });
     it('Object - nested wrong type 5 - enforce_type: "none"', function(){
@@ -1832,7 +1832,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return error.message === "Extra field `buzz` in [foo][0] not allowed.";
+            return error.message === "Extra field `buzz` in .foo[i] not allowed.";
         });
     });
     it('Extra field - 3', function(){
@@ -1851,7 +1851,7 @@ describe('validate', function(){
         assert.throws(function() {
             doc.validate();
         }, function(error) {
-            return error.message === "Extra field `buzz` in [foo] not allowed.";
+            return error.message === "Extra field `buzz` in .foo not allowed.";
         });
     });
     it('Extra field - enforce_extra:"remove" - global option', function(){
@@ -1922,7 +1922,7 @@ describe('validate', function(){
             })
 
         }, function(error) {
-            return (error instanceof Error) && (error.message === "Value for [field] must be a string.")
+            return (error instanceof Error) && (error.message === "Value for .field must be a string.")
         });
     });
 });
@@ -1960,7 +1960,7 @@ describe('validateAll', function() {
         assert.throws(function() {
             doc.validateAll();
         }, function(error) {
-            return error.message === "Value for [otherDoc][field] must be a string or null.";
+            return error.message === "Value for [otherDoc].field must be a string or null.";
         });
     });
     it('it should check joined Document too -- hasOne - 2', function() {
@@ -1995,7 +1995,7 @@ describe('validateAll', function() {
         assert.throws(function() {
             doc.validateAll({otherDoc: true});
         }, function(error) {
-            return error.message === "Value for [otherDoc][field] must be a string or null.";
+            return error.message === "Value for [otherDoc].field must be a string or null.";
         });
     });
     it('it should check joined Document too -- belongsTo - 1', function() {
@@ -2031,7 +2031,7 @@ describe('validateAll', function() {
         assert.throws(function() {
             doc.validateAll();
         }, function(error) {
-            return error.message === "Value for [otherDoc][field] must be a string or null.";
+            return error.message === "Value for [otherDoc].field must be a string or null.";
         });
     });
     it('it should check joined Document too -- belongsTo - 2', function() {
@@ -2067,7 +2067,7 @@ describe('validateAll', function() {
         assert.throws(function() {
             doc.validateAll({otherDoc: true});
         }, function(error) {
-            return error.message === "Value for [otherDoc][field] must be a string or null.";
+            return error.message === "Value for [otherDoc].field must be a string or null.";
         });
     });
     it('it should check joined Document too -- hasMany - 1', function() {
@@ -2103,7 +2103,7 @@ describe('validateAll', function() {
         assert.throws(function() {
             doc.validateAll();
         }, function(error) {
-            return error.message === "Value for [otherDocs][0][field] must be a string or null.";
+            return error.message === "Value for [otherDocs][0].field must be a string or null.";
         });
     });
     it('it should check joined Document too -- hasMany - 2', function() {
@@ -2139,7 +2139,7 @@ describe('validateAll', function() {
         assert.throws(function() {
             doc.validateAll({otherDocs: true});
         }, function(error) {
-            return error.message === "Value for [otherDocs][0][field] must be a string or null.";
+            return error.message === "Value for [otherDocs][0].field must be a string or null.";
         });
     });
     it('it should check joined Document too -- hasAndBelongsToMany - 1', function() {
@@ -2175,7 +2175,7 @@ describe('validateAll', function() {
         assert.throws(function() {
             doc.validateAll();
         }, function(error) {
-            return error.message === "Value for [otherDocs][0][field] must be a string or null.";
+            return error.message === "Value for [otherDocs][0].field must be a string or null.";
         });
     });
     it('it should check joined Document too -- hasAndBelongsToMany - 2', function() {
@@ -2211,7 +2211,7 @@ describe('validateAll', function() {
         assert.throws(function() {
             doc.validateAll({otherDocs: true});
         }, function(error) {
-            return error.message === "Value for [otherDocs][0][field] must be a string or null.";
+            return error.message === "Value for [otherDocs][0].field must be a string or null.";
         });
     });
     it('hasOne with a circular reference', function() {
@@ -2257,7 +2257,7 @@ describe('validateAll', function() {
         assert.throws(function() {
             doc.validateAll({}, {has: {belongsTo: true}});
         }, function(error) {
-            return error.message === "Value for [has][belongsTo][id] must be a string or null.";
+            return error.message === "Value for [has][belongsTo].id must be a string or null.";
         });
     });
 });
@@ -2474,7 +2474,7 @@ describe('_validator', function(){
             doc.validate();
         }, function(error) {
             return (error instanceof Error)
-                && (error.message === "Validator for the field [field] returned `false`.")
+                && (error.message === "Validator for the field .field returned `false`.")
         });
     });
     it('validate on a field - 4', function(){
@@ -2489,7 +2489,7 @@ describe('_validator', function(){
             doc.validate();
         }, function(error) {
             return (error instanceof Error)
-                && (error.message === "Validator for the field [field] returned `false`.")
+                && (error.message === "Validator for the field .field returned `false`.")
         });
     });
     it('validate on the whole document - nested field - 1 ', function(){
@@ -2548,7 +2548,7 @@ describe('_validator', function(){
             doc.validate();
         }, function(error) {
             return (error instanceof Error)
-                && (error.message === "Value for [arr][1] must be a number or null.")
+                && (error.message === "Value for .arr[i] must be a number or null.")
         });
     });
     it('validate with _type: Object - 1', function(){
@@ -2571,7 +2571,7 @@ describe('_validator', function(){
             doc.validate();
         }, function(error) {
             return (error instanceof Error)
-                && (error.message === "Value for [ob][foo] must be a string or null.")
+                && (error.message === "Value for .ob.foo must be a string or null.")
         });
     });
     it('Check extra fields only if the schema is an object without the _type field', function(){
@@ -2608,7 +2608,7 @@ describe('_validator', function(){
             doc.validate();
         }, function(error) {
             return (error instanceof Error)
-                && (error.message === "The field [field] must be one of these values: foo, bar, buzz.")
+                && (error.message === "The field .field must be one of these values: foo, bar, buzz.")
         });
     });
     it('Enum - throw - 2', function(){
@@ -2621,7 +2621,7 @@ describe('_validator', function(){
             doc.validate();
         }, function(error) {
             return (error instanceof Error)
-                && (error.message === "The field [field] must be one of these values: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10.")
+                && (error.message === "The field .field must be one of these values: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10.")
         });
     });
     it('Enum - throw - 3', function(){
@@ -2634,7 +2634,7 @@ describe('_validator', function(){
             doc.validate();
         }, function(error) {
             return (error instanceof Error)
-                && (error.message === "The field [field] must be one of these values: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10...")
+                && (error.message === "The field .field must be one of these values: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10...")
         });
 
     });
diff --git a/test/settings.js b/test/settings.js
index 4bb25373..965ddaed 100644
--- a/test/settings.js
+++ b/test/settings.js
@@ -119,7 +119,7 @@ describe('Priorities for options', function() {
         assert.throws(function() {
             var doc = new Model({})
         }, function(error) {
-            return error.message === "Value for [id] must be defined.";
+            return error.message === "Value for .id must be defined.";
         });
     });
     it("Thinky options can be overwritten by the Model's one", function() {