diff --git a/.idea/misc.xml b/.idea/misc.xml
deleted file mode 100644
index 72abef0a7321..000000000000
--- a/.idea/misc.xml
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectLevelVcsManager" settingsEditedManually="false">
-    <OptionsSetting value="true" id="Add" />
-    <OptionsSetting value="true" id="Remove" />
-    <OptionsSetting value="true" id="Checkout" />
-    <OptionsSetting value="true" id="Update" />
-    <OptionsSetting value="true" id="Status" />
-    <OptionsSetting value="true" id="Edit" />
-    <ConfirmationsSetting value="0" id="Add" />
-    <ConfirmationsSetting value="0" id="Remove" />
-  </component>
-</project>
\ No newline at end of file
diff --git a/Apps/Sandcastle/gallery/3D Models Coloring.html b/Apps/Sandcastle/gallery/3D Models Coloring.html
new file mode 100644
index 000000000000..e67783ba0e80
--- /dev/null
+++ b/Apps/Sandcastle/gallery/3D Models Coloring.html	
@@ -0,0 +1,194 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no">
+    <meta name="description" content="Change color of 3D models.">
+    <meta name="cesium-sandcastle-labels" content="Showcases">
+    <title>Cesium Demo</title>
+    <script type="text/javascript" src="../Sandcastle-header.js"></script>
+    <script type="text/javascript" src="../../../ThirdParty/requirejs-2.1.20/require.js"></script>
+    <script type="text/javascript">
+    require.config({
+        baseUrl : '../../../Source',
+        waitSeconds : 60
+    });
+    </script>
+</head>
+<body class="sandcastle-loading" data-sandcastle-bucket="bucket-requirejs.html">
+<style>
+    @import url(../templates/bucket.css);
+    #toolbar {
+        background: rgba(42, 42, 42, 0.8);
+        padding: 4px;
+        border-radius: 4px;
+    }
+    #toolbar input {
+        vertical-align: middle;
+        padding-top: 2px;
+        padding-bottom: 2px;
+    }
+</style>
+<div id="cesiumContainer" class="fullSize"></div>
+<div id="loadingOverlay"><h1>Loading...</h1></div>
+<div id="toolbar">
+    <table><tbody>
+    <tr>
+        <td>Mode</td>
+        <td><select data-bind="options: colorBlendModes, value: colorBlendMode"></select></td>
+    </tr>
+    <tr>
+        <td>Color</td>
+        <td><select data-bind="options: colors, value: color"></select></td>
+    </tr>
+    <tr>
+        <td>Alpha</td>
+        <td>
+            <input type="range" min="0.0" max="1.0" step="0.01" data-bind="value: alpha, valueUpdate: 'input'">
+            <input type="text" size="5" data-bind="value: alpha">
+        </td>
+    </tr>
+    <tr>
+        <td data-bind="style: { color: colorBlendAmountEnabled ? '' : 'gray'}">Mix</td>
+        <td>
+            <input type="range" min="0.0" max="1.0" step="0.01" data-bind="value: colorBlendAmount, valueUpdate: 'input', enable: colorBlendAmountEnabled">
+            <input type="text" size="5" data-bind="value: colorBlendAmount, enable: colorBlendAmountEnabled">
+        </td>
+    </tr>
+    </tbody></table>
+</div>
+<script id="cesium_sandcastle_script">
+function startup(Cesium) {
+    'use strict';
+//Sandcastle_Begin
+var viewer = new Cesium.Viewer('cesiumContainer', {
+    infoBox : false,
+    selectionIndicator : false,
+    shadows : true
+});
+
+var entity;
+
+function getColorBlendMode(colorBlendMode) {
+    return Cesium.ColorBlendMode[colorBlendMode.toUpperCase()];
+}
+
+function getColor(color) {
+    return Cesium.Color[color.toUpperCase()];
+}
+
+// The viewModel tracks the state of our mini application.
+var viewModel = {
+    color : 'Red',
+    colors : ['White', 'Red', 'Green', 'Blue', 'Yellow', 'Gray'],
+    alpha : 1.0,
+    colorBlendMode : 'Highlight',
+    colorBlendModes : ['Highlight', 'Replace', 'Mix'],
+    colorBlendAmount : 0.5,
+    colorBlendAmountEnabled : false
+};
+
+// Convert the viewModel members into knockout observables.
+Cesium.knockout.track(viewModel);
+
+// Bind the viewModel to the DOM elements of the UI that call for it.
+var toolbar = document.getElementById('toolbar');
+Cesium.knockout.applyBindings(viewModel, toolbar);
+
+Cesium.knockout.getObservable(viewModel, 'color').subscribe(
+    function(newValue) {
+        entity.model.color = Cesium.Color.fromAlpha(getColor(newValue), viewModel.alpha);
+    }
+);
+
+Cesium.knockout.getObservable(viewModel, 'alpha').subscribe(
+    function(newValue) {
+        entity.model.color = Cesium.Color.fromAlpha(getColor(viewModel.color), newValue);
+    }
+);
+
+Cesium.knockout.getObservable(viewModel, 'colorBlendMode').subscribe(
+    function(newValue) {
+        var colorBlendMode = getColorBlendMode(newValue);
+        entity.model.colorBlendMode = colorBlendMode;
+        viewModel.colorBlendAmountEnabled = (colorBlendMode === Cesium.ColorBlendMode.MIX);
+    }
+);
+
+Cesium.knockout.getObservable(viewModel, 'colorBlendAmount').subscribe(
+    function(newValue) {
+        entity.model.colorBlendAmount = newValue;
+    }
+);
+
+function createModel(url, height) {
+    viewer.entities.removeAll();
+
+    var position = Cesium.Cartesian3.fromDegrees(-123.0744619, 44.0503706, height);
+    var heading = Cesium.Math.toRadians(135);
+    var pitch = 0;
+    var roll = 0;
+    var hpr = new Cesium.HeadingPitchRoll(heading, pitch, roll);
+    var orientation = Cesium.Transforms.headingPitchRollQuaternion(position, hpr);
+
+    entity = viewer.entities.add({
+        name : url,
+        position : position,
+        orientation : orientation,
+        model : {
+            uri : url,
+            minimumPixelSize : 128,
+            maximumScale : 20000,
+            color : Cesium.Color.fromAlpha(getColor(viewModel.color), viewModel.alpha),
+            colorBlendMode : getColorBlendMode(viewModel.colorBlendMode),
+            colorBlendAmount : viewModel.colorBlendAmount
+        }
+    });
+    viewer.trackedEntity = entity;
+}
+
+var options = [{
+    text : 'Aircraft',
+    onselect : function() {
+        createModel('../../SampleData/models/CesiumAir/Cesium_Air.glb', 5000.0);
+    }
+}, {
+    text : 'Ground vehicle',
+    onselect : function() {
+        createModel('../../SampleData/models/CesiumGround/Cesium_Ground.glb', 0);
+    }
+}, {
+    text : 'Hot Air Balloon',
+    onselect : function() {
+        createModel('../../SampleData/models/CesiumBalloon/CesiumBalloon.glb', 1000.0);
+    }
+}, {
+    text : 'Milk truck',
+    onselect : function() {
+        createModel('../../SampleData/models/CesiumMilkTruck/CesiumMilkTruck-kmc.glb', 0);
+    }
+}, {
+    text : 'Skinned character',
+    onselect : function() {
+        createModel('../../SampleData/models/CesiumMan/Cesium_Man.glb', 0);
+    }
+}];
+
+Sandcastle.addToolbarMenu(options);
+
+Sandcastle.addToggleButton('Shadows', viewer.shadows, function(checked) {
+    viewer.shadows = checked;
+});
+
+//Sandcastle_End
+Sandcastle.finishedLoading();
+}
+if (typeof Cesium !== "undefined") {
+    startup(Cesium);
+} else if (typeof require === "function") {
+    require(["Cesium"], startup);
+}
+</script>
+</body>
+</html>
diff --git a/Apps/Sandcastle/gallery/3D Models Coloring.jpg b/Apps/Sandcastle/gallery/3D Models Coloring.jpg
new file mode 100644
index 000000000000..dff69552e5ca
Binary files /dev/null and b/Apps/Sandcastle/gallery/3D Models Coloring.jpg differ
diff --git a/Apps/Sandcastle/gallery/3D Models.html b/Apps/Sandcastle/gallery/3D Models.html
index 30caabdb7188..faa2af95ed0a 100644
--- a/Apps/Sandcastle/gallery/3D Models.html	
+++ b/Apps/Sandcastle/gallery/3D Models.html	
@@ -94,4 +94,4 @@
 }
 </script>
 </body>
