diff --git a/jquery.h5validate.js b/jquery.h5validate.js
index b151b06..0efb9be 100644
--- a/jquery.h5validate.js
+++ b/jquery.h5validate.js
@@ -92,6 +92,9 @@
 				// Callback stubs
 				invalidCallback: function () {},
 				validCallback: function () {},
+				
+				// Array of Validator Functions. View the comment for addValidator for more information.
+				validators: [],
 
 				// Elements to validate with allValid (only validating visible elements)
 				allValidSelectors: ':input:visible:not(:button):not(:disabled):not(.novalidate)',
@@ -139,7 +142,7 @@
 					$element.removeClass(options.errorClass).removeClass(options.validClass);
 					$element.form.find("#" + options.element.id).removeClass(options.errorClass).removeClass(options.validClass);
 					return $element;
-				}
+				},
 			}
 		},
 
@@ -150,17 +153,75 @@
 		createValidity = function createValidity(validity) {
 			return $.extend({
 				customError: validity.customError || false,
-				patternMismatch: validity.patternMismatch || false,
+				failedValidatorNames: [],
 				rangeOverflow: validity.rangeOverflow || false,
 				rangeUnderflow: validity.rangeUnderflow || false,
 				stepMismatch: validity.stepMismatch || false,
-				tooLong: validity.tooLong || false,
 				typeMismatch: validity.typeMismatch || false,
 				valid: validity.valid || true,
-				valueMissing: validity.valueMissing || false
 			}, validity);
 		},
 
