diff --git a/Apps/Sandcastle/gallery/3D Models Coloring.html b/Apps/Sandcastle/gallery/3D Models Coloring.html
index e67783ba0e80..979c9a6f955a 100644
--- a/Apps/Sandcastle/gallery/3D Models Coloring.html	
+++ b/Apps/Sandcastle/gallery/3D Models Coloring.html	
@@ -29,11 +29,15 @@
         padding-top: 2px;
         padding-bottom: 2px;
     }
+    #toolbar .header {
+        font-weight: bold;
+    }
 </style>
 <div id="cesiumContainer" class="fullSize"></div>
 <div id="loadingOverlay"><h1>Loading...</h1></div>
 <div id="toolbar">
     <table><tbody>
+    <tr><td class="header">Model Color</td></tr>
     <tr>
         <td>Mode</td>
         <td><select data-bind="options: colorBlendModes, value: colorBlendMode"></select></td>
@@ -56,6 +60,25 @@
             <input type="text" size="5" data-bind="value: colorBlendAmount, enable: colorBlendAmountEnabled">
         </td>
     </tr>
+    <tr><td class="header">Model Silhouette</td></tr>
+    <tr>
+        <td>Color</td>
+        <td><select data-bind="options: silhouetteColors, value: silhouetteColor"></select></td>
+    </tr>
+    <tr>
+        <td>Alpha</td>
+        <td>
+            <input type="range" min="0.0" max="1.0" step="0.01" data-bind="value: silhouetteAlpha, valueUpdate: 'input'">
+            <input type="text" size="5" data-bind="value: silhouetteAlpha">
+        </td>
+    </tr>
+    <tr>
+        <td>Size</td>
+        <td>
+            <input type="range" min="0.0" max="10.0" step="0.01" data-bind="value: silhouetteSize, valueUpdate: 'input'">
+            <input type="text" size="5" data-bind="value: silhouetteSize">
+        </td>
+    </tr>
     </tbody></table>
 </div>
 <script id="cesium_sandcastle_script">
@@ -74,8 +97,9 @@
     return Cesium.ColorBlendMode[colorBlendMode.toUpperCase()];
 }
 
-function getColor(color) {
-    return Cesium.Color[color.toUpperCase()];
+function getColor(colorName, alpha) {
+    var color = Cesium.Color[colorName.toUpperCase()];
+    return Cesium.Color.fromAlpha(color, parseFloat(alpha));
 }
 
 // The viewModel tracks the state of our mini application.
@@ -86,7 +110,11 @@
     colorBlendMode : 'Highlight',
     colorBlendModes : ['Highlight', 'Replace', 'Mix'],
     colorBlendAmount : 0.5,
-    colorBlendAmountEnabled : false
+    colorBlendAmountEnabled : false,
+    silhouetteColor : 'Red',
+    silhouetteColors : ['Red', 'Green', 'Blue', 'Yellow', 'Gray'],
+    silhouetteAlpha : 1.0,
+    silhouetteSize : 2.0
 };
 
 // Convert the viewModel members into knockout observables.
@@ -98,13 +126,13 @@
 
 Cesium.knockout.getObservable(viewModel, 'color').subscribe(
     function(newValue) {
-        entity.model.color = Cesium.Color.fromAlpha(getColor(newValue), viewModel.alpha);
+        entity.model.color = getColor(newValue, viewModel.alpha);
     }
 );
 
 Cesium.knockout.getObservable(viewModel, 'alpha').subscribe(
     function(newValue) {
-        entity.model.color = Cesium.Color.fromAlpha(getColor(viewModel.color), newValue);
+        entity.model.color = getColor(viewModel.color, newValue);
     }
 );
 
@@ -118,7 +146,25 @@
 
 Cesium.knockout.getObservable(viewModel, 'colorBlendAmount').subscribe(
     function(newValue) {
-        entity.model.colorBlendAmount = newValue;
+        entity.model.colorBlendAmount = parseFloat(newValue);
+    }
+);
+
+Cesium.knockout.getObservable(viewModel, 'silhouetteColor').subscribe(
+    function(newValue) {
+        entity.model.silhouetteColor = getColor(newValue, viewModel.silhouetteAlpha);
+    }
+);
+
+Cesium.knockout.getObservable(viewModel, 'silhouetteAlpha').subscribe(
+    function(newValue) {
+        entity.model.silhouetteColor = getColor(viewModel.silhouetteColor, newValue);
+    }
+);
+
+Cesium.knockout.getObservable(viewModel, 'silhouetteSize').subscribe(
+    function(newValue) {
+        entity.model.silhouetteSize = parseFloat(newValue);
     }
 );
 
@@ -140,9 +186,11 @@
             uri : url,
             minimumPixelSize : 128,
             maximumScale : 20000,
-            color : Cesium.Color.fromAlpha(getColor(viewModel.color), viewModel.alpha),
+            color : getColor(viewModel.color, viewModel.alpha),
             colorBlendMode : getColorBlendMode(viewModel.colorBlendMode),
-            colorBlendAmount : viewModel.colorBlendAmount
+            colorBlendAmount : parseFloat(viewModel.colorBlendAmount),
+            silhouetteColor : getColor(viewModel.silhouetteColor, viewModel.silhouetteAlpha),
+            silhouetteSize : parseFloat(viewModel.silhouetteSize)
         }
     });
     viewer.trackedEntity = entity;
diff --git a/CHANGES.md b/CHANGES.md
index 1d754f687786..d8934a4cfa3e 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -4,6 +4,7 @@ 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)
+* Added the ability to render a `Model` with a silhouette. Added `silhouetteColor` and `silhouetteSize` properties to `Model`, `ModelGraphics`, and CZML. [#4314](https://github.com/AnalyticalGraphicsInc/cesium/pull/4314)
 * Added new `Label` properties `showBackground`, `backgroundColor`, and `backgroundPadding` to the primitive, Entity, and CZML layers.
 * Added new enum `VerticalOrigin.BASELINE`.  Previously, `VerticalOrigin.BOTTOM` would sometimes align to the baseline depending on the contents of a label.
 * Fixed tooltips for gallery thumbnails in Sandcastle [#4702](https://github.com/AnalyticalGraphicsInc/cesium/pull/4702)
diff --git a/Source/DataSources/CzmlDataSource.js b/Source/DataSources/CzmlDataSource.js
index aa5ebaa85c84..ebbbf8454303 100644
--- a/Source/DataSources/CzmlDataSource.js
+++ b/Source/DataSources/CzmlDataSource.js
@@ -1420,6 +1420,8 @@ 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, 'silhouetteColor', modelData.silhouetteColor, interval, sourceUri, entityCollection);
+        processPacketData(Number, model, 'silhouetteSize', modelData.silhouetteSize, 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);
diff --git a/Source/DataSources/ModelGraphics.js b/Source/DataSources/ModelGraphics.js
index d98013280b19..766d60064855 100644
--- a/Source/DataSources/ModelGraphics.js
+++ b/Source/DataSources/ModelGraphics.js
@@ -50,6 +50,8 @@ 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.silhouetteColor=Color.RED] A Property specifying the {@link Color} of the silhouette.
+     * @param {Property} [options.silhouetteSize=0.0] A numeric Property specifying the size of the silhouette in pixels.
      * @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.
