diff --git a/README.md b/README.md
index b55cc575b..d2affa36d 100755
--- a/README.md
+++ b/README.md
@@ -65,6 +65,7 @@ List of Definitions
 * [EaselJS](http://www.createjs.com/#!/EaselJS) (by [Pedro Ferreira](https://bitbucket.org/drk4))
 * [ember.js](http://emberjs.com/) (by [Boris Yankov](https://github.com/borisyankov))
 * [EpicEditor](http://epiceditor.com/) (by [Boris Yankov](https://github.com/borisyankov))
+* [ES6-Promises](https://github.com/jakearchibald/ES6-Promises) (by [François de Campredon](https://github.com/fdecampredon/))
 * [expect.js](https://github.com/LearnBoost/expect.js) (by [Teppei Sato](https://github.com/teppeis))
 * [expectations](https://github.com/spmason/expectations) (by [vvakame](https://github.com/vvakame))
 * [Express](http://expressjs.com/) (by [Boris Yankov](https://github.com/borisyankov))
diff --git a/es6-promises/es6-promises-tests.ts b/es6-promises/es6-promises-tests.ts
new file mode 100644
index 000000000..774d3763e
--- /dev/null
+++ b/es6-promises/es6-promises-tests.ts
@@ -0,0 +1,162 @@
+/// <reference path="es6-promises.d.ts" />
+
+
+var promiseString: Promise<string>,
+ 	promiseStringArr: Promise<string[]>,
+	arrayOfPromise: Promise<string>[],
+	promiseNumber: Promise<number>,
+	promiseAny: Promise<any>,
+	thenable: Thenable<string>;
+
+// constructor test
+var constructResult = new Promise<string>((resolve, reject) => {
+	resolve('a string');
+});
+promiseString = constructResult;
+
+
+var constructResult1 = new Promise<string>((resolve:(promise: Thenable<string>) => void) => {
+	resolve(Promise.resolve('a string'));
+});
+promiseString = constructResult1;
+
+//cast test
+var castResult = Promise.cast('a string');
+promiseString = castResult;
+var castResult1 = Promise.cast(Promise.resolve('a string'));
+promiseString = castResult1;
+
+//resolve test
+var resolveResult = Promise.resolve('a string');
+promiseString = resolveResult;
+
+var resolveResult1 = Promise.resolve(thenable);
+promiseString = resolveResult1;
+
+//reject test
+var rejectResult = Promise.reject('there is an error');
+promiseAny = rejectResult;
+
+//all test
+var allResult = Promise.all(arrayOfPromise);
+promiseStringArr = allResult;
+
+//race test
+var raceResult = Promise.race(arrayOfPromise);
+promiseString = raceResult;
+ 
+
+//then test
+var thenWithPromiseResult = promiseString.then(word => Promise.resolve(word.length));
+promiseNumber = thenWithPromiseResult;
+
+var thenWithPromiseResultAndPromiseReject = promiseString.then(word => Promise.resolve(word.length), error => Promise.resolve(10));
+promiseNumber = thenWithPromiseResultAndPromiseReject;	
+
+var thenWithPromiseResultAndSimpleReject = promiseString.then(word => Promise.resolve(word.length), error => 10);
+promiseNumber = thenWithPromiseResultAndSimpleReject;	
+	
+var thenWithSimpleResult = promiseString.then(word => word.length);
+promiseNumber = thenWithSimpleResult;
+
+var thenWithSimpleResultAndPromiseReject = promiseString.then(word => word.length, error => Promise.resolve(10));
+promiseNumber = thenWithSimpleResultAndPromiseReject;	
+
+var thenWithSimpleResultAndSimpleReject = promiseString.then(word => word.length, error => 10);
+promiseNumber = thenWithSimpleResultAndSimpleReject;	
+
+var thenWithUndefinedFullFillAndSimpleReject = promiseString.then(undefined, error => 10);
+promiseNumber = thenWithUndefinedFullFillAndSimpleReject;
+
+var thenWithUndefinedFullFillAndPromiseReject = promiseString.then(undefined, error => Promise.resolve(10));
+promiseNumber = thenWithUndefinedFullFillAndPromiseReject;
+
+var thenWithNoResultAndNoReject = promiseString.then<number>();
+promiseNumber = thenWithNoResultAndNoReject;
+
+//catch test
+var catchWithSimpleResult = promiseString.catch(error => 10);	
+promiseNumber = catchWithSimpleResult;
+
+var catchWithPromiseResult = promiseString.catch(error => Promise.resolve(10));	
+promiseNumber = catchWithPromiseResult;
+
+
+//examples coming from http://www.html5rocks.com/en/tutorials/es6/promises/
+
+function get(url: string) {
+    // Return a new promise.
+    return new Promise<string>(function(resolve, reject) {
+        // Do the usual XHR stuff
+        var req = new XMLHttpRequest();
+        req.open('GET', url);
+    
+        req.onload = function() {
+            // This is called even on 404 etc
+            // so check the status
+            if (req.status == 200) {
+                // Resolve the promise with the response text
+                resolve(req.response);
+            }
+            else {
+                // Otherwise reject with the status text
+                // which will hopefully be a meaningful error
+                reject(Error(req.statusText));
+            }
+        };
+    
+        // Handle network errors
+        req.onerror = function() {
+            reject(Error("Network Error"));
+        };
+    
+        // Make the request
+        req.send();
+    });
+}
+
+
+
+function getJSON(url: string) {
+	return get(url).then(JSON.parse);
+}
+
+function addHtmlToPage(html: string) {
+	
+}
+
+function addTextToPage(text: string) {
+	
+}
+
+interface Story {
+	heading: string;
+	chapterUrls: string[]
+}
+
+getJSON('story.json').then(function(story: Story) {
+  addHtmlToPage(story.heading);
+
+  // Map our array of chapter urls to
+  // an array of chapter json promises.
+  // This makes sure they all download parallel.
+  return story.chapterUrls.map(getJSON)
+    .reduce(function(sequence, chapterPromise) {
+      // Use reduce to chain the promises together,
+      // adding content to the page for each chapter
+      return sequence.then(function() {
+        // Wait for everything in the sequence so far,
+        // then wait for this chapter to arrive.
+        return chapterPromise;
+      }).then(function(chapter) {
+        addHtmlToPage(chapter.html);
+      });
+    }, Promise.resolve());
+}).then(function() {
+  addTextToPage("All done");
+}).catch(function(err) {
+  // catch any error that happened along the way
+  addTextToPage("Argh, broken: " + err.message);
+}).then(function() {
+  (<HTMLElement>document.querySelector('.spinner')).style.display = 'none';
+});
diff --git a/es6-promises/es6-promises-tests.ts.tscparams b/es6-promises/es6-promises-tests.ts.tscparams
new file mode 100644
index 000000000..3cc762b55
--- /dev/null
+++ b/es6-promises/es6-promises-tests.ts.tscparams
@@ -0,0 +1 @@
+""
\ No newline at end of file
diff --git a/es6-promises/es6-promises.d.ts b/es6-promises/es6-promises.d.ts
new file mode 100644
index 000000000..a44355233
--- /dev/null
+++ b/es6-promises/es6-promises.d.ts
@@ -0,0 +1,133 @@
+// Type definitions for es6-promises
+// Project: https://github.com/jakearchibald/ES6-Promises
+// Definitions by: François de Campredon <https://github.com/fdecampredon/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+
+interface Thenable<R> {
+	then<U>(onFulfill: (value: R) => Thenable<U>,  onReject: (error: any) => Thenable<U>): Thenable<U>;
+    then<U>(onFulfill: (value: R) => Thenable<U>, onReject?: (error: any) => U): Thenable<U>;
+    then<U>(onFulfill: (value: R) => U, onReject: (error: any) => Thenable<U>): Thenable<U>;
+    then<U>(onFulfill?: (value: R) => U, onReject?: (error: any) => U): Thenable<U>;
+	
+}
+
+declare class Promise<R> implements Thenable<R> {
+    /**
+     * If you call resolve in the body of the callback passed to the constructor, 
+     * your promise is fulfilled with result object passed to resolve.
+     * If you call reject your promise is rejected with the object passed to resolve. 
+     * For consistency and debugging (eg stack traces), obj should be an instanceof Error. 
+     * Any errors thrown in the constructor callback will be implicitly passed to reject().
+     */
+	constructor(callback: (resolve : (result: R) => void, reject: (error: any) => void) => void);
+    /**
+     * If you call resolve in the body of the callback passed to the constructor, 
+     * your promise will be fulfilled/rejected with the outcome of thenable passed to resolve.
+     * If you call reject your promise is rejected with the object passed to resolve. 
+     * For consistency and debugging (eg stack traces), obj should be an instanceof Error. 
+     * Any errors thrown in the constructor callback will be implicitly passed to reject().
+     */
+	constructor(callback: (resolve : (thenable: Thenable<R>) => void, reject: (error: any) => void) => void);
+	
+    
+    /**
+     * onFulFill is called when/if "promise" resolves. onRejected is called when/if "promise" rejects. 
+     * Both are optional, if either/both are omitted the next onFulfilled/onRejected in the chain is called. 
+     * Both callbacks have a single parameter , the fulfillment value or rejection reason. 
+     * "then" returns a new promise equivalent to the value you return from onFulfilled/onRejected after being passed through Promise.resolve. 
+     * If an error is thrown in the callback, the returned promise rejects with that error.
+     * 
+     * @param onFulFill called when/if "promise" resolves
+     * @param onReject called when/if "promise" rejects
+     */
+	then<U>(onFulfill: (value: R) => Thenable<U>,  onReject: (error: any) => Thenable<U>): Promise<U>;
+    /**
+     * onFulFill is called when/if "promise" resolves. onRejected is called when/if "promise" rejects. 
+     * Both are optional, if either/both are omitted the next onFulfilled/onRejected in the chain is called. 
+     * Both callbacks have a single parameter , the fulfillment value or rejection reason. 
+     * "then" returns a new promise equivalent to the value you return from onFulfilled/onRejected after being passed through Promise.resolve. 
+     * If an error is thrown in the callback, the returned promise rejects with that error.
+     * 
+     * @param onFulFill called when/if "promise" resolves
+     * @param onReject called when/if "promise" rejects
+     */
+    then<U>(onFulfill: (value: R) => Thenable<U>, onReject?: (error: any) => U): Promise<U>;
+    /**
+     * onFulFill is called when/if "promise" resolves. onRejected is called when/if "promise" rejects. 
+     * Both are optional, if either/both are omitted the next onFulfilled/onRejected in the chain is called. 
+     * Both callbacks have a single parameter , the fulfillment value or rejection reason. 
+     * "then" returns a new promise equivalent to the value you return from onFulfilled/onRejected after being passed through Promise.resolve. 
+     * If an error is thrown in the callback, the returned promise rejects with that error.
+     * 
+     * @param onFulFill called when/if "promise" resolves
+     * @param onReject called when/if "promise" rejects
+     */
+    then<U>(onFulfill: (value: R) => U, onReject: (error: any) => Thenable<U>): Promise<U>;
+    /**
+     * onFulFill is called when/if "promise" resolves. onRejected is called when/if "promise" rejects. 
+     * Both are optional, if either/both are omitted the next onFulfilled/onRejected in the chain is called. 
+     * Both callbacks have a single parameter , the fulfillment value or rejection reason. 
+     * "then" returns a new promise equivalent to the value you return from onFulfilled/onRejected after being passed through Promise.resolve. 
+     * If an error is thrown in the callback, the returned promise rejects with that error.
+     * 
+     * @param onFulFill called when/if "promise" resolves
+     * @param onReject called when/if "promise" rejects
+     */
+    then<U>(onFulfill?: (value: R) => U, onReject?: (error: any) => U): Promise<U>;
+    
+    
+    /**
+     * Sugar for promise.then(undefined, onRejected)
+     * 
+     * @param onReject called when/if "promise" rejects
+     */
+	catch<U>(onReject?: (error: any) => Thenable<U>): Promise<U>;
+    /**
+     * Sugar for promise.then(undefined, onRejected)
+     * 
+     * @param onReject called when/if "promise" rejects
+     */
+	catch<U>(onReject?: (error: any) => U): Promise<U>;
+}
+
+declare module Promise {
+	
+	/**
+	 * Returns promise (only if promise.constructor == Promise)
+	 */
+	function cast<R>(promise: Promise<R>): Promise<R>;
+    /**
+	 * Make a promise that fulfills to obj.
+	 */
+	function cast<R>(object?: R): Promise<R>;
+    
+	
+    /**
+     * Make a new promise from the thenable. 
+     * A thenable is promise-like in as far as it has a "then" method. 
+     * This also creates a new promise if you pass it a genuine JavaScript promise, making it less efficient for casting than Promise.cast.
+     */
+	function resolve<R>(thenable: Thenable<R>): Promise<R>;
+    /**
+     * Make a promise that fulfills to obj. Same as Promise.cast(obj) in this situation.
+     */
+	function resolve<R>(object?: R): Promise<R>;
+    
+	/**
+	 * Make a promise that rejects to obj. For consistency and debugging (eg stack traces), obj should be an instanceof Error
+	 */
+	function reject(error?: any): Promise<any>;
+	
+    /**
+     * Make a promise that fulfills when every item in the array fulfills, and rejects if (and when) any item rejects. 
+     * the array passed to all can be a mixture of promise-like objects and other objects. 
+     * The fulfillment value is an array (in order) of fulfillment values. The rejection value is the first rejection value.
+     */
+	function all<R>(promises: Promise<R>[]): Promise<R[]>;
+	
+    /**
+     * Make a Promise that fulfills when any item fulfills, and rejects if any item rejects.
+     */
+	function race<R>(promises: Promise<R>[]): Promise<R>;
+}
\ No newline at end of file