diff --git a/spec/operators/repeat-spec.js b/spec/operators/repeat-spec.js
new file mode 100644
index 0000000000..2e1cf68267
--- /dev/null
+++ b/spec/operators/repeat-spec.js
@@ -0,0 +1,15 @@
+/* globals describe, it, expect */
+var Rx = require('../../dist/cjs/Rx');
+var Observable = Rx.Observable;
+
+describe('Observable.prototype.repeat()', function () {
+  it('should resubscribe count number of times', function (done) {   
+    var expected = [1, 2, 1, 2];
+    Observable.of(1,2)
+      .repeat(2)
+      .subscribe(function(x){
+        expect(x).toBe(expected.shift());
+      }, null, done);
+  });
+  
+});
\ No newline at end of file
diff --git a/src/Observable.ts b/src/Observable.ts
index 95ad2c6baf..3f302039db 100644
--- a/src/Observable.ts
+++ b/src/Observable.ts
@@ -156,8 +156,9 @@ export default class Observable<T> {
 
   catch: (selector: (err: any, source: Observable<T>, caught: Observable<any>) => Observable<any>) => Observable<T>;
   retryWhen: (notifier: (errors: Observable<any>) => Observable<any>) => Observable<T>;
+  repeat: <T>(count: number) => Observable<T>;
   
   groupBy: <T, R>(keySelector: (value:T) => string, durationSelector?: (group:GroupSubject<R>) => Observable<any>, elementSelector?: (value:T) => R) => Observable<R>;
 
   finally: (ensure: () => void, thisArg?: any) => Observable<T>;
- }
+ }
\ No newline at end of file
diff --git a/src/Rx.ts b/src/Rx.ts
index a4d39261a4..574b68ac02 100644
--- a/src/Rx.ts
+++ b/src/Rx.ts
@@ -147,9 +147,11 @@ observableProto.materialize = materialize;
 
 import _catch from './operators/catch';
 import retryWhen from './operators/retryWhen';
+import repeat from './operators/repeat';
 
 observableProto.catch = _catch;
 observableProto.retryWhen = retryWhen;
+observableProto.repeat = repeat;
 
 import _finally from './operators/finally';
 
diff --git a/src/operators/repeat.ts b/src/operators/repeat.ts
new file mode 100644
index 0000000000..7857fa1cae
--- /dev/null
+++ b/src/operators/repeat.ts
@@ -0,0 +1,42 @@
+import Operator from '../Operator';
+import Observer from '../Observer';
+import Subscriber from '../Subscriber';
+import Observable from '../Observable';
+import Subject from '../Subject';
+import Subscription from '../Subscription';
+
+import tryCatch from '../util/tryCatch';
+import {errorObject} from '../util/errorObject';
+
+export default function repeat<T>(count: number): Observable<T> {
+  return this.lift(new RepeatOperator(count, this));
+}
+
+export class RepeatOperator<T, R> extends Operator<T, R> {
+  constructor(protected count: number, protected original:Observable<T>) {
+    super();
+  }
+
+  call(observer: Observer<T>): Observer<T> {
+    return new RepeatSubscriber<T>(observer, this.count, this.original);
+  }
+}
+
+export class RepeatSubscriber<T> extends Subscriber<T> {
+  private repeated: number = 0;
+  constructor(destination: Observer<T>, public count: number, public original: Observable<T>) {
+    super(destination);
+  }
+  
+  _complete(){
+    if (this.count === (this.repeated+=1)){
+      this.destination.complete();
+    }else{
+      this.resubscribe();  
+    }             
+  }
+
+  resubscribe() {    
+    this.original.subscribe(this);
+  }
+}