diff --git a/webrender/src/render_backend.rs b/webrender/src/render_backend.rs
index 65416e4594..25aa970d0a 100644
--- a/webrender/src/render_backend.rs
+++ b/webrender/src/render_backend.rs
@@ -17,6 +17,7 @@ use std::sync::{Arc, Mutex};
 use std::sync::mpsc::Sender;
 use texture_cache::TextureCache;
 use thread_profiler::register_thread_with_profiler;
+use threadpool::ThreadPool;
 use webrender_traits::{ApiMsg, AuxiliaryLists, BuiltDisplayList, IdNamespace, ImageData};
 use webrender_traits::{PipelineId, RenderNotifier, RenderDispatcher, WebGLCommand, WebGLContextId};
 use webrender_traits::channel::{PayloadHelperMethods, PayloadReceiver, PayloadSender, MsgReceiver};
@@ -61,6 +62,7 @@ impl RenderBackend {
                device_pixel_ratio: f32,
                texture_cache: TextureCache,
                enable_aa: bool,
+               workers: Arc<Mutex<ThreadPool>>,
                notifier: Arc<Mutex<Option<Box<RenderNotifier>>>>,
                webrender_context_handle: Option<GLContextHandleWrapper>,
                config: FrameBuilderConfig,
@@ -68,8 +70,7 @@ impl RenderBackend {
                main_thread_dispatcher: Arc<Mutex<Option<Box<RenderDispatcher>>>>,
                vr_compositor_handler: Arc<Mutex<Option<Box<VRCompositorHandler>>>>) -> RenderBackend {
 
-        let resource_cache = ResourceCache::new(texture_cache,
-                                                enable_aa);
+        let resource_cache = ResourceCache::new(texture_cache, workers, enable_aa);
 
         register_thread_with_profiler("Backend".to_string());
 
diff --git a/webrender/src/renderer.rs b/webrender/src/renderer.rs
index df6e8a5ece..3cbb27f4dd 100644
--- a/webrender/src/renderer.rs
+++ b/webrender/src/renderer.rs
@@ -39,6 +39,7 @@ use std::sync::{Arc, Mutex};
 use std::sync::mpsc::{channel, Receiver, Sender};
 use std::thread;
 use texture_cache::TextureCache;
+use threadpool::ThreadPool;
 use tiling::{AlphaBatchKind, BlurCommand, Frame, PrimitiveBatch, PrimitiveBatchData};
 use tiling::{CacheClipInstance, PrimitiveInstance, RenderTarget};
 use time::precise_time_ns;
@@ -500,7 +501,7 @@ impl Renderer {
     /// };
     /// let (renderer, sender) = Renderer::new(opts);
     /// ```
-    pub fn new(options: RendererOptions) -> Result<(Renderer, RenderApiSender), InitError> {
+    pub fn new(mut options: RendererOptions) -> Result<(Renderer, RenderApiSender), InitError> {
         let (api_tx, api_rx) = try!{ channel::msg_channel() };
         let (payload_tx, payload_rx) = try!{ channel::payload_channel() };
         let (result_tx, result_rx) = channel();
@@ -760,6 +761,10 @@ impl Renderer {
         let render_target_debug = options.render_target_debug;
         let payload_tx_for_backend = payload_tx.clone();
         let recorder = options.recorder;
+        let workers = options.workers.take().unwrap_or_else(||{
+            // TODO(gw): Use a heuristic to select best # of worker threads.
+            Arc::new(Mutex::new(ThreadPool::new_with_name("WebRender:Worker".to_string(), 4)))
+        });
         try!{ thread::Builder::new().name("RenderBackend".to_string()).spawn(move || {
             let mut backend = RenderBackend::new(api_rx,
                                                  payload_rx,
@@ -768,6 +773,7 @@ impl Renderer {
                                                  device_pixel_ratio,
                                                  texture_cache,
                                                  enable_aa,
+                                                 workers,
                                                  backend_notifier,
                                                  context_handle,
                                                  config,
@@ -1731,6 +1737,7 @@ pub struct RendererOptions {
     pub clear_framebuffer: bool,
     pub clear_color: ColorF,
     pub render_target_debug: bool,
+    pub workers: Option<Arc<Mutex<ThreadPool>>>,
     pub recorder: Option<Box<ApiRecordingReceiver>>,
 }
 
@@ -1749,6 +1756,7 @@ impl Default for RendererOptions {
             clear_framebuffer: true,
             clear_color: ColorF::new(1.0, 1.0, 1.0, 1.0),
             render_target_debug: false,
+            workers: None,
             recorder: None,
         }
     }
diff --git a/webrender/src/resource_cache.rs b/webrender/src/resource_cache.rs
index 41c4c8557c..2681ca7aa7 100644
--- a/webrender/src/resource_cache.rs
+++ b/webrender/src/resource_cache.rs
@@ -15,7 +15,7 @@ use std::fmt::Debug;
 use std::hash::BuildHasherDefault;
 use std::hash::Hash;
 use std::mem;
-use std::sync::{Arc, Barrier};
+use std::sync::{Arc, Barrier, Mutex};
 use std::sync::mpsc::{channel, Receiver, Sender};
 use std::thread;
 use texture_cache::{TextureCache, TextureCacheItemId};
@@ -213,8 +213,9 @@ pub struct ResourceCache {
 
 impl ResourceCache {
     pub fn new(texture_cache: TextureCache,
+               workers: Arc<Mutex<ThreadPool>>,
                enable_aa: bool) -> ResourceCache {
-        let (glyph_cache_tx, glyph_cache_result_queue) = spawn_glyph_cache_thread();
+        let (glyph_cache_tx, glyph_cache_result_queue) = spawn_glyph_cache_thread(workers);
 
         ResourceCache {
             cached_glyphs: Some(ResourceClassCache::new()),
@@ -624,7 +625,10 @@ impl Resource for CachedImageInfo {
     }
 }
 
-fn spawn_glyph_cache_thread() -> (Sender<GlyphCacheMsg>, Receiver<GlyphCacheResultMsg>) {
+fn spawn_glyph_cache_thread(workers: Arc<Mutex<ThreadPool>>) -> (Sender<GlyphCacheMsg>, Receiver<GlyphCacheResultMsg>) {
+    let worker_count = {
+        workers.lock().unwrap().max_count()
+    };
     // Used for messages from resource cache -> glyph cache thread.
     let (msg_tx, msg_rx) = channel();
     // Used for returning results from glyph cache thread -> resource cache.
@@ -633,10 +637,6 @@ fn spawn_glyph_cache_thread() -> (Sender<GlyphCacheMsg>, Receiver<GlyphCacheResu
     let (glyph_tx, glyph_rx) = channel();
 
     thread::Builder::new().name("GlyphCache".to_string()).spawn(move|| {
-        // TODO(gw): Use a heuristic to select best # of worker threads.
-        let worker_count = 4;
-        let thread_pool = ThreadPool::new(worker_count);
-
         let mut glyph_cache = None;
         let mut current_frame_id = FrameId(0);
 
@@ -645,7 +645,7 @@ fn spawn_glyph_cache_thread() -> (Sender<GlyphCacheMsg>, Receiver<GlyphCacheResu
         let barrier = Arc::new(Barrier::new(worker_count));
         for i in 0..worker_count {
             let barrier = barrier.clone();
-            thread_pool.execute(move || {
+            workers.lock().unwrap().execute(move || {
                 register_thread_with_profiler(format!("Glyph Worker {}", i));
                 barrier.wait();
             });
@@ -682,7 +682,7 @@ fn spawn_glyph_cache_thread() -> (Sender<GlyphCacheMsg>, Receiver<GlyphCacheResu
                     for _ in 0..worker_count {
                         let barrier = barrier.clone();
                         let font_template = font_template.clone();
-                        thread_pool.execute(move || {
+                        workers.lock().unwrap().execute(move || {
                             FONT_CONTEXT.with(|font_context| {
                                 let mut font_context = font_context.borrow_mut();
                                 match font_template {
@@ -723,7 +723,7 @@ fn spawn_glyph_cache_thread() -> (Sender<GlyphCacheMsg>, Receiver<GlyphCacheResu
                            !pending_glyphs.contains(&glyph_key) {
                             let glyph_tx = glyph_tx.clone();
                             pending_glyphs.insert(glyph_key.clone());
-                            thread_pool.execute(move || {
+                            workers.lock().unwrap().execute(move || {
                                 profile_scope!("glyph");
                                 FONT_CONTEXT.with(move |font_context| {
                                     let mut font_context = font_context.borrow_mut();