+		/**
+		 * Add builtin validators to h5Validate. Currently, this adds the following validators:
+		 *   Required
+		 *   Maxlength
+		 *   Pattern
+		 * @param  {object}  settings   instance settings
+		 */
+		addBuiltinValidators = function (settings) {
+			settings.validators.push({selector: "*", validator: function(value) {
+				var maxlength = parseInt($(this).attr('maxlength'), 10);
+				return isNaN(maxlength) || value.length <= maxlength;
+			}, options: {
+				validityFailureFlag: 'tooLong',
+				name: 'maxlength',
+			}});
+
+			settings.validators.push({selector: "*", validator: function(value) {
+				var required = false,
+					$checkRequired = $('<input required>'),
+					$this = $(this);
+
+				/*	If the required attribute exists, set it required to true, unless it's set 'false'.
+				*	This is a minor deviation from the spec, but it seems some browsers have falsey 
+				*	required values if the attribute is empty (should be true). The more conformant 
+				*	version of this failed sanity checking in the browser environment.
+				*	This plugin is meant to be practical, not ideologically married to the spec.
+				*/
+				if ($checkRequired.filter('[required]') && $checkRequired.filter('[required]').length) {
+					required = ($this.filter('[required]').length && $this.attr('required') !== 'false');
+				} else {
+					required = ($this.attr('required') !== undefined);
+				}
+
+				return !required || value;
+			}, options: {
+				validityFailureFlag: 'valueMissing',
+				name: 'required',
+			}});
+
+			settings.validators.push({selector: "*", validator: function(value) {
+				// Get the HTML5 pattern attribute if it exists.
+				// ** TODO: If a pattern class exists, grab the pattern from the patternLibrary, but the pattern attrib should override that value.
+				var $this = $(this),
+					pattern = $this.filter('[pattern]')[0] ? $this.attr('pattern') : false,
+					// The pattern attribute must match the whole value, not just a subset:
+					// "...as if it implied a ^(?: at the start of the pattern and a )$ at the end."
+					re = new RegExp('^(?:' + pattern + ')$');
+
+				if (settings.debug && window.console) {
+					console.log('Validate called on "' + value + '" with regex "' + re + '".'); // **DEBUG
+					console.log('Regex test: ' + re.test(value) + ', Pattern: ' + pattern); // **DEBUG
+				}
+
+				return !pattern || re.test(value) || !value;
+			}, options: {
+				validityFailureFlag: 'patternMismatch',
+				name: 'pattern',
+			}});
+		},
+		
 		methods = {
 			/**
 			 * Check the validity of the current field
@@ -231,14 +292,7 @@
 				return valid;
 			},
 			validate: function (settings) {
-				// Get the HTML5 pattern attribute if it exists.
-				// ** TODO: If a pattern class exists, grab the pattern from the patternLibrary, but the pattern attrib should override that value.
 				var $this = $(this),
-					pattern = $this.filter('[pattern]')[0] ? $this.attr('pattern') : false,
-
-					// The pattern attribute must match the whole value, not just a subset:
-					// "...as if it implied a ^(?: at the start of the pattern and a )$ at the end."
-					re = new RegExp('^(?:' + pattern + ')$'),
 					$radiosWithSameName = null,
 					value = ($this.is('[type=checkbox]')) ?
 							$this.is(':checked') : ($this.is('[type=radio]') ?
@@ -252,66 +306,53 @@
 					validClass = settings.validClass,
 					errorIDbare = $this.attr(settings.errorAttribute) || false, // Get the ID of the error element.
 					errorID = errorIDbare ? '#' + errorIDbare.replace(/(:|\.|\[|\])/g,'\\$1') : false, // Add the hash for convenience. This is done in two steps to avoid two attribute lookups.
-					required = false,
-					validity = createValidity({element: this, valid: true}),
-					$checkRequired = $('<input required>'),
-					maxlength;
-
-				/*	If the required attribute exists, set it required to true, unless it's set 'false'.
-				*	This is a minor deviation from the spec, but it seems some browsers have falsey 
-				*	required values if the attribute is empty (should be true). The more conformant 
-				*	version of this failed sanity checking in the browser environment.
-				*	This plugin is meant to be practical, not ideologically married to the spec.
-				*/
-				// Feature fork
-				if ($checkRequired.filter('[required]') && $checkRequired.filter('[required]').length) {
-					required = ($this.filter('[required]').length && $this.attr('required') !== 'false');
-				} else {
-					required = ($this.attr('required') !== undefined);
-				}
-
-				if (settings.debug && window.console) {
-					console.log('Validate called on "' + value + '" with regex "' + re + '". Required: ' + required); // **DEBUG
-					console.log('Regex test: ' + re.test(value) + ', Pattern: ' + pattern); // **DEBUG
-				}
-
-				maxlength = parseInt($this.attr('maxlength'), 10);
-				if (!isNaN(maxlength) && value.length > maxlength) {
-						validity.valid = false;	
-						validity.tooLong = true;
-				}
-
-				if (required && !value) {
-					validity.valid = false;
-					validity.valueMissing = true;
-				} else if (pattern && !re.test(value) && value) {
-					validity.valid = false;
-					validity.patternMismatch = true;
-				} else {
-					if (!settings.RODom) {
-						settings.markValid({
-							element: this,
-							validity: validity,
-							errorClass: errorClass,
-							validClass: validClass,
-							errorID: errorID,
-							settings: settings
-						});
+					validity = createValidity({element: this, valid: true});
+
+				// Iterate through the validators. If any fail, the field fails.
+				for (var i = 0;i<settings.validators.length;i++) {
+					var validator = settings.validators[i].validator,
+						selector = settings.validators[i].selector,
+						options = settings.validators[i].options,
+						setFailureFlag = false;
+					
+					// We don't want to overwrite any of the other validity properties (such as "valid")
+					if (options.validityFailureFlag && !validity.hasOwnProperty(options.validityFailureFlag)) {
+						setFailureFlag = true;
+						validity[options.validityFailureFlag] = false;
+					}
+					
+					if ($(this).is(selector)) {
+						var boundValidator = validator.bind(this);
+						if (!boundValidator(value)) {
+							validity.valid = false;	
+							validity.failedValidator = true;
+							if (options.name) {
+								validity.failedValidatorNames.push(options.name);
+							}
+							if (setFailureFlag) {
+								validity[options.validityFailureFlag] = true;
+							}
+						}
 					}
 				}
-
-				if (!validity.valid) {
-					if (!settings.RODom) {
-						settings.markInvalid({
-							element: this,
-							validity: validity,
-							errorClass: errorClass,
-							validClass: validClass,
-							errorID: errorID,
-							settings: settings
-						});
+								
+				if (!settings.RODom) {
+					var options = {
+						element: this,
+						validity: validity,
+						errorClass: errorClass,
+						validClass: validClass,
+						errorID: errorID,
+						settings: settings
+					};
+					
+					if (validity.valid) {
+						settings.markValid(options);
+					} else {
+						settings.markInvalid(options);
 					}
 				}
+
 				$this.trigger('validated', validity);
 
 				// If it's a radio button, also validate the other radio buttons with the same name
@@ -458,6 +499,8 @@
 			// Combine defaults and options to get current settings.
 			var settings = $.extend({}, defaults, options, methods),
 				activeClass = settings.classPrefix + settings.activeClass;
+			
+			addBuiltinValidators(settings);
 
 			return $.extend(settings, {
 				activeClass: activeClass,
@@ -523,6 +566,26 @@
 			}
 			re = new RegExp('^(?:' + pattern + ')$');
 			$(selector).data('regex', re);
+		},
+		/**
+		 * Takes a selector and a function that is used to do validation of all fields.
+		 * This is useful for doing validation against a webservice
+		 * (e.g. 'http://example.com/is_value_valid/example_value')
+		 * Each validator will be matched using the corresponding selector against every field attached to h5Validate.
+		 * 
+		 * @param {Selector} selector - A jquery selector of the field on which to apply the validator.
+		 *		example: [name="target-field"]
+		 * @param {Function} validator - An validator function with the following definition:
+		 *		@param {String} value - The value of the input being validated.
+		 *		@return {Boolean} - The result of the validation (true = pass, false = fail).
+		 *		@this {DOM Element} - The dom element being validated. 
+		 * @throws {Error} - If the validator is not a function, throw an exception
+		 */
+		addValidator: function(selector, validator, options) {
+			if (!$.isFunction(validator)) {
+				throw new Error('Expected validator function. Saw ', validator);
+			}
+			defaults.validators.push({selector: selector, validator: validator, options: options || {}} );
 		}
 	};
 
diff --git a/test/index.html b/test/index.html
index dba376e..2991966 100644
--- a/test/index.html
+++ b/test/index.html
@@ -71,7 +71,12 @@ <h3>HTMTL5 pattern attribute. e.g.</h3>
 		</form>
 		<p><em>Hint: It's expecting mm/dd/yyyy. Try typing "jQuery rocks!" instead.</em></p>
 
-		
+		<h3>HTMTL5 maxlength attribute. e.g.</h3>
+
+		<form class="h5-defaults">
+		<label for="short-answer">Short Answer:</label>
+		<input id="short-answer" name="answer" type="text" placeholder="shortanswr" title="Short Answer" maxlength="10" />
+		</form>
 
 		<h3>Pattern Library</h3>
 		
@@ -259,6 +264,21 @@ <h2>Bypassing Validation tests (via 'formnovalidate')</h2>
 				<input id="bypassSubmit" type="submit" formnovalidate="formnovalidate"/>
 			</form>
 		</section>
+		
+		<section>
+			<h2>Form Validation Tests</h2>
+			<form id="validationForm">
+				<input id="validationFieldPass" type="text" />
+				<input id="validationFieldFail" type="text" />
+				<input id="validationFieldExample" type="text" value="example" />
+				<input id="validationFieldNotExample" type="text" value="notexample" />
+				<input id="validationFieldNotExampleNotNamed" type="text" value="notexample" />
+				<input id="validationFieldNotExampleNamed" type="text" value="notexample" />
+			</form>
+			<form id="validationFormPass">
+				<input id="validationFieldUnused" type="text" />
+			</form>
+		</section>
 
 
 		<script src="http://code.jquery.com/jquery.js"></script>
diff --git a/test/test.h5validate.js b/test/test.h5validate.js
index 8446eb4..4cf4947 100644
--- a/test/test.h5validate.js
+++ b/test/test.h5validate.js
@@ -9,6 +9,45 @@
       ok((typeof $('<div>').h5Validate === 'function'), 'h5Validate exists');
     });
 
+    test('Required validation failure flag false by default:', function () {
+      var $form = $('<form />'),
+        $input = $('<textarea />').appendTo($form);
+
+      $form.appendTo('body').h5Validate();
+
+	  $input.val('Bob');
+	  $input.on('validated',function(event,validity) {
+	    strictEqual(validity.valueMissing, false, 'If the required validator does not fail, the validity property "valueMissing" should be false.');
+	  });
+      $input.h5Validate('isValid');
+    });
+
+    test('Maxlength validation failure flag false by default:', function () {
+      var $form = $('<form />'),
+        $input = $('<textarea />').appendTo($form);
+
+      $form.appendTo('body').h5Validate();
+
+	  $input.val('Bob');
+	  $input.on('validated',function(event,validity) {
+	    strictEqual(validity.tooLong, false, 'If the maxlength validator does not fail, the validity property "tooLong" should be false.');
+	  });
+      $input.h5Validate('isValid');
+    });
+
+    test('Pattern validation failure flag false by default:', function () {
+      var $form = $('<form />'),
+        $input = $('<textarea />').appendTo($form);
+
+      $form.appendTo('body').h5Validate();
+
+	  $input.val('Bob');
+	  $input.on('validated',function(event,validity) {
+	    strictEqual(validity.patternMismatch, false, 'If the pattern validator does not fail, the validity property "patternMismatch" should be false.');
+	  });
+      $input.h5Validate('isValid');
+    });
+
     test('Required:', function () {
       var $input = $('#name');
       ok((!$input.h5Validate('isValid')), 'Required input should be invalid when empty.');
@@ -17,6 +56,15 @@
       $input.val('');
     });
 
+    test('Required validation failure flag set:', function () {
+      var $input = $('#name');
+      $input.val('');
+	  $input.on('validated',function(event,validity) {
+	    ok(validity.valueMissing, 'If the required validator fails, the validity property "valueMissing" should be true.');
+	  });
+      $input.h5Validate('isValid');
+    });
+
     test('Pattern attribute:', function () {
       var $input = $('#birthdate');
       ok(($input.h5Validate('isValid')), 'Optional input should be valid when empty.');
@@ -26,6 +74,24 @@
       ok((!$input.h5Validate('isValid')), 'Input should be invalid when given invalid input.');
     });
 
+    test('Pattern validation failure flag set:', function () {
+      var $input = $('#birthdate');
+      $input.val('foo');
+	  $input.on('validated',function(event,validity) {
+	    ok(validity.patternMismatch, 'If the pattern validator fails, the validity property "patternMismatch" should be true.');
+	  });
+      $input.h5Validate('isValid');
+	});
+
+    test('Maxlength validation failure flag set', function () {
+      var $input = $('#short-answer');
+      $input.val('something longer than 10 characters');
+	  $input.on('validated',function(event,validity) {
+		ok(validity.tooLong, 'If the maxlength validator fails, the validity property "tooLong" should be true.');
+      });
+      $input.h5Validate('isValid');
+    });
+	  
     test('Pattern library:', function () {
       var $input = $('#email');
       $input.val('test@example.com');
@@ -302,6 +368,128 @@
       $form.empty().remove();
     });	
 
+	test('Adding an validator should fail for non functions',function () {
+		raises(function() {
+			$.h5Validate.addValidator('[name="target-field"]',5);
+		}, Error, 'Should not be able to add an integer as an validator.');
+
+		raises(function() {
+			$.h5Validate.addValidator('[name="target-field"]','5');
+		}, Error, 'Should not be able to add a string as an validator.');
+
+		raises(function() {
+			$.h5Validate.addValidator('[name="target-field"]',null);
+		}, Error, 'Should not be able to add a null as an validator.');
+
+		raises(function() {
+			$.h5Validate.addValidator('[name="target-field"]',{});
+		}, Error, 'Should not be able to add an object as an validator.');
+
+		raises(function() {
+			$.h5Validate.addValidator('[name="target-field"]',[]);
+		}, Error, 'Should not be able to add an array as an validator.');
+	});
+
+	test('Adding an validator should succeed for functions',function () {
+		$.h5Validate.addValidator('[name="target-field"]',function(){return true;});
+		ok(true, 'Should be able to add a function as an validator without causing an exception.');
+	});
+
+	test('Adding an validator that returns true should not cause validation to fail.',function () {
+		var $form = $('#validationForm'),
+			$field = $('#validationFieldPass');
+		$.h5Validate.addValidator($field,function(){return true;});
+		$form.h5Validate();
+		equal($field.h5Validate('isValid'), true, 'Adding an validator that returns true should not cause validation to fail.');
+	});
+
+	test('Adding an validator that returns false should cause validation to fail.',function () {
+		var $form = $('#validationForm'),
+			$field = $('#validationFieldFail');
+		$.h5Validate.addValidator($field,function(){return false;});
+		$form.h5Validate();
+		equal($field.h5Validate('isValid'), false, 'Adding an validator that returns false should cause validation to fail.');
+	});
+
+	test('Adding an validator that confirms the value of the input should not cause validation to fail.',function () {
+		var $form = $('#validationForm'),
+			$field = $('#validationFieldExample');
+		$.h5Validate.addValidator($field,function(value){return value == 'example';});
+		$form.h5Validate();
+		equal($field.h5Validate('isValid'), true, 'Adding an validator that confirms the value of the input should not cause validation to fail.');
+	});
+
+	test('Adding an validator that disconfirms the value of the input should cause validation to fail.',function () {
+		var $form = $('#validationForm'),
+			$field = $('#validationFieldNotExample');
+		$.h5Validate.addValidator($field,function(value){return value == 'example';});
+		$form.h5Validate();
+		equal($field.h5Validate('isValid'), false, 'Adding an validator that disconfirms the value of the input should cause validation to fail.');
+	});
+
+	test('Adding an validator to a selector that does not exist should not cause validation to fail.',function () {
+		var $form = $('#validationFormPass');
+		$.h5Validate.addValidator('atagthatdoesntexistinhtml',function(){return false;});
+		$form.h5Validate();
+		equal($form.h5Validate('allValid'), true, 'Adding an validator to a selector that does not exist should not cause validation to fail.');
+	});
+
+	test('validators should be passed the value of the DOM element.',function () {
+		var $form = $('#validationForm'),
+			$field = $('#validationFieldExample');
+		$.h5Validate.addValidator($field,function(value) {
+			equal(value, $field.val(), 'validators should be passed the value of the DOM element.');
+			return true;
+		});
+		$form.h5Validate();
+		$field.h5Validate('isValid');
+	});
+
+	test('validators should be run in the context of the DOM element of the target field.',function () {
+		var $form = $('#validationForm'),
+			$field = $('#validationFieldExample');
+		$.h5Validate.addValidator($field,function() {
+			equal(this, $field.get(0), 'validators should be run in the context of the DOM element of the target field.');
+			return true;
+		});
+		$form.h5Validate();
+		$field.h5Validate('isValid');
+	});
+
+	test('If an added validator fails, the validity "failedValidator" field should be true.',function () {
+		var $form = $('#validationForm'),
+			$field = $('#validationFieldNotExampleNotNamed');
+		$.h5Validate.addValidator($field,function(value){return value == 'example';});
+		$field.on('validated',function(event,validity) {
+			ok(validity.failedValidator, 'If an added validator fails, the validity "failedValidator" field should be true.');
+		});
+		$form.h5Validate();
+		$field.h5Validate('isValid');
+	});
+
+	test('If no validator name is supplied,the validity "failedValidatorNames" property should be null.',function () {
+		var $form = $('#validationForm'),
+			$field = $('#validationFieldNotExampleNotNamed');
+		$.h5Validate.addValidator($field,function(value){return value == 'example';});
+		$field.on('validated',function(event,validity) {
+			deepEqual(validity.failedValidatorNames, [], 'If no validator name is supplied,the validity "failedValidatorNames" property should be an empty array.');
+		});
+		$form.h5Validate();
+		$field.h5Validate('isValid');
+	});
+
+	test('Supplied validator names should be assigned to the validity "failedValidatorNames" property if they exist.',function () {
+		var $form = $('#validationForm'),
+			$field = $('#validationFieldNotExampleNamed'),
+			validatorName = 'exampleValidator';
+		$.h5Validate.addValidator($field,function(value){return value == 'example';},{name: validatorName});
+		$field.on('validated',function(event,validity) {
+			deepEqual(validity.failedValidatorNames, [validatorName], 'Supplied validator names should be assigned to the validity "failedValidatorNames" property if they exist.');
+		});
+		$form.h5Validate();
+		$field.h5Validate('isValid');
+	});
+
   }
   exports.runTests = runTests;
 }((typeof exports !== 'undefined') ? exports : window));