-</html>
+</html>
\ No newline at end of file
diff --git a/Apps/Sandcastle/gallery/development/3D Models.html b/Apps/Sandcastle/gallery/development/3D Models.html
index 0504f5af2a7b..ffc969e4dc54 100644
--- a/Apps/Sandcastle/gallery/development/3D Models.html	
+++ b/Apps/Sandcastle/gallery/development/3D Models.html	
@@ -19,16 +19,107 @@
 <body class="sandcastle-loading" data-sandcastle-bucket="bucket-requirejs.html">
 <style>
     @import url(../templates/bucket.css);
+    #toolbar {
+        background: rgba(42, 42, 42, 0.8);
+        padding: 4px;
+        border-radius: 4px;
+    }
+    #toolbar input {
+        vertical-align: middle;
+        padding-top: 2px;
+        padding-bottom: 2px;
+    }
 </style>
 <div id="cesiumContainer" class="fullSize"></div>
 <div id="loadingOverlay"><h1>Loading...</h1></div>
-<div id="toolbar"></div>
+<div id="toolbar">
+    <table><tbody>
+    <tr>
+        <td>Mode</td>
+        <td><select data-bind="options: colorBlendModes, value: colorBlendMode"></select></td>
+    </tr>
+    <tr>
+        <td>Color</td>
+        <td><select data-bind="options: colors, value: color"></select></td>
+    </tr>
+    <tr>
+        <td>Alpha</td>
+        <td>
+            <input type="range" min="0.0" max="1.0" step="0.01" data-bind="value: alpha, valueUpdate: 'input'">
+            <input type="text" size="5" data-bind="value: alpha">
+        </td>
+    </tr>
+    <tr>
+        <td data-bind="style: { color: colorBlendAmountEnabled ? '' : 'gray'}">Mix</td>
+        <td>
+            <input type="range" min="0.0" max="1.0" step="0.01" data-bind="value: colorBlendAmount, valueUpdate: 'input', enable: colorBlendAmountEnabled">
+            <input type="text" size="5" data-bind="value: colorBlendAmount, enable: colorBlendAmountEnabled">
+        </td>
+    </tr>
+    </tbody></table>
+</div>
 <script id="cesium_sandcastle_script">
 function startup(Cesium) {
     'use strict';
 //Sandcastle_Begin
-var viewer = new Cesium.Viewer('cesiumContainer');
+var viewer = new Cesium.Viewer('cesiumContainer', {
+    shadows : true
+});
+
 var scene = viewer.scene;
+var model;
+
+function getColorBlendMode(colorBlendMode) {
+    return Cesium.ColorBlendMode[colorBlendMode.toUpperCase()];
+}
+
+function getColor(color) {
+    return Cesium.Color[color.toUpperCase()];
+}
+
+// The viewModel tracks the state of our mini application.
+var viewModel = {
+    color : 'White',
+    colors : ['White', 'Red', 'Green', 'Blue', 'Yellow', 'Gray'],
+    alpha : 1.0,
+    colorBlendMode : 'Highlight',
+    colorBlendModes : ['Highlight', 'Replace', 'Mix'],
+    colorBlendAmount : 0.5,
+    colorBlendAmountEnabled : false
+};
+
+// Convert the viewModel members into knockout observables.
+Cesium.knockout.track(viewModel);
+
+// Bind the viewModel to the DOM elements of the UI that call for it.
+var toolbar = document.getElementById('toolbar');
+Cesium.knockout.applyBindings(viewModel, toolbar);
+
+Cesium.knockout.getObservable(viewModel, 'color').subscribe(
+    function(newValue) {
+        model.color = Cesium.Color.fromAlpha(getColor(newValue), viewModel.alpha);
+    }
+);
+
+Cesium.knockout.getObservable(viewModel, 'alpha').subscribe(
+    function(newValue) {
+        model.color = Cesium.Color.fromAlpha(getColor(viewModel.color), newValue);
+    }
+);
+
+Cesium.knockout.getObservable(viewModel, 'colorBlendMode').subscribe(
+    function(newValue) {
+        var colorBlendMode = getColorBlendMode(newValue);
+        model.colorBlendMode = colorBlendMode;
+        viewModel.colorBlendAmountEnabled = (colorBlendMode === Cesium.ColorBlendMode.MIX);
+    }
+);
+
+Cesium.knockout.getObservable(viewModel, 'colorBlendAmount').subscribe(
+    function(newValue) {
+        model.colorBlendAmount = newValue;
+    }
+);
 
 function createModel(url, height, heading, pitch, roll) {
     height = Cesium.defaultValue(height, 0.0);
@@ -41,26 +132,29 @@
     var modelMatrix = Cesium.Transforms.headingPitchRollToFixedFrame(origin, hpr);
 
     scene.primitives.removeAll(); // Remove previous model
-    var model = scene.primitives.add(Cesium.Model.fromGltf({
+    model = scene.primitives.add(Cesium.Model.fromGltf({
         url : url,
         modelMatrix : modelMatrix,
         minimumPixelSize : 128
     }));
 
     model.readyPromise.then(function(model) {
+        model.color = Cesium.Color.fromAlpha(getColor(viewModel.color), viewModel.alpha);
+        model.colorBlendMode = getColorBlendMode(viewModel.colorBlendMode);
+        model.colorBlendAmount = viewModel.colorBlendAmount;
         // Play and loop all animations at half-speed
         model.activeAnimations.addAll({
             speedup : 0.5,
             loop : Cesium.ModelAnimationLoop.REPEAT
         });
-        
+
         var camera = viewer.camera;
-        
+
         // Zoom to model
         var controller = scene.screenSpaceCameraController;
         var r = 2.0 * Math.max(model.boundingSphere.radius, camera.frustum.near);
         controller.minimumZoomDistance = r * 0.5;
-        
+
         var center = Cesium.Matrix4.multiplyByPoint(model.modelMatrix, model.boundingSphere.center, new Cesium.Cartesian3());
         var heading = Cesium.Math.toRadians(230.0);
         var pitch = Cesium.Math.toRadians(-20.0);
@@ -74,7 +168,7 @@
 handler.setInputAction(function(movement) {
     var pick = scene.pick(movement.endPosition);
     if (Cesium.defined(pick) && Cesium.defined(pick.node) && Cesium.defined(pick.mesh)) {
-        // Output glTF node and mesh under the mouse. 
+        // Output glTF node and mesh under the mouse.
         console.log('node: ' + pick.node.name + '. mesh: ' + pick.mesh.name);
     }
 }, Cesium.ScreenSpaceEventType.MOUSE_MOVE);
@@ -82,8 +176,8 @@
 ///////////////////////////////////////////////////////////////////////////
 
 var options = [{
-text : 'Aircraft',
-onselect : function() {
+    text : 'Aircraft',
+    onselect : function() {
         var height = 5000.0;
         var heading = 0.0;
         var pitch = Cesium.Math.toRadians(10.0);
@@ -91,15 +185,15 @@
         createModel('../../SampleData/models/CesiumAir/Cesium_Air.glb', height, heading, pitch, roll);
     }
 }, {
-text : 'Ground vehicle',
+    text : 'Ground vehicle',
     onselect : function() {
         createModel('../../SampleData/models/CesiumGround/Cesium_Ground.glb');
     }
 }, {
-text : 'Milk truck',
-onselect : function() {
-    createModel('../../SampleData/models/CesiumMilkTruck/CesiumMilkTruck.glb');
-}
+    text : 'Milk truck',
+    onselect : function() {
+        createModel('../../SampleData/models/CesiumMilkTruck/CesiumMilkTruck.glb');
+    }
 }, {
     text : 'Skinned character',
     onselect : function() {
@@ -108,6 +202,11 @@
 }];
 
 Sandcastle.addToolbarMenu(options);
+
+Sandcastle.addToggleButton('Shadows', viewer.shadows, function(checked) {
+    viewer.shadows = checked;
+});
+
 //Sandcastle_End
 Sandcastle.finishedLoading();
 }
diff --git a/CHANGES.md b/CHANGES.md
index eb8baf4b733f..f9eeb43dd66d 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,6 +1,10 @@
 Change Log
 ==========
 
+### 1.29 - 2017-01-02
+
+* Added the ability to blend a `Model` with a color/translucency. Added `color`, `colorBlendMode`, and `colorBlendAmount` properties to `Model`, `ModelGraphics`, and CZML. Added `ColorBlendMode` enum. [#4547](https://github.com/AnalyticalGraphicsInc/cesium/pull/4547)
+
 ### 1.28 - 2016-12-01
 
 * Improved terrain/imagery load ordering, especially when the terrain is already fully loaded and a new imagery layer is loaded.  This results in a 25% reduction in load times in many cases. [#4616](https://github.com/AnalyticalGraphicsInc/cesium/pull/4616)
diff --git a/Source/DataSources/CzmlDataSource.js b/Source/DataSources/CzmlDataSource.js
index 46563103ff83..02b3b7ca4bd5 100644
--- a/Source/DataSources/CzmlDataSource.js
+++ b/Source/DataSources/CzmlDataSource.js
@@ -34,6 +34,7 @@ define([
         '../Core/Spherical',
         '../Core/TimeInterval',
         '../Core/TimeIntervalCollection',
+        '../Scene/ColorBlendMode',
         '../Scene/HeightReference',
         '../Scene/HorizontalOrigin',
         '../Scene/LabelStyle',
@@ -118,6 +119,7 @@ define([
         Spherical,
         TimeInterval,
         TimeIntervalCollection,
+        ColorBlendMode,
         HeightReference,
         HorizontalOrigin,
         LabelStyle,
@@ -430,6 +432,8 @@ define([
                 return unwrapCartesianInterval(czmlInterval);
             case Color:
                 return unwrapColorInterval(czmlInterval);
+            case ColorBlendMode:
+                return ColorBlendMode[defaultValue(czmlInterval.colorBlendMode, czmlInterval)];
             case CornerType:
                 return CornerType[defaultValue(czmlInterval.cornerType, czmlInterval)];
             case HeightReference:
@@ -1413,6 +1417,9 @@ define([
         processPacketData(Boolean, model, 'runAnimations', modelData.runAnimations, interval, sourceUri, entityCollection);
         processPacketData(ShadowMode, model, 'shadows', modelData.shadows, interval, sourceUri, entityCollection);
         processPacketData(HeightReference, model, 'heightReference', modelData.heightReference, interval, sourceUri, entityCollection);
+        processPacketData(Color, model, 'color', modelData.color, interval, sourceUri, entityCollection);
+        processPacketData(ColorBlendMode, model, 'colorBlendMode', modelData.colorBlendMode, interval, sourceUri, entityCollection);
+        processPacketData(Number, model, 'colorBlendAmount', modelData.colorBlendAmount, interval, sourceUri, entityCollection);
 
         var nodeTransformationsData = modelData.nodeTransformations;
         if (defined(nodeTransformationsData)) {
diff --git a/Source/DataSources/ModelGraphics.js b/Source/DataSources/ModelGraphics.js
index 81d48182b0cb..d98013280b19 100644
--- a/Source/DataSources/ModelGraphics.js
+++ b/Source/DataSources/ModelGraphics.js
@@ -50,6 +50,9 @@ define([
      * @param {Property} [options.shadows=ShadowMode.ENABLED] An enum Property specifying whether the model casts or receives shadows from each light source.
      * @param {Property} [options.heightReference=HeightReference.NONE] A Property specifying what the height is relative to.
      * @param {Property} [options.distanceDisplayCondition] A Property specifying at what distance from the camera that this model will be displayed.
+     * @param {Property} [options.color=Color.WHITE] A Property specifying the {@link Color} that blends with the model's rendered color.
+     * @param {Property} [options.colorBlendMode=ColorBlendMode.HIGHLIGHT] An enum Property specifying how the color blends with the model.
+     * @param {Property} [options.colorBlendAmount=0.5] A numeric Property specifying the color strength when the <code>colorBlendMode</code> is <code>MIX</code>. A value of 0.0 results in the model's rendered color while a value of 1.0 results in a solid color, with any value in-between resulting in a mix of the two.
      *
      * @see {@link http://cesiumjs.org/2014/03/03/Cesium-3D-Models-Tutorial/|3D Models Tutorial}
      * @demo {@link http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=3D%20Models.html|Cesium Sandcastle 3D Models Demo}
@@ -77,6 +80,12 @@ define([
         this._heightReferenceSubscription = undefined;
         this._distanceDisplayCondition = undefined;
         this._distanceDisplayConditionSubscription = undefined;
+        this._color = undefined;
+        this._colorSubscription = undefined;
+        this._colorBlendMode = undefined;
+        this._colorBlendModeSubscription = undefined;
+        this._colorBlendAmount = undefined;
+        this._colorBlendAmountSubscription = undefined;
         this._definitionChanged = new Event();
 
         this.merge(defaultValue(options, defaultValue.EMPTY_OBJECT));
@@ -186,7 +195,33 @@ define([
          * @memberof ModelGraphics.prototype
          * @type {Property}
          */
-        distanceDisplayCondition : createPropertyDescriptor('distanceDisplayCondition')
+        distanceDisplayCondition : createPropertyDescriptor('distanceDisplayCondition'),
+
+        /**
+         * Gets or sets the Property specifying the {@link Color} that blends with the model's rendered color.
+         * @memberof ModelGraphics.prototype
+         * @type {Property}
+         * @default Color.WHITE
+         */
+        color : createPropertyDescriptor('color'),
+
+        /**
+         * Gets or sets the enum Property specifying how the color blends with the model.
+         * @memberof ModelGraphics.prototype
+         * @type {Property}
+         * @default ColorBlendMode.HIGHLIGHT
+         */
+        colorBlendMode : createPropertyDescriptor('colorBlendMode'),
+
+        /**
+         * A numeric Property specifying the color strength when the <code>colorBlendMode</code> is MIX.
+         * A value of 0.0 results in the model's rendered color while a value of 1.0 results in a solid color, with
+         * any value in-between resulting in a mix of the two.
+         * @memberof ModelGraphics.prototype
+         * @type {Property}
+         * @default 0.5
+         */
+        colorBlendAmount : createPropertyDescriptor('colorBlendAmount')
     });
 
     /**
@@ -210,6 +245,9 @@ define([
         result.nodeTransformations = this.nodeTransformations;
         result.heightReference = this._heightReference;
         result.distanceDisplayCondition = this.distanceDisplayCondition;
+        result.color = this.color;
+        result.colorBlendMode = this.colorBlendMode;
+        result.colorBlendAmount = this.colorBlendAmount;
 
         return result;
     };
@@ -237,6 +275,9 @@ define([
         this.runAnimations = defaultValue(this.runAnimations, source.runAnimations);
         this.heightReference = defaultValue(this.heightReference, source.heightReference);
         this.distanceDisplayCondition = defaultValue(this.distanceDisplayCondition, source.distanceDisplayCondition);
+        this.color = defaultValue(this.color, source.color);
+        this.colorBlendMode = defaultValue(this.colorBlendMode, source.colorBlendMode);
+        this.colorBlendAmount = defaultValue(this.colorBlendAmount, source.colorBlendAmount);
 
         var sourceNodeTransformations = source.nodeTransformations;
         if (defined(sourceNodeTransformations)) {
diff --git a/Source/DataSources/ModelVisualizer.js b/Source/DataSources/ModelVisualizer.js
index 110aafe889f8..0cfd2fc8c248 100644
--- a/Source/DataSources/ModelVisualizer.js
+++ b/Source/DataSources/ModelVisualizer.js
@@ -2,10 +2,12 @@
 define([
         '../Core/AssociativeArray',
         '../Core/BoundingSphere',
+        '../Core/Color',
         '../Core/defined',
         '../Core/destroyObject',
         '../Core/DeveloperError',
         '../Core/Matrix4',
+        '../Scene/ColorBlendMode',
         '../Scene/HeightReference',
         '../Scene/Model',
         '../Scene/ModelAnimationLoop',
@@ -15,10 +17,12 @@ define([
     ], function(
         AssociativeArray,
         BoundingSphere,
+        Color,
         defined,
         destroyObject,
         DeveloperError,
         Matrix4,
+        ColorBlendMode,
         HeightReference,
         Model,
         ModelAnimationLoop,
@@ -32,7 +36,11 @@ define([
     var defaultIncrementallyLoadTextures = true;
     var defaultShadows = ShadowMode.ENABLED;
     var defaultHeightReference = HeightReference.NONE;
+    var defaultColor = Color.WHITE;
+    var defaultColorBlendMode = ColorBlendMode.HIGHLIGHT;
+    var defaultColorBlendAmount = 0.5;
 
+    var color = new Color();
     var modelMatrixScratch = new Matrix4();
     var nodeMatrixScratch = new Matrix4();
 
@@ -139,6 +147,9 @@ define([
             model.shadows = Property.getValueOrDefault(modelGraphics._shadows, time, defaultShadows);
             model.heightReference = Property.getValueOrDefault(modelGraphics._heightReference, time, defaultHeightReference);
             model.distanceDisplayCondition = Property.getValueOrUndefined(modelGraphics._distanceDisplayCondition, time);
+            model.color = Property.getValueOrDefault(modelGraphics._color, time, defaultColor, color);
+            model.colorBlendMode = Property.getValueOrDefault(modelGraphics._colorBlendMode, time, defaultColorBlendMode);
+            model.colorBlendAmount = Property.getValueOrDefault(modelGraphics._colorBlendAmount, time, defaultColorBlendAmount);
 
             if (model.ready) {
                 var runAnimations = Property.getValueOrDefault(modelGraphics._runAnimations, time, true);
diff --git a/Source/Scene/ColorBlendMode.js b/Source/Scene/ColorBlendMode.js
new file mode 100644
index 000000000000..224acbb5284e
--- /dev/null
+++ b/Source/Scene/ColorBlendMode.js
@@ -0,0 +1,39 @@
+/*global define*/
+define([
+        '../Core/freezeObject',
+        '../Core/Math'
+], function(
+        freezeObject,
+        CesiumMath) {
+    'use strict';
+
+    /**
+     * Defines different modes for blending between a target color and a primitive's source color.
+     *
+     * HIGHLIGHT multiplies the source color by the target color
+     * REPLACE replaces the source color with the target color
+     * MIX blends the source color and target color together
+     *
+     * @exports ColorBlendMode
+     *
+     * @see Model.colorBlendMode
+     */
+    var ColorBlendMode = {
+        HIGHLIGHT : 0,
+        REPLACE : 1,
+        MIX : 2
+    };
+
+    ColorBlendMode.getColorBlend = function(colorBlendMode, colorBlendAmount) {
+        if (colorBlendMode === ColorBlendMode.HIGHLIGHT) {
+            return 0.0;
+        } else if (colorBlendMode === ColorBlendMode.REPLACE) {
+            return 1.0;
+        } else if (colorBlendMode === ColorBlendMode.MIX) {
+            // The value 0.0 is reserved for highlight, so clamp to just above 0.0.
+            return CesiumMath.clamp(colorBlendAmount, CesiumMath.EPSILON4, 1.0);
+        }
+    };
+
+    return freezeObject(ColorBlendMode);
+});
\ No newline at end of file
diff --git a/Source/Scene/Model.js b/Source/Scene/Model.js
index 697013a61d5a..703abe4e8708 100644
--- a/Source/Scene/Model.js
+++ b/Source/Scene/Model.js
@@ -6,6 +6,7 @@ define([
         '../Core/Cartesian4',
         '../Core/Cartographic',
         '../Core/clone',
+        '../Core/Color',
         '../Core/combine',
         '../Core/defaultValue',
         '../Core/defined',
@@ -47,6 +48,8 @@ define([
         '../ThirdParty/gltfDefaults',
         '../ThirdParty/Uri',
         '../ThirdParty/when',
+        './BlendingState',
+        './ColorBlendMode',
         './getBinaryAccessor',
         './HeightReference',
         './ModelAnimationCache',
@@ -65,6 +68,7 @@ define([
         Cartesian4,
         Cartographic,
         clone,
+        Color,
         combine,
         defaultValue,
         defined,
@@ -106,6 +110,8 @@ define([
         gltfDefaults,
         Uri,
         when,
+        BlendingState,
+        ColorBlendMode,
         getBinaryAccessor,
         HeightReference,
         ModelAnimationCache,
@@ -319,6 +325,9 @@ define([
      * @param {HeightReference} [options.heightReference] Determines how the model is drawn relative to terrain.
      * @param {Scene} [options.scene] Must be passed in for models that use the height reference property.
      * @param {DistanceDisplayCondition} [options.istanceDisplayCondition] The condition specifying at what distance from the camera that this model will be displayed.
+     * @param {Color} [options.color=Color.WHITE] A color that blends with the model's rendered color.
+     * @param {ColorBlendMode} [options.colorBlendMode=ColorBlendMode.HIGHLIGHT] Defines how the color blends with the model.
+     * @param {Number} [options.colorBlendAmount=0.5] Value used to determine the color strength when the <code>colorBlendMode</code> is <code>MIX</code>. A value of 0.0 results in the model's rendered color while a value of 1.0 results in a solid color, with any value in-between resulting in a mix of the two.
      *
      * @exception {DeveloperError} bgltf is not a valid Binary glTF file.
      * @exception {DeveloperError} Only glTF Binary version 1 is supported.
@@ -514,6 +523,35 @@ define([
         this.shadows = defaultValue(options.shadows, ShadowMode.ENABLED);
         this._shadows = this.shadows;
 
+        /**
+         * A color that blends with the model's rendered color.
+         *
+         * @type {Color}
+         *
+         * @default Color.WHITE
+         */
+        this.color = defaultValue(options.color, Color.WHITE);
+
+        /**
+         * Defines how the color blends with the model.
+         *
+         * @type {ColorBlendMode}
+         *
+         * @default ColorBlendMode.HIGHLIGHT
+         */
+        this.colorBlendMode = defaultValue(options.colorBlendMode, ColorBlendMode.HIGHLIGHT);
+
+        /**
+         * Value used to determine the color strength when the <code>colorBlendMode</code> is <code>MIX</code>.
+         * A value of 0.0 results in the model's rendered color while a value of 1.0 results in a solid color, with
+         * any value in-between resulting in a mix of the two.
+         *
+         * @type {Number}
+         *
+         * @default 0.5
+         */
+        this.colorBlendAmount = defaultValue(options.colorBlendAmount, 0.5);
+
         /**
          * This property is for debugging only; it is not for production use nor is it optimized.
          * <p>
@@ -1655,7 +1693,7 @@ define([
             if (getProgramForPrimitive(model, primitive) === programName) {
                 for (var attributeSemantic in primitive.attributes) {
                     if (primitive.attributes.hasOwnProperty(attributeSemantic)) {
-                        var decodeUniformVarName = 'czm_u_dec_' + attributeSemantic.toLowerCase();
+                        var decodeUniformVarName = 'gltf_u_dec_' + attributeSemantic.toLowerCase();
                         var decodeUniformVarNameScale = decodeUniformVarName + '_scale';
                         var decodeUniformVarNameTranslate = decodeUniformVarName + '_translate';
                         if (!defined(quantizedUniforms[decodeUniformVarName]) && !defined(quantizedUniforms[decodeUniformVarNameScale])) {
@@ -1664,8 +1702,8 @@ define([
                             if (defined(quantizedAttributes)) {
                                 var attributeVarName = getAttributeVariableName(model, primitive, attributeSemantic);
                                 var decodeMatrix = quantizedAttributes.decodeMatrix;
-                                var newMain = 'czm_decoded_' + attributeSemantic;
-                                var decodedAttributeVarName = attributeVarName.replace('a_', 'czm_a_dec_');
+                                var newMain = 'gltf_decoded_' + attributeSemantic;
+                                var decodedAttributeVarName = attributeVarName.replace('a_', 'gltf_a_dec_');
                                 var size = Math.floor(Math.sqrt(decodeMatrix.length));
 
                                 // replace usages of the original attribute with the decoded version, but not the declaration
@@ -1717,6 +1755,35 @@ define([
         return shader;
     }
 
+    function hasPremultipliedAlpha(model) {
+        var gltf = model.gltf;
+        return defined(gltf.asset) ? defaultValue(gltf.asset.premultipliedAlpha, false) : false;
+    }
+
+    function modifyShaderForColor(shader, premultipliedAlpha) {
+        shader = ShaderSource.replaceMain(shader, 'gltf_blend_main');
+        shader +=
+            'uniform vec4 gltf_color; \n' +
+            'uniform float gltf_colorBlend; \n' +
+            'void main() \n' +
+            '{ \n' +
+            '    gltf_blend_main(); \n';
+
+        // Un-premultiply the alpha so that blending is correct.
+        if (premultipliedAlpha) {
+            shader += '    gl_FragColor.rgb /= gl_FragColor.a; \n';
+        }
+
+        shader +=
+            '    gl_FragColor.rgb = mix(gl_FragColor.rgb, gltf_color.rgb, gltf_colorBlend); \n' +
+            '    float highlight = ceil(gltf_colorBlend); \n' +
+            '    gl_FragColor.rgb *= mix(gltf_color.rgb, vec3(1.0), highlight); \n' +
+            '    gl_FragColor.a *= gltf_color.a; \n' +
+            '} \n';
+
+        return shader;
+    }
+
     function modifyShader(shader, programName, callback) {
         if (defined(callback)) {
             shader = callback(shader, programName);
@@ -1748,8 +1815,11 @@ define([
             vs = modifyShaderForQuantizedAttributes(vs, id, model, context);
         }
 
+        var premultipliedAlpha = hasPremultipliedAlpha(model);
+        var blendFS = modifyShaderForColor(fs, premultipliedAlpha);
+
         var drawVS = modifyShader(vs, id, model._vertexShaderLoaded);
-        var drawFS = modifyShader(fs, id, model._fragmentShaderLoaded);
+        var drawFS = modifyShader(blendFS, id, model._fragmentShaderLoaded);
 
         model._rendererResources.programs[id] = ShaderProgram.fromCache({
             context : context,
@@ -2282,6 +2352,16 @@ define([
         var polygonOffset = defaultValue(statesFunctions.polygonOffset, [0.0, 0.0]);
         var scissor = defaultValue(statesFunctions.scissor, [0.0, 0.0, 0.0, 0.0]);
 
+        // Change the render state to use traditional alpha blending instead of premultiplied alpha blending
+        if (booleanStates[WebGLConstants.BLEND] && hasPremultipliedAlpha(model)) {
+            if ((blendFuncSeparate[0] === WebGLConstants.ONE) && (blendFuncSeparate[1] === WebGLConstants.ONE_MINUS_SRC_ALPHA)) {
+                blendFuncSeparate[0] = WebGLConstants.SRC_ALPHA;
+                blendFuncSeparate[1] = WebGLConstants.ONE_MINUS_SRC_ALPHA;
+                blendFuncSeparate[2] = WebGLConstants.SRC_ALPHA;
+                blendFuncSeparate[3] = WebGLConstants.ONE_MINUS_SRC_ALPHA;
+            }
+        }
+
         rendererRenderStates[id] = RenderState.fromCache({
             frontFace : defined(statesFunctions.frontFace) ? statesFunctions.frontFace[0] : WebGLConstants.CCW,
             cull : {
@@ -2772,7 +2852,7 @@ define([
                     var quantizedAttributes = extensions.WEB3D_quantized_attributes;
                     if (defined(quantizedAttributes)) {
                         var decodeMatrix = quantizedAttributes.decodeMatrix;
-                        var uniformVariable = 'czm_u_dec_' + attribute.toLowerCase();
+                        var uniformVariable = 'gltf_u_dec_' + attribute.toLowerCase();
 
                         switch (a.type) {
                             case 'SCALAR':
@@ -2839,6 +2919,18 @@ define([
         };
     }
 
+    function createColorFunction(model) {
+        return function() {
+            return model.color;
+        };
+    }
+
+    function createColorBlendFunction(model) {
+        return function() {
+            return ColorBlendMode.getColorBlend(model.colorBlendMode, model.colorBlendAmount);
+        };
+    }
+
     function createCommand(model, gltfNode, runtimeNode, context, scene3DOnly) {
         var nodeCommands = model._nodeCommands;
         var pickIds = model._pickIds;
@@ -2907,6 +2999,11 @@ define([
                     uniformMap = combine(uniformMap, jointUniformMap);
                 }
 
+                uniformMap = combine(uniformMap, {
+                    gltf_color : createColorFunction(model),
+                    gltf_colorBlend : createColorBlendFunction(model)
+                });
+
                 // Allow callback to modify the uniformMap
                 if (defined(model._uniformMapLoaded)) {
                     uniformMap = model._uniformMapLoaded(uniformMap, programId, runtimeNode);
@@ -3009,7 +3106,10 @@ define([
                     command : command,
                     pickCommand : pickCommand,
                     command2D : command2D,
-                    pickCommand2D : pickCommand2D
+                    pickCommand2D : pickCommand2D,
+                    // Generate on demand when color alpha is less than 1.0
+                    translucentCommand : undefined,
+                    translucentCommand2D : undefined
                 };
                 runtimeNode.commands.push(nodeCommand);
                 nodeCommands.push(nodeCommand);
@@ -3386,6 +3486,44 @@ define([
         }
     }
 
+    function getTranslucentRenderState(renderState) {
+        var rs = clone(renderState, true);
+        rs.cull.enabled = false;
+        rs.depthTest.enabled = true;
+        rs.depthMask = false;
+        rs.blending = BlendingState.ALPHA_BLEND;
+
+        return RenderState.fromCache(rs);
+    }
+
+    function deriveTranslucentCommand(command) {
+        var translucentCommand = DrawCommand.shallowClone(command);
+        translucentCommand.pass = Pass.TRANSLUCENT;
+        translucentCommand.renderState = getTranslucentRenderState(command.renderState);
+        return translucentCommand;
+    }
+
+    function updateColor(model, frameState) {
+        var scene3DOnly = frameState.scene3DOnly;
+        var alpha = model.color.alpha;
+        if ((alpha > 0.0) && (alpha < 1.0)) {
+            var nodeCommands = model._nodeCommands;
+            var length = nodeCommands.length;
+            // Generate translucent commands when the blend color has an alpha less than 1.0
+            if (!defined(nodeCommands[0].translucentCommand)) {
+                for (var i = 0; i < length; ++i) {
+                    var nodeCommand = nodeCommands[i];
+                    var command = nodeCommand.command;
+                    nodeCommand.translucentCommand = deriveTranslucentCommand(command);
+                    if (!scene3DOnly) {
+                        var command2D = nodeCommand.command2D;
+                        nodeCommand.translucentCommand2D = deriveTranslucentCommand(command2D);
+                    }
+                }
+            }
+        }
+    }
+
     var scratchBoundingSphere = new BoundingSphere();
 
     function scaleInPixels(positionWC, radius, frameState) {
@@ -3720,8 +3858,9 @@ define([
             }
         }
 
+        var alpha = this.color.alpha;
         var displayConditionPassed = defined(this.distanceDisplayCondition) ? distanceDisplayConditionVisible(this, frameState) : true;
-        var show = this.show && displayConditionPassed && (this.scale !== 0.0);
+        var show = this.show && displayConditionPassed && (this.scale !== 0.0) && (alpha > 0.0);
 
         if ((show && this._state === ModelState.LOADED) || justLoaded) {
             var animated = this.activeAnimations.update(frameState) || this._cesiumAnimationsDirty;
@@ -3780,6 +3919,7 @@ define([
             updateWireframe(this);
             updateShowBoundingVolume(this);
             updateShadows(this);
+            updateColor(this, frameState);
         }
 
         if (justLoaded) {
@@ -3811,13 +3951,14 @@ define([
                 for (i = 0; i < length; ++i) {
                     nc = nodeCommands[i];
                     if (nc.show) {
-                        var command = nc.command;
+                        var translucent = (alpha < 1.0);
+                        var command = translucent ? nc.translucentCommand : nc.command;
                         commandList.push(command);
-
-                        boundingVolume = command.boundingVolume;
+                        boundingVolume = nc.command.boundingVolume;
                         if (frameState.mode === SceneMode.SCENE2D &&
                             (boundingVolume.center.y + boundingVolume.radius > idl2D || boundingVolume.center.y - boundingVolume.radius < idl2D)) {
-                            commandList.push(nc.command2D);
+                            var command2D = translucent ? nc.translucentCommand2D : nc.command2D;
+                            commandList.push(command2D);
                         }
                     }
                 }
diff --git a/Specs/DataSources/CzmlDataSourceSpec.js b/Specs/DataSources/CzmlDataSourceSpec.js
index 5a6cbbe0fa81..b3be324ede7e 100644
--- a/Specs/DataSources/CzmlDataSourceSpec.js
+++ b/Specs/DataSources/CzmlDataSourceSpec.js
@@ -27,6 +27,7 @@ defineSuite([
         'DataSources/EntityCollection',
         'DataSources/ReferenceProperty',
         'DataSources/StripeOrientation',
+        'Scene/ColorBlendMode',
         'Scene/HeightReference',
         'Scene/HorizontalOrigin',
         'Scene/LabelStyle',
@@ -61,6 +62,7 @@ defineSuite([
         EntityCollection,
         ReferenceProperty,
         StripeOrientation,
+        ColorBlendMode,
         HeightReference,
         HorizontalOrigin,
         LabelStyle,
@@ -1838,6 +1840,11 @@ defineSuite([
                 incrementallyLoadTextures : true,
                 shadows : 'ENABLED',
                 heightReference: 'CLAMP_TO_GROUND',
+                color : {
+                    rgbaf : [0.0, 1.0, 0.0, 0.2]
+                },
+                colorBlendMode : 'HIGHLIGHT',
+                colorBlendAmount : 0.5,
                 nodeTransformations : {
                     Mesh : {
                         scale : {
@@ -1867,6 +1874,9 @@ defineSuite([
         expect(entity.model.incrementallyLoadTextures.getValue(Iso8601.MINIMUM_VALUE)).toEqual(true);
         expect(entity.model.shadows.getValue(Iso8601.MINIMUM_VALUE)).toEqual(ShadowMode.ENABLED);
         expect(entity.model.heightReference.getValue(Iso8601.MINIMUM_VALUE)).toEqual(HeightReference.CLAMP_TO_GROUND);
+        expect(entity.model.color.getValue(Iso8601.MINIMUM_VALUE)).toEqual(new Color(0.0, 1.0, 0.0, 0.2));
+        expect(entity.model.colorBlendMode.getValue(Iso8601.MINIMUM_VALUE)).toEqual(ColorBlendMode.HIGHLIGHT);
+        expect(entity.model.colorBlendAmount.getValue(Iso8601.MINIMUM_VALUE)).toEqual(0.5);
 
         var nodeTransform = entity.model.nodeTransformations.getValue(Iso8601.MINIMUM_VALUE).Mesh;
         expect(nodeTransform).toBeDefined();
@@ -1892,6 +1902,12 @@ defineSuite([
                 gltf : './Data/Models/Box/CesiumBoxTest.gltf',
                 incrementallyLoadTextures : true,
                 shadows : 'ENABLED',
+                heightReference: 'CLAMP_TO_GROUND',
+                color : {
+                    rgbaf : [0.0, 1.0, 0.0, 0.2]
+                },
+                colorBlendMode : 'HIGHLIGHT',
+                colorBlendAmount : 0.5,
                 nodeTransformations : {
                     Mesh : {
                         scale : {
@@ -1924,6 +1940,10 @@ defineSuite([
         expect(entity.model.uri.getValue(validTime)).toEqual('./Data/Models/Box/CesiumBoxTest.gltf');
         expect(entity.model.incrementallyLoadTextures.getValue(validTime)).toEqual(true);
         expect(entity.model.shadows.getValue(validTime)).toEqual(ShadowMode.ENABLED);
+        expect(entity.model.heightReference.getValue(validTime)).toEqual(HeightReference.CLAMP_TO_GROUND);
+        expect(entity.model.color.getValue(validTime)).toEqual(new Color(0.0, 1.0, 0.0, 0.2));
+        expect(entity.model.colorBlendMode.getValue(validTime)).toEqual(ColorBlendMode.HIGHLIGHT);
+        expect(entity.model.colorBlendAmount.getValue(validTime)).toEqual(0.5);
 
         var nodeTransform = entity.model.nodeTransformations.getValue(validTime).Mesh;
         expect(nodeTransform).toBeDefined();
@@ -1944,6 +1964,10 @@ defineSuite([
         expect(entity.model.uri.getValue(invalidTime)).toBeUndefined();
         expect(entity.model.incrementallyLoadTextures.getValue(invalidTime)).toBeUndefined();
         expect(entity.model.shadows.getValue(invalidTime)).toBeUndefined();
+        expect(entity.model.heightReference.getValue(invalidTime)).toBeUndefined();
+        expect(entity.model.color.getValue(invalidTime)).toBeUndefined();
+        expect(entity.model.colorBlendMode.getValue(invalidTime)).toBeUndefined();
+        expect(entity.model.colorBlendAmount.getValue(invalidTime)).toBeUndefined();
 
         expect(entity.model.nodeTransformations.Mesh.getValue(invalidTime)).toEqual(new TranslationRotationScale());
         expect(entity.model.nodeTransformations.Mesh.scale.getValue(invalidTime)).toBeUndefined();
diff --git a/Specs/DataSources/ModelGraphicsSpec.js b/Specs/DataSources/ModelGraphicsSpec.js
index c2c18f2965df..5c6fdb521c99 100644
--- a/Specs/DataSources/ModelGraphicsSpec.js
+++ b/Specs/DataSources/ModelGraphicsSpec.js
@@ -2,22 +2,28 @@
 defineSuite([
         'DataSources/ModelGraphics',
         'Core/Cartesian3',
+        'Core/Color',
         'Core/DistanceDisplayCondition',
         'Core/JulianDate',
         'Core/Quaternion',
         'DataSources/ConstantProperty',
         'DataSources/NodeTransformationProperty',
         'DataSources/PropertyBag',
+        'Scene/ColorBlendMode',
+        'Scene/HeightReference',
         'Scene/ShadowMode'
     ], function(
         ModelGraphics,
         Cartesian3,
+        Color,
         DistanceDisplayCondition,
         JulianDate,
         Quaternion,
         ConstantProperty,
         NodeTransformationProperty,
         PropertyBag,
+        ColorBlendMode,
+        HeightReference,
         ShadowMode) {
     'use strict';
 
@@ -31,7 +37,11 @@ defineSuite([
             incrementallyLoadTextures : false,
             runAnimations : false,
             shadows : ShadowMode.DISABLED,
+            heightReference : HeightReference.CLAMP_TO_GROUND,
             distanceDisplayCondition : new DistanceDisplayCondition(),
+            color : new Color(0.0, 1.0, 0.0, 0.2),
+            colorBlendMode : ColorBlendMode.HIGHLIGHT,
+            colorBlendAmount : 0.5,
             nodeTransformations : {
                 node1 : {
                     translation : Cartesian3.UNIT_Y,
@@ -49,6 +59,11 @@ defineSuite([
         expect(model.maximumScale).toBeInstanceOf(ConstantProperty);
         expect(model.incrementallyLoadTextures).toBeInstanceOf(ConstantProperty);
         expect(model.shadows).toBeInstanceOf(ConstantProperty);
+        expect(model.heightReference).toBeInstanceOf(ConstantProperty);
+        expect(model.distanceDisplayCondition).toBeInstanceOf(ConstantProperty);
+        expect(model.color).toBeInstanceOf(ConstantProperty);
+        expect(model.colorBlendMode).toBeInstanceOf(ConstantProperty);
+        expect(model.colorBlendAmount).toBeInstanceOf(ConstantProperty);
         expect(model.runAnimations).toBeInstanceOf(ConstantProperty);
 
         expect(model.nodeTransformations).toBeInstanceOf(PropertyBag);
@@ -60,7 +75,11 @@ defineSuite([
         expect(model.maximumScale.getValue()).toEqual(options.maximumScale);
         expect(model.incrementallyLoadTextures.getValue()).toEqual(options.incrementallyLoadTextures);
         expect(model.shadows.getValue()).toEqual(options.shadows);
+        expect(model.heightReference.getValue()).toEqual(options.heightReference);
         expect(model.distanceDisplayCondition.getValue()).toEqual(options.distanceDisplayCondition);
+        expect(model.color.getValue()).toEqual(options.color);
+        expect(model.colorBlendMode.getValue()).toEqual(options.colorBlendMode);
+        expect(model.colorBlendAmount.getValue()).toEqual(options.colorBlendAmount);
         expect(model.runAnimations.getValue()).toEqual(options.runAnimations);
 
         var actualNodeTransformations = model.nodeTransformations.getValue(new JulianDate());
@@ -81,7 +100,11 @@ defineSuite([
         source.maximumScale = new ConstantProperty(200.0);
         source.incrementallyLoadTextures = new ConstantProperty(true);
         source.shadows = new ConstantProperty(ShadowMode.ENABLED);
+        source.heightReference = new ConstantProperty(HeightReference.CLAMP_TO_GROUND);
         source.distanceDisplayCondition = new ConstantProperty(new DistanceDisplayCondition());
+        source.color = new ConstantProperty(new Color(0.0, 1.0, 0.0, 0.2));
+        source.colorBlendMode = new ConstantProperty(ColorBlendMode.HIGHLIGHT);
+        source.colorBlendAmount = new ConstantProperty(0.5);
         source.runAnimations = new ConstantProperty(true);
         source.nodeTransformations = {
             node1 : new NodeTransformationProperty({
@@ -104,7 +127,11 @@ defineSuite([
         expect(target.maximumScale).toBe(source.maximumScale);
         expect(target.incrementallyLoadTextures).toBe(source.incrementallyLoadTextures);
         expect(target.shadows).toBe(source.shadows);
+        expect(target.heightReference).toBe(source.heightReference);
         expect(target.distanceDisplayCondition).toBe(source.distanceDisplayCondition);
+        expect(target.color).toBe(source.color);
+        expect(target.colorBlendMode).toBe(source.colorBlendMode);
+        expect(target.colorBlendAmount).toBe(source.colorBlendAmount);
         expect(target.runAnimations).toBe(source.runAnimations);
         expect(target.nodeTransformations).toEqual(source.nodeTransformations);
     });
@@ -118,7 +145,11 @@ defineSuite([
         source.maximumScale = new ConstantProperty(200.0);
         source.incrementallyLoadTextures = new ConstantProperty(true);
         source.shadows = new ConstantProperty(ShadowMode.ENABLED);
+        source.heightReference = new ConstantProperty(HeightReference.CLAMP_TO_GROUND);
         source.distanceDisplayCondition = new ConstantProperty(new DistanceDisplayCondition());
+        source.color = new ConstantProperty(new Color(0.0, 1.0, 0.0, 0.2));
+        source.colorBlendMode = new ConstantProperty(ColorBlendMode.HIGHLIGHT);
+        source.colorBlendAmount = new ConstantProperty(0.5);
         source.runAnimations = new ConstantProperty(true);
         source.nodeTransformations = {
             transform : new NodeTransformationProperty()
@@ -131,7 +162,11 @@ defineSuite([
         var maximumScale = new ConstantProperty(200.0);
         var incrementallyLoadTextures = new ConstantProperty(true);
         var shadows = new ConstantProperty(ShadowMode.ENABLED);
+        var heightReference = new ConstantProperty(HeightReference.CLAMP_TO_GROUND);
         var distanceDisplayCondition = new ConstantProperty(new DistanceDisplayCondition());
+        var color = new ConstantProperty(new Color(0.0, 1.0, 0.0, 0.2));
+        var colorBlendMode = new ConstantProperty(ColorBlendMode.HIGHLIGHT);
+        var colorBlendAmount = new ConstantProperty(0.5);
         var runAnimations = new ConstantProperty(true);
         var nodeTransformations = new PropertyBag({
             transform : new NodeTransformationProperty()
@@ -145,7 +180,11 @@ defineSuite([
         target.maximumScale = maximumScale;
         target.incrementallyLoadTextures = incrementallyLoadTextures;
         target.shadows = shadows;
+        target.heightReference = heightReference;
         target.distanceDisplayCondition = distanceDisplayCondition;
+        target.color = color;
+        target.colorBlendMode = colorBlendMode;
+        target.colorBlendAmount = colorBlendAmount;
         target.runAnimations = runAnimations;
         target.nodeTransformations = nodeTransformations;
 
@@ -158,7 +197,11 @@ defineSuite([
         expect(target.maximumScale).toBe(maximumScale);
         expect(target.incrementallyLoadTextures).toBe(incrementallyLoadTextures);
         expect(target.shadows).toBe(shadows);
+        expect(target.heightReference).toBe(heightReference);
         expect(target.distanceDisplayCondition).toBe(distanceDisplayCondition);
+        expect(target.color).toBe(color);
+        expect(target.colorBlendMode).toBe(colorBlendMode);
+        expect(target.colorBlendAmount).toBe(colorBlendAmount);
         expect(target.runAnimations).toBe(runAnimations);
         expect(target.nodeTransformations).toBe(nodeTransformations);
     });
@@ -172,7 +215,11 @@ defineSuite([
         source.maximumScale = new ConstantProperty(200.0);
         source.incrementallyLoadTextures = new ConstantProperty(true);
         source.shadows = new ConstantProperty(ShadowMode.ENABLED);
+        source.heightReference = new ConstantProperty(HeightReference.CLAMP_TO_GROUND);
         source.distanceDisplayCondition = new ConstantProperty(new DistanceDisplayCondition());
+        source.color = new ConstantProperty(new Color(0.0, 1.0, 0.0, 0.2));
+        source.colorBlendMode = new ConstantProperty(ColorBlendMode.HIGHLIGHT);
+        source.colorBlendAmount = new ConstantProperty(0.5);
         source.runAnimations = new ConstantProperty(true);
         source.nodeTransformations = {
             node1 : new NodeTransformationProperty(),
@@ -187,7 +234,11 @@ defineSuite([
         expect(result.maximumScale).toBe(source.maximumScale);
         expect(result.incrementallyLoadTextures).toBe(source.incrementallyLoadTextures);
         expect(result.shadows).toBe(source.shadows);
+        expect(result.heightReference).toBe(source.heightReference);
         expect(result.distanceDisplayCondition).toBe(source.distanceDisplayCondition);
+        expect(result.color).toBe(source.color);
+        expect(result.colorBlendMode).toBe(source.colorBlendMode);
+        expect(result.colorBlendAmount).toBe(source.colorBlendAmount);
         expect(result.runAnimations).toBe(source.runAnimations);
         expect(result.nodeTransformations).toEqual(source.nodeTransformations);
     });
diff --git a/Specs/Scene/ModelSpec.js b/Specs/Scene/ModelSpec.js
index a7ad11f11fa2..3e4d240a34e1 100644
--- a/Specs/Scene/ModelSpec.js
+++ b/Specs/Scene/ModelSpec.js
@@ -6,6 +6,7 @@ defineSuite([
         'Core/Cartesian4',
         'Core/CesiumTerrainProvider',
         'Core/clone',
+        'Core/Color',
         'Core/combine',
         'Core/defined',
         'Core/defineProperties',
@@ -25,6 +26,7 @@ defineSuite([
         'Renderer/RenderState',
         'Renderer/ShaderSource',
         'Renderer/WebGLConstants',
+        'Scene/ColorBlendMode',
         'Scene/HeightReference',
         'Scene/ModelAnimationLoop',
         'Specs/createScene',
@@ -37,6 +39,7 @@ defineSuite([
         Cartesian4,
         CesiumTerrainProvider,
         clone,
+        Color,
         combine,
         defined,
         defineProperties,
@@ -56,6 +59,7 @@ defineSuite([
         RenderState,
         ShaderSource,
         WebGLConstants,
+        ColorBlendMode,
         HeightReference,
         ModelAnimationLoop,
         createScene,
@@ -1867,6 +1871,66 @@ defineSuite([
         });
     });
 
+    it('renders with a color', function() {
+        return loadModel(boxUrl).then(function(model) {
+            model.show = true;
+            model.zoomTo();
+
+            // Model is originally red
+            var sourceColor = scene.renderForSpecs();
+            expect(sourceColor[0]).toBeGreaterThan(0);
+            expect(sourceColor[1]).toEqual(0);
+
+            // Check MIX
+            model.colorBlendMode = ColorBlendMode.MIX;
+            model.color = Color.LIME;
+
+            model.colorBlendAmount = 0.0;
+            var color = scene.renderForSpecs();
+            expect(color).toEqual(sourceColor);
+
+            model.colorBlendAmount = 0.5;
+            color = scene.renderForSpecs();
+            expect(color[0]).toBeGreaterThan(0);
+            expect(color[1]).toBeGreaterThan(0);
+
+            model.colorBlendAmount = 1.0;
+            color = scene.renderForSpecs();
+            expect(color[0]).toEqual(0);
+            expect(color[1]).toEqual(255);
+
+            // Check REPLACE
+            model.colorBlendMode = ColorBlendMode.REPLACE;
+            model.colorBlendAmount = 0.5; // Should have no effect
+            color = scene.renderForSpecs();
+            expect(color[0]).toEqual(0);
+            expect(color[1]).toEqual(255);
+
+            // Check HIGHLIGHT
+            model.colorBlendMode = ColorBlendMode.HIGHLIGHT;
+            model.color = Color.DARKGRAY;
+            color = scene.renderForSpecs();
+            expect(sourceColor[0]).toBeGreaterThan(0);
+            expect(sourceColor[0]).toBeLessThan(255);
+            expect(sourceColor[1]).toEqual(0);
+            expect(sourceColor[2]).toEqual(0);
+
+            // Check alpha
+            model.colorBlendMode = ColorBlendMode.REPLACE;
+            model.color = Color.fromAlpha(Color.LIME, 0.5);
+            color = scene.renderForSpecs();
+            expect(color[0]).toEqual(0);
+            expect(color[1]).toBeLessThan(255);
+            expect(color[1]).toBeGreaterThan(0);
+
+            // No commands are issued when the alpha is 0.0
+            model.color = Color.fromAlpha(Color.LIME, 0.0);
+            scene.renderForSpecs();
+            var commands = scene.frameState.commandList;
+            expect(commands.length).toBe(0);
+        });
+    });
+
     describe('height referenced model', function() {
         function createMockGlobe() {
             var globe = {
