diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 903287707503c..d533f5f82fbb3 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -64,6 +64,7 @@ namespace ts {
         const noUnusedIdentifiers = !!compilerOptions.noUnusedLocals || !!compilerOptions.noUnusedParameters;
         const allowSyntheticDefaultImports = typeof compilerOptions.allowSyntheticDefaultImports !== "undefined" ? compilerOptions.allowSyntheticDefaultImports : modulekind === ModuleKind.System;
         const strictNullChecks = compilerOptions.strictNullChecks === undefined ? compilerOptions.strict : compilerOptions.strictNullChecks;
+        const strictTuples = compilerOptions.strictTuples === undefined ? compilerOptions.strict : compilerOptions.strictTuples;
         const noImplicitAny = compilerOptions.noImplicitAny === undefined ? compilerOptions.strict : compilerOptions.noImplicitAny;
         const noImplicitThis = compilerOptions.noImplicitThis === undefined ? compilerOptions.strict : compilerOptions.noImplicitThis;
 
@@ -7161,6 +7162,12 @@ namespace ts {
                 property.type = typeParameter;
                 properties.push(property);
             }
+            if (strictTuples) {
+                const lengthSymbol = createSymbol(SymbolFlags.Property, "length" as __String);
+                lengthSymbol.type = getLiteralType(arity);
+                lengthSymbol.checkFlags = CheckFlags.Readonly;
+                properties.push(lengthSymbol);
+            }
             const type = <GenericType & InterfaceTypeWithDeclaredMembers>createObjectType(ObjectFlags.Tuple | ObjectFlags.Reference);
             type.typeParameters = typeParameters;
             type.outerTypeParameters = undefined;
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index c92d147f9a93a..f6baca6864787 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -269,6 +269,13 @@ namespace ts {
             category: Diagnostics.Strict_Type_Checking_Options,
             description: Diagnostics.Enable_strict_null_checks
         },
+        {
+            name: "strictTuples",
+            type: "boolean",
+            showInSimplifiedHelpView: true,
+            category: Diagnostics.Strict_Type_Checking_Options,
+            description: Diagnostics.Enable_strict_tuple_checks
+        },
         {
             name: "noImplicitThis",
             type: "boolean",
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 77e7f7e7b6246..bda14f2c9ce35 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -3302,6 +3302,10 @@
         "category": "Message",
         "code": 6185
     },
+    "Enable strict tuple checks.": {
+        "category": "Message",
+        "code": 6187
+    },
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",
         "code": 7005
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 0a09bb5b6ecba..bc06d247f2c16 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -3622,6 +3622,7 @@ namespace ts {
         sourceRoot?: string;
         strict?: boolean;
         strictNullChecks?: boolean;  // Always combine with strict property
+        strictTuples?: boolean;
         /* @internal */ stripInternal?: boolean;
         suppressExcessPropertyErrors?: boolean;
         suppressImplicitAnyIndexErrors?: boolean;
diff --git a/src/harness/unittests/configurationExtension.ts b/src/harness/unittests/configurationExtension.ts
index 2d50d2cb2af97..776feb535c5a8 100644
--- a/src/harness/unittests/configurationExtension.ts
+++ b/src/harness/unittests/configurationExtension.ts
@@ -16,6 +16,12 @@ namespace ts {
                 strictNullChecks: false
             }
         },
+        "/dev/tsconfig.strictTuples.json": {
+            extends: "./tsconfig",
+            compilerOptions: {
+                strictTuples: false
+            }
+        },
         "/dev/configs/base.json": {
             compilerOptions: {
                 allowJs: true,
diff --git a/src/harness/unittests/transpile.ts b/src/harness/unittests/transpile.ts
index e0c96797827f0..f727fff559446 100644
--- a/src/harness/unittests/transpile.ts
+++ b/src/harness/unittests/transpile.ts
@@ -413,6 +413,10 @@ var x = 0;`, {
             options: { compilerOptions: { strictNullChecks: true }, fileName: "input.js", reportDiagnostics: true }
         });
 
+        transpilesCorrectly("Supports setting 'strictTuples'", "x;", {
+            options: { compilerOptions: { strictTuples: true }, fileName: "input.js", reportDiagnostics: true }
+        });
+
         transpilesCorrectly("Supports setting 'stripInternal'", "x;", {
             options: { compilerOptions: { stripInternal: true }, fileName: "input.js", reportDiagnostics: true }
         });
diff --git a/src/server/protocol.ts b/src/server/protocol.ts
index 0b7405c7b6986..b5c959b484f01 100644
--- a/src/server/protocol.ts
+++ b/src/server/protocol.ts
@@ -2448,6 +2448,7 @@ namespace ts.server.protocol {
         sourceRoot?: string;
         strict?: boolean;
         strictNullChecks?: boolean;
+        strictTuples?: boolean;
         suppressExcessPropertyErrors?: boolean;
         suppressImplicitAnyIndexErrors?: boolean;
         target?: ScriptTarget | ts.ScriptTarget;
diff --git a/tests/baselines/reference/genericTypeAliases.js b/tests/baselines/reference/genericTypeAliases.js
index 8218f5c886cfa..282fd9868a970 100644
--- a/tests/baselines/reference/genericTypeAliases.js
+++ b/tests/baselines/reference/genericTypeAliases.js
@@ -40,12 +40,12 @@ type Strange<T> = string;  // Type parameter not used
 var s: Strange<number>;
 s = "hello";
 
-interface Tuple<A, B> {
+interface AB<A, B> {
     a: A;
     b: B;
 }
 
-type Pair<T> = Tuple<T, T>;
+type Pair<T> = AB<T, T>;
 
 interface TaggedPair<T> extends Pair<T> {
     tag: string;
diff --git a/tests/baselines/reference/genericTypeAliases.symbols b/tests/baselines/reference/genericTypeAliases.symbols
index d5f68ec061588..521afe800b327 100644
--- a/tests/baselines/reference/genericTypeAliases.symbols
+++ b/tests/baselines/reference/genericTypeAliases.symbols
@@ -124,29 +124,29 @@ var s: Strange<number>;
 s = "hello";
 >s : Symbol(s, Decl(genericTypeAliases.ts, 38, 3))
 
-interface Tuple<A, B> {
->Tuple : Symbol(Tuple, Decl(genericTypeAliases.ts, 39, 12))
->A : Symbol(A, Decl(genericTypeAliases.ts, 41, 16))
->B : Symbol(B, Decl(genericTypeAliases.ts, 41, 18))
+interface AB<A, B> {
+>AB : Symbol(AB, Decl(genericTypeAliases.ts, 39, 12))
+>A : Symbol(A, Decl(genericTypeAliases.ts, 41, 13))
+>B : Symbol(B, Decl(genericTypeAliases.ts, 41, 15))
 
     a: A;
->a : Symbol(Tuple.a, Decl(genericTypeAliases.ts, 41, 23))
->A : Symbol(A, Decl(genericTypeAliases.ts, 41, 16))
+>a : Symbol(AB.a, Decl(genericTypeAliases.ts, 41, 20))
+>A : Symbol(A, Decl(genericTypeAliases.ts, 41, 13))
 
     b: B;
->b : Symbol(Tuple.b, Decl(genericTypeAliases.ts, 42, 9))
->B : Symbol(B, Decl(genericTypeAliases.ts, 41, 18))
+>b : Symbol(AB.b, Decl(genericTypeAliases.ts, 42, 9))
+>B : Symbol(B, Decl(genericTypeAliases.ts, 41, 15))
 }
 
-type Pair<T> = Tuple<T, T>;
+type Pair<T> = AB<T, T>;
 >Pair : Symbol(Pair, Decl(genericTypeAliases.ts, 44, 1))
 >T : Symbol(T, Decl(genericTypeAliases.ts, 46, 10))
->Tuple : Symbol(Tuple, Decl(genericTypeAliases.ts, 39, 12))
+>AB : Symbol(AB, Decl(genericTypeAliases.ts, 39, 12))
 >T : Symbol(T, Decl(genericTypeAliases.ts, 46, 10))
 >T : Symbol(T, Decl(genericTypeAliases.ts, 46, 10))
 
 interface TaggedPair<T> extends Pair<T> {
->TaggedPair : Symbol(TaggedPair, Decl(genericTypeAliases.ts, 46, 27))
+>TaggedPair : Symbol(TaggedPair, Decl(genericTypeAliases.ts, 46, 24))
 >T : Symbol(T, Decl(genericTypeAliases.ts, 48, 21))
 >Pair : Symbol(Pair, Decl(genericTypeAliases.ts, 44, 1))
 >T : Symbol(T, Decl(genericTypeAliases.ts, 48, 21))
@@ -157,17 +157,17 @@ interface TaggedPair<T> extends Pair<T> {
 
 var p: TaggedPair<number>;
 >p : Symbol(p, Decl(genericTypeAliases.ts, 52, 3))
->TaggedPair : Symbol(TaggedPair, Decl(genericTypeAliases.ts, 46, 27))
+>TaggedPair : Symbol(TaggedPair, Decl(genericTypeAliases.ts, 46, 24))
 
 p.a = 1;
->p.a : Symbol(Tuple.a, Decl(genericTypeAliases.ts, 41, 23))
+>p.a : Symbol(AB.a, Decl(genericTypeAliases.ts, 41, 20))
 >p : Symbol(p, Decl(genericTypeAliases.ts, 52, 3))
->a : Symbol(Tuple.a, Decl(genericTypeAliases.ts, 41, 23))
+>a : Symbol(AB.a, Decl(genericTypeAliases.ts, 41, 20))
 
 p.b = 2;
->p.b : Symbol(Tuple.b, Decl(genericTypeAliases.ts, 42, 9))
+>p.b : Symbol(AB.b, Decl(genericTypeAliases.ts, 42, 9))
 >p : Symbol(p, Decl(genericTypeAliases.ts, 52, 3))
->b : Symbol(Tuple.b, Decl(genericTypeAliases.ts, 42, 9))
+>b : Symbol(AB.b, Decl(genericTypeAliases.ts, 42, 9))
 
 p.tag = "test";
 >p.tag : Symbol(TaggedPair.tag, Decl(genericTypeAliases.ts, 48, 41))
diff --git a/tests/baselines/reference/genericTypeAliases.types b/tests/baselines/reference/genericTypeAliases.types
index b4c75841245d3..722347b0f72b3 100644
--- a/tests/baselines/reference/genericTypeAliases.types
+++ b/tests/baselines/reference/genericTypeAliases.types
@@ -158,8 +158,8 @@ s = "hello";
 >s : string
 >"hello" : "hello"
 
-interface Tuple<A, B> {
->Tuple : Tuple<A, B>
+interface AB<A, B> {
+>AB : AB<A, B>
 >A : A
 >B : B
 
@@ -172,17 +172,17 @@ interface Tuple<A, B> {
 >B : B
 }
 
-type Pair<T> = Tuple<T, T>;
->Pair : Tuple<T, T>
+type Pair<T> = AB<T, T>;
+>Pair : AB<T, T>
 >T : T
->Tuple : Tuple<A, B>
+>AB : AB<A, B>
 >T : T
 >T : T
 
 interface TaggedPair<T> extends Pair<T> {
 >TaggedPair : TaggedPair<T>
 >T : T
->Pair : Tuple<T, T>
+>Pair : AB<T, T>
 >T : T
 
     tag: string;
diff --git a/tests/baselines/reference/nominalSubtypeCheckOfTypeParameter.js b/tests/baselines/reference/nominalSubtypeCheckOfTypeParameter.js
index 3259b3287fa50..5712fb7c2445d 100644
--- a/tests/baselines/reference/nominalSubtypeCheckOfTypeParameter.js
+++ b/tests/baselines/reference/nominalSubtypeCheckOfTypeParameter.js
@@ -1,20 +1,20 @@
 //// [nominalSubtypeCheckOfTypeParameter.ts]
-interface Tuple<T, S> {
+interface BinaryTuple<T, S> {
     first: T
-      second: S
+    second: S
 }
 
 interface Sequence<T> {
     hasNext(): boolean
-      pop(): T
-      zip<S>(seq: Sequence<S>): Sequence<Tuple<T, S>>
+    pop(): T
+    zip<S>(seq: Sequence<S>): Sequence<BinaryTuple<T, S>>
 }
 
 // error, despite the fact that the code explicitly says List<T> extends Sequence<T>, the current rules for infinitely expanding type references 
 // perform nominal subtyping checks that allow variance for type arguments, but not nominal subtyping for the generic type itself
 interface List<T> extends Sequence<T> {
     getLength(): number
-      zip<S>(seq: Sequence<S>): List<Tuple<T, S>>
+    zip<S>(seq: Sequence<S>): List<BinaryTuple<T, S>>
 }
 
 
diff --git a/tests/baselines/reference/nominalSubtypeCheckOfTypeParameter.symbols b/tests/baselines/reference/nominalSubtypeCheckOfTypeParameter.symbols
index c7d9a1b50f44b..3d24b82aa8f24 100644
--- a/tests/baselines/reference/nominalSubtypeCheckOfTypeParameter.symbols
+++ b/tests/baselines/reference/nominalSubtypeCheckOfTypeParameter.symbols
@@ -1,16 +1,16 @@
 === tests/cases/conformance/types/typeRelationships/recursiveTypes/nominalSubtypeCheckOfTypeParameter.ts ===
-interface Tuple<T, S> {
->Tuple : Symbol(Tuple, Decl(nominalSubtypeCheckOfTypeParameter.ts, 0, 0))
->T : Symbol(T, Decl(nominalSubtypeCheckOfTypeParameter.ts, 0, 16))
->S : Symbol(S, Decl(nominalSubtypeCheckOfTypeParameter.ts, 0, 18))
+interface BinaryTuple<T, S> {
+>BinaryTuple : Symbol(BinaryTuple, Decl(nominalSubtypeCheckOfTypeParameter.ts, 0, 0))
+>T : Symbol(T, Decl(nominalSubtypeCheckOfTypeParameter.ts, 0, 22))
+>S : Symbol(S, Decl(nominalSubtypeCheckOfTypeParameter.ts, 0, 24))
 
     first: T
->first : Symbol(Tuple.first, Decl(nominalSubtypeCheckOfTypeParameter.ts, 0, 23))
->T : Symbol(T, Decl(nominalSubtypeCheckOfTypeParameter.ts, 0, 16))
+>first : Symbol(BinaryTuple.first, Decl(nominalSubtypeCheckOfTypeParameter.ts, 0, 29))
+>T : Symbol(T, Decl(nominalSubtypeCheckOfTypeParameter.ts, 0, 22))
 
-      second: S
->second : Symbol(Tuple.second, Decl(nominalSubtypeCheckOfTypeParameter.ts, 1, 12))
->S : Symbol(S, Decl(nominalSubtypeCheckOfTypeParameter.ts, 0, 18))
+    second: S
+>second : Symbol(BinaryTuple.second, Decl(nominalSubtypeCheckOfTypeParameter.ts, 1, 12))
+>S : Symbol(S, Decl(nominalSubtypeCheckOfTypeParameter.ts, 0, 24))
 }
 
 interface Sequence<T> {
@@ -20,20 +20,20 @@ interface Sequence<T> {
     hasNext(): boolean
 >hasNext : Symbol(Sequence.hasNext, Decl(nominalSubtypeCheckOfTypeParameter.ts, 5, 23))
 
-      pop(): T
+    pop(): T
 >pop : Symbol(Sequence.pop, Decl(nominalSubtypeCheckOfTypeParameter.ts, 6, 22))
 >T : Symbol(T, Decl(nominalSubtypeCheckOfTypeParameter.ts, 5, 19))
 
-      zip<S>(seq: Sequence<S>): Sequence<Tuple<T, S>>
->zip : Symbol(Sequence.zip, Decl(nominalSubtypeCheckOfTypeParameter.ts, 7, 14))
->S : Symbol(S, Decl(nominalSubtypeCheckOfTypeParameter.ts, 8, 10))
->seq : Symbol(seq, Decl(nominalSubtypeCheckOfTypeParameter.ts, 8, 13))
+    zip<S>(seq: Sequence<S>): Sequence<BinaryTuple<T, S>>
+>zip : Symbol(Sequence.zip, Decl(nominalSubtypeCheckOfTypeParameter.ts, 7, 12))
+>S : Symbol(S, Decl(nominalSubtypeCheckOfTypeParameter.ts, 8, 8))
+>seq : Symbol(seq, Decl(nominalSubtypeCheckOfTypeParameter.ts, 8, 11))
 >Sequence : Symbol(Sequence, Decl(nominalSubtypeCheckOfTypeParameter.ts, 3, 1))
->S : Symbol(S, Decl(nominalSubtypeCheckOfTypeParameter.ts, 8, 10))
+>S : Symbol(S, Decl(nominalSubtypeCheckOfTypeParameter.ts, 8, 8))
 >Sequence : Symbol(Sequence, Decl(nominalSubtypeCheckOfTypeParameter.ts, 3, 1))
->Tuple : Symbol(Tuple, Decl(nominalSubtypeCheckOfTypeParameter.ts, 0, 0))
+>BinaryTuple : Symbol(BinaryTuple, Decl(nominalSubtypeCheckOfTypeParameter.ts, 0, 0))
 >T : Symbol(T, Decl(nominalSubtypeCheckOfTypeParameter.ts, 5, 19))
->S : Symbol(S, Decl(nominalSubtypeCheckOfTypeParameter.ts, 8, 10))
+>S : Symbol(S, Decl(nominalSubtypeCheckOfTypeParameter.ts, 8, 8))
 }
 
 // error, despite the fact that the code explicitly says List<T> extends Sequence<T>, the current rules for infinitely expanding type references 
@@ -47,15 +47,15 @@ interface List<T> extends Sequence<T> {
     getLength(): number
 >getLength : Symbol(List.getLength, Decl(nominalSubtypeCheckOfTypeParameter.ts, 13, 39))
 
-      zip<S>(seq: Sequence<S>): List<Tuple<T, S>>
+    zip<S>(seq: Sequence<S>): List<BinaryTuple<T, S>>
 >zip : Symbol(List.zip, Decl(nominalSubtypeCheckOfTypeParameter.ts, 14, 23))
->S : Symbol(S, Decl(nominalSubtypeCheckOfTypeParameter.ts, 15, 10))
->seq : Symbol(seq, Decl(nominalSubtypeCheckOfTypeParameter.ts, 15, 13))
+>S : Symbol(S, Decl(nominalSubtypeCheckOfTypeParameter.ts, 15, 8))
+>seq : Symbol(seq, Decl(nominalSubtypeCheckOfTypeParameter.ts, 15, 11))
 >Sequence : Symbol(Sequence, Decl(nominalSubtypeCheckOfTypeParameter.ts, 3, 1))
->S : Symbol(S, Decl(nominalSubtypeCheckOfTypeParameter.ts, 15, 10))
+>S : Symbol(S, Decl(nominalSubtypeCheckOfTypeParameter.ts, 15, 8))
 >List : Symbol(List, Decl(nominalSubtypeCheckOfTypeParameter.ts, 9, 1))
->Tuple : Symbol(Tuple, Decl(nominalSubtypeCheckOfTypeParameter.ts, 0, 0))
+>BinaryTuple : Symbol(BinaryTuple, Decl(nominalSubtypeCheckOfTypeParameter.ts, 0, 0))
 >T : Symbol(T, Decl(nominalSubtypeCheckOfTypeParameter.ts, 13, 15))
->S : Symbol(S, Decl(nominalSubtypeCheckOfTypeParameter.ts, 15, 10))
+>S : Symbol(S, Decl(nominalSubtypeCheckOfTypeParameter.ts, 15, 8))
 }
 
diff --git a/tests/baselines/reference/nominalSubtypeCheckOfTypeParameter.types b/tests/baselines/reference/nominalSubtypeCheckOfTypeParameter.types
index 79b2ac77d78d2..5da84d0c8a48b 100644
--- a/tests/baselines/reference/nominalSubtypeCheckOfTypeParameter.types
+++ b/tests/baselines/reference/nominalSubtypeCheckOfTypeParameter.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/typeRelationships/recursiveTypes/nominalSubtypeCheckOfTypeParameter.ts ===
-interface Tuple<T, S> {
->Tuple : Tuple<T, S>
+interface BinaryTuple<T, S> {
+>BinaryTuple : BinaryTuple<T, S>
 >T : T
 >S : S
 
@@ -8,7 +8,7 @@ interface Tuple<T, S> {
 >first : T
 >T : T
 
-      second: S
+    second: S
 >second : S
 >S : S
 }
@@ -20,18 +20,18 @@ interface Sequence<T> {
     hasNext(): boolean
 >hasNext : () => boolean
 
-      pop(): T
+    pop(): T
 >pop : () => T
 >T : T
 
-      zip<S>(seq: Sequence<S>): Sequence<Tuple<T, S>>
->zip : <S>(seq: Sequence<S>) => Sequence<Tuple<T, S>>
+    zip<S>(seq: Sequence<S>): Sequence<BinaryTuple<T, S>>
+>zip : <S>(seq: Sequence<S>) => Sequence<BinaryTuple<T, S>>
 >S : S
 >seq : Sequence<S>
 >Sequence : Sequence<T>
 >S : S
 >Sequence : Sequence<T>
->Tuple : Tuple<T, S>
+>BinaryTuple : BinaryTuple<T, S>
 >T : T
 >S : S
 }
@@ -47,14 +47,14 @@ interface List<T> extends Sequence<T> {
     getLength(): number
 >getLength : () => number
 
-      zip<S>(seq: Sequence<S>): List<Tuple<T, S>>
->zip : <S>(seq: Sequence<S>) => List<Tuple<T, S>>
+    zip<S>(seq: Sequence<S>): List<BinaryTuple<T, S>>
+>zip : <S>(seq: Sequence<S>) => List<BinaryTuple<T, S>>
 >S : S
 >seq : Sequence<S>
 >Sequence : Sequence<T>
 >S : S
 >List : List<T>
->Tuple : Tuple<T, S>
+>BinaryTuple : BinaryTuple<T, S>
 >T : T
 >S : S
 }
diff --git a/tests/baselines/reference/transpile/Supports setting strictTuples.js b/tests/baselines/reference/transpile/Supports setting strictTuples.js
new file mode 100644
index 0000000000000..8394371f9081a
--- /dev/null
+++ b/tests/baselines/reference/transpile/Supports setting strictTuples.js	
@@ -0,0 +1,2 @@
+x;
+//# sourceMappingURL=input.js.map
\ No newline at end of file
diff --git a/tests/baselines/reference/tsConfig/Default initialized TSConfig/tsconfig.json b/tests/baselines/reference/tsConfig/Default initialized TSConfig/tsconfig.json
index 0f5b23784683f..5218d687724bc 100644
--- a/tests/baselines/reference/tsConfig/Default initialized TSConfig/tsconfig.json	
+++ b/tests/baselines/reference/tsConfig/Default initialized TSConfig/tsconfig.json	
@@ -22,6 +22,7 @@
     "strict": true                            /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictTuples": true,                  /* Enable strict tuple checks. */
     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
 
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json
index a545124a72397..4fc67f07f0e57 100644
--- a/tests/baselines/reference/tsConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json	
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with boolean value compiler options/tsconfig.json	
@@ -22,6 +22,7 @@
     "strict": true,                           /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictTuples": true,                  /* Enable strict tuple checks. */
     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
 
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with enum value compiler options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with enum value compiler options/tsconfig.json
index b53ac2d8552d8..cd190298fd8e1 100644
--- a/tests/baselines/reference/tsConfig/Initialized TSConfig with enum value compiler options/tsconfig.json	
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with enum value compiler options/tsconfig.json	
@@ -22,6 +22,7 @@
     "strict": true                            /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictTuples": true,                  /* Enable strict tuple checks. */
     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
 
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with files options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with files options/tsconfig.json
index 4e06e06d159a4..278322852f832 100644
--- a/tests/baselines/reference/tsConfig/Initialized TSConfig with files options/tsconfig.json	
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with files options/tsconfig.json	
@@ -22,6 +22,7 @@
     "strict": true                            /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictTuples": true,                  /* Enable strict tuple checks. */
     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
 
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json
index 94808d89ed05d..c81634bccea15 100644
--- a/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json	
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option value/tsconfig.json	
@@ -22,6 +22,7 @@
     "strict": true                            /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictTuples": true,                  /* Enable strict tuple checks. */
     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
 
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json
index 0f5b23784683f..5218d687724bc 100644
--- a/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json	
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with incorrect compiler option/tsconfig.json	
@@ -22,6 +22,7 @@
     "strict": true                            /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictTuples": true,                  /* Enable strict tuple checks. */
     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
 
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json
index d165b0f277541..0b34f4724f84a 100644
--- a/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json	
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options with enum value/tsconfig.json	
@@ -22,6 +22,7 @@
     "strict": true                            /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictTuples": true,                  /* Enable strict tuple checks. */
     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
 
diff --git a/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options/tsconfig.json b/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options/tsconfig.json
index 2a169b3aaafa1..9a63db2069be6 100644
--- a/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options/tsconfig.json	
+++ b/tests/baselines/reference/tsConfig/Initialized TSConfig with list compiler options/tsconfig.json	
@@ -22,6 +22,7 @@
     "strict": true,                           /* Enable all strict type-checking options. */
     // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
     // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictTuples": true,                  /* Enable strict tuple checks. */
     // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
     // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
 
diff --git a/tests/baselines/reference/tupleLength.errors.txt b/tests/baselines/reference/tupleLength.errors.txt
new file mode 100644
index 0000000000000..c68bd652c8568
--- /dev/null
+++ b/tests/baselines/reference/tupleLength.errors.txt
@@ -0,0 +1,26 @@
+tests/cases/compiler/tupleLength.ts(11,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 't1' must be of type '[number]', but here has type '[number, number]'.
+tests/cases/compiler/tupleLength.ts(12,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 't2' must be of type '[number, number]', but here has type '[number]'.
+
+
+==== tests/cases/compiler/tupleLength.ts (2 errors) ====
+    // var t0: [];
+    var t1: [number];
+    var t2: [number, number];
+    var arr: number[];
+    
+    // var len0: 0 = t0.length;
+    var len1: 1 = t1.length;
+    var len2: 2 = t2.length;
+    var lena: number = arr.length;
+    
+    var t1 = t2; // error
+        ~~
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 't1' must be of type '[number]', but here has type '[number, number]'.
+    var t2 = t1; // error
+        ~~
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 't2' must be of type '[number, number]', but here has type '[number]'.
+    
+    type A<T extends any[]> = T['length'];
+    var b: A<[boolean]>;
+    var c: 1 = b;
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/tupleLength.js b/tests/baselines/reference/tupleLength.js
new file mode 100644
index 0000000000000..3893305421bb7
--- /dev/null
+++ b/tests/baselines/reference/tupleLength.js
@@ -0,0 +1,32 @@
+//// [tupleLength.ts]
+// var t0: [];
+var t1: [number];
+var t2: [number, number];
+var arr: number[];
+
+// var len0: 0 = t0.length;
+var len1: 1 = t1.length;
+var len2: 2 = t2.length;
+var lena: number = arr.length;
+
+var t1 = t2; // error
+var t2 = t1; // error
+
+type A<T extends any[]> = T['length'];
+var b: A<[boolean]>;
+var c: 1 = b;
+
+
+//// [tupleLength.js]
+// var t0: [];
+var t1;
+var t2;
+var arr;
+// var len0: 0 = t0.length;
+var len1 = t1.length;
+var len2 = t2.length;
+var lena = arr.length;
+var t1 = t2; // error
+var t2 = t1; // error
+var b;
+var c = b;
diff --git a/tests/cases/compiler/tupleLength.ts b/tests/cases/compiler/tupleLength.ts
new file mode 100644
index 0000000000000..3c6db1a034a92
--- /dev/null
+++ b/tests/cases/compiler/tupleLength.ts
@@ -0,0 +1,18 @@
+// @strictTuples: true
+
+// var t0: [];
+var t1: [number];
+var t2: [number, number];
+var arr: number[];
+
+// var len0: 0 = t0.length;
+var len1: 1 = t1.length;
+var len2: 2 = t2.length;
+var lena: number = arr.length;
+
+var t1 = t2; // error
+var t2 = t1; // error
+
+type A<T extends any[]> = T['length'];
+var b: A<[boolean]>;
+var c: 1 = b;
diff --git a/tests/cases/conformance/types/typeAliases/genericTypeAliases.ts b/tests/cases/conformance/types/typeAliases/genericTypeAliases.ts
index e26279a8a4189..8c8ab3291fafe 100644
--- a/tests/cases/conformance/types/typeAliases/genericTypeAliases.ts
+++ b/tests/cases/conformance/types/typeAliases/genericTypeAliases.ts
@@ -39,12 +39,12 @@ type Strange<T> = string;  // Type parameter not used
 var s: Strange<number>;
 s = "hello";
 
-interface Tuple<A, B> {
+interface AB<A, B> {
     a: A;
     b: B;
 }
 
-type Pair<T> = Tuple<T, T>;
+type Pair<T> = AB<T, T>;
 
 interface TaggedPair<T> extends Pair<T> {
     tag: string;
diff --git a/tests/cases/conformance/types/typeRelationships/recursiveTypes/nominalSubtypeCheckOfTypeParameter.ts b/tests/cases/conformance/types/typeRelationships/recursiveTypes/nominalSubtypeCheckOfTypeParameter.ts
index ed8d724300d9a..ea16201ae91a6 100644
--- a/tests/cases/conformance/types/typeRelationships/recursiveTypes/nominalSubtypeCheckOfTypeParameter.ts
+++ b/tests/cases/conformance/types/typeRelationships/recursiveTypes/nominalSubtypeCheckOfTypeParameter.ts
@@ -1,17 +1,17 @@
-interface Tuple<T, S> {
+interface BinaryTuple<T, S> {
     first: T
-      second: S
+    second: S
 }
 
 interface Sequence<T> {
     hasNext(): boolean
-      pop(): T
-      zip<S>(seq: Sequence<S>): Sequence<Tuple<T, S>>
+    pop(): T
+    zip<S>(seq: Sequence<S>): Sequence<BinaryTuple<T, S>>
 }
 
 // error, despite the fact that the code explicitly says List<T> extends Sequence<T>, the current rules for infinitely expanding type references 
 // perform nominal subtyping checks that allow variance for type arguments, but not nominal subtyping for the generic type itself
 interface List<T> extends Sequence<T> {
     getLength(): number
-      zip<S>(seq: Sequence<S>): List<Tuple<T, S>>
+    zip<S>(seq: Sequence<S>): List<BinaryTuple<T, S>>
 }