diff --git a/.travis.yml b/.travis.yml
index 589efde750..91c5777bea 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -7,5 +7,8 @@ node_js:
   - 0.12
   - 0.11
 
+before_script:
+  - typings install
+
 after_success:
   - bash <(curl -s https://codecov.io/bash)
\ No newline at end of file
diff --git a/README.md b/README.md
index 6138ca1e13..804355976a 100644
--- a/README.md
+++ b/README.md
@@ -6,24 +6,45 @@
 [![Dependency Status](https://david-dm.org/pleerock/class-validator.svg)](https://david-dm.org/pleerock/class-validator)
 [![devDependency Status](https://david-dm.org/pleerock/class-validator/dev-status.svg)](https://david-dm.org/pleerock/class-validator#info=devDependencies)
 
-Allows use of decorator and non-decorator based validation. Internally uses [validator.js][1] to perform validation.
+Allows use of decorator and non-decorator based validation.
+Internally uses [validator.js][1] to perform validation.
+Class-validator works on both browser and node.js platforms.
 
 ## Installation
 
-1. Install module:
+Install module:
 
-    `npm install class-validator --save`
+`npm install class-validator --save`
 
-2. ES6 features are used, so you may want to install [es6-shim](https://github.com/paulmillr/es6-shim) too:
+#### Old versions of node.js/browser
 
-    `npm install es6-shim --save`
+ES6 features are used, if you are using old versions of node (or browser) you may want to install [es6-shim](https://github.com/paulmillr/es6-shim) too:
 
-    and use it somewhere in the global place of your app:
+`npm install es6-shim --save`
 
-    * for nodejs: `require("es6-shim")` (or `import "es6-shim";`) in your app's entry point (for example in `app.ts`)
-    * for browser: `<script src="node_modules/es6-shim/es6-shim.js">` in your `index.html`
+and use it somewhere in the global place of your app:
 
-    For node.js users this step is only required if you are using old versions of node.
+* for nodejs: `require("es6-shim")` (or `import "es6-shim";`) in your app's entry point (for example in `app.ts`)
+* for browser: `<script src="node_modules/es6-shim/es6-shim.js">` in your `index.html`
+
+This step is only required if you are using old versions of node/browser.
+
+#### Using in browser
+
+If you are using class-validator with system.js in browser then use following configuration:
+
+```javascript
+System.config({
+    map: {
+        'class-validator': 'vendor/class-validator',
+        'validator': 'vendor/validator'
+    },
+    packages: {
+        'class-validator': { 'defaultExtension': 'js', 'main': 'index.js' },
+        'validator': { 'defaultExtension': 'js', 'main': 'validator.js' },
+    }
+};
+```
 
 ## Usage
 
@@ -295,7 +316,7 @@ If you have custom validation logic you can create a *Constraint class*:
     ```typescript
     import {ValidatorConstraint, ValidatorConstraintInterface, ValidationArguments} from "class-validator";
 
-    @ValidatorConstraint()
+    @ValidatorConstraint({ name: "customText", async: false })
     export class CustomTextLength implements ValidatorConstraintInterface {
 
         validate(text: string, args: ValidationArguments) {
@@ -389,17 +410,25 @@ Lets create a decorator called `@IsLongerThan`:
 1. Create a decorator itself:
 
     ```typescript
-    import {registerDecorator, ValidationOptions} from "class-validator";
+    import {registerDecorator, ValidationOptions, ValidationArguments} from "class-validator";
 
     export function IsLongerThan(property: string, validationOptions?: ValidationOptions) {
        return function (object: Object, propertyName: string) {
-           registerDecorator(object, propertyName, validationOptions, [property], "is_longer_than", (value, args) => {
-               const [relatedPropertyName] = args.constraints;
-               const relatedValue = (args.object as any)[relatedPropertyName];
-               return  typeof value === "string" &&
-                       typeof relatedValue === "string" &&
-                       value.length > relatedValue.length; // you can return a Promise<boolean> here as well, if you want to make async validation
-           });
+            registerDecorator({
+                name: "isLongerThan",
+                target: object.constructor,
+                propertyName: propertyName,
+                options: validationOptions,
+                validator: {
+                    validate(value: any, args: ValidationArguments) {
+                        const [relatedPropertyName] = args.constraints;
+                        const relatedValue = (args.object as any)[relatedPropertyName];
+                        return  typeof value === "string" &&
+                               typeof relatedValue === "string" &&
+                               value.length > relatedValue.length; // you can return a Promise<boolean> here as well, if you want to make async validation
+                    }
+                }
+            });
        };
     }
     ```
@@ -430,7 +459,7 @@ Lets create another custom validation decorator called `IsUserAlreadyExist`:
     ```typescript
     import {registerDecorator, ValidationOptions, ValidatorConstraint, ValidatorConstraintInterface, ValidationArguments} from "class-validator";
 
-    @ValidatorConstraint()
+    @ValidatorConstraint({ async: true })
     export class IsUserAlreadyExistConstraint implements ValidatorConstraintInterface {
 
         validate(userName: any, args: ValidationArguments) {
@@ -444,11 +473,19 @@ Lets create another custom validation decorator called `IsUserAlreadyExist`:
 
     export function IsUserAlreadyExist(validationOptions?: ValidationOptions) {
        return function (object: Object, propertyName: string) {
-           registerDecorator(object, propertyName, validationOptions, [], IsUserAlreadyExistConstraint);
+            registerDecorator({
+                target: object.constructor,
+                propertyName: propertyName,
+                options: validationOptions,
+                constraints: [],
+                validator: IsUserAlreadyExistConstraint
+            });
        };
     }
     ```
 
+    note that we marked our constraint that it will by async by adding `{ async: true }` in validation options.
+
 2. And put it to use:
 
     ```typescript
@@ -481,6 +518,12 @@ let validator = Container.get(Validator);
 // also you can inject classes using constructor injection into your custom ValidatorConstraint-s
 ```
 
+## Synchronous validation
+
+If you want to perform a simple non async validation you can use `validateSync` method instead of regular `validate`
+ method. It has the same arguments as `validate` method. But note, this method **ignores** all async validations
+ you have.
+
 ## Manual validation
 
 There are several method exist in the Validator that allows to perform non-decorator based validation:
diff --git a/doc/release-notes.md b/doc/release-notes.md
index 2fc28a1f50..bd436e4e26 100644
--- a/doc/release-notes.md
+++ b/doc/release-notes.md
@@ -1,10 +1,18 @@
 # Release notes
 
+**0.5.0**
+
+* async validations must be marked with `{ async: true }` option now.
+This is optional, but it helps to determine which decorators are async to prevent their execution in `validateSync` method.
+* added `validateSync` method that performs non asynchronous validation and ignores validations that marked with `async: true`.
+* there is a breaking change in `registerDecorator` method. Now it accepts options object.
+* breaking change with `@ValidatorConstraint` decorator. Now it accepts option object instead of single name.
+
 **0.4.1**
 
 * fixed issue with wrong source maps packaged
 
-**0.4.0** *[BREAKING CHANGES]*
+**0.4.0**
 
 * everything should be imported from "class-validator" main entry point now
 * `ValidatorInterface` has been renamed to `ValidatorConstraintInterface`
diff --git a/package.json b/package.json
index 083acb9c10..985b602afb 100644
--- a/package.json
+++ b/package.json
@@ -1,8 +1,8 @@
 {
   "name": "class-validator",
   "private": true,
-  "version": "0.4.1",
-  "description": "Class-based validation in Typescript using decorators",
+  "version": "0.5.0-alpha.3",
+  "description": "Class-based validation with Typescript / ES6 / ES5 using decorators or validation schemas. Supports both node.js and browser",
   "license": "MIT",
   "readmeFilename": "README.md",
   "author": {
@@ -50,7 +50,6 @@
     "typings": "^1.3.1"
   },
   "scripts": {
-    "postinstall": "typings install",
     "test": "gulp tests"
   }
 }
diff --git a/sample/sample6-custom-decorator/IsLongerThan.ts b/sample/sample6-custom-decorator/IsLongerThan.ts
index e3aa516fde..90bde6e092 100644
--- a/sample/sample6-custom-decorator/IsLongerThan.ts
+++ b/sample/sample6-custom-decorator/IsLongerThan.ts
@@ -6,11 +6,17 @@ import {ValidationArguments} from "../../src/validation/ValidationArguments";
 
 export function IsLongerThan(property: string, validationOptions?: ValidationOptions) {
     return function (object: Object, propertyName: string) {
-        registerDecorator(object, propertyName, validationOptions, [property], IsLongerThanConstraint);
+        registerDecorator({
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            constraints: [property],
+            validator: IsLongerThanConstraint
+        });
     };
 }
 
-@ValidatorConstraint("is_longer_than")
+@ValidatorConstraint({ name: "isLongerThan" })
 export class IsLongerThanConstraint implements ValidatorConstraintInterface {
     
     validate(value: any, args: ValidationArguments) {
diff --git a/sample/sample6-custom-decorator/IsUserAlreadyExist.ts b/sample/sample6-custom-decorator/IsUserAlreadyExist.ts
index 0a32c94b07..49474e9c61 100644
--- a/sample/sample6-custom-decorator/IsUserAlreadyExist.ts
+++ b/sample/sample6-custom-decorator/IsUserAlreadyExist.ts
@@ -4,15 +4,23 @@ import {ValidationArguments} from "../../src/validation/ValidationArguments";
 
 export function IsUserAlreadyExist(validationOptions?: ValidationOptions) {
     return function (object: Object, propertyName: string) {
-        const constraints: any[] = [/*constraints your decorator can have*/];
-        registerDecorator(object, propertyName, validationOptions, constraints, "user_exists", (userName, args) => {
-            return new Promise(ok => {
-                if (userName !== "admin" && userName !== "user") {
-                    ok(true);
-                } else {
-                    ok(false);
+        registerDecorator({
+            name: "isUserAlreadyExist",
+            async: true,
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate(value: any, args: ValidationArguments) {
+                    return new Promise(ok => {
+                        if (value !== "admin" && value !== "user") {
+                            ok(true);
+                        } else {
+                            ok(false);
+                        }
+                    });
                 }
-            });
+            }
         });
     };
 }
\ No newline at end of file
diff --git a/src/container.ts b/src/container.ts
new file mode 100644
index 0000000000..cc18963daf
--- /dev/null
+++ b/src/container.ts
@@ -0,0 +1,66 @@
+
+/**
+ * Container options.
+ */
+export interface UseContainerOptions {
+
+    /**
+     * If set to true, then default container will be used in the case if given container haven't returned anything.
+     */
+    fallback?: boolean;
+
+    /**
+     * If set to true, then default container will be used in the case if given container thrown an exception.
+     */
+    fallbackOnErrors?: boolean;
+
+}
+
+/**
+ * Container to be used by this library for inversion control. If container was not implicitly set then by default
+ * container simply creates a new instance of the given class.
+ */
+const defaultContainer: { get<T>(someClass: { new (...args: any[]): T }|Function): T } = new (class {
+    private instances: { type: Function, object: any }[] = [];
+    get<T>(someClass: { new (...args: any[]): T }): T {
+        let instance = this.instances.find(instance => instance.type === someClass);
+        if (!instance) {
+            instance = { type: someClass, object: new someClass() };
+            this.instances.push(instance);
+        }
+
+        return instance.object;
+    }
+})();
+
+let userContainer: { get<T>(someClass: { new (...args: any[]): T }|Function): T };
+let userContainerOptions: UseContainerOptions;
+
+/**
+ * Sets container to be used by this library.
+ */
+export function useContainer(iocContainer: { get(someClass: any): any }, options?: UseContainerOptions) {
+    userContainer = iocContainer;
+    userContainerOptions = options;
+}
+
+/**
+ * Gets the IOC container used by this library.
+ */
+export function getFromContainer<T>(someClass: { new (...args: any[]): T }|Function): T {
+    if (userContainer) {
+        try {
+            const instance = userContainer.get(someClass);
+            if (instance)
+                return instance;
+
+            if (!userContainerOptions || !userContainerOptions.fallback)
+                return instance;
+
+        } catch (error) {
+            if (!userContainerOptions || !userContainerOptions.fallbackOnErrors)
+                throw error;
+        }
+    }
+    return defaultContainer.get<T>(someClass);
+}
diff --git a/src/decorator/decorators.ts b/src/decorator/decorators.ts
index c3f862ea2a..4711193ae6 100644
--- a/src/decorator/decorators.ts
+++ b/src/decorator/decorators.ts
@@ -14,14 +14,17 @@ import {MetadataStorage} from "../metadata/MetadataStorage";
 /**
  * Registers custom validator class.
  */
-export function ValidatorConstraint(name?: string) {
+export function ValidatorConstraint(options?: { name?: string, async?: boolean }) {
     return function(target: Function) {
+        const isAsync = options && options.async ? true : false;
+        let name = options && options.name ? options.name : "";
         if (!name) {
             name = (target as any).name;
             if (!name) // generate name if it was not given
                 name = name.replace(/\.?([A-Z]+)/g, (x, y) => "_" + y.toLowerCase()).replace(/^_/, "");
         }
-        getFromContainer(MetadataStorage).addConstraintMetadata(new ConstraintMetadata(target, name));
+        const metadata = new ConstraintMetadata(target, name, isAsync);
+        getFromContainer(MetadataStorage).addConstraintMetadata(metadata);
     };
 } 
 
diff --git a/src/index.ts b/src/index.ts
index 263f073204..813607597d 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -2,85 +2,14 @@ import {ValidationError} from "./validation/ValidationError";
 import {ValidatorOptions} from "./validation/ValidatorOptions";
 import {ValidationSchema} from "./validation-schema/ValidationSchema";
 import {MetadataStorage} from "./metadata/MetadataStorage";
-import {ConstraintMetadata} from "./metadata/ConstraintMetadata";
-import {ValidatorConstraintInterface} from "./validation/ValidatorConstraintInterface";
-import {ValidationMetadata} from "./metadata/ValidationMetadata";
-import {ValidationMetadataArgs} from "./metadata/ValidationMetadataArgs";
-import {ValidationTypes} from "./validation/ValidationTypes";
 import {Validator} from "./validation/Validator";
-import {ValidationArguments} from "./validation/ValidationArguments";
-
-// -------------------------------------------------------------------------
-// Global Container
-// -------------------------------------------------------------------------
-
-/**
- * Container options.
- */
-export interface UseContainerOptions {
-
-    /**
-     * If set to true, then default container will be used in the case if given container haven't returned anything.
-     */
-    fallback?: boolean;
-
-    /**
-     * If set to true, then default container will be used in the case if given container thrown an exception.
-     */
-    fallbackOnErrors?: boolean;
-
-}
-
-/**
- * Container to be used by this library for inversion control. If container was not implicitly set then by default
- * container simply creates a new instance of the given class.
- */
-const defaultContainer: { get<T>(someClass: { new (...args: any[]): T }|Function): T } = new (class {
-    private instances: any[] = [];
-    get<T>(someClass: { new (...args: any[]): T }): T {
-        if (!this.instances[someClass as any])
-            this.instances[someClass as any] = new someClass();
-
-        return this.instances[<any>someClass];
-    }
-})();
-
-let userContainer: { get<T>(someClass: { new (...args: any[]): T }|Function): T };
-let userContainerOptions: UseContainerOptions;
-
-/**
- * Sets container to be used by this library.
- */
-export function useContainer(iocContainer: { get(someClass: any): any }, options?: UseContainerOptions) {
-    userContainer = iocContainer;
-    userContainerOptions = options;
-}
-
-/**
- * Gets the IOC container used by this library.
- */
-export function getFromContainer<T>(someClass: { new (...args: any[]): T }|Function): T {
-    if (userContainer) {
-        try {
-            const instance = userContainer.get(someClass);
-            if (instance)
-                return instance;
-
-            if (!userContainerOptions || !userContainerOptions.fallback)
-                return instance;
-
-        } catch (error) {
-            if (!userContainerOptions || !userContainerOptions.fallbackOnErrors)
-                throw error;
-        }
-    }
-    return defaultContainer.get<T>(someClass);
-}
+import {getFromContainer} from "./container";
 
 // -------------------------------------------------------------------------
 // Export everything api users needs
 // -------------------------------------------------------------------------
 
+export * from "./container";
 export * from "./decorator/decorators";
 export * from "./decorator/ValidationOptions";
 export * from "./validation/ValidatorConstraintInterface";
@@ -91,6 +20,7 @@ export * from "./validation/ValidationArguments";
 export * from "./validation/ValidationTypes";
 export * from "./validation/Validator";
 export * from "./validation-schema/ValidationSchema";
+export * from "./register-decorator";
 
 // -------------------------------------------------------------------------
 // Shortcut methods for api users
@@ -109,7 +39,9 @@ export function validate(schemaName: string, object: Object, validatorOptions?:
 /**
  * Validates given object by object's decorators or given validation schema.
  */
-export function validate(schemaNameOrObject: Object|string, objectOrValidationOptions?: Object|ValidatorOptions, maybeValidatorOptions?: ValidatorOptions): Promise<ValidationError[]> {
+export function validate(schemaNameOrObject: Object|string, 
+                         objectOrValidationOptions?: Object|ValidatorOptions, 
+                         maybeValidatorOptions?: ValidatorOptions): Promise<ValidationError[]> {
     if (typeof schemaNameOrObject === "string") {
         return getFromContainer(Validator).validate(schemaNameOrObject as string, objectOrValidationOptions as Object, maybeValidatorOptions);
     } else {
@@ -118,70 +50,37 @@ export function validate(schemaNameOrObject: Object|string, objectOrValidationOp
 }
 
 /**
- * Registers a new validation schema.
- */
-export function registerSchema(schema: ValidationSchema): void {
-    getFromContainer(MetadataStorage).addValidationSchema(schema);
-}
-
-/**
- * Registers a custom validation decorator.
+ * Performs sync validation of the given object. 
+ * Note that this method completely ignores async validations.
+ * If you want to properly perform validation you need to call validate method instead.
  */
-export function registerDecorator(object: Object,
-                                  propertyName: string,
-                                  validationOptions: ValidatorOptions,
-                                  constraints: any[],
-                                  constraintCls: Function): void;
+export function validateSync(object: Object, validatorOptions?: ValidatorOptions): ValidationError[];
 
 /**
- * Registers a custom validation decorator.
+ * Validates given object by a given validation schema.
+ * Note that this method completely ignores async validations.
+ * If you want to properly perform validation you need to call validate method instead.
  */
-export function registerDecorator(object: Object,
-                                  propertyName: string,
-                                  validationOptions: ValidatorOptions,
-                                  constraints: any[],
-                                  validationName: string,
-                                  validateCallback: (value?: any, args?: ValidationArguments) => boolean|Promise<boolean>,
-                                  defaultMessageCallback?: (args?: ValidationArguments) => string): void;
+export function validateSync(schemaName: string, object: Object, validatorOptions?: ValidatorOptions): ValidationError[];
 
 /**
- * Registers a custom validation decorator.
+ * Validates given object by object's decorators or given validation schema.
+ * Note that this method completely ignores async validations.
+ * If you want to properly perform validation you need to call validate method instead.
  */
-export function registerDecorator(object: Object,
-                                  propertyName: string,
-                                  validationOptions: ValidatorOptions,
-                                  constraints: any[],
-                                  validationNameOrConstraintCls: string|Function,
-                                  callback?: (value?: any, validationArguments?: ValidationArguments) => boolean|Promise<boolean>,
-                                  defaultMessageCallback?: (args?: ValidationArguments) => string): void {
-    
-    let constraintCls: Function;
-    if (validationNameOrConstraintCls instanceof Function) {
-        constraintCls = validationNameOrConstraintCls as Function;
+export function validateSync(schemaNameOrObject: Object|string, 
+                             objectOrValidationOptions?: Object|ValidatorOptions, 
+                             maybeValidatorOptions?: ValidatorOptions): ValidationError[] {
+    if (typeof schemaNameOrObject === "string") {
+        return getFromContainer(Validator).validateSync(schemaNameOrObject as string, objectOrValidationOptions as Object, maybeValidatorOptions);
     } else {
-        constraintCls = class CustomConstraint implements ValidatorConstraintInterface {
-            validate(value: any, validationArguments?: ValidationArguments): Promise<boolean>|boolean {
-                return callback(value, validationArguments);
-            }
-
-            defaultMessage(validationArguments?: ValidationArguments) {
-                if (defaultMessageCallback) {
-                    return defaultMessageCallback(validationArguments);
-                }
-
-                return "";
-            }
-        };
-        getFromContainer(MetadataStorage).addConstraintMetadata(new ConstraintMetadata(constraintCls, validationNameOrConstraintCls as string));
+        return getFromContainer(Validator).validateSync(schemaNameOrObject as Object, objectOrValidationOptions as ValidatorOptions);
     }
+}
 
-    const validationMetadataArgs: ValidationMetadataArgs = {
-        type: ValidationTypes.CUSTOM_VALIDATION,
-        target: object.constructor,
-        propertyName: propertyName,
-        validationOptions: validationOptions,
-        constraintCls: constraintCls,
-        constraints: constraints
-    };
-    getFromContainer(MetadataStorage).addValidationMetadata(new ValidationMetadata(validationMetadataArgs));
-}
\ No newline at end of file
+/**
+ * Registers a new validation schema.
+ */
+export function registerSchema(schema: ValidationSchema): void {
+    getFromContainer(MetadataStorage).addValidationSchema(schema);
+}
diff --git a/src/metadata/ConstraintMetadata.ts b/src/metadata/ConstraintMetadata.ts
index 3eb75fcf74..7eef4fde9a 100644
--- a/src/metadata/ConstraintMetadata.ts
+++ b/src/metadata/ConstraintMetadata.ts
@@ -20,13 +20,19 @@ export class ConstraintMetadata {
      */
     name: string;
 
+    /**
+     * Indicates if this validation is asynchronous or not.
+     */
+    async: boolean;
+
     // -------------------------------------------------------------------------
     // Constructor
     // -------------------------------------------------------------------------
     
-    constructor(target: Function, name?: string) {
+    constructor(target: Function, name?: string, async: boolean = false) {
         this.target = target;
         this.name = name;
+        this.async = async;
     }
 
     // -------------------------------------------------------------------------
diff --git a/src/register-decorator.ts b/src/register-decorator.ts
new file mode 100644
index 0000000000..6f7c50d96d
--- /dev/null
+++ b/src/register-decorator.ts
@@ -0,0 +1,84 @@
+import {ValidatorOptions} from "./validation/ValidatorOptions";
+import {MetadataStorage} from "./metadata/MetadataStorage";
+import {ConstraintMetadata} from "./metadata/ConstraintMetadata";
+import {ValidatorConstraintInterface} from "./validation/ValidatorConstraintInterface";
+import {ValidationMetadata} from "./metadata/ValidationMetadata";
+import {ValidationMetadataArgs} from "./metadata/ValidationMetadataArgs";
+import {ValidationTypes} from "./validation/ValidationTypes";
+import {ValidationArguments} from "./validation/ValidationArguments";
+import {getFromContainer} from "./container";
+
+export interface ValidationDecoratorOptions {
+
+    /**
+     * Target object to be validated.
+     */
+    target: Function;
+
+    /**
+     * Target object's property name to be validated.
+     */
+    propertyName: string;
+
+    /**
+     * Name of the validation that is being registered.
+     */
+    name?: string;
+
+    /**
+     * Indicates if this decorator will perform async validation.
+     */
+    async?: boolean;
+
+    /**
+     * Validator options.
+     */
+    options: ValidatorOptions;
+
+    /**
+     * Array of validation constraints.
+     */
+    constraints?: any[];
+
+    /**
+     * Validator that performs validation.
+     */
+    validator: ValidatorConstraintInterface|Function;
+}
+
+/**
+ * Registers a custom validation decorator.
+ */
+export function registerDecorator(options: ValidationDecoratorOptions): void {
+
+    let constraintCls: Function;
+    if (options.validator instanceof Function) {
+        constraintCls = options.validator as Function;
+    } else {
+        const validator = options.validator as ValidatorConstraintInterface;
+        constraintCls = class CustomConstraint implements ValidatorConstraintInterface {
+            validate(value: any, validationArguments?: ValidationArguments): Promise<boolean>|boolean {
+                return validator.validate(value, validationArguments);
+            }
+
+            defaultMessage(validationArguments?: ValidationArguments) {
+                if (validator.defaultMessage) {
+                    return validator.defaultMessage(validationArguments);
+                }
+
+                return "";
+            }
+        };
+        getFromContainer(MetadataStorage).addConstraintMetadata(new ConstraintMetadata(constraintCls, options.name, options.async));
+    }
+
+    const validationMetadataArgs: ValidationMetadataArgs = {
+        type: ValidationTypes.CUSTOM_VALIDATION,
+        target: options.target,
+        propertyName: options.propertyName,
+        validationOptions: options.options,
+        constraintCls: constraintCls,
+        constraints: options.constraints
+    };
+    getFromContainer(MetadataStorage).addValidationMetadata(new ValidationMetadata(validationMetadataArgs));
+}
\ No newline at end of file
diff --git a/src/validation/ValidationExecutor.ts b/src/validation/ValidationExecutor.ts
index 93aa41fc54..2c924a5799 100644
--- a/src/validation/ValidationExecutor.ts
+++ b/src/validation/ValidationExecutor.ts
@@ -18,7 +18,8 @@ export class ValidationExecutor {
     // Properties
     // -------------------------------------------------------------------------
 
-    private awaitingPromises: Promise<any>[] = [];
+    awaitingPromises: Promise<any>[] = [];
+    ignoreAsyncValidations: boolean = false;
 
     // -------------------------------------------------------------------------
     // Private Properties
@@ -78,22 +79,14 @@ export class ValidationExecutor {
 
             this.defaultValidations(object, value, metadatas, validationError.constraints);
             this.customValidations(object, value, customValidationMetadatas, validationError.constraints);
-            this.nestedValidations(object, value, nestedValidationMetadatas, validationError.children);
-        });
-
-        return Promise.all(this.awaitingPromises).then(() => {
-            return this.removeEmptyErrors(validationErrors);
+            this.nestedValidations(value, nestedValidationMetadatas, validationError.children);
         });
     }
-    
-    // -------------------------------------------------------------------------
-    // Private Methods
-    // -------------------------------------------------------------------------
 
-    private removeEmptyErrors(errors: ValidationError[]) {
+    stripEmptyErrors(errors: ValidationError[]) {
         return errors.filter(error => {
             if (error.children) {
-                error.children = this.removeEmptyErrors(error.children);
+                error.children = this.stripEmptyErrors(error.children);
             }
 
             if (Object.keys(error.constraints).length === 0) {
@@ -107,6 +100,10 @@ export class ValidationExecutor {
             return true;
         });
     }
+    
+    // -------------------------------------------------------------------------
+    // Private Methods
+    // -------------------------------------------------------------------------
 
     private defaultValidations(object: Object,
                                value: any,
@@ -137,6 +134,8 @@ export class ValidationExecutor {
             getFromContainer(MetadataStorage)
                 .getTargetValidatorConstraints(metadata.constraintCls)
                 .forEach(customConstraintMetadata => {
+                    if (customConstraintMetadata.async && this.ignoreAsyncValidations)
+                        return;
 
                     const validationArguments: ValidationArguments = {
                         targetName: object.constructor ? (object.constructor as any).name : undefined,
@@ -164,16 +163,16 @@ export class ValidationExecutor {
         });
     }
     
-    private nestedValidations(object: Object, value: any, metadatas: ValidationMetadata[], errors: ValidationError[]) {
+    private nestedValidations(value: any, metadatas: ValidationMetadata[], errors: ValidationError[]) {
         metadatas.forEach(metadata => {
             if (metadata.type !== ValidationTypes.NESTED_VALIDATION) return;
             const targetSchema = typeof metadata.target === "string" ? metadata.target as string : undefined;
 
             if (value instanceof Array) {
-                value.forEach((subValue: any) => this.awaitingPromises.push(this.execute(subValue, targetSchema, errors)));
+                value.forEach((subValue: any) => this.execute(subValue, targetSchema, errors));
 
             } else if (value instanceof Object) {
-                this.awaitingPromises.push(this.execute(value, targetSchema, errors));
+                this.execute(value, targetSchema, errors);
 
             } else {
                 throw new Error("Only objects and arrays are supported to nested validation");
diff --git a/src/validation/Validator.ts b/src/validation/Validator.ts
index 2f5c0ca657..935f782704 100644
--- a/src/validation/Validator.ts
+++ b/src/validation/Validator.ts
@@ -24,22 +24,54 @@ export class Validator {
     /**
      * Performs validation of the given object based on decorators used in given object class.
      */
-    validate(object: Object, validatorOptions?: ValidatorOptions): Promise<ValidationError[]>;
+    validate(object: Object, options?: ValidatorOptions): Promise<ValidationError[]>;
 
     /**
      * Performs validation of the given object based on validation schema.
      */
-    validate(schemaName: string, object: Object, validatorOptions?: ValidatorOptions): Promise<ValidationError[]>;
+    validate(schemaName: string, object: Object, options?: ValidatorOptions): Promise<ValidationError[]>;
 
     /**
      * Performs validation of the given object based on decorators or validation schema.
      */
     validate(objectOrSchemaName: Object|string, objectOrValidationOptions: Object|ValidationOptions, maybeValidatorOptions?: ValidatorOptions): Promise<ValidationError[]> {
-        if (typeof objectOrSchemaName === "string") {
-            return new ValidationExecutor(this, maybeValidatorOptions).execute(objectOrValidationOptions as Object, objectOrSchemaName as string, []);
-        } else {
-            return new ValidationExecutor(this, objectOrValidationOptions as ValidationOptions).execute(objectOrSchemaName as Object, undefined, []);
-        }
+        const object = typeof objectOrSchemaName === "string" ? objectOrValidationOptions as Object : objectOrSchemaName as Object;
+        const options = typeof objectOrSchemaName === "string" ? maybeValidatorOptions : objectOrValidationOptions as ValidationOptions;
+        const schema = typeof objectOrSchemaName === "string" ? objectOrSchemaName as string : undefined;
+
+        const executor = new ValidationExecutor(this, options);
+        const validationErrors: ValidationError[] = [];
+        executor.execute(object, schema, validationErrors);
+
+        return Promise.all(executor.awaitingPromises).then(() => {
+            return executor.stripEmptyErrors(validationErrors);
+        });
+    }
+    
+    /**
+     * Performs validation of the given object based on decorators used in given object class.
+     * NOTE: This method completely ignores all async validations.
+     */
+    validateSync(object: Object, options?: ValidatorOptions): ValidationError[];
+
+    /**
+     * Performs validation of the given object based on validation schema.
+     */
+    validateSync(schemaName: string, object: Object, options?: ValidatorOptions): ValidationError[];
+
+    /**
+     * Performs validation of the given object based on decorators or validation schema.
+     */
+    validateSync(objectOrSchemaName: Object|string, objectOrValidationOptions: Object|ValidationOptions, maybeValidatorOptions?: ValidatorOptions): ValidationError[] {
+        const object = typeof objectOrSchemaName === "string" ? objectOrValidationOptions as Object : objectOrSchemaName as Object;
+        const options = typeof objectOrSchemaName === "string" ? maybeValidatorOptions : objectOrValidationOptions as ValidationOptions;
+        const schema = typeof objectOrSchemaName === "string" ? objectOrSchemaName as string : undefined;
+
+        const executor = new ValidationExecutor(this, options);
+        executor.ignoreAsyncValidations = true;
+        const validationErrors: ValidationError[] = [];
+        executor.execute(object, schema, validationErrors);
+        return executor.stripEmptyErrors(validationErrors);
     }
 
     /**
diff --git a/test/functional/custom-decorators.spec.ts b/test/functional/custom-decorators.spec.ts
new file mode 100644
index 0000000000..198789c5a7
--- /dev/null
+++ b/test/functional/custom-decorators.spec.ts
@@ -0,0 +1,221 @@
+import "es6-shim";
+import {Validator} from "../../src/validation/Validator";
+import {ValidationArguments} from "../../src/validation/ValidationArguments";
+import {registerDecorator} from "../../src/register-decorator";
+import {ValidationOptions} from "../../src/decorator/ValidationOptions";
+import {ValidatorConstraint} from "../../src/decorator/decorators";
+import {ValidatorConstraintInterface} from "../../src/validation/ValidatorConstraintInterface";
+
+// -------------------------------------------------------------------------
+// Setup
+// -------------------------------------------------------------------------
+
+const validator = new Validator();
+
+// -------------------------------------------------------------------------
+// Specifications: common decorators
+// -------------------------------------------------------------------------
+
+describe("custom decorators", function() {
+
+    describe("decorator with inline validation", function() {
+
+        function IsLongerThan(property: string, validationOptions?: ValidationOptions) {
+            return function (object: Object, propertyName: string) {
+                registerDecorator({
+                    target: object.constructor,
+                    propertyName: propertyName,
+                    options: validationOptions,
+                    constraints: [property],
+                    name: "isLongerThan",
+                    validator: {
+                        validate(value: any, args: ValidationArguments) {
+                            const [relatedPropertyName] = args.constraints;
+                            const relatedValue = (args.object as any)[relatedPropertyName];
+                            if (relatedValue === undefined || relatedValue === null)
+                                return true;
+                            
+                            return typeof value === "string" &&
+                                typeof relatedValue === "string" &&
+                                value.length > relatedValue.length;
+                        }
+                    }
+                });
+            };
+        }
+        
+        class MyClass {
+            @IsLongerThan("lastName", {
+                message: "$property must be longer then $constraint1. Given value: $value"
+            })
+            firstName: string;
+            
+            lastName: string;
+        }
+
+        it("if firstName is not empty and lastLame is empty then it should succeed", function() {
+            const model = new MyClass();
+            model.firstName = "hell no world";
+            return validator.validate(model).then(errors => {
+                errors.length.should.be.equal(0);
+            });
+        });
+
+        it("if firstName is empty and lastLame is not empty then it should fail", function() {
+            const model = new MyClass();
+            model.firstName = "";
+            model.lastName = "Kim";
+            return validator.validate(model).then(errors => {
+                errors.length.should.be.equal(1);
+                errors[0].constraints.should.be.eql({ isLongerThan: "firstName must be longer then lastName. Given value: " });
+            });
+        });
+
+        it("if firstName is shorter then lastLame then it should fail", function() {
+            const model = new MyClass();
+            model.firstName = "Li";
+            model.lastName = "Kim";
+            return validator.validate(model).then(errors => {
+                errors.length.should.be.equal(1);
+                errors[0].constraints.should.be.eql({ isLongerThan: "firstName must be longer then lastName. Given value: Li" });
+            });
+        });
+        
+    });
+    
+    describe("decorator with default message", function() {
+
+        function IsLonger(property: string, validationOptions?: ValidationOptions) {
+            return function (object: Object, propertyName: string) {
+                registerDecorator({
+                    target: object.constructor,
+                    propertyName: propertyName,
+                    options: validationOptions,
+                    constraints: [property],
+                    name: "isLonger",
+                    validator: {
+                        validate(value: any, args: ValidationArguments) {
+                            const [relatedPropertyName] = args.constraints;
+                            const relatedValue = (args.object as any)[relatedPropertyName];
+                            if (relatedValue === undefined || relatedValue === null)
+                                return true;
+                            
+                            return typeof value === "string" &&
+                                typeof relatedValue === "string" &&
+                                value.length > relatedValue.length;
+                        },
+                        defaultMessage(args: ValidationArguments) {
+                            return args.property + " must be longer then " + args.constraints[0];
+                        }
+                    }
+                });
+            };
+        }
+        
+        class SecondClass {
+            @IsLonger("lastName")
+            firstName: string;
+            
+            lastName: string;
+        }
+
+        it("if firstName is not empty and lastLame is empty then it should succeed", function() {
+            const model = new SecondClass();
+            model.firstName = "hell no world";
+            return validator.validate(model).then(errors => {
+                errors.length.should.be.equal(0);
+            });
+        });
+
+        it("if firstName is empty and lastLame is not empty then it should fail", function() {
+            const model = new SecondClass();
+            model.firstName = "";
+            model.lastName = "Kim";
+            return validator.validate(model).then(errors => {
+                errors.length.should.be.equal(1);
+                errors[0].constraints.should.be.eql({ isLonger: "firstName must be longer then lastName" });
+            });
+        });
+
+        it("if firstName is shorter then lastLame then it should fail", function() {
+            const model = new SecondClass();
+            model.firstName = "Li";
+            model.lastName = "Kim";
+            return validator.validate(model).then(errors => {
+                errors.length.should.be.equal(1);
+                errors[0].constraints.should.be.eql({ isLonger: "firstName must be longer then lastName" });
+            });
+        });
+        
+    });
+
+    describe("decorator with separate validation constraint class", function() {
+
+        @ValidatorConstraint({ name: "isShortenThan" })
+        class IsShortenThanConstraint implements ValidatorConstraintInterface {
+
+            validate(value: any, args: ValidationArguments) {
+                const [relatedPropertyName] = args.constraints;
+                const relatedValue = (args.object as any)[relatedPropertyName];
+                if (value === null || value === undefined)
+                    return true;
+                
+                return  typeof value === "string" &&
+                        typeof relatedValue === "string" &&
+                        value.length < relatedValue.length;
+            }
+
+        }
+
+        function IsShortenThan(property: string, validationOptions?: ValidationOptions) {
+            return function (object: Object, propertyName: string) {
+                registerDecorator({
+                    target: object.constructor,
+                    propertyName: propertyName,
+                    options: validationOptions,
+                    constraints: [property],
+                    validator: IsShortenThanConstraint
+                });
+            };
+        }
+
+        class MyClass {
+            firstName: string;
+
+            @IsShortenThan("firstName", {
+                message: "$property must be shorter then $constraint1. Given value: $value"
+            })
+            lastName: string;
+        }
+
+        it("if firstName is not empty and lastLame is empty then it should succeed", function() {
+            const model = new MyClass();
+            model.firstName = "hell no world";
+            return validator.validate(model).then(errors => {
+                errors.length.should.be.equal(0);
+            });
+        });
+
+        it("if firstName is empty and lastLame is not empty then it should fail", function() {
+            const model = new MyClass();
+            model.firstName = "";
+            model.lastName = "Kim";
+            return validator.validate(model).then(errors => {
+                errors.length.should.be.equal(1);
+                errors[0].constraints.should.be.eql({ isShortenThan: "lastName must be shorter then firstName. Given value: Kim" });
+            });
+        });
+
+        it("if firstName is shorter then lastLame then it should fail", function() {
+            const model = new MyClass();
+            model.firstName = "Li";
+            model.lastName = "Kim";
+            return validator.validate(model).then(errors => {
+                errors.length.should.be.equal(1);
+                errors[0].constraints.should.be.eql({ isShortenThan: "lastName must be shorter then firstName. Given value: Kim" });
+            });
+        });
+
+    });
+
+});
diff --git a/test/functional/nested-validation.spec.ts b/test/functional/nested-validation.spec.ts
index 534756394f..752693d749 100644
--- a/test/functional/nested-validation.spec.ts
+++ b/test/functional/nested-validation.spec.ts
@@ -42,7 +42,6 @@ describe("nested validation", function() {
         model.mySubClasses[0].name = "my";
         model.mySubClasses[1].name = "not-short";
         return validator.validate(model).then(errors => {
-            console.log(errors);
             errors.length.should.be.equal(3);
 
             errors[0].target.should.be.equal(model);
diff --git a/test/functional/sync-validation.ts b/test/functional/sync-validation.ts
new file mode 100644
index 0000000000..7888567b0c
--- /dev/null
+++ b/test/functional/sync-validation.ts
@@ -0,0 +1,86 @@
+import "es6-shim";
+import {Validator} from "../../src/validation/Validator";
+import {ValidationArguments} from "../../src/validation/ValidationArguments";
+import {registerDecorator} from "../../src/register-decorator";
+import {ValidationOptions} from "../../src/decorator/ValidationOptions";
+import {ValidatorConstraint, Validate, IsNotEmpty} from "../../src/decorator/decorators";
+import {ValidatorConstraintInterface} from "../../src/validation/ValidatorConstraintInterface";
+
+// -------------------------------------------------------------------------
+// Setup
+// -------------------------------------------------------------------------
+
+const validator = new Validator();
+
+// -------------------------------------------------------------------------
+// Specifications: common decorators
+// -------------------------------------------------------------------------
+
+describe("sync validation", function() {
+
+    describe("sync validation should ignore async validation constraints", function() {
+
+        @ValidatorConstraint({ name: "isShortenThan", async: true })
+        class IsShortenThanConstraint implements ValidatorConstraintInterface {
+
+            validate(value: any, args: ValidationArguments) {
+                return Promise.resolve(false);
+            }
+
+        }
+        
+        function IsLonger(property: string, validationOptions?: ValidationOptions) {
+            return function (object: Object, propertyName: string) {
+                registerDecorator({
+                    target: object.constructor,
+                    propertyName: propertyName,
+                    options: validationOptions,
+                    constraints: [property],
+                    async: true,
+                    name: "isLonger",
+                    validator: {
+                        validate(value: any, args: ValidationArguments) {
+                            return Promise.resolve(false);
+                        }
+                    }
+                });
+            };
+        }
+        
+        class SecondClass {
+            @IsLonger("lastName")
+            firstName: string;
+            
+            @Validate(IsShortenThanConstraint)
+            lastName: string;
+            
+            @IsNotEmpty({ message: "name should not be empty" })
+            name: string;
+            
+            @IsNotEmpty()
+            alwaysWithValue: string = "this field always has a value";
+        }
+
+        it("should ignore async validations and validate only sync validation types", function() {
+            const model = new SecondClass();
+            model.firstName = "such validation may lead";
+            model.firstName = "to recursion";
+            model.name = "Umed";
+            const errors = validator.validateSync(model);
+            console.log(errors);
+            errors.length.should.be.equal(0);
+        });
+
+        it("should ignore async validations and validate only sync validation types", function() {
+            const model = new SecondClass();
+            model.firstName = "such validation may lead";
+            model.firstName = "to recursion";
+            model.name = "";
+            const errors = validator.validateSync(model);
+            errors.length.should.be.equal(1);
+            errors[0].constraints.should.be.eql({ isNotEmpty: "name should not be empty" });
+        });
+        
+    });
+
+});