@@ -80,6 +82,10 @@ define([
         this._heightReferenceSubscription = undefined;
         this._distanceDisplayCondition = undefined;
         this._distanceDisplayConditionSubscription = undefined;
+        this._silhouetteColor = undefined;
+        this._silhouetteColorSubscription = undefined;
+        this._silhouetteSize = undefined;
+        this._silhouetteSizeSubscription = undefined;
         this._color = undefined;
         this._colorSubscription = undefined;
         this._colorBlendMode = undefined;
@@ -197,6 +203,22 @@ define([
          */
         distanceDisplayCondition : createPropertyDescriptor('distanceDisplayCondition'),
 
+        /**
+         * Gets or sets the Property specifying the {@link Color} of the silhouette.
+         * @memberof ModelGraphics.prototype
+         * @type {Property}
+         * @default Color.RED
+         */
+        silhouetteColor: createPropertyDescriptor('silhouetteColor'),
+
+        /**
+         * Gets or sets the numeric Property specifying the size of the silhouette in pixels.
+         * @memberof ModelGraphics.prototype
+         * @type {Property}
+         * @default 0.0
+         */
+        silhouetteSize : createPropertyDescriptor('silhouetteSize'),
+
         /**
          * Gets or sets the Property specifying the {@link Color} that blends with the model's rendered color.
          * @memberof ModelGraphics.prototype
@@ -245,6 +267,8 @@ define([
         result.nodeTransformations = this.nodeTransformations;
         result.heightReference = this._heightReference;
         result.distanceDisplayCondition = this.distanceDisplayCondition;
+        result.silhouetteColor = this.silhouetteColor;
+        result.silhouetteSize = this.silhouetteSize;
         result.color = this.color;
         result.colorBlendMode = this.colorBlendMode;
         result.colorBlendAmount = this.colorBlendAmount;
@@ -275,6 +299,8 @@ define([
         this.runAnimations = defaultValue(this.runAnimations, source.runAnimations);
         this.heightReference = defaultValue(this.heightReference, source.heightReference);
         this.distanceDisplayCondition = defaultValue(this.distanceDisplayCondition, source.distanceDisplayCondition);
+        this.silhouetteColor = defaultValue(this.silhouetteColor, source.silhouetteColor);
+        this.silhouetteSize = defaultValue(this.silhouetteSize, source.silhouetteSize);
         this.color = defaultValue(this.color, source.color);
         this.colorBlendMode = defaultValue(this.colorBlendMode, source.colorBlendMode);
         this.colorBlendAmount = defaultValue(this.colorBlendAmount, source.colorBlendAmount);
diff --git a/Source/DataSources/ModelVisualizer.js b/Source/DataSources/ModelVisualizer.js
index 0cfd2fc8c248..bd00c0ae9829 100644
--- a/Source/DataSources/ModelVisualizer.js
+++ b/Source/DataSources/ModelVisualizer.js
@@ -36,6 +36,8 @@ define([
     var defaultIncrementallyLoadTextures = true;
     var defaultShadows = ShadowMode.ENABLED;
     var defaultHeightReference = HeightReference.NONE;
+    var defaultSilhouetteColor = Color.RED;
+    var defaultSilhouetteSize = 0.0;
     var defaultColor = Color.WHITE;
     var defaultColorBlendMode = ColorBlendMode.HIGHLIGHT;
     var defaultColorBlendAmount = 0.5;
@@ -147,6 +149,8 @@ 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.silhouetteColor = Property.getValueOrDefault(modelGraphics.silhouetteColor, time, defaultSilhouetteColor);
+            model.silhouetteSize = Property.getValueOrDefault(modelGraphics.silhouetteSize, time, defaultSilhouetteSize);
             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);
diff --git a/Source/Renderer/Context.js b/Source/Renderer/Context.js
index ca41b53f505f..2d889140979f 100644
--- a/Source/Renderer/Context.js
+++ b/Source/Renderer/Context.js
@@ -193,6 +193,7 @@ define([
 
         // Override select WebGL defaults
         webglOptions.alpha = defaultValue(webglOptions.alpha, false); // WebGL default is true
+        webglOptions.stencil = defaultValue(webglOptions.stencil, true); // WebGL default is false
 
         var defaultToWebgl2 = false;
         var webgl2Supported = (typeof WebGL2RenderingContext !== 'undefined');
@@ -507,6 +508,18 @@ define([
             }
         },
 
+        /**
+         * <code>true</code> if the WebGL context supports stencil buffers.
+         * Stencil buffers are not supported by all systems.
+         * @memberof Context.prototype
+         * @type {Boolean}
+         */
+        stencilBuffer : {
+            get : function() {
+                return this._stencilBits >= 8;
+            }
+        },
+
         /**
          * <code>true</code> if the WebGL context supports antialiasing.  By default
          * antialiasing is requested, but it is not supported by all systems.
diff --git a/Source/Renderer/RenderState.js b/Source/Renderer/RenderState.js
index 92aea5c35a45..9966cc98daff 100644
--- a/Source/Renderer/RenderState.js
+++ b/Source/Renderer/RenderState.js
@@ -589,7 +589,7 @@ define([
             // Section 6.8 of the WebGL spec requires the reference and masks to be the same for
             // front- and back-face tests.  This call prevents invalid operation errors when calling
             // stencilFuncSeparate on Firefox.  Perhaps they should delay validation to avoid requiring this.
-            gl.stencilFunc(stencilTest.frontFunction, stencilTest.reference, stencilTest.mask);
+            gl.stencilFunc(frontFunction, reference, mask);
             gl.stencilFuncSeparate(gl.BACK, backFunction, reference, mask);
             gl.stencilFuncSeparate(gl.FRONT, frontFunction, reference, mask);
 
diff --git a/Source/Scene/ColorBlendMode.js b/Source/Scene/ColorBlendMode.js
index 224acbb5284e..c020c1dd1248 100644
--- a/Source/Scene/ColorBlendMode.js
+++ b/Source/Scene/ColorBlendMode.js
@@ -24,6 +24,9 @@ define([
         MIX : 2
     };
 
+    /**
+     * @private
+     */
     ColorBlendMode.getColorBlend = function(colorBlendMode, colorBlendAmount) {
         if (colorBlendMode === ColorBlendMode.HIGHLIGHT) {
             return 0.0;
diff --git a/Source/Scene/GroundPrimitive.js b/Source/Scene/GroundPrimitive.js
index c35c4b1828c5..cfcea5ec94e3 100644
--- a/Source/Scene/GroundPrimitive.js
+++ b/Source/Scene/GroundPrimitive.js
@@ -396,7 +396,7 @@ define([
      * @returns {Boolean} <code>true</code> if GroundPrimitives are supported; otherwise, returns <code>false</code>
      */
     GroundPrimitive.isSupported = function(scene) {
-        return scene.context.fragmentDepth;
+        return scene.context.fragmentDepth && scene.context.stencilBuffer;
     };
 
     GroundPrimitive._defaultMaxTerrainHeight = 9000.0;
diff --git a/Source/Scene/Model.js b/Source/Scene/Model.js
index 633cdd7e8c8e..e620037690f2 100644
--- a/Source/Scene/Model.js
+++ b/Source/Scene/Model.js
@@ -50,6 +50,7 @@ define([
         '../ThirdParty/when',
         './BlendingState',
         './ColorBlendMode',
+        './getAttributeOrUniformBySemantic',
         './getBinaryAccessor',
         './HeightReference',
         './ModelAnimationCache',
@@ -112,6 +113,7 @@ define([
         when,
         BlendingState,
         ColorBlendMode,
+        getAttributeOrUniformBySemantic,
         getBinaryAccessor,
         HeightReference,
         ModelAnimationCache,
@@ -324,10 +326,12 @@ define([
      * @param {Boolean} [options.debugWireframe=false] For debugging only. Draws the model in wireframe.
      * @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 {DistanceDisplayCondition} [options.distanceDisplayCondition] 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.
+     * @param {Color} [options.silhouetteColor=Color.RED] The silhouette color. If more than 256 models have silhouettes enabled, there is a small chance that overlapping models will have minor artifacts.
+     * @param {Number} [options.silhouetteSize=0.0] The size of the silhouette in pixels.
      *
      * @exception {DeveloperError} bgltf is not a valid Binary glTF file.
      * @exception {DeveloperError} Only glTF Binary version 1 is supported.
@@ -405,6 +409,26 @@ define([
          */
         this.show = defaultValue(options.show, true);
 
+        /**
+         * The silhouette color.
+         *
+         * @type {Color}
+         *
+         * @default Color.RED
+         */
+        this.silhouetteColor = defaultValue(options.silhouetteColor, Color.RED);
+        this._silhouetteColor = new Color();
+        this._normalAttributeName = undefined;
+
+        /**
+         * The size of the silhouette in pixels.
+         *
+         * @type {Number}
+         *
+         * @default 0.0
+         */
+        this.silhouetteSize = defaultValue(options.silhouetteSize, 0.0);
+
         /**
          * The 4x4 transformation matrix that transforms the model from model to world coordinates.
          * When this is the identity matrix, the model is drawn in world coordinates, i.e., Earth's WGS84 coordinates.
@@ -531,6 +555,7 @@ define([
          * @default Color.WHITE
          */
         this.color = defaultValue(options.color, Color.WHITE);
+        this._color = new Color();
 
         /**
          * Defines how the color blends with the model.
@@ -631,6 +656,7 @@ define([
             vertexArrays : {},
             programs : {},
             pickPrograms : {},
+            silhouettePrograms: {},
             textures : {},
 
             samplers : {},
@@ -925,6 +951,20 @@ define([
 
     var sizeOfUint32 = Uint32Array.BYTES_PER_ELEMENT;
 
+    function silhouetteSupported(context) {
+        return context.stencilBuffer;
+    }
+
+    /**
+     * Determines if silhouettes are supported.
+     *
+     * @param {Scene} scene The scene.
+     * @returns {Boolean} <code>true</code> if silhouettes are supported; otherwise, returns <code>false</code>
+     */
+    Model.silhouetteSupported = function(scene) {
+        return silhouetteSupported(scene.context);
+    };
+
     /**
      * This function differs from the normal subarray function
      * because it takes offset and length, rather than begin and end.
@@ -2928,6 +2968,18 @@ define([
         };
     }
 
+    function createSilhouetteColorFunction(model) {
+        return function() {
+            return model.silhouetteColor;
+        };
+    }
+
+    function createSilhouetteSizeFunction(model) {
+        return function() {
+            return model.silhouetteSize;
+        };
+    }
+
     function createColorFunction(model) {
         return function() {
             return model.color;
@@ -3037,7 +3089,7 @@ define([
 
                 var castShadows = ShadowMode.castShadows(model._shadows);
                 var receiveShadows = ShadowMode.receiveShadows(model._shadows);
-                
+
                 var command = new DrawCommand({
                     boundingVolume : new BoundingSphere(), // updated in update()
                     cull : model.cull,
@@ -3099,13 +3151,13 @@ define([
                 var pickCommand2D;
                 if (!scene3DOnly) {
                     command2D = DrawCommand.shallowClone(command);
-                    command2D.boundingVolume = new BoundingSphere();
-                    command2D.modelMatrix = new Matrix4();
+                    command2D.boundingVolume = new BoundingSphere(); // updated in update()
+                    command2D.modelMatrix = new Matrix4();           // updated in update()
 
                     if (allowPicking) {
                         pickCommand2D = DrawCommand.shallowClone(pickCommand);
-                        pickCommand2D.boundingVolume = new BoundingSphere();
-                        pickCommand2D.modelMatrix = new Matrix4();
+                        pickCommand2D.boundingVolume = new BoundingSphere(); // updated in update()
+                        pickCommand2D.modelMatrix = new Matrix4();           // updated in update()
                     }
                 }
 
@@ -3116,7 +3168,12 @@ define([
                     pickCommand : pickCommand,
                     command2D : command2D,
                     pickCommand2D : pickCommand2D,
-                    // Generate on demand when color alpha is less than 1.0
+                    // Generated on demand when silhouette size is greater than 0.0 and silhouette alpha is greater than 0.0
+                    silhouetteModelCommand : undefined,
+                    silhouetteModelCommand2D : undefined,
+                    silhouetteColorCommand : undefined,
+                    silhouetteColorCommand2D : undefined,
+                    // Generated on demand when color alpha is less than 1.0
                     translucentCommand : undefined,
                     translucentCommand2D : undefined
                 };
@@ -3215,6 +3272,7 @@ define([
             resources.vertexArrays = cachedResources.vertexArrays;
             resources.programs = cachedResources.programs;
             resources.pickPrograms = cachedResources.pickPrograms;
+            resources.silhouettePrograms = cachedResources.silhouettePrograms;
             resources.textures = cachedResources.textures;
             resources.samplers = cachedResources.samplers;
             resources.renderStates = cachedResources.renderStates;
@@ -3513,12 +3571,12 @@ define([
     }
 
     function updateColor(model, frameState) {
+        // Generate translucent commands when the blend color has an alpha in the range (0.0, 1.0) exclusive
         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];
@@ -3533,6 +3591,227 @@ define([
         }
     }
 
+    function getProgramId(model, program) {
+        var programs = model._rendererResources.programs;
+        for (var id in programs) {
+            if (programs.hasOwnProperty(id)) {
+                if (programs[id] === program) {
+                    return id;
+                }
+            }
+        }
+    }
+
+    function createSilhouetteProgram(model, program, frameState) {
+        var vs = program.vertexShaderSource.sources[0];
+        var attributeLocations = program._attributeLocations;
+        var normalAttributeName = model._normalAttributeName;
+
+        // Modified from http://forum.unity3d.com/threads/toon-outline-but-with-diffuse-surface.24668/
+        vs = ShaderSource.replaceMain(vs, 'gltf_silhouette_main');
+        vs +=
+            'uniform float gltf_silhouetteSize; \n' +
+            'void main() \n' +
+            '{ \n' +
+            '    gltf_silhouette_main(); \n' +
+            '    vec3 n = normalize(czm_normal3D * ' + normalAttributeName + '); \n' +
+            '    n.x *= czm_projection[0][0]; \n' +
+            '    n.y *= czm_projection[1][1]; \n' +
+            '    vec4 clip = gl_Position; \n' +
+            '    clip.xy += n.xy * clip.w * gltf_silhouetteSize / czm_viewport.z; \n' +
+            '    gl_Position = clip; \n' +
+            '}';
+
+        var fs =
+            'uniform vec4 gltf_silhouetteColor; \n' +
+            'void main() \n' +
+            '{ \n' +
+            '    gl_FragColor = gltf_silhouetteColor; \n' +
+            '}';
+
+        return ShaderProgram.fromCache({
+            context : frameState.context,
+            vertexShaderSource : vs,
+            fragmentShaderSource : fs,
+            attributeLocations : attributeLocations
+        });
+    }
+
+    function hasSilhouette(model, frameState) {
+        return silhouetteSupported(frameState.context) && (model.silhouetteSize > 0.0) && (model.silhouetteColor.alpha > 0.0) && defined(model._normalAttributeName);
+    }
+
+    function hasTranslucentCommands(model) {
+        var nodeCommands = model._nodeCommands;
+        var length = nodeCommands.length;
+        for (var i = 0; i < length; ++i) {
+            var nodeCommand = nodeCommands[i];
+            var command = nodeCommand.command;
+            if (command.pass === Pass.TRANSLUCENT) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    function isTranslucent(model) {
+        return (model.color.alpha > 0.0) && (model.color.alpha < 1.0);
+    }
+
+    function isInvisible(model) {
+        return (model.color.alpha === 0.0);
+    }
+
+    function alphaDirty(currAlpha, prevAlpha) {
+        // Returns whether the alpha state has changed between invisible, translucent, or opaque
+        return (Math.floor(currAlpha) !== Math.floor(prevAlpha)) || (Math.ceil(currAlpha) !== Math.ceil(prevAlpha));
+    }
+
+    var silhouettesLength = 0;
+
+    function createSilhouetteCommands(model, frameState) {
+        // Wrap around after exceeding the 8-bit stencil limit.
+        // The reference is unique to each model until this point.
+        var stencilReference = (++silhouettesLength) % 255;
+
+        // If the model is translucent the silhouette needs to be in the translucent pass.
+        // Otherwise the silhouette would be rendered before the model.
+        var silhouetteTranslucent = hasTranslucentCommands(model) || isTranslucent(model) || (model.silhouetteColor.alpha < 1.0);
+        var silhouettePrograms = model._rendererResources.silhouettePrograms;
+        var scene3DOnly = frameState.scene3DOnly;
+        var nodeCommands = model._nodeCommands;
+        var length = nodeCommands.length;
+        for (var i = 0; i < length; ++i) {
+            var nodeCommand = nodeCommands[i];
+            var command = nodeCommand.command;
+
+            // Create model command
+            var modelCommand = isTranslucent(model) ? nodeCommand.translucentCommand : command;
+            var silhouetteModelCommand = DrawCommand.shallowClone(modelCommand);
+            var renderState = clone(modelCommand.renderState);
+
+            // Write the reference value into the stencil buffer.
+            renderState.stencilTest = {
+                enabled : true,
+                frontFunction : WebGLConstants.ALWAYS,
+                backFunction : WebGLConstants.ALWAYS,
+                reference : stencilReference,
+                mask : ~0,
+                frontOperation : {
+                    fail : WebGLConstants.KEEP,
+                    zFail : WebGLConstants.KEEP,
+                    zPass : WebGLConstants.REPLACE
+                },
+                backOperation : {
+                    fail : WebGLConstants.KEEP,
+                    zFail : WebGLConstants.KEEP,
+                    zPass : WebGLConstants.REPLACE
+                }
+            };
+
+            if (isInvisible(model)) {
+                // When the model is invisible disable color and depth writes but still write into the stencil buffer
+                renderState.colorMask = {
+                    red : false,
+                    green : false,
+                    blue : false,
+                    alpha : false
+                };
+                renderState.depthMask = false;
+            }
+            renderState = RenderState.fromCache(renderState);
+            silhouetteModelCommand.renderState = renderState;
+            nodeCommand.silhouetteModelCommand = silhouetteModelCommand;
+
+            // Create color command
+            var silhouetteColorCommand = DrawCommand.shallowClone(command);
+            renderState = clone(command.renderState, true);
+            renderState.depthTest.enabled = true;
+            renderState.cull.enabled = false;
+            if (silhouetteTranslucent) {
+                silhouetteColorCommand.pass = Pass.TRANSLUCENT;
+                renderState.depthMask = false;
+                renderState.blending = BlendingState.ALPHA_BLEND;
+            }
+
+            // Only render silhouette if the value in the stencil buffer equals the reference
+            renderState.stencilTest = {
+                enabled : true,
+                frontFunction : WebGLConstants.NOTEQUAL,
+                backFunction : WebGLConstants.NOTEQUAL,
+                reference : stencilReference,
+                mask : ~0,
+                frontOperation : {
+                    fail : WebGLConstants.KEEP,
+                    zFail : WebGLConstants.KEEP,
+                    zPass : WebGLConstants.KEEP
+                },
+                backOperation : {
+                    fail : WebGLConstants.KEEP,
+                    zFail : WebGLConstants.KEEP,
+                    zPass : WebGLConstants.KEEP
+                }
+            };
+            renderState = RenderState.fromCache(renderState);
+
+            // If the silhouette program has already been cached use it
+            var program = command.shaderProgram;
+            var id = getProgramId(model, program);
+            var silhouetteProgram = silhouettePrograms[id];
+            if (!defined(silhouetteProgram)) {
+                silhouetteProgram = createSilhouetteProgram(model, program, frameState);
+                silhouettePrograms[id] = silhouetteProgram;
+            }
+
+            var silhouetteUniformMap = combine(command.uniformMap, {
+                gltf_silhouetteColor : createSilhouetteColorFunction(model),
+                gltf_silhouetteSize : createSilhouetteSizeFunction(model)
+            });
+
+            silhouetteColorCommand.renderState = renderState;
+            silhouetteColorCommand.shaderProgram = silhouetteProgram;
+            silhouetteColorCommand.uniformMap = silhouetteUniformMap;
+            silhouetteColorCommand.castShadows = false;
+            silhouetteColorCommand.receiveShadows = false;
+            nodeCommand.silhouetteColorCommand = silhouetteColorCommand;
+
+            if (!scene3DOnly) {
+                var command2D = nodeCommand.command2D;
+                var silhouetteModelCommand2D = DrawCommand.shallowClone(silhouetteModelCommand);
+                silhouetteModelCommand2D.boundingVolume = command2D.boundingVolume;
+                silhouetteModelCommand2D.modelMatrix = command2D.modelMatrix;
+                nodeCommand.silhouetteModelCommand2D = silhouetteModelCommand2D;
+
+                var silhouetteColorCommand2D = DrawCommand.shallowClone(silhouetteColorCommand);
+                silhouetteModelCommand2D.boundingVolume = command2D.boundingVolume;
+                silhouetteModelCommand2D.modelMatrix = command2D.modelMatrix;
+                nodeCommand.silhouetteColorCommand2D = silhouetteColorCommand2D;
+            }
+        }
+    }
+
+    function updateSilhouette(model, frameState) {
+        // Generate silhouette commands when the silhouette size is greater than 0.0 and the alpha is greater than 0.0
+        // There are two silhouette commands:
+        //     1. silhouetteModelCommand : render model normally while enabling stencil mask
+        //     2. silhouetteColorCommand : render enlarged model with a solid color while enabling stencil tests
+        if (!hasSilhouette(model, frameState)) {
+            return;
+        }
+
+        var nodeCommands = model._nodeCommands;
+        var dirty = alphaDirty(model.color.alpha, model._color.alpha) ||
+                    alphaDirty(model.silhouetteColor.alpha, model._silhouetteColor.alpha) ||
+                    !defined(nodeCommands[0].silhouetteModelCommand);
+
+        Color.clone(model.color, model._color);
+        Color.clone(model.silhouetteColor, model._silhouetteColor);
+
+        if (dirty) {
+            createSilhouetteCommands(model, frameState);
+        }
+    }
+
     var scratchBoundingSphere = new BoundingSphere();
 
     function scaleInPixels(positionWC, radius, frameState) {
@@ -3612,6 +3891,7 @@ define([
         this.vertexArrays = undefined;
         this.programs = undefined;
         this.pickPrograms = undefined;
+        this.silhouettePrograms = undefined;
         this.textures = undefined;
         this.samplers = undefined;
         this.renderStates = undefined;
@@ -3635,6 +3915,7 @@ define([
         destroy(resources.vertexArrays);
         destroy(resources.programs);
         destroy(resources.pickPrograms);
+        destroy(resources.silhouettePrograms);
         destroy(resources.textures);
     }
 
@@ -3851,11 +4132,15 @@ define([
                 cachedResources.vertexArrays = resources.vertexArrays;
                 cachedResources.programs = resources.programs;
                 cachedResources.pickPrograms = resources.pickPrograms;
+                cachedResources.silhouettePrograms = resources.silhouettePrograms;
                 cachedResources.textures = resources.textures;
                 cachedResources.samplers = resources.samplers;
                 cachedResources.renderStates = resources.renderStates;
                 cachedResources.ready = true;
 
+                // The normal attribute name is required for silhouettes, so get it before the gltf JSON is released
+                this._normalAttributeName = getAttributeOrUniformBySemantic(this.gltf, 'NORMAL');
+
                 // Vertex arrays are unique to this model, do not store in cache.
                 if (defined(this._precreatedAttributes)) {
                     cachedResources.vertexArrays = {};
@@ -3867,9 +4152,11 @@ define([
             }
         }
 
-        var alpha = this.color.alpha;
+        var silhouette = hasSilhouette(this, frameState);
+        var translucent = isTranslucent(this);
+        var invisible = isInvisible(this);
         var displayConditionPassed = defined(this.distanceDisplayCondition) ? distanceDisplayConditionVisible(this, frameState) : true;
-        var show = this.show && displayConditionPassed && (this.scale !== 0.0) && (alpha > 0.0);
+        var show = this.show && displayConditionPassed && (this.scale !== 0.0) && (!invisible || silhouette);
 
         if ((show && this._state === ModelState.LOADED) || justLoaded) {
             var animated = this.activeAnimations.update(frameState) || this._cesiumAnimationsDirty;
@@ -3929,6 +4216,7 @@ define([
             updateShowBoundingVolume(this);
             updateShadows(this);
             updateColor(this, frameState);
+            updateSilhouette(this, frameState);
         }
 
         if (justLoaded) {
@@ -3960,17 +4248,33 @@ define([
                 for (i = 0; i < length; ++i) {
                     nc = nodeCommands[i];
                     if (nc.show) {
-                        var translucent = (alpha < 1.0);
                         var command = translucent ? nc.translucentCommand : nc.command;
+                        command = silhouette ? nc.silhouetteModelCommand : command;
                         commandList.push(command);
                         boundingVolume = nc.command.boundingVolume;
                         if (frameState.mode === SceneMode.SCENE2D &&
                             (boundingVolume.center.y + boundingVolume.radius > idl2D || boundingVolume.center.y - boundingVolume.radius < idl2D)) {
                             var command2D = translucent ? nc.translucentCommand2D : nc.command2D;
+                            command2D = silhouette ? nc.silhouetteModelCommand2D : command2D;
                             commandList.push(command2D);
                         }
                     }
                 }
+
+                if (silhouette) {
+                    // Render second silhouette pass
+                    for (i = 0; i < length; ++i) {
+                        nc = nodeCommands[i];
+                        if (nc.show) {
+                            commandList.push(nc.silhouetteColorCommand);
+                            boundingVolume = nc.command.boundingVolume;
+                            if (frameState.mode === SceneMode.SCENE2D &&
+                                (boundingVolume.center.y + boundingVolume.radius > idl2D || boundingVolume.center.y - boundingVolume.radius < idl2D)) {
+                                commandList.push(nc.silhouetteColorCommand2D);
+                            }
+                        }
+                    }
+                }
             }
 
             if (passes.pick && this.allowPicking) {
diff --git a/Source/Scene/Scene.js b/Source/Scene/Scene.js
index 439e70b1baef..e8e5840d0464 100644
--- a/Source/Scene/Scene.js
+++ b/Source/Scene/Scene.js
@@ -285,6 +285,9 @@ define([
             depth : 1.0,
             owner : this
         });
+        this._stencilClearCommand = new ClearCommand({
+            stencil : 0
+        });
 
         this._pickDepths = [];
         this._debugGlobeDepths = [];
@@ -1755,6 +1758,11 @@ define([
                 executeCommand(commands[j], scene, context, passState);
             }
 
+            // Clear the stencil after the ground pass
+            if (length > 0 && context.stencilBuffer) {
+                scene._stencilClearCommand.execute(context, passState);
+            }
+
             if (clearGlobeDepth) {
                 clearDepth.execute(context, passState);
                 if (useDepthPlane) {
diff --git a/Source/Scene/getAttributeOrUniformBySemantic.js b/Source/Scene/getAttributeOrUniformBySemantic.js
new file mode 100644
index 000000000000..41520014e123
--- /dev/null
+++ b/Source/Scene/getAttributeOrUniformBySemantic.js
@@ -0,0 +1,38 @@
+/*global define*/
+define([], function() {
+    'use strict';
+
+    /**
+     * Return the uniform or attribute that has the given semantic.
+     *
+     * @private
+     */
+    function getAttributeOrUniformBySemantic(gltf, semantic) {
+        var techniques = gltf.techniques;
+        for (var techniqueName in techniques) {
+            if (techniques.hasOwnProperty(techniqueName)) {
+                var technique = techniques[techniqueName];
+                var parameters = technique.parameters;
+                var attributes = technique.attributes;
+                var uniforms = technique.uniforms;
+                for (var attributeName in attributes) {
+                    if (attributes.hasOwnProperty(attributeName)) {
+                        if (parameters[attributes[attributeName]].semantic === semantic) {
+                            return attributeName;
+                        }
+                    }
+                }
+                for (var uniformName in uniforms) {
+                    if (uniforms.hasOwnProperty(uniformName)) {
+                        if (parameters[uniforms[uniformName]].semantic === semantic) {
+                            return uniformName;
+                        }
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+
+    return getAttributeOrUniformBySemantic;
+});
diff --git a/Specs/DataSources/CzmlDataSourceSpec.js b/Specs/DataSources/CzmlDataSourceSpec.js
index 321dced1255d..1da26e311f2f 100644
--- a/Specs/DataSources/CzmlDataSourceSpec.js
+++ b/Specs/DataSources/CzmlDataSourceSpec.js
@@ -1839,7 +1839,11 @@ defineSuite([
                 gltf : './Data/Models/Box/CesiumBoxTest.gltf',
                 incrementallyLoadTextures : true,
                 shadows : 'ENABLED',
-                heightReference: 'CLAMP_TO_GROUND',
+                heightReference : 'CLAMP_TO_GROUND',
+                silhouetteColor : {
+                    rgbaf : [1.0, 0.0, 0.0, 1.0]
+                },
+                silhouetteSize : 2.0,
                 color : {
                     rgbaf : [0.0, 1.0, 0.0, 0.2]
                 },
@@ -1874,6 +1878,8 @@ 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.silhouetteColor.getValue(Iso8601.MINIMUM_VALUE)).toEqual(new Color(1.0, 0.0, 0.0, 1.0));
+        expect(entity.model.silhouetteSize.getValue(Iso8601.MINIMUM_VALUE)).toEqual(2.0);
         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);
@@ -1903,6 +1909,10 @@ defineSuite([
                 incrementallyLoadTextures : true,
                 shadows : 'ENABLED',
                 heightReference: 'CLAMP_TO_GROUND',
+                silhouetteColor : {
+                    rgbaf : [1.0, 0.0, 0.0, 1.0]
+                },
+                silhouetteSize : 2.0,
                 color : {
                     rgbaf : [0.0, 1.0, 0.0, 0.2]
                 },
@@ -1941,6 +1951,8 @@ defineSuite([
         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.silhouetteColor.getValue(validTime)).toEqual(new Color(1.0, 0.0, 0.0, 1.0));
+        expect(entity.model.silhouetteSize.getValue(validTime)).toEqual(2.0);
         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);
@@ -1966,6 +1978,8 @@ defineSuite([
         expect(entity.model.shadows.getValue(invalidTime)).toBeUndefined();
         expect(entity.model.heightReference.getValue(invalidTime)).toBeUndefined();
         expect(entity.model.color.getValue(invalidTime)).toBeUndefined();
+        expect(entity.model.silhouetteColor.getValue(invalidTime)).toBeUndefined();
+        expect(entity.model.silhouetteSize.getValue(invalidTime)).toBeUndefined();
         expect(entity.model.colorBlendMode.getValue(invalidTime)).toBeUndefined();
         expect(entity.model.colorBlendAmount.getValue(invalidTime)).toBeUndefined();
 
diff --git a/Specs/DataSources/ModelGraphicsSpec.js b/Specs/DataSources/ModelGraphicsSpec.js
index 5c6fdb521c99..34fe22724987 100644
--- a/Specs/DataSources/ModelGraphicsSpec.js
+++ b/Specs/DataSources/ModelGraphicsSpec.js
@@ -39,6 +39,8 @@ defineSuite([
             shadows : ShadowMode.DISABLED,
             heightReference : HeightReference.CLAMP_TO_GROUND,
             distanceDisplayCondition : new DistanceDisplayCondition(),
+            silhouetteColor : new Color(1.0, 0.0, 0.0, 1.0),
+            silhouetteSize : 3.0,
             color : new Color(0.0, 1.0, 0.0, 0.2),
             colorBlendMode : ColorBlendMode.HIGHLIGHT,
             colorBlendAmount : 0.5,
@@ -61,6 +63,8 @@ defineSuite([
         expect(model.shadows).toBeInstanceOf(ConstantProperty);
         expect(model.heightReference).toBeInstanceOf(ConstantProperty);
         expect(model.distanceDisplayCondition).toBeInstanceOf(ConstantProperty);
+        expect(model.silhouetteColor).toBeInstanceOf(ConstantProperty);
+        expect(model.silhouetteSize).toBeInstanceOf(ConstantProperty);
         expect(model.color).toBeInstanceOf(ConstantProperty);
         expect(model.colorBlendMode).toBeInstanceOf(ConstantProperty);
         expect(model.colorBlendAmount).toBeInstanceOf(ConstantProperty);
@@ -77,6 +81,8 @@ defineSuite([
         expect(model.shadows.getValue()).toEqual(options.shadows);
         expect(model.heightReference.getValue()).toEqual(options.heightReference);
         expect(model.distanceDisplayCondition.getValue()).toEqual(options.distanceDisplayCondition);
+        expect(model.silhouetteColor.getValue()).toEqual(options.silhouetteColor);
+        expect(model.silhouetteSize.getValue()).toEqual(options.silhouetteSize);
         expect(model.color.getValue()).toEqual(options.color);
         expect(model.colorBlendMode.getValue()).toEqual(options.colorBlendMode);
         expect(model.colorBlendAmount.getValue()).toEqual(options.colorBlendAmount);
@@ -102,6 +108,8 @@ defineSuite([
         source.shadows = new ConstantProperty(ShadowMode.ENABLED);
         source.heightReference = new ConstantProperty(HeightReference.CLAMP_TO_GROUND);
         source.distanceDisplayCondition = new ConstantProperty(new DistanceDisplayCondition());
+        source.silhouetteColor = new ConstantProperty(new Color(1.0, 0.0, 0.0, 1.0));
+        source.silhouetteSize = new ConstantProperty(3.0);
         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);
@@ -129,6 +137,8 @@ defineSuite([
         expect(target.shadows).toBe(source.shadows);
         expect(target.heightReference).toBe(source.heightReference);
         expect(target.distanceDisplayCondition).toBe(source.distanceDisplayCondition);
+        expect(target.silhouetteColor).toEqual(source.silhouetteColor);
+        expect(target.silhouetteSize).toEqual(source.silhouetteSize);
         expect(target.color).toBe(source.color);
         expect(target.colorBlendMode).toBe(source.colorBlendMode);
         expect(target.colorBlendAmount).toBe(source.colorBlendAmount);
@@ -147,6 +157,8 @@ defineSuite([
         source.shadows = new ConstantProperty(ShadowMode.ENABLED);
         source.heightReference = new ConstantProperty(HeightReference.CLAMP_TO_GROUND);
         source.distanceDisplayCondition = new ConstantProperty(new DistanceDisplayCondition());
+        source.silhouetteColor = new ConstantProperty(new Color());
+        source.silhouetteSize = new ConstantProperty(1.0);
         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);
@@ -164,6 +176,8 @@ defineSuite([
         var shadows = new ConstantProperty(ShadowMode.ENABLED);
         var heightReference = new ConstantProperty(HeightReference.CLAMP_TO_GROUND);
         var distanceDisplayCondition = new ConstantProperty(new DistanceDisplayCondition());
+        var silhouetteColor = new ConstantProperty(new Color());
+        var silhouetteSize = new ConstantProperty(1.0);
         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);
@@ -182,6 +196,8 @@ defineSuite([
         target.shadows = shadows;
         target.heightReference = heightReference;
         target.distanceDisplayCondition = distanceDisplayCondition;
+        target.silhouetteColor = silhouetteColor;
+        target.silhouetteSize = silhouetteSize;
         target.color = color;
         target.colorBlendMode = colorBlendMode;
         target.colorBlendAmount = colorBlendAmount;
@@ -199,6 +215,8 @@ defineSuite([
         expect(target.shadows).toBe(shadows);
         expect(target.heightReference).toBe(heightReference);
         expect(target.distanceDisplayCondition).toBe(distanceDisplayCondition);
+        expect(target.silhouetteColor).toBe(silhouetteColor);
+        expect(target.silhouetteSize).toBe(silhouetteSize);
         expect(target.color).toBe(color);
         expect(target.colorBlendMode).toBe(colorBlendMode);
         expect(target.colorBlendAmount).toBe(colorBlendAmount);
@@ -217,6 +235,8 @@ defineSuite([
         source.shadows = new ConstantProperty(ShadowMode.ENABLED);
         source.heightReference = new ConstantProperty(HeightReference.CLAMP_TO_GROUND);
         source.distanceDisplayCondition = new ConstantProperty(new DistanceDisplayCondition());
+        source.silhouetteColor = new ConstantProperty(new Color());
+        source.silhouetteSize = new ConstantProperty(2.0);
         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);
@@ -236,6 +256,8 @@ defineSuite([
         expect(result.shadows).toBe(source.shadows);
         expect(result.heightReference).toBe(source.heightReference);
         expect(result.distanceDisplayCondition).toBe(source.distanceDisplayCondition);
+        expect(result.silhouetteColor).toEqual(source.silhouetteColor);
+        expect(result.silhouetteSize).toEqual(source.silhouetteSize);
         expect(result.color).toBe(source.color);
         expect(result.colorBlendMode).toBe(source.colorBlendMode);
         expect(result.colorBlendAmount).toBe(source.colorBlendAmount);
diff --git a/Specs/Scene/ModelSpec.js b/Specs/Scene/ModelSpec.js
index 3e4d240a34e1..5c56d9c4c468 100644
--- a/Specs/Scene/ModelSpec.js
+++ b/Specs/Scene/ModelSpec.js
@@ -28,6 +28,7 @@ defineSuite([
         'Renderer/WebGLConstants',
         'Scene/ColorBlendMode',
         'Scene/HeightReference',
+        'Scene/Pass',
         'Scene/ModelAnimationLoop',
         'Specs/createScene',
         'Specs/pollToPromise',
@@ -61,6 +62,7 @@ defineSuite([
         WebGLConstants,
         ColorBlendMode,
         HeightReference,
+        Pass,
         ModelAnimationLoop,
         createScene,
         pollToPromise,
@@ -235,6 +237,11 @@ defineSuite([
         expect(texturedBoxModel.debugShowBoundingVolume).toEqual(false);
         expect(texturedBoxModel.debugWireframe).toEqual(false);
         expect(texturedBoxModel.distanceDisplayCondition).toBeUndefined();
+        expect(texturedBoxModel.silhouetteColor).toEqual(Color.RED);
+        expect(texturedBoxModel.silhouetteSize).toEqual(0.0);
+        expect(texturedBoxModel.color).toEqual(Color.WHITE);
+        expect(texturedBoxModel.colorBlendMode).toEqual(ColorBlendMode.HIGHLIGHT);
+        expect(texturedBoxModel.colorBlendAmount).toEqual(0.5);
     });
 
     it('renders', function() {
@@ -1931,6 +1938,130 @@ defineSuite([
         });
     });
 
+    it('silhouetteSupported', function() {
+        expect(Model.silhouetteSupported(scene)).toBe(true);
+        scene.context._stencilBits = 0;
+        expect(Model.silhouetteSupported(scene)).toBe(false);
+        scene.context._stencilBits = 8;
+    });
+
+    it('renders with a silhouette', function() {
+        return loadModel(boxUrl).then(function(model) {
+            model.show = true;
+            model.zoomTo();
+
+            var commands = scene.frameState.commandList;
+
+            // No silhouette
+            model.silhouetteSize = 0.0;
+            scene.renderForSpecs();
+            expect(commands.length).toBe(1);
+            expect(commands[0].renderState.stencilTest.enabled).toBe(false);
+            expect(commands[0].pass).toBe(Pass.OPAQUE);
+
+            // Opaque silhouette
+            model.silhouetteSize = 1.0;
+            scene.renderForSpecs();
+            expect(commands.length).toBe(2);
+            expect(commands[0].renderState.stencilTest.enabled).toBe(true);
+            expect(commands[0].pass).toBe(Pass.OPAQUE);
+            expect(commands[1].renderState.stencilTest.enabled).toBe(true);
+            expect(commands[1].pass).toBe(Pass.OPAQUE);
+
+            // Translucent silhouette
+            model.silhouetteColor = Color.fromAlpha(Color.GREEN, 0.5);
+            scene.renderForSpecs();
+            expect(commands.length).toBe(2);
+            expect(commands[0].renderState.stencilTest.enabled).toBe(true);
+            expect(commands[0].pass).toBe(Pass.OPAQUE);
+            expect(commands[1].renderState.stencilTest.enabled).toBe(true);
+            expect(commands[1].pass).toBe(Pass.TRANSLUCENT);
+
+            // Invisible silhouette. The model is rendered normally.
+            model.silhouetteColor = Color.fromAlpha(Color.GREEN, 0.0);
+            scene.renderForSpecs();
+            expect(commands.length).toBe(1);
+            expect(commands[0].renderState.stencilTest.enabled).toBe(false);
+            expect(commands[0].pass).toBe(Pass.OPAQUE);
+
+            // Invisible model with no silhouette. No commands.
+            model.color = Color.fromAlpha(Color.WHITE, 0.0);
+            model.silhouetteColor = Color.GREEN;
+            model.silhouetteSize = 0.0;
+            scene.renderForSpecs();
+            expect(commands.length).toBe(0);
+
+            // Invisible model with silhouette. Model command is stencil-only.
+            model.silhouetteSize = 1.0;
+            scene.renderForSpecs();
+            expect(commands.length).toBe(2);
+            expect(commands[0].renderState.colorMask).toEqual({
+                red : false,
+                green : false,
+                blue : false,
+                alpha : false
+            });
+            expect(commands[0].renderState.depthMask).toEqual(false);
+            expect(commands[0].renderState.stencilTest.enabled).toBe(true);
+            expect(commands[0].pass).toBe(Pass.OPAQUE);
+            expect(commands[1].renderState.stencilTest.enabled).toBe(true);
+            expect(commands[1].pass).toBe(Pass.OPAQUE);
+
+            // Translucent model with opaque silhouette. Silhouette is placed in the translucent pass.
+            model.color = Color.fromAlpha(Color.WHITE, 0.5);
+            scene.renderForSpecs();
+            expect(commands.length).toBe(2);
+            expect(commands[0].renderState.stencilTest.enabled).toBe(true);
+            expect(commands[0].pass).toBe(Pass.TRANSLUCENT);
+            expect(commands[1].renderState.stencilTest.enabled).toBe(true);
+            expect(commands[1].pass).toBe(Pass.TRANSLUCENT);
+
+            // Model with translucent commands with silhouette
+            model.color = Color.WHITE;
+            model._nodeCommands[0].command.pass = Pass.TRANSLUCENT;
+            scene.renderForSpecs();
+            expect(commands.length).toBe(2);
+            expect(commands[0].renderState.stencilTest.enabled).toBe(true);
+            expect(commands[0].pass).toBe(Pass.TRANSLUCENT);
+            expect(commands[1].renderState.stencilTest.enabled).toBe(true);
+            expect(commands[1].pass).toBe(Pass.TRANSLUCENT);
+            model._nodeCommands[0].command.pass = Pass.OPAQUE; // Revert change
+
+            // Translucent model with translucent silhouette.
+            model.color = Color.fromAlpha(Color.WHITE, 0.5);
+            model.silhouetteColor = Color.fromAlpha(Color.GREEN, 0.5);
+            scene.renderForSpecs();
+            expect(commands.length).toBe(2);
+            expect(commands[0].renderState.stencilTest.enabled).toBe(true);
+            expect(commands[0].pass).toBe(Pass.TRANSLUCENT);
+            expect(commands[1].renderState.stencilTest.enabled).toBe(true);
+            expect(commands[1].pass).toBe(Pass.TRANSLUCENT);
+
+            model.color = Color.WHITE;
+            model.silhouetteColor = Color.GREEN;
+
+            // Load a second model
+            return loadModel(boxUrl).then(function(model) {
+                model.show = true;
+                model.silhouetteSize = 1.0;
+                scene.renderForSpecs();
+                expect(commands.length).toBe(4);
+                expect(commands[0].renderState.stencilTest.enabled).toBe(true);
+                expect(commands[0].pass).toBe(Pass.OPAQUE);
+                expect(commands[1].renderState.stencilTest.enabled).toBe(true);
+                expect(commands[1].pass).toBe(Pass.OPAQUE);
+                expect(commands[2].renderState.stencilTest.enabled).toBe(true);
+                expect(commands[2].pass).toBe(Pass.OPAQUE);
+                expect(commands[3].renderState.stencilTest.enabled).toBe(true);
+                expect(commands[3].pass).toBe(Pass.OPAQUE);
+
+                var reference1 = commands[0].renderState.stencilTest.reference;
+                var reference2 = commands[2].renderState.stencilTest.reference;
+                expect(reference2).toEqual(reference1 + 1);
+            });
+        });
+    });
+
     describe('height referenced model', function() {
         function createMockGlobe() {
             var globe = {
@@ -2050,7 +2181,7 @@ defineSuite([
                 scene.renderForSpecs();
                 expect(scene.globe.removedCallback).toEqual(true);
                 expect(scene.globe.callback).not.toBeDefined();
-                
+
                 primitives.remove(model);
             });
         });
diff --git a/Specs/createScene.js b/Specs/createScene.js
index bbb1d7e7009f..6b070ae6772a 100644
--- a/Specs/createScene.js
+++ b/Specs/createScene.js
@@ -32,6 +32,7 @@ define([
         var contextOptions = options.contextOptions;
         contextOptions.webgl = defaultValue(contextOptions.webgl, {});
         contextOptions.webgl.antialias = defaultValue(contextOptions.webgl.antialias, false);
+        contextOptions.webgl.stencil = defaultValue(contextOptions.webgl.stencil, true);
 
         var scene = new Scene(options);