src: add multi-context support

This commit makes it possible to use multiple V8 execution contexts
within a single event loop.  Put another way, handle and request wrap
objects now "remember" the context they belong to and switch back to
that context when the time comes to call into JS land.

This could have been done in a quick and hacky way by calling
v8::Object::GetCreationContext() on the wrap object right before
making a callback but that leaves a fairly wide margin for bugs.

Instead, we make the context explicit through a new Environment class
that encapsulates everything (or almost everything) that belongs to
the context.  Variables that used to be a static or a global are now
members of the aforementioned class.  An additional benefit is that
this approach should make it relatively straightforward to add full
isolate support in due course.

There is no JavaScript API yet but that will be added in the near
future.

This work was graciously sponsored by GitHub, Inc.

44 files changed, 2515 insertions, 1704 deletions

diff --git a/src/cares_wrap.cc b/src/cares_wrap.cc
index f09590e88e..00238788ad 100644
--- a/src/cares_wrap.cc
+++ b/src/cares_wrap.cc
@@ -21,6 +21,8 @@
 
 #define CARES_STATICLIB
 #include "ares.h"
+#include "env.h"
+#include "env-inl.h"
 #include "node.h"
 #include "req_wrap.h"
 #include "tree.h"
@@ -45,6 +47,7 @@ namespace node {
 namespace cares_wrap {
 
 using v8::Array;
+using v8::Context;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::Handle;
@@ -57,22 +60,8 @@ using v8::Persistent;
 using v8::String;
 using v8::Value;
 
-
 typedef class ReqWrap<uv_getaddrinfo_t> GetAddrInfoReqWrap;
 
-struct ares_task_t {
-  uv_loop_t* loop;
-  ares_socket_t sock;
-  uv_poll_t poll_watcher;
-  RB_ENTRY(ares_task_t) node;
-};
-
-
-static Cached<String> oncomplete_sym;
-static ares_channel ares_channel;
-static uv_timer_t ares_timer;
-static RB_HEAD(ares_task_list, ares_task_t) ares_tasks;
-
 
 static int cmp_ares_tasks(const ares_task_t* a, const ares_task_t* b) {
   if (a->sock < b->sock) return -1;
@@ -88,26 +77,28 @@ RB_GENERATE_STATIC(ares_task_list, ares_task_t, node, cmp_ares_tasks)
 /* This is called once per second by loop->timer. It is used to constantly */
 /* call back into c-ares for possibly processing timeouts. */
 static void ares_timeout(uv_timer_t* handle, int status) {
-  assert(!RB_EMPTY(&ares_tasks));
-  ares_process_fd(ares_channel, ARES_SOCKET_BAD, ARES_SOCKET_BAD);
+  Environment* env = Environment::from_cares_timer_handle(handle);
+  assert(!RB_EMPTY(env->cares_task_list()));
+  ares_process_fd(env->cares_channel(), ARES_SOCKET_BAD, ARES_SOCKET_BAD);
 }
 
 
 static void ares_poll_cb(uv_poll_t* watcher, int status, int events) {
   ares_task_t* task = container_of(watcher, ares_task_t, poll_watcher);
+  Environment* env = task->env;
 
   /* Reset the idle timer */
-  uv_timer_again(&ares_timer);
+  uv_timer_again(env->cares_timer_handle());
 
   if (status < 0) {
     /* An error happened. Just pretend that the socket is both readable and */
     /* writable. */
-    ares_process_fd(ares_channel, task->sock, task->sock);
+    ares_process_fd(env->cares_channel(), task->sock, task->sock);
     return;
   }
 
   /* Process DNS responses */
-  ares_process_fd(ares_channel,
+  ares_process_fd(env->cares_channel(),
                   events & UV_READABLE ? task->sock : ARES_SOCKET_BAD,
                   events & UV_WRITABLE ? task->sock : ARES_SOCKET_BAD);
 }
@@ -120,7 +111,7 @@ static void ares_poll_close_cb(uv_handle_t* watcher) {
 
 
 /* Allocates and returns a new ares_task_t */
-static ares_task_t* ares_task_create(uv_loop_t* loop, ares_socket_t sock) {
+static ares_task_t* ares_task_create(Environment* env, ares_socket_t sock) {
   ares_task_t* task = static_cast<ares_task_t*>(malloc(sizeof(*task)));
 
   if (task == NULL) {
@@ -128,10 +119,10 @@ static ares_task_t* ares_task_create(uv_loop_t* loop, ares_socket_t sock) {
     return NULL;
   }
 
-  task->loop = loop;
+  task->env = env;
   task->sock = sock;
 
-  if (uv_poll_init_socket(loop, &task->poll_watcher, sock) < 0) {
+  if (uv_poll_init_socket(env->event_loop(), &task->poll_watcher, sock) < 0) {
     /* This should never happen. */
     free(task);
     return NULL;
@@ -146,24 +137,25 @@ static void ares_sockstate_cb(void* data,
                               ares_socket_t sock,
                               int read,
                               int write) {
-  uv_loop_t* loop = static_cast<uv_loop_t*>(data);
+  Environment* env = static_cast<Environment*>(data);
   ares_task_t* task;
 
   ares_task_t lookup_task;
   lookup_task.sock = sock;
-  task = RB_FIND(ares_task_list, &ares_tasks, &lookup_task);
+  task = RB_FIND(ares_task_list, env->cares_task_list(), &lookup_task);
 
   if (read || write) {
     if (!task) {
       /* New socket */
 
       /* If this is the first socket then start the timer. */
-      if (!uv_is_active(reinterpret_cast<uv_handle_t*>(&ares_timer))) {
-        assert(RB_EMPTY(&ares_tasks));
-        uv_timer_start(&ares_timer, ares_timeout, 1000, 1000);
+      uv_timer_t* timer_handle = env->cares_timer_handle();
+      if (!uv_is_active(reinterpret_cast<uv_handle_t*>(timer_handle))) {
+        assert(RB_EMPTY(env->cares_task_list()));
+        uv_timer_start(timer_handle, ares_timeout, 1000, 1000);
       }
 
-      task = ares_task_create(loop, sock);
+      task = ares_task_create(env, sock);
       if (task == NULL) {
         /* This should never happen unless we're out of memory or something */
         /* is seriously wrong. The socket won't be polled, but the the query */
@@ -171,7 +163,7 @@ static void ares_sockstate_cb(void* data,
         return;
       }
 
-      RB_INSERT(ares_task_list, &ares_tasks, task);
+      RB_INSERT(ares_task_list, env->cares_task_list(), task);
     }
 
     /* This should never fail. If it fails anyway, the query will eventually */
@@ -187,12 +179,12 @@ static void ares_sockstate_cb(void* data,
     assert(task &&
            "When an ares socket is closed we should have a handle for it");
 
-    RB_REMOVE(ares_task_list, &ares_tasks, task);
+    RB_REMOVE(ares_task_list, env->cares_task_list(), task);
     uv_close(reinterpret_cast<uv_handle_t*>(&task->poll_watcher),
              ares_poll_close_cb);
 
-    if (RB_EMPTY(&ares_tasks)) {
-      uv_timer_stop(&ares_timer);
+    if (RB_EMPTY(env->cares_task_list())) {
+      uv_timer_stop(env->cares_timer_handle());
     }
   }
 }
@@ -228,7 +220,7 @@ static Local<Array> HostentToNames(struct hostent* host) {
 
 class QueryWrap {
  public:
-  explicit QueryWrap(Local<Object> req_wrap_obj) {
+  QueryWrap(Environment* env, Local<Object> req_wrap_obj) : env_(env) {
     HandleScope scope(node_isolate);
     persistent().Reset(node_isolate, req_wrap_obj);
   }
@@ -289,24 +281,46 @@ class QueryWrap {
   }
 
   void CallOnComplete(Local<Value> answer) {
-    HandleScope scope(node_isolate);
-    Local<Value> argv[2] = { Integer::New(0, node_isolate), answer };
-    MakeCallback(object(), oncomplete_sym, ARRAY_SIZE(argv), argv);
+    Context::Scope context_scope(env()->context());
+    HandleScope handle_scope(env()->isolate());
+    Local<Value> argv[] = {
+      Integer::New(0, env()->isolate()),
+      answer
+    };
+    MakeCallback(env(),
+                 object(),
+                 env()->oncomplete_string(),
+                 ARRAY_SIZE(argv),
+                 argv);
   }
 
   void CallOnComplete(Local<Value> answer, Local<Value> family) {
-    HandleScope scope(node_isolate);
-    Local<Value> argv[3] = { Integer::New(0, node_isolate), answer, family };
-    MakeCallback(object(), oncomplete_sym, ARRAY_SIZE(argv), argv);
+    Context::Scope context_scope(env()->context());
+    HandleScope handle_scope(env()->isolate());
+    Local<Value> argv[] = {
+      Integer::New(0, env()->isolate()),
+      answer,
+      family
+    };
+    MakeCallback(env(),
+                 object(),
+                 env()->oncomplete_string(),
+                 ARRAY_SIZE(argv),
+                 argv);
   }
 
   void ParseError(int status) {
     assert(status != ARES_SUCCESS);
-    HandleScope scope(node_isolate);
+    Context::Scope context_scope(env()->context());
+    HandleScope handle_scope(env()->isolate());
     Local<Value> argv[] = {
-      Integer::New(status, node_isolate)
+      Integer::New(status, env()->isolate())
     };
-    MakeCallback(object(), oncomplete_sym, ARRAY_SIZE(argv), argv);
+    MakeCallback(env(),
+                 object(),
+                 env()->oncomplete_string(),
+                 ARRAY_SIZE(argv),
+                 argv);
   }
 
   // Subclasses should implement the appropriate Parse method.
@@ -318,18 +332,29 @@ class QueryWrap {
     assert(0);
   };
 
+  inline Environment* env() const {
+    return env_;
+  }
+
  private:
   Persistent<Object> object_;
+  Environment* const env_;
 };
 
 
 class QueryAWrap: public QueryWrap {
  public:
-  explicit QueryAWrap(Local<Object> req_wrap_obj) : QueryWrap(req_wrap_obj) {
+  QueryAWrap(Environment* env, Local<Object> req_wrap_obj)
+      : QueryWrap(env, req_wrap_obj) {
   }
 
   int Send(const char* name) {
-    ares_query(ares_channel, name, ns_c_in, ns_t_a, Callback, GetQueryArg());
+    ares_query(env()->cares_channel(),
+               name,
+               ns_c_in,
+               ns_t_a,
+               Callback,
+               GetQueryArg());
     return 0;
   }
 
@@ -355,11 +380,12 @@ class QueryAWrap: public QueryWrap {
 
 class QueryAaaaWrap: public QueryWrap {
  public:
-  explicit QueryAaaaWrap(Local<Object> req_wrap_obj) : QueryWrap(req_wrap_obj) {
+  QueryAaaaWrap(Environment* env, Local<Object> req_wrap_obj)
+      : QueryWrap(env, req_wrap_obj) {
   }
 
   int Send(const char* name) {
-    ares_query(ares_channel,
+    ares_query(env()->cares_channel(),
                name,
                ns_c_in,
                ns_t_aaaa,
@@ -390,12 +416,12 @@ class QueryAaaaWrap: public QueryWrap {
 
 class QueryCnameWrap: public QueryWrap {
  public:
-  explicit QueryCnameWrap(Local<Object> req_wrap_obj)
-      : QueryWrap(req_wrap_obj) {
+  QueryCnameWrap(Environment* env, Local<Object> req_wrap_obj)
+      : QueryWrap(env, req_wrap_obj) {
   }
 
   int Send(const char* name) {
-    ares_query(ares_channel,
+    ares_query(env()->cares_channel(),
                name,
                ns_c_in,
                ns_t_cname,
@@ -429,11 +455,17 @@ class QueryCnameWrap: public QueryWrap {
 
 class QueryMxWrap: public QueryWrap {
  public:
-  explicit QueryMxWrap(Local<Object> req_wrap_obj) : QueryWrap(req_wrap_obj) {
+  QueryMxWrap(Environment* env, Local<Object> req_wrap_obj)
+      : QueryWrap(env, req_wrap_obj) {
   }
 
   int Send(const char* name) {
-    ares_query(ares_channel, name, ns_c_in, ns_t_mx, Callback, GetQueryArg());
+    ares_query(env()->cares_channel(),
+               name,
+               ns_c_in,
+               ns_t_mx,
+               Callback,
+               GetQueryArg());
     return 0;
   }
 
@@ -473,11 +505,17 @@ class QueryMxWrap: public QueryWrap {
 
 class QueryNsWrap: public QueryWrap {
  public:
-  explicit QueryNsWrap(Local<Object> req_wrap_obj) : QueryWrap(req_wrap_obj) {
+  QueryNsWrap(Environment* env, Local<Object> req_wrap_obj)
+      : QueryWrap(env, req_wrap_obj) {
   }
 
   int Send(const char* name) {
-    ares_query(ares_channel, name, ns_c_in, ns_t_ns, Callback, GetQueryArg());
+    ares_query(env()->cares_channel(),
+               name,
+               ns_c_in,
+               ns_t_ns,
+               Callback,
+               GetQueryArg());
     return 0;
   }
 
@@ -501,11 +539,17 @@ class QueryNsWrap: public QueryWrap {
 
 class QueryTxtWrap: public QueryWrap {
  public:
-  explicit QueryTxtWrap(Local<Object> req_wrap_obj) : QueryWrap(req_wrap_obj) {
+  QueryTxtWrap(Environment* env, Local<Object> req_wrap_obj)
+      : QueryWrap(env, req_wrap_obj) {
   }
 
   int Send(const char* name) {
-    ares_query(ares_channel, name, ns_c_in, ns_t_txt, Callback, GetQueryArg());
+    ares_query(env()->cares_channel(),
+               name,
+               ns_c_in,
+               ns_t_txt,
+               Callback,
+               GetQueryArg());
     return 0;
   }
 
@@ -536,11 +580,12 @@ class QueryTxtWrap: public QueryWrap {
 
 class QuerySrvWrap: public QueryWrap {
  public:
-  explicit QuerySrvWrap(Local<Object> req_wrap_obj) : QueryWrap(req_wrap_obj) {
+  explicit QuerySrvWrap(Environment* env, Local<Object> req_wrap_obj)
+      : QueryWrap(env, req_wrap_obj) {
   }
 
   int Send(const char* name) {
-    ares_query(ares_channel,
+    ares_query(env()->cares_channel(),
                name,
                ns_c_in,
                ns_t_srv,
@@ -592,12 +637,12 @@ class QuerySrvWrap: public QueryWrap {
 
 class QueryNaptrWrap: public QueryWrap {
  public:
-  explicit QueryNaptrWrap(Local<Object> req_wrap_obj)
-      : QueryWrap(req_wrap_obj) {
+  explicit QueryNaptrWrap(Environment* env, Local<Object> req_wrap_obj)
+      : QueryWrap(env, req_wrap_obj) {
   }
 
   int Send(const char* name) {
-    ares_query(ares_channel,
+    ares_query(env()->cares_channel(),
                name,
                ns_c_in,
                ns_t_naptr,
@@ -659,8 +704,8 @@ class QueryNaptrWrap: public QueryWrap {
 
 class GetHostByAddrWrap: public QueryWrap {
  public:
-  explicit GetHostByAddrWrap(Local<Object> req_wrap_obj)
-      : QueryWrap(req_wrap_obj) {
+  explicit GetHostByAddrWrap(Environment* env, Local<Object> req_wrap_obj)
+      : QueryWrap(env, req_wrap_obj) {
   }
 
   int Send(const char* name) {
@@ -677,7 +722,7 @@ class GetHostByAddrWrap: public QueryWrap {
       return UV_EINVAL;  // So errnoException() reports a proper error.
     }
 
-    ares_gethostbyaddr(ares_channel,
+    ares_gethostbyaddr(env()->cares_channel(),
                        address_buffer,
                        length,
                        family,
@@ -697,12 +742,16 @@ class GetHostByAddrWrap: public QueryWrap {
 
 class GetHostByNameWrap: public QueryWrap {
  public:
-  explicit GetHostByNameWrap(Local<Object> req_wrap_obj)
-      : QueryWrap(req_wrap_obj) {
+  explicit GetHostByNameWrap(Environment* env, Local<Object> req_wrap_obj)
+      : QueryWrap(env, req_wrap_obj) {
   }
 
   int Send(const char* name, int family) {
-    ares_gethostbyname(ares_channel, name, family, Callback, GetQueryArg());
+    ares_gethostbyname(env()->cares_channel(),
+                       name,
+                       family,
+                       Callback,
+                       GetQueryArg());
     return 0;
   }
 
@@ -720,7 +769,8 @@ class GetHostByNameWrap: public QueryWrap {
 
 template <class Wrap>
 static void Query(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   assert(!args.IsConstructCall());
   assert(args[0]->IsObject());
@@ -728,7 +778,7 @@ static void Query(const FunctionCallbackInfo<Value>& args) {
 
   Local<Object> req_wrap_obj = args[0].As<Object>();
   Local<String> string = args[1].As<String>();
-  Wrap* wrap = new Wrap(req_wrap_obj);
+  Wrap* wrap = new Wrap(env, req_wrap_obj);
 
   String::Utf8Value name(string);
   int err = wrap->Send(*name);
@@ -739,9 +789,11 @@ static void Query(const FunctionCallbackInfo<Value>& args) {
 
 
 void AfterGetAddrInfo(uv_getaddrinfo_t* req, int status, struct addrinfo* res) {
-  HandleScope scope(node_isolate);
-
   GetAddrInfoReqWrap* req_wrap = static_cast<GetAddrInfoReqWrap*>(req->data);
+  Environment* env = req_wrap->env();
+
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
 
   Local<Value> argv[] = {
     Integer::New(status, node_isolate),
@@ -828,7 +880,11 @@ void AfterGetAddrInfo(uv_getaddrinfo_t* req, int status, struct addrinfo* res) {
   uv_freeaddrinfo(res);
 
   // Make the callback into JavaScript
-  MakeCallback(req_wrap->object(), oncomplete_sym, ARRAY_SIZE(argv), argv);
+  MakeCallback(env,
+               req_wrap->object(),
+               env->oncomplete_string(),
+               ARRAY_SIZE(argv),
+               argv);
 
   delete req_wrap;
 }
@@ -851,7 +907,8 @@ static void IsIP(const FunctionCallbackInfo<Value>& args) {
 
 
 static void GetAddrInfo(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   assert(args[0]->IsObject());
   assert(args[1]->IsString());
@@ -875,14 +932,14 @@ static void GetAddrInfo(const FunctionCallbackInfo<Value>& args) {
     abort();
   }
 
-  GetAddrInfoReqWrap* req_wrap = new GetAddrInfoReqWrap(req_wrap_obj);
+  GetAddrInfoReqWrap* req_wrap = new GetAddrInfoReqWrap(env, req_wrap_obj);
 
   struct addrinfo hints;
   memset(&hints, 0, sizeof(struct addrinfo));
   hints.ai_family = family;
   hints.ai_socktype = SOCK_STREAM;
 
-  int err = uv_getaddrinfo(uv_default_loop(),
+  int err = uv_getaddrinfo(env->event_loop(),
                            &req_wrap->req_,
                            AfterGetAddrInfo,
                            *hostname,
@@ -896,13 +953,14 @@ static void GetAddrInfo(const FunctionCallbackInfo<Value>& args) {
 
 
 static void GetServers(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   Local<Array> server_array = Array::New();
 
   ares_addr_node* servers;
 
-  int r = ares_get_servers(ares_channel, &servers);
+  int r = ares_get_servers(env->cares_channel(), &servers);
   assert(r == ARES_SUCCESS);
 
   ares_addr_node* cur = servers;
@@ -925,7 +983,8 @@ static void GetServers(const FunctionCallbackInfo<Value>& args) {
 
 
 static void SetServers(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   assert(args[0]->IsArray());
 
@@ -934,7 +993,7 @@ static void SetServers(const FunctionCallbackInfo<Value>& args) {
   uint32_t len = arr->Length();
 
   if (len == 0) {
-    int rv = ares_set_servers(ares_channel, NULL);
+    int rv = ares_set_servers(env->cares_channel(), NULL);
     return args.GetReturnValue().Set(rv);
   }
 
@@ -982,7 +1041,7 @@ static void SetServers(const FunctionCallbackInfo<Value>& args) {
   }
 
   if (err == 0)
-    err = ares_set_servers(ares_channel, &servers[0]);
+    err = ares_set_servers(env->cares_channel(), &servers[0]);
   else
     err = ARES_EBADSTR;
 
@@ -999,28 +1058,29 @@ static void StrError(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-static void Initialize(Handle<Object> target) {
-  HandleScope scope(node_isolate);
-  int r;
+static void Initialize(Handle<Object> target,
+                       Handle<Value> unused,
+                       Handle<Context> context) {
+  Environment* env = Environment::GetCurrent(context);
 
-  r = ares_library_init(ARES_LIB_INIT_ALL);
+  int r = ares_library_init(ARES_LIB_INIT_ALL);
   assert(r == ARES_SUCCESS);
 
   struct ares_options options;
   memset(&options, 0, sizeof(options));
   options.flags = ARES_FLAG_NOCHECKRESP;
   options.sock_state_cb = ares_sockstate_cb;
-  options.sock_state_cb_data = uv_default_loop();
+  options.sock_state_cb_data = env;
 
   /* We do the call to ares_init_option for caller. */
-  r = ares_init_options(&ares_channel,
+  r = ares_init_options(env->cares_channel_ptr(),
                         &options,
                         ARES_OPT_FLAGS | ARES_OPT_SOCK_STATE_CB);
   assert(r == ARES_SUCCESS);
 
   /* Initialize the timeout timer. The timer won't be started until the */
   /* first socket is opened. */
-  uv_timer_init(uv_default_loop(), &ares_timer);
+  uv_timer_init(env->event_loop(), env->cares_timer_handle());
 
   NODE_SET_METHOD(target, "queryA", Query<QueryAWrap>);
   NODE_SET_METHOD(target, "queryAaaa", Query<QueryAaaaWrap>);
@@ -1045,11 +1105,9 @@ static void Initialize(Handle<Object> target) {
               Integer::New(AF_INET6, node_isolate));
   target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "AF_UNSPEC"),
               Integer::New(AF_UNSPEC, node_isolate));
-
-  oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
 }
 
 }  // namespace cares_wrap
 }  // namespace node
 
-NODE_MODULE(node_cares_wrap, node::cares_wrap::Initialize)
+NODE_MODULE_CONTEXT_AWARE(node_cares_wrap, node::cares_wrap::Initialize)
diff --git a/src/env-inl.h b/src/env-inl.h
new file mode 100644
index 0000000000..a8fcc58603
--- /dev/null
+++ b/src/env-inl.h
@@ -0,0 +1,289 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SRC_ENV_INL_H_
+#define SRC_ENV_INL_H_
+
+#include "env.h"
+#include "util.h"
+#include "util-inl.h"
+#include "uv.h"
+#include "v8.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+namespace node {
+
+inline Environment::IsolateData* Environment::IsolateData::GetOrCreate(
+    v8::Isolate* isolate) {
+  IsolateData* isolate_data = static_cast<IsolateData*>(isolate->GetData());
+  if (isolate_data == NULL) {
+    isolate_data = new IsolateData(isolate);
+    isolate->SetData(isolate_data);
+  }
+  isolate_data->ref_count_ += 1;
+  return isolate_data;
+}
+
+inline void Environment::IsolateData::Put() {
+  if (--ref_count_ == 0) {
+    isolate()->SetData(NULL);
+    delete this;
+  }
+}
+
+inline Environment::IsolateData::IsolateData(v8::Isolate* isolate)
+    : event_loop_(uv_default_loop())
+    , isolate_(isolate)
+#define V(PropertyName, StringValue)                                          \
+    , PropertyName ## _index_(                                                \
+        FIXED_ONE_BYTE_STRING(isolate, StringValue).Eternalize(isolate))
+    PER_ISOLATE_STRING_PROPERTIES(V)
+#undef V
+    , ref_count_(0) {
+}
+
+inline uv_loop_t* Environment::IsolateData::event_loop() const {
+  return event_loop_;
+}
+
+inline v8::Isolate* Environment::IsolateData::isolate() const {
+  return isolate_;
+}
+
+inline Environment::DomainFlag::DomainFlag() {
+  for (int i = 0; i < kFieldsCount; ++i) fields_[i] = 0;
+}
+
+inline uint32_t* Environment::DomainFlag::fields() {
+  return fields_;
+}
+
+inline int Environment::DomainFlag::fields_count() const {
+  return kFieldsCount;
+}
+
+inline uint32_t Environment::DomainFlag::count() const {
+  return fields_[kCount];
+}
+
+inline Environment::TickInfo::TickInfo() {
+  for (int i = 0; i < kFieldsCount; ++i) fields_[i] = 0;
+}
+
+inline uint32_t* Environment::TickInfo::fields() {
+  return fields_;
+}
+
+inline int Environment::TickInfo::fields_count() const {
+  return kFieldsCount;
+}
+
+inline uint32_t Environment::TickInfo::in_tick() const {
+  return fields_[kInTick];
+}
+
+inline uint32_t Environment::TickInfo::index() const {
+  return fields_[kIndex];
+}
+
+inline uint32_t Environment::TickInfo::last_threw() const {
+  return fields_[kLastThrew];
+}
+
+inline uint32_t Environment::TickInfo::length() const {
+  return fields_[kLength];
+}
+
+inline void Environment::TickInfo::set_index(uint32_t value) {
+  fields_[kIndex] = value;
+}
+
+inline void Environment::TickInfo::set_last_threw(uint32_t value) {
+  fields_[kLastThrew] = value;
+}
+
+inline Environment* Environment::New(v8::Local<v8::Context> context) {
+  Environment* env = new Environment(context);
+  context->SetAlignedPointerInEmbedderData(kContextEmbedderDataIndex, env);
+  return env;
+}
+
+inline Environment* Environment::GetCurrent(v8::Isolate* isolate) {
+  return GetCurrent(isolate->GetCurrentContext());
+}
+
+inline Environment* Environment::GetCurrent(v8::Local<v8::Context> context) {
+  return static_cast<Environment*>(
+      context->GetAlignedPointerFromEmbedderData(kContextEmbedderDataIndex));
+}
+
+inline Environment* Environment::GetCurrentChecked(v8::Isolate* isolate) {
+  if (isolate == NULL) {
+    return NULL;
+  } else {
+    return GetCurrentChecked(isolate->GetCurrentContext());
+  }
+}
+
+inline Environment* Environment::GetCurrentChecked(
+    v8::Local<v8::Context> context) {
+  if (context.IsEmpty()) {
+    return NULL;
+  } else {
+    return GetCurrent(context);
+  }
+}
+
+inline Environment::Environment(v8::Local<v8::Context> context)
+    : isolate_(context->GetIsolate())
+    , isolate_data_(IsolateData::GetOrCreate(context->GetIsolate()))
+    , using_smalloc_alloc_cb_(false)
+    , using_domains_(false)
+    , context_(context->GetIsolate(), context) {
+  // We'll be creating new objects so make sure we've entered the context.
+  v8::Context::Scope context_scope(context);
+  v8::HandleScope handle_scope(isolate());
+  set_binding_cache_object(v8::Object::New());
+  set_module_load_list_array(v8::Array::New());
+}
+
+inline Environment::~Environment() {
+  context()->SetAlignedPointerInEmbedderData(kContextEmbedderDataIndex, NULL);
+#define V(PropertyName, TypeName) PropertyName ## _.Dispose();
+  ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V)
+#undef V
+  isolate_data()->Put();
+}
+
+inline void Environment::Dispose() {
+  delete this;
+}
+
+inline v8::Isolate* Environment::isolate() const {
+  return isolate_;
+}
+
+inline bool Environment::in_domain() const {
+  // The const_cast is okay, it doesn't violate conceptual const-ness.
+  return using_domains() &&
+         const_cast<Environment*>(this)->domain_flag()->count() > 0;
+}
+
+inline Environment* Environment::from_immediate_check_handle(
+    uv_check_t* handle) {
+  return CONTAINER_OF(handle, Environment, immediate_check_handle_);
+}
+
+inline uv_check_t* Environment::immediate_check_handle() {
+  return &immediate_check_handle_;
+}
+
+inline uv_idle_t* Environment::immediate_idle_handle() {
+  return &immediate_idle_handle_;
+}
+
+inline uv_loop_t* Environment::event_loop() const {
+  return isolate_data()->event_loop();
+}
+
+inline Environment::DomainFlag* Environment::domain_flag() {
+  return &domain_flag_;
+}
+
+inline Environment::TickInfo* Environment::tick_info() {
+  return &tick_info_;
+}
+
+inline bool Environment::using_smalloc_alloc_cb() const {
+  return using_smalloc_alloc_cb_;
+}
+
+inline void Environment::set_using_smalloc_alloc_cb(bool value) {
+  using_smalloc_alloc_cb_ = value;
+}
+
+inline bool Environment::using_domains() const {
+  return using_domains_;
+}
+
+inline void Environment::set_using_domains(bool value) {
+  using_domains_ = value;
+}
+
+inline Environment* Environment::from_cares_timer_handle(uv_timer_t* handle) {
+  return CONTAINER_OF(handle, Environment, cares_timer_handle_);
+}
+
+inline uv_timer_t* Environment::cares_timer_handle() {
+  return &cares_timer_handle_;
+}
+
+inline ares_channel Environment::cares_channel() {
+  return cares_channel_;
+}
+
+// Only used in the call to ares_init_options().
+inline ares_channel* Environment::cares_channel_ptr() {
+  return &cares_channel_;
+}
+
+inline ares_task_list* Environment::cares_task_list() {
+  return &cares_task_list_;
+}
+
+inline Environment::IsolateData* Environment::isolate_data() const {
+  return isolate_data_;
+}
+
+#define V(PropertyName, StringValue)                                          \
+  inline                                                                      \
+  v8::Local<v8::String> Environment::IsolateData::PropertyName() const {      \
+    return v8::Local<v8::String>::GetEternal(isolate(),                       \
+                                             PropertyName ## _index_);        \
+  }
+  PER_ISOLATE_STRING_PROPERTIES(V)
+#undef V
+
+#define V(PropertyName, StringValue)                                          \
+  inline v8::Local<v8::String> Environment::PropertyName() const {            \
+    return isolate_data()->PropertyName();                                    \
+  }
+  PER_ISOLATE_STRING_PROPERTIES(V)
+#undef V
+
+#define V(PropertyName, TypeName)                                             \
+  inline v8::Local<TypeName> Environment::PropertyName() const {              \
+    return StrongPersistentToLocal(PropertyName ## _);                        \
+  }                                                                           \
+  inline void Environment::set_ ## PropertyName(v8::Local<TypeName> value) {  \
+    PropertyName ## _.Reset(isolate(), value);                                \
+  }
+  ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V)
+#undef V
+
+#undef ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES
+#undef PER_ISOLATE_STRING_PROPERTIES
+
+}  // namespace node
+
+#endif  // SRC_ENV_INL_H_
diff --git a/src/env.h b/src/env.h
new file mode 100644
index 0000000000..db8d660c30
--- /dev/null
+++ b/src/env.h
@@ -0,0 +1,324 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SRC_ENV_H_
+#define SRC_ENV_H_
+
+#include "ares.h"
+#include "tree.h"
+#include "util.h"
+#include "uv.h"
+#include "v8.h"
+
+#include <stdint.h>
+
+// Caveat emptor: we're going slightly crazy with macros here but the end
+// hopefully justifies the means. We have a lot of per-context properties
+// and adding and maintaining their getters and setters by hand would be
+// a nightmare so let's make the preprocessor generate them for us.
+//
+// Make sure that any macros defined here are undefined again at the bottom
+// of context-inl.h. The sole exception is NODE_CONTEXT_EMBEDDER_DATA_INDEX,
+// it may have been defined externally.
+namespace node {
+
+// Pick an index that's hopefully out of the way when we're embedded inside
+// another application. Performance-wise or memory-wise it doesn't matter:
+// Context::SetAlignedPointerInEmbedderData() is backed by a FixedArray,
+// worst case we pay a one-time penalty for resizing the array.
+#ifndef NODE_CONTEXT_EMBEDDER_DATA_INDEX
+#define NODE_CONTEXT_EMBEDDER_DATA_INDEX 32
+#endif
+
+// Strings are per-isolate primitives but Environment proxies them
+// for the sake of convenience.
+#define PER_ISOLATE_STRING_PROPERTIES(V)                                      \
+  V(DELETE_string, "DELETE")                                                  \
+  V(GET_string, "GET")                                                        \
+  V(HEAD_string, "HEAD")                                                      \
+  V(POST_string, "POST")                                                      \
+  V(PUT_string, "PUT")                                                        \
+  V(address_string, "address")                                                \
+  V(atime_string, "atime")                                                    \
+  V(birthtime_string, "birthtime")                                            \
+  V(blksize_string, "blksize")                                                \
+  V(blocks_string, "blocks")                                                  \
+  V(buffer_string, "buffer")                                                  \
+  V(bytes_string, "bytes")                                                    \
+  V(callback_string, "callback")                                              \
+  V(change_string, "change")                                                  \
+  V(close_string, "close")                                                    \
+  V(code_string, "code")                                                      \
+  V(ctime_string, "ctime")                                                    \
+  V(dev_string, "dev")                                                        \
+  V(disposed_string, "_disposed")                                             \
+  V(domain_string, "domain")                                                  \
+  V(enter_string, "enter")                                                    \
+  V(errno_string, "errno")                                                    \
+  V(exit_string, "exit")                                                      \
+  V(exponent_string, "exponent")                                              \
+  V(exports_string, "exports")                                                \
+  V(ext_key_usage_string, "ext_key_usage")                                    \
+  V(family_string, "family")                                                  \
+  V(fatal_exception_string, "_fatalException")                                \
+  V(fingerprint_string, "fingerprint")                                        \
+  V(gid_string, "gid")                                                        \
+  V(handle_string, "handle")                                                  \
+  V(headers_string, "headers")                                                \
+  V(heap_total_string, "heapTotal")                                           \
+  V(heap_used_string, "heapUsed")                                             \
+  V(immediate_callback_string, "_immediateCallback")                          \
+  V(ino_string, "ino")                                                        \
+  V(ipv4_string, "IPv4")                                                      \
+  V(ipv6_string, "IPv6")                                                      \
+  V(issuer_string, "issuer")                                                  \
+  V(method_string, "method")                                                  \
+  V(mode_string, "mode")                                                      \
+  V(modulus_string, "modulus")                                                \
+  V(mtime_string, "mtime")                                                    \
+  V(name_string, "name")                                                      \
+  V(nlink_string, "nlink")                                                    \
+  V(onchange_string, "onchange")                                              \
+  V(onclienthello_string, "onclienthello")                                    \
+  V(oncomplete_string, "oncomplete")                                          \
+  V(onconnection_string, "onconnection")                                      \
+  V(onerror_string, "onerror")                                                \
+  V(onexit_string, "onexit")                                                  \
+  V(onhandshakedone_string, "onhandshakedone")                                \
+  V(onhandshakestart_string, "onhandshakestart")                              \
+  V(onmessage_string, "onmessage")                                            \
+  V(onnewsession_string, "onnewsession")                                      \
+  V(onread_string, "onread")                                                  \
+  V(onsignal_string, "onsignal")                                              \
+  V(onstop_string, "onstop")                                                  \
+  V(path_string, "path")                                                      \
+  V(port_string, "port")                                                      \
+  V(rdev_string, "rdev")                                                      \
+  V(rename_string, "rename")                                                  \
+  V(rss_string, "rss")                                                        \
+  V(servername_string, "servername")                                          \
+  V(session_id_string, "sessionId")                                           \
+  V(should_keep_alive_string, "shouldKeepAlive")                              \
+  V(size_string, "size")                                                      \
+  V(smalloc_p_string, "_smalloc_p")                                           \
+  V(sni_context_string, "sni_context")                                        \
+  V(status_code_string, "statusCode")                                         \
+  V(subject_string, "subject")                                                \
+  V(subjectaltname_string, "subjectaltname")                                  \
+  V(syscall_string, "syscall")                                                \
+  V(tls_ticket_string, "tlsTicket")                                           \
+  V(uid_string, "uid")                                                        \
+  V(upgrade_string, "upgrade")                                                \
+  V(url_string, "url")                                                        \
+  V(valid_from_string, "valid_from")                                          \
+  V(valid_to_string, "valid_to")                                              \
+  V(version_major_string, "versionMajor")                                     \
+  V(version_minor_string, "versionMinor")                                     \
+  V(version_string, "version")                                                \
+  V(write_queue_size_string, "writeQueueSize")                                \
+
+#define ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V)                           \
+  V(binding_cache_object, v8::Object)                                         \
+  V(buffer_constructor_function, v8::Function)                                \
+  V(context, v8::Context)                                                     \
+  V(domain_array, v8::Array)                                                  \
+  V(module_load_list_array, v8::Array)                                        \
+  V(pipe_constructor_template, v8::FunctionTemplate)                          \
+  V(process_object, v8::Object)                                               \
+  V(script_context_constructor_template, v8::FunctionTemplate)                \
+  V(script_data_constructor_function, v8::Function)                           \
+  V(secure_context_constructor_template, v8::FunctionTemplate)                \
+  V(stats_constructor_function, v8::Function)                                 \
+  V(tcp_constructor_template, v8::FunctionTemplate)                           \
+  V(tick_callback_function, v8::Function)                                     \
+  V(tls_wrap_constructor_function, v8::Function)                              \
+  V(tty_constructor_template, v8::FunctionTemplate)                           \
+  V(udp_constructor_function, v8::Function)                                   \
+
+class Environment;
+
+// TODO(bnoordhuis) Rename struct, the ares_ prefix implies it's part
+// of the c-ares API while the _t suffix implies it's a typedef.
+struct ares_task_t {
+  Environment* env;
+  ares_socket_t sock;
+  uv_poll_t poll_watcher;
+  RB_ENTRY(ares_task_t) node;
+};
+
+RB_HEAD(ares_task_list, ares_task_t);
+
+class Environment {
+ public:
+  class DomainFlag {
+   public:
+    inline uint32_t* fields();
+    inline int fields_count() const;
+    inline uint32_t count() const;
+
+   private:
+    friend class Environment;  // So we can call the constructor.
+    inline DomainFlag();
+
+    enum Fields {
+      kCount,
+      kFieldsCount
+    };
+
+    uint32_t fields_[kFieldsCount];
+
+    DISALLOW_COPY_AND_ASSIGN(DomainFlag);
+  };
+
+  class TickInfo {
+   public:
+    inline uint32_t* fields();
+    inline int fields_count() const;
+    inline uint32_t in_tick() const;
+    inline uint32_t index() const;
+    inline uint32_t last_threw() const;
+    inline uint32_t length() const;
+    inline void set_index(uint32_t value);
+    inline void set_last_threw(uint32_t value);
+
+   private:
+    friend class Environment;  // So we can call the constructor.
+    inline TickInfo();
+
+    enum Fields {
+      kInTick,
+      kIndex,
+      kLastThrew,
+      kLength,
+      kFieldsCount
+    };
+
+    uint32_t fields_[kFieldsCount];
+
+    DISALLOW_COPY_AND_ASSIGN(TickInfo);
+  };
+
+  static inline Environment* GetCurrent(v8::Isolate* isolate);
+  static inline Environment* GetCurrent(v8::Local<v8::Context> context);
+  static inline Environment* GetCurrentChecked(v8::Isolate* isolate);
+  static inline Environment* GetCurrentChecked(v8::Local<v8::Context> context);
+
+  // See CreateEnvironment() in src/node.cc.
+  static inline Environment* New(v8::Local<v8::Context> context);
+  inline void Dispose();
+
+  inline v8::Isolate* isolate() const;
+  inline uv_loop_t* event_loop() const;
+  inline bool in_domain() const;
+
+  static inline Environment* from_immediate_check_handle(uv_check_t* handle);
+  inline uv_check_t* immediate_check_handle();
+  inline uv_idle_t* immediate_idle_handle();
+  inline DomainFlag* domain_flag();
+  inline TickInfo* tick_info();
+
+  static inline Environment* from_cares_timer_handle(uv_timer_t* handle);
+  inline uv_timer_t* cares_timer_handle();
+  inline ares_channel cares_channel();
+  inline ares_channel* cares_channel_ptr();
+  inline ares_task_list* cares_task_list();
+
+  inline bool using_smalloc_alloc_cb() const;
+  inline void set_using_smalloc_alloc_cb(bool value);
+
+  inline bool using_domains() const;
+  inline void set_using_domains(bool value);
+
+  // Strings are shared across shared contexts. The getters simply proxy to
+  // the per-isolate primitive.
+#define V(PropertyName, StringValue)                                          \
+  inline v8::Local<v8::String> PropertyName() const;
+  PER_ISOLATE_STRING_PROPERTIES(V)
+#undef V
+
+#define V(PropertyName, TypeName)                                             \
+  inline v8::Local<TypeName> PropertyName() const;                            \
+  inline void set_ ## PropertyName(v8::Local<TypeName> value);
+  ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V)
+#undef V
+
+ private:
+  class IsolateData;
+  inline explicit Environment(v8::Local<v8::Context> context);
+  inline ~Environment();
+  inline IsolateData* isolate_data() const;
+
+  enum ContextEmbedderDataIndex {
+    kContextEmbedderDataIndex = NODE_CONTEXT_EMBEDDER_DATA_INDEX
+  };
+
+  v8::Isolate* const isolate_;
+  IsolateData* const isolate_data_;
+  uv_check_t immediate_check_handle_;
+  uv_idle_t immediate_idle_handle_;
+  DomainFlag domain_flag_;
+  TickInfo tick_info_;
+  uv_timer_t cares_timer_handle_;
+  ares_channel cares_channel_;
+  ares_task_list cares_task_list_;
+  bool using_smalloc_alloc_cb_;
+  bool using_domains_;
+
+#define V(PropertyName, TypeName)                                             \
+  v8::Persistent<TypeName> PropertyName ## _;
+  ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V)
+#undef V
+
+  // Per-thread, reference-counted singleton.
+  class IsolateData {
+   public:
+    static inline IsolateData* GetOrCreate(v8::Isolate* isolate);
+    inline void Put();
+    inline uv_loop_t* event_loop() const;
+
+#define V(PropertyName, StringValue)                                          \
+    inline v8::Local<v8::String> PropertyName() const;
+    PER_ISOLATE_STRING_PROPERTIES(V)
+#undef V
+
+   private:
+    inline explicit IsolateData(v8::Isolate* isolate);
+    inline v8::Isolate* isolate() const;
+
+    uv_loop_t* const event_loop_;
+    v8::Isolate* const isolate_;
+
+#define V(PropertyName, StringValue)                                          \
+    const int PropertyName ## _index_;
+    PER_ISOLATE_STRING_PROPERTIES(V)
+#undef V
+
+    unsigned int ref_count_;
+
+    DISALLOW_COPY_AND_ASSIGN(IsolateData);
+  };
+
+  DISALLOW_COPY_AND_ASSIGN(Environment);
+};
+
+}  // namespace node
+
+#endif  // SRC_ENV_H_
diff --git a/src/fs_event_wrap.cc b/src/fs_event_wrap.cc
index 8906f43ee3..719ee8c7eb 100644
--- a/src/fs_event_wrap.cc
+++ b/src/fs_event_wrap.cc
@@ -19,6 +19,8 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+#include "env.h"
+#include "env-inl.h"
 #include "node.h"
 #include "handle_wrap.h"
 
@@ -26,6 +28,7 @@
 
 namespace node {
 
+using v8::Context;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::Handle;
@@ -36,19 +39,17 @@ using v8::Object;
 using v8::String;
 using v8::Value;
 
-static Cached<String> change_sym;
-static Cached<String> onchange_sym;
-static Cached<String> rename_sym;
-
 class FSEventWrap: public HandleWrap {
  public:
-  static void Initialize(Handle<Object> target);
+  static void Initialize(Handle<Object> target,
+                         Handle<Value> unused,
+                         Handle<Context> context);
   static void New(const FunctionCallbackInfo<Value>& args);
   static void Start(const FunctionCallbackInfo<Value>& args);
   static void Close(const FunctionCallbackInfo<Value>& args);
 
  private:
-  explicit FSEventWrap(Handle<Object> object);
+  FSEventWrap(Environment* env, Handle<Object> object);
   virtual ~FSEventWrap();
 
   static void OnEvent(uv_fs_event_t* handle, const char* filename, int events,
@@ -59,8 +60,8 @@ class FSEventWrap: public HandleWrap {
 };
 
 
-FSEventWrap::FSEventWrap(Handle<Object> object)
-    : HandleWrap(object, reinterpret_cast<uv_handle_t*>(&handle_)) {
+FSEventWrap::FSEventWrap(Environment* env, Handle<Object> object)
+    : HandleWrap(env, object, reinterpret_cast<uv_handle_t*>(&handle_)) {
   initialized_ = false;
 }
 
@@ -70,8 +71,11 @@ FSEventWrap::~FSEventWrap() {
 }
 
 
-void FSEventWrap::Initialize(Handle<Object> target) {
-  HandleScope scope(node_isolate);
+void FSEventWrap::Initialize(Handle<Object> target,
+                             Handle<Value> unused,
+                             Handle<Context> context) {
+  Environment* env = Environment::GetCurrent(context);
+  HandleScope handle_scope(env->isolate());
 
   Local<FunctionTemplate> t = FunctionTemplate::New(New);
   t->InstanceTemplate()->SetInternalFieldCount(1);
@@ -81,17 +85,13 @@ void FSEventWrap::Initialize(Handle<Object> target) {
   NODE_SET_PROTOTYPE_METHOD(t, "close", Close);
 
   target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "FSEvent"), t->GetFunction());
-
-  change_sym = FIXED_ONE_BYTE_STRING(node_isolate, "change");
-  onchange_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onchange");
-  rename_sym = FIXED_ONE_BYTE_STRING(node_isolate, "rename");
 }
 
 
 void FSEventWrap::New(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
   assert(args.IsConstructCall());
-  new FSEventWrap(args.This());
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  new FSEventWrap(env, args.This());
 }
 
 
@@ -107,7 +107,7 @@ void FSEventWrap::Start(const FunctionCallbackInfo<Value>& args) {
 
   String::Utf8Value path(args[0]);
 
-  int err = uv_fs_event_init(uv_default_loop(),
+  int err = uv_fs_event_init(wrap->env()->event_loop(),
                              &wrap->handle_,
                              *path,
                              OnEvent,
@@ -126,10 +126,11 @@ void FSEventWrap::Start(const FunctionCallbackInfo<Value>& args) {
 
 void FSEventWrap::OnEvent(uv_fs_event_t* handle, const char* filename,
     int events, int status) {
-  HandleScope scope(node_isolate);
-  Handle<String> eventStr;
-
   FSEventWrap* wrap = static_cast<FSEventWrap*>(handle->data);
+  Environment* env = wrap->env();
+
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
 
   assert(wrap->persistent().IsEmpty() == false);
 
@@ -144,20 +145,21 @@ void FSEventWrap::OnEvent(uv_fs_event_t* handle, const char* filename,
   // For now, ignore the UV_CHANGE event if UV_RENAME is also set. Make the
   // assumption that a rename implicitly means an attribute change. Not too
   // unreasonable, right? Still, we should revisit this before v1.0.
+  Local<String> event_string;
   if (status) {
-    eventStr = String::Empty(node_isolate);
+    event_string = String::Empty(node_isolate);
   } else if (events & UV_RENAME) {
-    eventStr = rename_sym;
+    event_string = env->rename_string();
   } else if (events & UV_CHANGE) {
-    eventStr = change_sym;
+    event_string = env->change_string();
   } else {
     assert(0 && "bad fs events flag");
     abort();
   }
 
-  Handle<Value> argv[3] = {
+  Local<Value> argv[] = {
     Integer::New(status, node_isolate),
-    eventStr,
+    event_string,
     Null(node_isolate)
   };
 
@@ -165,7 +167,11 @@ void FSEventWrap::OnEvent(uv_fs_event_t* handle, const char* filename,
     argv[2] = OneByteString(node_isolate, filename);
   }
 
-  MakeCallback(wrap->object(), onchange_sym, ARRAY_SIZE(argv), argv);
+  MakeCallback(env,
+               wrap->object(),
+               env->onchange_string(),
+               ARRAY_SIZE(argv),
+               argv);
 }
 
 
@@ -183,4 +189,4 @@ void FSEventWrap::Close(const FunctionCallbackInfo<Value>& args) {
 
 }  // namespace node
 
-NODE_MODULE(node_fs_event_wrap, node::FSEventWrap::Initialize)
+NODE_MODULE_CONTEXT_AWARE(node_fs_event_wrap, node::FSEventWrap::Initialize)
diff --git a/src/handle_wrap.cc b/src/handle_wrap.cc
index 858b55cdd4..05d4c4dddc 100644
--- a/src/handle_wrap.cc
+++ b/src/handle_wrap.cc
@@ -20,22 +20,23 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include "handle_wrap.h"
+#include "env.h"
+#include "env-inl.h"
 #include "node.h"
 #include "queue.h"
 
 namespace node {
 
+using v8::Context;
 using v8::FunctionCallbackInfo;
 using v8::Handle;
 using v8::HandleScope;
 using v8::Local;
 using v8::Object;
-using v8::String;
 using v8::Value;
 
 // defined in node.cc
 extern QUEUE handle_wrap_queue;
-static Cached<String> close_sym;
 
 
 void HandleWrap::Ref(const FunctionCallbackInfo<Value>& args) {
@@ -73,27 +74,26 @@ void HandleWrap::Close(const FunctionCallbackInfo<Value>& args) {
   // guard against uninitialized handle or double close
   if (wrap == NULL || wrap->handle__ == NULL) return;
 
+  Environment* env = wrap->env();
   assert(!wrap->persistent().IsEmpty());
   uv_close(wrap->handle__, OnClose);
   wrap->handle__ = NULL;
 
   if (args[0]->IsFunction()) {
-    if (close_sym.IsEmpty() == true) {
-      close_sym = FIXED_ONE_BYTE_STRING(node_isolate, "close");
-    }
-    wrap->object()->Set(close_sym, args[0]);
+    wrap->object()->Set(env->close_string(), args[0]);
     wrap->flags_ |= kCloseCallback;
   }
 }
 
 
-HandleWrap::HandleWrap(Handle<Object> object, uv_handle_t* h) {
-  flags_ = 0;
-  handle__ = h;
+HandleWrap::HandleWrap(Environment* env,
+                       Handle<Object> object,
+                       uv_handle_t* handle)
+    : env_(env)
+    , flags_(0)
+    , handle__(handle) {
   handle__->data = this;
-
   HandleScope scope(node_isolate);
-  assert(persistent().IsEmpty());
   persistent().Reset(node_isolate, object);
   NODE_WRAP(object, this);
   QUEUE_INSERT_TAIL(&handle_wrap_queue, &handle_wrap_queue_);
@@ -108,6 +108,7 @@ HandleWrap::~HandleWrap() {
 
 void HandleWrap::OnClose(uv_handle_t* handle) {
   HandleWrap* wrap = static_cast<HandleWrap*>(handle->data);
+  Environment* env = wrap->env();
 
   // The wrap object should still be there.
   assert(wrap->persistent().IsEmpty() == false);
@@ -115,12 +116,12 @@ void HandleWrap::OnClose(uv_handle_t* handle) {
   // But the handle pointer should be gone.
   assert(wrap->handle__ == NULL);
 
-  HandleScope scope(node_isolate);
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
   Local<Object> object = wrap->object();
 
   if (wrap->flags_ & kCloseCallback) {
-    assert(close_sym.IsEmpty() == false);
-    MakeCallback(object, close_sym, 0, NULL);
+    MakeCallback(env, object, env->close_string());
   }
 
   object->SetAlignedPointerInInternalField(0, NULL);
diff --git a/src/handle_wrap.h b/src/handle_wrap.h
index b5918f5dfe..73a43c3a3f 100644
--- a/src/handle_wrap.h
+++ b/src/handle_wrap.h
@@ -22,6 +22,7 @@
 #ifndef SRC_HANDLE_WRAP_H_
 #define SRC_HANDLE_WRAP_H_
 
+#include "env.h"
 #include "node.h"
 #include "queue.h"
 #include "uv.h"
@@ -58,11 +59,17 @@ class HandleWrap {
   inline uv_handle_t* GetHandle() { return handle__; }
 
  protected:
-  explicit HandleWrap(v8::Handle<v8::Object> object, uv_handle_t* handle);
+  HandleWrap(Environment* env,
+             v8::Handle<v8::Object> object,
+             uv_handle_t* handle);
   virtual ~HandleWrap();
 
+  inline Environment* env() const {
+    return env_;
+  }
+
   inline v8::Local<v8::Object> object() {
-    return PersistentToLocal(node_isolate, persistent());
+    return PersistentToLocal(env()->isolate(), persistent());
   }
 
   inline v8::Persistent<v8::Object>& persistent() {
@@ -74,10 +81,11 @@ class HandleWrap {
   static void OnClose(uv_handle_t* handle);
   v8::Persistent<v8::Object> object_;
   QUEUE handle_wrap_queue_;
+  Environment* const env_;
+  unsigned int flags_;
   // Using double underscore due to handle_ member in tcp_wrap. Probably
   // tcp_wrap should rename it's member to 'handle'.
   uv_handle_t* handle__;
-  unsigned int flags_;
 
   static const unsigned int kUnref = 1;
   static const unsigned int kCloseCallback = 2;
diff --git a/src/node.cc b/src/node.cc
index c88b0effba..4670151a8a 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -44,6 +44,8 @@
 #endif
 
 #include "ares.h"
+#include "env.h"
+#include "env-inl.h"
 #include "handle_wrap.h"
 #include "req_wrap.h"
 #include "string_bytes.h"
@@ -106,10 +108,7 @@ using v8::Message;
 using v8::Number;
 using v8::Object;
 using v8::ObjectTemplate;
-using v8::Persistent;
 using v8::PropertyCallbackInfo;
-using v8::ResourceConstraints;
-using v8::SetResourceConstraints;
 using v8::String;
 using v8::ThrowException;
 using v8::TryCatch;
@@ -118,43 +117,10 @@ using v8::V8;
 using v8::Value;
 using v8::kExternalUnsignedIntArray;
 
+// FIXME(bnoordhuis) Make these per-context?
 QUEUE handle_wrap_queue = { &handle_wrap_queue, &handle_wrap_queue };
 QUEUE req_wrap_queue = { &req_wrap_queue, &req_wrap_queue };
 
-// declared in req_wrap.h
-Cached<String> process_symbol;
-Cached<String> domain_symbol;
-
-// declared in node_internals.h
-Persistent<Object> process_p;
-
-static Persistent<Function> process_tickCallback;
-static Persistent<Object> binding_cache;
-static Persistent<Array> module_load_list;
-static Persistent<Array> p_domain_box;
-
-static Cached<String> exports_symbol;
-
-static Cached<String> errno_symbol;
-static Cached<String> syscall_symbol;
-static Cached<String> errpath_symbol;
-static Cached<String> code_symbol;
-
-static Cached<String> rss_symbol;
-static Cached<String> heap_total_symbol;
-static Cached<String> heap_used_symbol;
-
-static Cached<String> fatal_exception_symbol;
-
-static Cached<String> enter_symbol;
-static Cached<String> exit_symbol;
-static Cached<String> disposed_symbol;
-
-// Essential for node_wrap.h
-Persistent<FunctionTemplate> pipeConstructorTmpl;
-Persistent<FunctionTemplate> tcpConstructorTmpl;
-Persistent<FunctionTemplate> ttyConstructorTmpl;
-
 static bool print_eval = false;
 static bool force_repl = false;
 static bool trace_deprecation = false;
@@ -163,29 +129,10 @@ static const char* eval_string = NULL;
 static bool use_debug_agent = false;
 static bool debug_wait_connect = false;
 static int debug_port = 5858;
-bool using_domains = false;
 
 // used by C++ modules as well
 bool no_deprecation = false;
 
-static uv_check_t check_immediate_watcher;
-static uv_idle_t idle_immediate_dummy;
-static bool need_immediate_cb;
-static Cached<String> immediate_callback_sym;
-
-// for quick ref to tickCallback values
-static struct {
-  uint32_t length;
-  uint32_t index;
-  uint32_t in_tick;
-  uint32_t last_threw;
-} tick_infobox;
-
-// easily communicate domain depth
-static struct {
-  uint32_t count;
-} domain_flag;
-
 // process-relative uptime base, initialized at start-up
 static double prog_start_time;
 
@@ -227,24 +174,15 @@ void ArrayBufferAllocator::Free(void* data) {
 
 
 static void CheckImmediate(uv_check_t* handle, int status) {
-  assert(handle == &check_immediate_watcher);
-  assert(status == 0);
-
-  HandleScope scope(node_isolate);
-
-  if (immediate_callback_sym.IsEmpty()) {
-    immediate_callback_sym =
-        FIXED_ONE_BYTE_STRING(node_isolate, "_immediateCallback");
-  }
-
-  MakeCallback(process_p, immediate_callback_sym, 0, NULL);
+  Environment* env = Environment::from_immediate_check_handle(handle);
+  Context::Scope context_scope(env->context());
+  MakeCallback(env, env->process_object(), env->immediate_callback_string());
 }
 
 
-static void IdleImmediateDummy(uv_idle_t* handle, int status) {
-  // Do nothing. Only for maintaining event loop
-  assert(handle == &idle_immediate_dummy);
-  assert(status == 0);
+static void IdleImmediateDummy(uv_idle_t*, int) {
+  // Do nothing. Only for maintaining event loop.
+  // TODO(bnoordhuis) Maybe make libuv accept NULL idle callbacks.
 }
 
 
@@ -729,6 +667,8 @@ Local<Value> ErrnoException(int errorno,
                             const char *syscall,
                             const char *msg,
                             const char *path) {
+  Environment* env = Environment::GetCurrent(node_isolate);
+
   Local<Value> e;
   Local<String> estring = OneByteString(node_isolate, errno_string(errorno));
   if (msg == NULL || msg[0] == '\0') {
@@ -740,13 +680,6 @@ Local<Value> ErrnoException(int errorno,
       String::Concat(estring, FIXED_ONE_BYTE_STRING(node_isolate, ", "));
   Local<String> cons2 = String::Concat(cons1, message);
 
-  if (syscall_symbol.IsEmpty()) {
-    syscall_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "syscall");
-    errno_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "errno");
-    errpath_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "path");
-    code_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "code");
-  }
-
   if (path) {
     Local<String> cons3 =
         String::Concat(cons2, FIXED_ONE_BYTE_STRING(node_isolate, " '"));
@@ -760,11 +693,17 @@ Local<Value> ErrnoException(int errorno,
   }
 
   Local<Object> obj = e->ToObject();
+  obj->Set(env->errno_string(), Integer::New(errorno, node_isolate));
+  obj->Set(env->code_string(), estring);
+
+  if (path != NULL) {
+    obj->Set(env->path_string(), String::NewFromUtf8(node_isolate, path));
+  }
+
+  if (syscall != NULL) {
+    obj->Set(env->syscall_string(), OneByteString(node_isolate, syscall));
+  }
 
-  obj->Set(errno_symbol, Integer::New(errorno, node_isolate));
-  obj->Set(code_symbol, estring);
-  if (path) obj->Set(errpath_symbol, String::NewFromUtf8(node_isolate, path));
-  if (syscall) obj->Set(syscall_symbol, OneByteString(node_isolate, syscall));
   return e;
 }
 
@@ -774,12 +713,7 @@ Local<Value> UVException(int errorno,
                          const char *syscall,
                          const char *msg,
                          const char *path) {
-  if (syscall_symbol.IsEmpty()) {
-    syscall_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "syscall");
-    errno_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "errno");
-    errpath_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "path");
-    code_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "code");
-  }
+  Environment* env = Environment::GetCurrent(node_isolate);
 
   if (!msg || !msg[0])
     msg = uv_strerror(errorno);
@@ -820,12 +754,18 @@ Local<Value> UVException(int errorno,
   }
 
   Local<Object> obj = e->ToObject();
-
   // TODO(piscisaureus) errno should probably go
-  obj->Set(errno_symbol, Integer::New(errorno, node_isolate));
-  obj->Set(code_symbol, estring);
-  if (path) obj->Set(errpath_symbol, path_str);
-  if (syscall) obj->Set(syscall_symbol, OneByteString(node_isolate, syscall));
+  obj->Set(env->errno_string(), Integer::New(errorno, node_isolate));
+  obj->Set(env->code_string(), estring);
+
+  if (path != NULL) {
+    obj->Set(env->path_string(), path_str);
+  }
+
+  if (syscall != NULL) {
+    obj->Set(env->syscall_string(), OneByteString(node_isolate, syscall));
+  }
+
   return e;
 }
 
@@ -859,19 +799,14 @@ Local<Value> WinapiErrnoException(int errorno,
                                   const char* syscall,
                                   const char* msg,
                                   const char* path) {
+  Environment* env = Environment::GetCurrent(node_isolate);
+
   Local<Value> e;
   if (!msg || !msg[0]) {
     msg = winapi_strerror(errorno);
   }
   Local<String> message = OneByteString(node_isolate, msg);
 
-  if (syscall_symbol.IsEmpty()) {
-    syscall_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "syscall");
-    errno_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "errno");
-    errpath_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "path");
-    code_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "code");
-  }
-
   if (path) {
     Local<String> cons1 =
         String::Concat(message, FIXED_ONE_BYTE_STRING(node_isolate, " '"));
@@ -885,91 +820,92 @@ Local<Value> WinapiErrnoException(int errorno,
   }
 
   Local<Object> obj = e->ToObject();
+  obj->Set(env->errno_string(), Integer::New(errorno, node_isolate));
+
+  if (path != NULL) {
+    obj->Set(env->path_string(), String::NewFromUtf8(node_isolate, path));
+  }
+
+  if (syscall != NULL) {
+    obj->Set(env->syscall_string(), OneByteString(node_isolate, syscall));
+  }
 
-  obj->Set(errno_symbol, Integer::New(errorno, node_isolate));
-  if (path) obj->Set(errpath_symbol, String::NewFromUtf8(node_isolate, path));
-  if (syscall) obj->Set(syscall_symbol, OneByteString(node_isolate, syscall));
   return e;
 }
 #endif
 
 
 void SetupDomainUse(const FunctionCallbackInfo<Value>& args) {
-  if (using_domains) return;
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+
+  if (env->using_domains()) return;
+  env->set_using_domains(true);
+
   HandleScope scope(node_isolate);
-  using_domains = true;
-  Local<Object> process = PersistentToLocal(node_isolate, process_p);
-  Local<Value> tdc_v =
-      process->Get(FIXED_ONE_BYTE_STRING(node_isolate, "_tickDomainCallback"));
-  if (!tdc_v->IsFunction()) {
+  Local<Object> process_object = env->process_object();
+
+  Local<String> tick_callback_function_key =
+      FIXED_ONE_BYTE_STRING(node_isolate, "_tickDomainCallback");
+  Local<Function> tick_callback_function =
+      process_object->Get(tick_callback_function_key).As<Function>();
+
+  if (!tick_callback_function->IsFunction()) {
     fprintf(stderr, "process._tickDomainCallback assigned to non-function\n");
     abort();
   }
-  Local<Function> tdc = tdc_v.As<Function>();
-  process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "_tickCallback"), tdc);
-  process_tickCallback.Reset(node_isolate, tdc);
+
+  process_object->Set(FIXED_ONE_BYTE_STRING(node_isolate, "_tickCallback"),
+                      tick_callback_function);
+  env->set_tick_callback_function(tick_callback_function);
+
   if (!args[0]->IsArray()) {
     fprintf(stderr, "_setupDomainUse first argument must be an array\n");
     abort();
   }
-  p_domain_box.Reset(node_isolate, args[0].As<Array>());
+  env->set_domain_array(args[0].As<Array>());
+
   if (!args[1]->IsObject()) {
     fprintf(stderr, "_setupDomainUse second argument must be an object\n");
     abort();
   }
-  Local<Object> flag = args[1].As<Object>();
-  flag->SetIndexedPropertiesToExternalArrayData(&domain_flag,
-                                                kExternalUnsignedIntArray,
-                                                1);
-}
 
-
-bool InDomain() {
-  return using_domains && domain_flag.count > 0;
+  Local<Object> domain_flag_obj = args[1].As<Object>();
+  Environment::DomainFlag* domain_flag = env->domain_flag();
+  domain_flag_obj->SetIndexedPropertiesToExternalArrayData(
+      domain_flag->fields(),
+      kExternalUnsignedIntArray,
+      domain_flag->fields_count());
 }
 
 
-Handle<Value> GetDomain() {
-  // no domain can exist if no domain module has been loaded
-  if (!InDomain() || p_domain_box.IsEmpty())
-    return Null(node_isolate);
-
-  return PersistentToLocal(node_isolate, p_domain_box)->Get(0);
-}
-
+Handle<Value> MakeDomainCallback(Environment* env,
+                                 const Handle<Object> object,
+                                 const Handle<Function> callback,
+                                 int argc,
+                                 Handle<Value> argv[]) {
+  // If you hit this assertion, you forgot to enter the v8::Context first.
+  assert(env->context() == env->isolate()->GetCurrentContext());
 
-Handle<Value>
-MakeDomainCallback(const Handle<Object> object,
-                   const Handle<Function> callback,
-                   int argc,
-                   Handle<Value> argv[]) {
   // TODO(trevnorris) Hook for long stack traces to be made here.
 
-  // lazy load domain specific symbols
-  if (enter_symbol.IsEmpty()) {
-    enter_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "enter");
-    exit_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "exit");
-    disposed_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "_disposed");
-  }
-
-  Local<Value> domain_v = object->Get(domain_symbol);
+  Local<Value> domain_v = object->Get(env->domain_string());
   Local<Object> domain;
-  Local<Function> enter;
-  Local<Function> exit;
 
   TryCatch try_catch;
   try_catch.SetVerbose(true);
 
   bool has_domain = domain_v->IsObject();
   if (has_domain) {
-    domain = domain_v->ToObject();
-    assert(!domain.IsEmpty());
-    if (domain->Get(disposed_symbol)->IsTrue()) {
+    domain = domain_v.As<Object>();
+
+    if (domain->Get(env->disposed_string())->IsTrue()) {
       // domain has been disposed of.
       return Undefined(node_isolate);
     }
-    enter = Local<Function>::Cast(domain->Get(enter_symbol));
-    assert(!enter.IsEmpty());
+
+    Local<Function> enter =
+        domain->Get(env->enter_string()).As<Function>();
+    assert(enter->IsFunction());
     enter->Call(domain, 0, NULL);
 
     if (try_catch.HasCaught()) {
@@ -984,8 +920,9 @@ MakeDomainCallback(const Handle<Object> object,
   }
 
   if (has_domain) {
-    exit = Local<Function>::Cast(domain->Get(exit_symbol));
-    assert(!exit.IsEmpty());
+    Local<Function> exit =
+        domain->Get(env->exit_string()).As<Function>();
+    assert(exit->IsFunction());
     exit->Call(domain, 0, NULL);
 
     if (try_catch.HasCaught()) {
@@ -993,24 +930,26 @@ MakeDomainCallback(const Handle<Object> object,
     }
   }
 
-  if (tick_infobox.last_threw == 1) {
-    tick_infobox.last_threw = 0;
+  Environment::TickInfo* tick_info = env->tick_info();
+
+  if (tick_info->last_threw() == 1) {
+    tick_info->set_last_threw(0);
     return ret;
   }
 
-  if (tick_infobox.in_tick == 1) {
+  if (tick_info->in_tick() == 1) {
     return ret;
   }
 
-  if (tick_infobox.length == 0) {
-    tick_infobox.index = 0;
+  if (tick_info->length() == 0) {
+    tick_info->set_index(0);
     return ret;
   }
 
   // process nextTicks after call
-  Local<Object> process = PersistentToLocal(node_isolate, process_p);
-  Local<Function> fn = PersistentToLocal(node_isolate, process_tickCallback);
-  fn->Call(process, 0, NULL);
+  Local<Object> process_object = env->process_object();
+  Local<Function> tick_callback_function = env->tick_callback_function();
+  tick_callback_function->Call(process_object, 0, NULL);
 
   if (try_catch.HasCaught()) {
     return Undefined(node_isolate);
@@ -1020,27 +959,19 @@ MakeDomainCallback(const Handle<Object> object,
 }
 
 
-Handle<Value>
-MakeCallback(const Handle<Object> object,
-             const Handle<Function> callback,
-             int argc,
-             Handle<Value> argv[]) {
+Handle<Value> MakeCallback(Environment* env,
+                           const Handle<Object> object,
+                           const Handle<Function> callback,
+                           int argc,
+                           Handle<Value> argv[]) {
+  // If you hit this assertion, you forgot to enter the v8::Context first.
+  assert(env->context() == env->isolate()->GetCurrentContext());
+
   // TODO(trevnorris) Hook for long stack traces to be made here.
-  Local<Object> process = PersistentToLocal(node_isolate, process_p);
+  Local<Object> process_object = env->process_object();
 
-  if (using_domains)
-    return MakeDomainCallback(object, callback, argc, argv);
-
-  // lazy load no domain next tick callbacks
-  if (process_tickCallback.IsEmpty()) {
-    Local<Value> cb_v =
-        process->Get(FIXED_ONE_BYTE_STRING(node_isolate, "_tickCallback"));
-    if (!cb_v->IsFunction()) {
-      fprintf(stderr, "process._tickCallback assigned to non-function\n");
-      abort();
-    }
-    process_tickCallback.Reset(node_isolate, cb_v.As<Function>());
-  }
+  if (env->using_domains())
+    return MakeDomainCallback(env, object, callback, argc, argv);
 
   TryCatch try_catch;
   try_catch.SetVerbose(true);
@@ -1051,18 +982,33 @@ MakeCallback(const Handle<Object> object,
     return Undefined(node_isolate);
   }
 
-  if (tick_infobox.in_tick == 1) {
+  Environment::TickInfo* tick_info = env->tick_info();
+
+  if (tick_info->in_tick() == 1) {
     return ret;
   }
 
-  if (tick_infobox.length == 0) {
-    tick_infobox.index = 0;
+  if (tick_info->length() == 0) {
+    tick_info->set_index(0);
     return ret;
   }
 
+  // lazy load no domain next tick callbacks
+  Local<Function> tick_callback_function = env->tick_callback_function();
+  if (tick_callback_function.IsEmpty()) {
+    Local<String> tick_callback_function_key =
+        FIXED_ONE_BYTE_STRING(node_isolate, "_tickCallback");
+    tick_callback_function =
+        process_object->Get(tick_callback_function_key).As<Function>();
+    if (!tick_callback_function->IsFunction()) {
+      fprintf(stderr, "process._tickCallback assigned to non-function\n");
+      abort();
+    }
+    env->set_tick_callback_function(tick_callback_function);
+  }
+
   // process nextTicks after call
-  Local<Function> fn = PersistentToLocal(node_isolate, process_tickCallback);
-  fn->Call(process, 0, NULL);
+  tick_callback_function->Call(process_object, 0, NULL);
 
   if (try_catch.HasCaught()) {
     return Undefined(node_isolate);
@@ -1073,49 +1019,102 @@ MakeCallback(const Handle<Object> object,
 
 
 // Internal only.
-Handle<Value>
-MakeCallback(const Handle<Object> object,
-             uint32_t index,
-             int argc,
-             Handle<Value> argv[]) {
-  HandleScope scope(node_isolate);
+Handle<Value> MakeCallback(Environment* env,
+                           const Handle<Object> object,
+                           uint32_t index,
+                           int argc,
+                           Handle<Value> argv[]) {
+  // If you hit this assertion, you forgot to enter the v8::Context first.
+  assert(env->context() == env->isolate()->GetCurrentContext());
 
   Local<Function> callback = object->Get(index).As<Function>();
   assert(callback->IsFunction());
 
-  if (using_domains)
-    return scope.Close(MakeDomainCallback(object, callback, argc, argv));
-  return scope.Close(MakeCallback(object, callback, argc, argv));
+  if (env->using_domains()) {
+    return MakeDomainCallback(env, object, callback, argc, argv);
+  }
+
+  return MakeCallback(env, object, callback, argc, argv);
 }
 
 
-Handle<Value>
-MakeCallback(const Handle<Object> object,
-             const Handle<String> symbol,
-             int argc,
-             Handle<Value> argv[]) {
-  HandleScope scope(node_isolate);
+Handle<Value> MakeCallback(Environment* env,
+                           const Handle<Object> object,
+                           const Handle<String> symbol,
+                           int argc,
+                           Handle<Value> argv[]) {
+  // If you hit this assertion, you forgot to enter the v8::Context first.
+  assert(env->context() == env->isolate()->GetCurrentContext());
 
   Local<Function> callback = object->Get(symbol).As<Function>();
   assert(callback->IsFunction());
 
-  if (using_domains)
-    return scope.Close(MakeDomainCallback(object, callback, argc, argv));
-  return scope.Close(MakeCallback(object, callback, argc, argv));
-}
+  if (env->using_domains()) {
+    return MakeDomainCallback(env, object, callback, argc, argv);
+  }
 
+  return MakeCallback(env, object, callback, argc, argv);
+}
 
-Handle<Value>
-MakeCallback(const Handle<Object> object,
-             const char* method,
-             int argc,
-             Handle<Value> argv[]) {
-  HandleScope scope(node_isolate);
 
+Handle<Value> MakeCallback(Environment* env,
+                           const Handle<Object> object,
+                           const char* method,
+                           int argc,
+                           Handle<Value> argv[]) {
+  // If you hit this assertion, you forgot to enter the v8::Context first.
+  assert(env->context() == env->isolate()->GetCurrentContext());
   Local<String> method_string = OneByteString(node_isolate, method);
-  Handle<Value> ret = MakeCallback(object, method_string, argc, argv);
+  return MakeCallback(env, object, method_string, argc, argv);
+}
 
-  return scope.Close(ret);
+
+Handle<Value> MakeCallback(const Handle<Object> object,
+                           const char* method,
+                           int argc,
+                           Handle<Value> argv[]) {
+  Local<Context> context = object->CreationContext();
+  Environment* env = Environment::GetCurrent(context);
+  Context::Scope context_scope(context);
+  HandleScope handle_scope(env->isolate());
+  return handle_scope.Close(MakeCallback(env, object, method, argc, argv));
+}
+
+
+Handle<Value> MakeCallback(const Handle<Object> object,
+                           const Handle<String> symbol,
+                           int argc,
+                           Handle<Value> argv[]) {
+  Local<Context> context = object->CreationContext();
+  Environment* env = Environment::GetCurrent(context);
+  Context::Scope context_scope(context);
+  HandleScope handle_scope(env->isolate());
+  return handle_scope.Close(MakeCallback(env, object, symbol, argc, argv));
+}
+
+
+Handle<Value> MakeCallback(const Handle<Object> object,
+                           const Handle<Function> callback,
+                           int argc,
+                           Handle<Value> argv[]) {
+  Local<Context> context = object->CreationContext();
+  Environment* env = Environment::GetCurrent(context);
+  Context::Scope context_scope(context);
+  HandleScope handle_scope(env->isolate());
+  return handle_scope.Close(MakeCallback(env, object, callback, argc, argv));
+}
+
+
+Handle<Value> MakeDomainCallback(const Handle<Object> object,
+                                 const Handle<Function> callback,
+                                 int argc,
+                                 Handle<Value> argv[]) {
+  Local<Context> context = object->CreationContext();
+  Environment* env = Environment::GetCurrent(context);
+  Context::Scope context_scope(context);
+  HandleScope handle_scope(env->isolate());
+  return handle_scope.Close(
+      MakeDomainCallback(env, object, callback, argc, argv));
 }
 
 
@@ -1730,34 +1729,28 @@ static void Uptime(const FunctionCallbackInfo<Value>& args) {
 
 
 void MemoryUsage(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   size_t rss;
-
   int err = uv_resident_set_memory(&rss);
   if (err) {
     return ThrowUVException(err, "uv_resident_set_memory");
   }
 
-  Local<Object> info = Object::New();
-
-  if (rss_symbol.IsEmpty()) {
-    rss_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "rss");
-    heap_total_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "heapTotal");
-    heap_used_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "heapUsed");
-  }
-
-  info->Set(rss_symbol, Number::New(rss));
-
   // V8 memory usage
   HeapStatistics v8_heap_stats;
   node_isolate->GetHeapStatistics(&v8_heap_stats);
-  info->Set(heap_total_symbol,
-            Integer::NewFromUnsigned(v8_heap_stats.total_heap_size(),
-                                     node_isolate));
-  info->Set(heap_used_symbol,
-            Integer::NewFromUnsigned(v8_heap_stats.used_heap_size(),
-                                     node_isolate));
+
+  Local<Integer> heap_total =
+      Integer::NewFromUnsigned(v8_heap_stats.total_heap_size(), node_isolate);
+  Local<Integer> heap_used =
+      Integer::NewFromUnsigned(v8_heap_stats.used_heap_size(), node_isolate);
+
+  Local<Object> info = Object::New();
+  info->Set(env->rss_string(), Number::New(node_isolate, rss));
+  info->Set(env->heap_total_string(), heap_total);
+  info->Set(env->heap_used_string(), heap_used);
 
   args.GetReturnValue().Set(info);
 }
@@ -1811,8 +1804,13 @@ typedef void (UV_DYNAMIC* extInit)(Handle<Object> exports);
 
 // DLOpen is process.dlopen(module, filename).
 // Used to load 'module.node' dynamically shared objects.
+//
+// FIXME(bnoordhuis) Not multi-context ready. TBD how to resolve the conflict
+// when two contexts try to load the same shared object. Maybe have a shadow
+// cache that's a plain C list or hash table that's shared across contexts?
 void DLOpen(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
   char symbol[1024], *base, *pos;
   uv_lib_t lib;
   int r;
@@ -1824,13 +1822,11 @@ void DLOpen(const FunctionCallbackInfo<Value>& args) {
   Local<Object> module = args[0]->ToObject();  // Cast
   String::Utf8Value filename(args[1]);  // Cast
 
-  if (exports_symbol.IsEmpty()) {
-    exports_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "exports");
-  }
-  Local<Object> exports = module->Get(exports_symbol)->ToObject();
+  Local<String> exports_string = env->exports_string();
+  Local<Object> exports = module->Get(exports_string)->ToObject();
 
   if (uv_dlopen(*filename, &lib)) {
-    Local<String> errmsg = OneByteString(node_isolate, uv_dlerror(&lib));
+    Local<String> errmsg = OneByteString(env->isolate(), uv_dlerror(&lib));
 #ifdef _WIN32
     // Windows needs to add the filename into the error message
     errmsg = String::Concat(errmsg, args[1]->ToString());
@@ -1894,7 +1890,13 @@ void DLOpen(const FunctionCallbackInfo<Value>& args) {
   }
 
   // Execute the C++ module
-  mod->register_func(exports, module);
+  if (mod->register_context_func != NULL) {
+    mod->register_context_func(exports, module, env->context());
+  } else if (mod->register_func != NULL) {
+    mod->register_func(exports, module);
+  } else {
+    return ThrowError("Module has no declared entry point.");
+  }
 
   // Tell coverity that 'handle' should not be freed when we return.
   // coverity[leaked_storage]
@@ -1925,30 +1927,27 @@ NO_RETURN void FatalError(const char* location, const char* message) {
 void FatalException(Handle<Value> error, Handle<Message> message) {
   HandleScope scope(node_isolate);
 
-  if (fatal_exception_symbol.IsEmpty()) {
-    fatal_exception_symbol =
-        FIXED_ONE_BYTE_STRING(node_isolate, "_fatalException");
-  }
+  Environment* env = Environment::GetCurrent(node_isolate);
+  Local<Object> process_object = env->process_object();
+  Local<String> fatal_exception_string = env->fatal_exception_string();
+  Local<Function> fatal_exception_function =
+      process_object->Get(fatal_exception_string).As<Function>();
 
-  Local<Object> process = PersistentToLocal(node_isolate, process_p);
-  Local<Value> fatal_v = process->Get(fatal_exception_symbol);
-
-  if (!fatal_v->IsFunction()) {
+  if (!fatal_exception_function->IsFunction()) {
     // failed before the process._fatalException function was added!
     // this is probably pretty bad.  Nothing to do but report and exit.
     ReportException(error, message);
     exit(6);
   }
 
-  Local<Function> fatal_f = Local<Function>::Cast(fatal_v);
-
   TryCatch fatal_try_catch;
 
   // Do not call FatalException when _fatalException handler throws
   fatal_try_catch.SetVerbose(false);
 
   // this will return true if the JS layer handled it, false otherwise
-  Local<Value> caught = fatal_f->Call(process, 1, &error);
+  Local<Value> caught =
+      fatal_exception_function->Call(process_object, 1, &error);
 
   if (fatal_try_catch.HasCaught()) {
     // the fatal exception function threw, so we must exit
@@ -1979,13 +1978,13 @@ void OnMessage(Handle<Message> message, Handle<Value> error) {
 
 
 static void Binding(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   Local<String> module = args[0]->ToString();
   String::Utf8Value module_v(module);
-  node_module_struct* modp;
 
-  Local<Object> cache = PersistentToLocal(node_isolate, binding_cache);
+  Local<Object> cache = env->binding_cache_object();
   Local<Object> exports;
 
   if (cache->Has(module)) {
@@ -1998,15 +1997,18 @@ static void Binding(const FunctionCallbackInfo<Value>& args) {
   char buf[1024];
   snprintf(buf, sizeof(buf), "Binding %s", *module_v);
 
-  Local<Array> modules = PersistentToLocal(node_isolate, module_load_list);
+  Local<Array> modules = env->module_load_list_array();
   uint32_t l = modules->Length();
   modules->Set(l, OneByteString(node_isolate, buf));
 
-  if ((modp = get_builtin_module(*module_v)) != NULL) {
+  node_module_struct* mod = get_builtin_module(*module_v);
+  if (mod != NULL) {
     exports = Object::New();
-    // Internal bindings don't have a "module" object,
-    // only exports.
-    modp->register_func(exports, Undefined(node_isolate));
+    // Internal bindings don't have a "module" object, only exports.
+    assert(mod->register_func == NULL);
+    assert(mod->register_context_func != NULL);
+    Local<Value> unused = Undefined(env->isolate());
+    mod->register_context_func(exports, unused, env->context());
     cache->Set(module, exports);
   } else if (!strcmp(*module_v, "constants")) {
     exports = Object::New();
@@ -2254,28 +2256,37 @@ static void DebugEnd(const FunctionCallbackInfo<Value>& args);
 
 void NeedImmediateCallbackGetter(Local<String> property,
                                  const PropertyCallbackInfo<Value>& info) {
-  info.GetReturnValue().Set(need_immediate_cb);
+  Environment* env = Environment::GetCurrent(info.GetIsolate());
+  const uv_check_t* immediate_check_handle = env->immediate_check_handle();
+  bool active = uv_is_active(
+      reinterpret_cast<const uv_handle_t*>(immediate_check_handle));
+  info.GetReturnValue().Set(active);
 }
 
 
-static void NeedImmediateCallbackSetter(Local<String> property,
-                                        Local<Value> value,
-                                        const PropertyCallbackInfo<void>&) {
-  HandleScope scope(node_isolate);
+static void NeedImmediateCallbackSetter(
+    Local<String> property,
+    Local<Value> value,
+    const PropertyCallbackInfo<void>& info) {
+  Environment* env = Environment::GetCurrent(info.GetIsolate());
+  HandleScope handle_scope(info.GetIsolate());
 
-  bool bool_value = value->BooleanValue();
+  uv_check_t* immediate_check_handle = env->immediate_check_handle();
+  bool active = uv_is_active(
+      reinterpret_cast<const uv_handle_t*>(immediate_check_handle));
 
-  if (need_immediate_cb == bool_value) return;
+  if (active == value->BooleanValue())
+    return;
 
-  need_immediate_cb = bool_value;
+  uv_idle_t* immediate_idle_handle = env->immediate_idle_handle();
 
-  if (need_immediate_cb) {
-    uv_check_start(&check_immediate_watcher, node::CheckImmediate);
-    // idle handle is needed only to maintain event loop
-    uv_idle_start(&idle_immediate_dummy, node::IdleImmediateDummy);
+  if (active) {
+    uv_check_stop(immediate_check_handle);
+    uv_idle_stop(immediate_idle_handle);
   } else {
-    uv_check_stop(&check_immediate_watcher);
-    uv_idle_stop(&idle_immediate_dummy);
+    uv_check_start(immediate_check_handle, CheckImmediate);
+    // Idle handle is needed only to stop the event loop from blocking in poll.
+    uv_idle_start(immediate_idle_handle, IdleImmediateDummy);
   }
 }
 
@@ -2286,23 +2297,15 @@ static void NeedImmediateCallbackSetter(Local<String> property,
   } while (0)
 
 
-Handle<Object> SetupProcessObject(int argc,
-                                  const char* const* argv,
-                                  int exec_argc,
-                                  const char* const* exec_argv) {
+void SetupProcessObject(Environment* env,
+                        int argc,
+                        const char* const* argv,
+                        int exec_argc,
+                        const char* const* exec_argv) {
   HandleScope scope(node_isolate);
-
   int i, j;
 
-  Local<FunctionTemplate> process_template = FunctionTemplate::New();
-  process_template->SetClassName(
-      FIXED_ONE_BYTE_STRING(node_isolate, "process"));
-
-  Local<Object> process = process_template->GetFunction()->NewInstance();
-  assert(process.IsEmpty() == false);
-  assert(process->IsObject() == true);
-
-  process_p.Reset(node_isolate, process);
+  Local<Object> process = env->process_object();
 
   process->SetAccessor(FIXED_ONE_BYTE_STRING(node_isolate, "title"),
                        ProcessTitleGetter,
@@ -2314,9 +2317,9 @@ Handle<Object> SetupProcessObject(int argc,
                     FIXED_ONE_BYTE_STRING(node_isolate, NODE_VERSION));
 
   // process.moduleLoadList
-  Local<Array> modules = Array::New();
-  module_load_list.Reset(node_isolate, modules);
-  READONLY_PROPERTY(process, "moduleLoadList", modules);
+  READONLY_PROPERTY(process,
+                    "moduleLoadList",
+                    env->module_load_list_array());
 
   // process.versions
   Local<Object> versions = Object::New();
@@ -2367,8 +2370,6 @@ Handle<Object> SetupProcessObject(int argc,
       OneByteString(node_isolate, &OPENSSL_VERSION_TEXT[i], j - i));
 #endif
 
-
-
   // process.arch
   READONLY_PROPERTY(process, "arch", OneByteString(node_isolate, ARCH));
 
@@ -2392,15 +2393,15 @@ Handle<Object> SetupProcessObject(int argc,
   process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "execArgv"), exec_arguments);
 
   // create process.env
-  Local<ObjectTemplate> envTemplate = ObjectTemplate::New();
-  envTemplate->SetNamedPropertyHandler(EnvGetter,
-                                       EnvSetter,
-                                       EnvQuery,
-                                       EnvDeleter,
-                                       EnvEnumerator,
-                                       Object::New());
-  Local<Object> env = envTemplate->NewInstance();
-  process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "env"), env);
+  Local<ObjectTemplate> process_env_template = ObjectTemplate::New();
+  process_env_template->SetNamedPropertyHandler(EnvGetter,
+                                                EnvSetter,
+                                                EnvQuery,
+                                                EnvDeleter,
+                                                EnvEnumerator,
+                                                Object::New());
+  Local<Object> process_env = process_env_template->NewInstance();
+  process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "env"), process_env);
 
   READONLY_PROPERTY(process, "pid", Integer::New(getpid(), node_isolate));
   READONLY_PROPERTY(process, "features", GetFeatures());
@@ -2500,16 +2501,15 @@ Handle<Object> SetupProcessObject(int argc,
   NODE_SET_METHOD(process, "_setupDomainUse", SetupDomainUse);
 
   // values use to cross communicate with processNextTick
-  Local<Object> info_box = Object::New();
-  info_box->SetIndexedPropertiesToExternalArrayData(&tick_infobox,
-                                                    kExternalUnsignedIntArray,
-                                                    4);
-  process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "_tickInfoBox"), info_box);
+  Local<Object> tick_info_obj = Object::New();
+  tick_info_obj->SetIndexedPropertiesToExternalArrayData(
+      env->tick_info()->fields(),
+      kExternalUnsignedIntArray,
+      env->tick_info()->fields_count());
+  process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "_tickInfo"), tick_info_obj);
 
   // pre-set _events object for faster emit checks
   process->Set(FIXED_ONE_BYTE_STRING(node_isolate, "_events"), Object::New());
-
-  return scope.Close(process);
 }
 
 
@@ -2543,12 +2543,9 @@ static void RawDebug(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-void Load(Handle<Object> process_l) {
+void Load(Environment* env) {
   HandleScope handle_scope(node_isolate);
 
-  process_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "process");
-  domain_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "domain");
-
   // Compile, execute the src/node.js file. (Which was included as static C
   // string in node_natives.h. 'natve_node' is the string containing that
   // source code.)
@@ -2581,7 +2578,7 @@ void Load(Handle<Object> process_l) {
   // Node's I/O bindings may want to replace 'f' with their own function.
 
   // Add a reference to the global object
-  Local<Object> global = v8::Context::GetCurrent()->Global();
+  Local<Object> global = env->context()->Global();
 
 #if defined HAVE_DTRACE || defined HAVE_ETW || defined HAVE_SYSTEMTAP
   InitDTrace(global);
@@ -2599,9 +2596,9 @@ void Load(Handle<Object> process_l) {
   // thrown during process startup.
   try_catch.SetVerbose(true);
 
-  NODE_SET_METHOD(process_l, "_rawDebug", RawDebug);
+  NODE_SET_METHOD(env->process_object(), "_rawDebug", RawDebug);
 
-  Local<Value> arg = process_l;
+  Local<Value> arg = env->process_object();
   f->Call(global, 1, &arg);
 }
 
@@ -2797,15 +2794,17 @@ static void DispatchMessagesDebugAgentCallback() {
 
 // Called from the main thread
 static void EmitDebugEnabledAsyncCallback(uv_async_t* handle, int status) {
-  HandleScope handle_scope(node_isolate);
-  Local<Object> obj = Object::New();
-  obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "cmd"),
-           FIXED_ONE_BYTE_STRING(node_isolate, "NODE_DEBUG_ENABLED"));
+  Environment* env = Environment::GetCurrent(node_isolate);
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
+  Local<Object> message = Object::New();
+  message->Set(FIXED_ONE_BYTE_STRING(node_isolate, "cmd"),
+               FIXED_ONE_BYTE_STRING(node_isolate, "NODE_DEBUG_ENABLED"));
   Local<Value> args[] = {
     FIXED_ONE_BYTE_STRING(node_isolate, "internalMessage"),
-    obj
+    message
   };
-  MakeCallback(process_p, "emit", ARRAY_SIZE(args), args);
+  MakeCallback(env, env->process_object(), "emit", ARRAY_SIZE(args), args);
 }
 
 
@@ -2837,10 +2836,9 @@ static void EnableDebug(bool wait_connect) {
 
   debugger_running = true;
 
-  // Do not emit NODE_DEBUG_ENABLED when debugger is enabled before starting
-  // the main process (i.e. when called via `node --debug`)
-  if (!process_p.IsEmpty())
+  if (Environment::GetCurrentChecked(node_isolate) != NULL) {
     EmitDebugEnabled();
+  }
 
   node_isolate->Exit();
 }
@@ -3058,12 +3056,14 @@ void Init(int* argc,
   uv_disable_stdio_inheritance();
 
   // init async debug messages dispatching
+  // FIXME(bnoordhuis) Should be per-isolate or per-context, not global.
   uv_async_init(uv_default_loop(),
                 &dispatch_debug_messages_async,
                 DispatchDebugMessagesAsyncCallback);
   uv_unref(reinterpret_cast<uv_handle_t*>(&dispatch_debug_messages_async));
 
   // init async NODE_DEBUG_ENABLED emitter
+  // FIXME(bnoordhuis) Should be per-isolate or per-context, not global.
   uv_async_init(uv_default_loop(),
                 &emit_debug_enabled_async,
                 EmitDebugEnabledAsyncCallback);
@@ -3109,10 +3109,6 @@ void Init(int* argc,
   RegisterSignalHandler(SIGTERM, SignalExit);
 #endif  // __POSIX__
 
-  uv_check_init(uv_default_loop(), &check_immediate_watcher);
-  uv_unref(reinterpret_cast<uv_handle_t*>(&check_immediate_watcher));
-  uv_idle_init(uv_default_loop(), &idle_immediate_dummy);
-
   V8::SetFatalErrorHandler(node::OnFatalError);
   V8::AddMessageListener(OnMessage);
 
@@ -3123,6 +3119,7 @@ void Init(int* argc,
 #ifdef _WIN32
     RegisterDebugSignalHandler();
 #else  // Posix
+    // FIXME(bnoordhuis) Should be per-isolate or per-context, not global.
     static uv_signal_t signal_watcher;
     uv_signal_init(uv_default_loop(), &signal_watcher);
     uv_signal_start(&signal_watcher, EnableDebugSignalHandler, SIGUSR1);
@@ -3141,7 +3138,8 @@ struct AtExitCallback {
 static AtExitCallback* at_exit_functions_;
 
 
-void RunAtExit() {
+// TODO(bnoordhuis) Turn into per-context event.
+void RunAtExit(Environment* env) {
   AtExitCallback* p = at_exit_functions_;
   at_exit_functions_ = NULL;
 
@@ -3163,15 +3161,47 @@ void AtExit(void (*cb)(void* arg), void* arg) {
 }
 
 
-void EmitExit(v8::Handle<v8::Object> process_l) {
+void EmitExit(Environment* env) {
   // process.emit('exit')
-  process_l->Set(FIXED_ONE_BYTE_STRING(node_isolate, "_exiting"),
-                 True(node_isolate));
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
+  Local<Object> process_object = env->process_object();
+  process_object->Set(FIXED_ONE_BYTE_STRING(node_isolate, "_exiting"),
+                      True(node_isolate));
   Local<Value> args[] = {
     FIXED_ONE_BYTE_STRING(node_isolate, "exit"),
     Integer::New(0, node_isolate)
   };
-  MakeCallback(process_l, "emit", ARRAY_SIZE(args), args);
+  MakeCallback(env, process_object, "emit", ARRAY_SIZE(args), args);
+}
+
+
+Environment* CreateEnvironment(Isolate* isolate,
+                               int argc,
+                               const char* const* argv,
+                               int exec_argc,
+                               const char* const* exec_argv) {
+  HandleScope handle_scope(isolate);
+
+  Local<Context> context = Context::New(isolate);
+  Context::Scope context_scope(context);
+  Environment* env = Environment::New(context);
+
+  uv_check_init(env->event_loop(), env->immediate_check_handle());
+  uv_unref(
+      reinterpret_cast<uv_handle_t*>(env->immediate_check_handle()));
+  uv_idle_init(env->event_loop(), env->immediate_idle_handle());
+
+  Local<FunctionTemplate> process_template = FunctionTemplate::New();
+  process_template->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "process"));
+
+  Local<Object> process_object = process_template->GetFunction()->NewInstance();
+  env->set_process_object(process_object);
+
+  SetupProcessObject(env, argc, argv, exec_argc, exec_argv);
+  Load(env);
+
+  return env;
 }
 
 
@@ -3190,31 +3220,15 @@ int Start(int argc, char** argv) {
   V8::Initialize();
   {
     Locker locker(node_isolate);
-    HandleScope handle_scope(node_isolate);
-
-    // Create the one and only Context.
-    Local<Context> context = Context::New(node_isolate);
-    Context::Scope context_scope(context);
-
-    binding_cache.Reset(node_isolate, Object::New());
-
-    // Use original argv, as we're just copying values out of it.
-    Local<Object> process_l =
-        SetupProcessObject(argc, argv, exec_argc, exec_argv);
-
-    // Create all the objects, load modules, do everything.
-    // so your next reading stop should be node::Load()!
-    Load(process_l);
-
-    // All our arguments are loaded. We've evaluated all of the scripts. We
-    // might even have created TCP servers. Now we enter the main eventloop. If
-    // there are no watchers on the loop (except for the ones that were
-    // uv_unref'd) then this function exits. As long as there are active
-    // watchers, it blocks.
-    uv_run(uv_default_loop(), UV_RUN_DEFAULT);
-
-    EmitExit(process_l);
-    RunAtExit();
+    Environment* env =
+        CreateEnvironment(node_isolate, argc, argv, exec_argc, exec_argv);
+    Context::Scope context_scope(env->context());
+    HandleScope handle_scope(env->isolate());
+    uv_run(env->event_loop(), UV_RUN_DEFAULT);
+    EmitExit(env);
+    RunAtExit(env);
+    env->Dispose();
+    env = NULL;
   }
 
 #ifndef NDEBUG
diff --git a/src/node.h b/src/node.h
index 527ac25a35..00f60d3fb1 100644
--- a/src/node.h
+++ b/src/node.h
@@ -58,6 +58,7 @@
 # define SIGKILL         9
 #endif
 
+#include "v8.h"  // NOLINT(build/include_order)
 #include "node_version.h"  // NODE_MODULE_VERSION
 #include "node_object_wrap.h"
 
@@ -95,9 +96,6 @@ NODE_EXTERN v8::Handle<v8::Value> MakeCallback(
 #include "node_internals.h"
 #endif
 
-#include "uv.h"
-#include "v8.h"
-
 #include <assert.h>
 
 #ifndef NODE_STRINGIFY
@@ -185,9 +183,6 @@ NODE_EXTERN ssize_t DecodeWrite(char *buf,
                                 v8::Handle<v8::Value>,
                                 enum encoding encoding = BINARY);
 
-v8::Local<v8::Object> BuildStatsObject(const uv_stat_t* s);
-
-
 #ifdef _WIN32
 NODE_EXTERN v8::Local<v8::Value> WinapiErrnoException(int errorno,
     const char *syscall = NULL,  const char *msg = "",
@@ -197,14 +192,21 @@ NODE_EXTERN v8::Local<v8::Value> WinapiErrnoException(int errorno,
 const char *signo_string(int errorno);
 
 
-NODE_EXTERN typedef void (* addon_register_func)(
-    v8::Handle<v8::Object> exports, v8::Handle<v8::Value> module);
+NODE_EXTERN typedef void (*addon_register_func)(
+    v8::Handle<v8::Object> exports,
+    v8::Handle<v8::Value> module);
+
+NODE_EXTERN typedef void (*addon_context_register_func)(
+    v8::Handle<v8::Object> exports,
+    v8::Handle<v8::Value> module,
+    v8::Handle<v8::Context> context);
 
 struct node_module_struct {
   int version;
   void *dso_handle;
   const char *filename;
   node::addon_register_func register_func;
+  node::addon_context_register_func register_context_func;
   const char *modname;
 };
 
@@ -226,7 +228,19 @@ node_module_struct* get_builtin_module(const char *name);
     NODE_MODULE_EXPORT node::node_module_struct modname ## _module =  \
     {                                                                 \
       NODE_STANDARD_MODULE_STUFF,                                     \
-      (node::addon_register_func)regfunc,                             \
+      (node::addon_register_func) (regfunc),                          \
+      NULL,                                                           \
+      NODE_STRINGIFY(modname)                                         \
+    };                                                                \
+  }
+
+#define NODE_MODULE_CONTEXT_AWARE(modname, regfunc)                   \
+  extern "C" {                                                        \
+    NODE_MODULE_EXPORT node::node_module_struct modname ## _module =  \
+    {                                                                 \
+      NODE_STANDARD_MODULE_STUFF,                                     \
+      NULL,                                                           \
+      (regfunc),                                                      \
       NODE_STRINGIFY(modname)                                         \
     };                                                                \
   }
diff --git a/src/node.js b/src/node.js
index 3c7ede82b8..9ba1b3b4a0 100644
--- a/src/node.js
+++ b/src/node.js
@@ -273,16 +273,15 @@
   startup.processNextTick = function() {
     var nextTickQueue = [];
 
-    // this infoBox thing is used so that the C++ code in src/node.cc
-    // can have easy access to our nextTick state, and avoid unnecessary
-    // calls into process._tickCallback.
-    // order is [length, index, inTick, lastThrew]
-    // Never write code like this without very good reason!
-    var infoBox = process._tickInfoBox;
-    var length = 0;
-    var index = 1;
-    var inTick = 2;
-    var lastThrew = 3;
+    // This tickInfo thing is used so that the C++ code in src/node.cc
+    // can have easy accesss to our nextTick state, and avoid unnecessary
+    var tickInfo = process._tickInfo;
+
+    // *Must* match Environment::TickInfo::Fields in src/env.h.
+    var kInTick = 0;
+    var kIndex = 1;
+    var kLastThrew = 2;
+    var kLength = 3;
 
     process.nextTick = nextTick;
     // needs to be accessible from cc land
@@ -290,17 +289,17 @@
     process._tickDomainCallback = _tickDomainCallback;
 
     function tickDone() {
-      if (infoBox[length] !== 0) {
-        if (infoBox[length] <= infoBox[index]) {
+      if (tickInfo[kLength] !== 0) {
+        if (tickInfo[kLength] <= tickInfo[kIndex]) {
           nextTickQueue = [];
-          infoBox[length] = 0;
+          tickInfo[kLength] = 0;
         } else {
-          nextTickQueue.splice(0, infoBox[index]);
-          infoBox[length] = nextTickQueue.length;
+          nextTickQueue.splice(0, tickInfo[kIndex]);
+          tickInfo[kLength] = nextTickQueue.length;
         }
       }
-      infoBox[inTick] = 0;
-      infoBox[index] = 0;
+      tickInfo[kInTick] = 0;
+      tickInfo[kIndex] = 0;
     }
 
     // run callbacks that have no domain
@@ -308,10 +307,10 @@
     function _tickCallback() {
       var callback, threw;
 
-      infoBox[inTick] = 1;
+      tickInfo[kInTick] = 1;
 
-      while (infoBox[index] < infoBox[length]) {
-        callback = nextTickQueue[infoBox[index]++].callback;
+      while (tickInfo[kIndex] < tickInfo[kLength]) {
+        callback = nextTickQueue[tickInfo[kIndex]++].callback;
         threw = true;
         try {
           callback();
@@ -327,22 +326,22 @@
     function _tickDomainCallback() {
       var tock, callback, domain;
 
-      infoBox[inTick] = 1;
+      tickInfo[kInTick] = 1;
 
-      while (infoBox[index] < infoBox[length]) {
-        tock = nextTickQueue[infoBox[index]++];
+      while (tickInfo[kIndex] < tickInfo[kLength]) {
+        tock = nextTickQueue[tickInfo[kIndex]++];
         callback = tock.callback;
         domain = tock.domain;
         if (domain) {
           if (domain._disposed) continue;
           domain.enter();
         }
-        infoBox[lastThrew] = 1;
+        tickInfo[kLastThrew] = 1;
         try {
           callback();
-          infoBox[lastThrew] = 0;
+          tickInfo[kLastThrew] = 0;
         } finally {
-          if (infoBox[lastThrew] === 1) tickDone();
+          if (tickInfo[kLastThrew] === 1) tickDone();
         }
         if (domain)
           domain.exit();
@@ -360,7 +359,7 @@
         callback: callback,
         domain: process.domain || null
       });
-      infoBox[length]++;
+      tickInfo[kLength]++;
     }
   };
 
diff --git a/src/node_buffer.cc b/src/node_buffer.cc
index 519fddf4c1..2e7374971c 100644
--- a/src/node_buffer.cc
+++ b/src/node_buffer.cc
@@ -22,11 +22,13 @@
 
 #include "node.h"
 #include "node_buffer.h"
+
+#include "env.h"
+#include "env-inl.h"
 #include "smalloc.h"
 #include "string_bytes.h"
-
-#include "v8.h"
 #include "v8-profiler.h"
+#include "v8.h"
 
 #include <assert.h>
 #include <string.h>
@@ -55,6 +57,7 @@
 namespace node {
 namespace Buffer {
 
+using v8::Context;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
@@ -63,13 +66,10 @@ using v8::HandleScope;
 using v8::Local;
 using v8::Number;
 using v8::Object;
-using v8::Persistent;
 using v8::String;
 using v8::Uint32;
 using v8::Value;
 
-static Persistent<Function> p_buffer_fn;
-
 
 bool HasInstance(Handle<Value> val) {
   return val->IsObject() && HasInstance(val.As<Object>());
@@ -124,12 +124,20 @@ Local<Object> New(Handle<String> string, enum encoding enc) {
 
 
 Local<Object> New(size_t length) {
+  Environment* env = Environment::GetCurrent(node_isolate);
+  return Buffer::New(env, length);
+}
+
+
+// TODO(trevnorris): these have a flaw by needing to call the Buffer inst then
+// Alloc. continue to look for a better architecture.
+Local<Object> New(Environment* env, size_t length) {
   HandleScope scope(node_isolate);
 
   assert(length <= kMaxLength);
 
   Local<Value> arg = Uint32::NewFromUnsigned(length, node_isolate);
-  Local<Object> obj = NewInstance(p_buffer_fn, 1, &arg);
+  Local<Object> obj = env->buffer_constructor_function()->NewInstance(1, &arg);
 
   // TODO(trevnorris): done like this to handle HasInstance since only checks
   // if external array data has been set, but would like to use a better
@@ -148,16 +156,22 @@ Local<Object> New(size_t length) {
 }
 
 
+Local<Object> New(const char* data, size_t length) {
+  Environment* env = Environment::GetCurrent(node_isolate);
+  return Buffer::New(env, data, length);
+}
+
+
 // TODO(trevnorris): for backwards compatibility this is left to copy the data,
 // but for consistency w/ the other should use data. And a copy version renamed
 // to something else.
-Local<Object> New(const char* data, size_t length) {
+Local<Object> New(Environment* env, const char* data, size_t length) {
   HandleScope scope(node_isolate);
 
   assert(length <= kMaxLength);
 
   Local<Value> arg = Uint32::NewFromUnsigned(length, node_isolate);
-  Local<Object> obj = NewInstance(p_buffer_fn, 1, &arg);
+  Local<Object> obj = env->buffer_constructor_function()->NewInstance(1, &arg);
 
   // TODO(trevnorris): done like this to handle HasInstance since only checks
   // if external array data has been set, but would like to use a better
@@ -182,12 +196,22 @@ Local<Object> New(char* data,
                   size_t length,
                   smalloc::FreeCallback callback,
                   void* hint) {
+  Environment* env = Environment::GetCurrent(node_isolate);
+  return Buffer::New(env, data, length, callback, hint);
+}
+
+
+Local<Object> New(Environment* env,
+                  char* data,
+                  size_t length,
+                  smalloc::FreeCallback callback,
+                  void* hint) {
   HandleScope scope(node_isolate);
 
   assert(length <= kMaxLength);
 
   Local<Value> arg = Uint32::NewFromUnsigned(length, node_isolate);
-  Local<Object> obj = NewInstance(p_buffer_fn, 1, &arg);
+  Local<Object> obj = env->buffer_constructor_function()->NewInstance(1, &arg);
 
   smalloc::Alloc(obj, data, length, callback, hint);
 
@@ -196,12 +220,18 @@ Local<Object> New(char* data,
 
 
 Local<Object> Use(char* data, uint32_t length) {
+  Environment* env = Environment::GetCurrent(node_isolate);
+  return Buffer::Use(env, data, length);
+}
+
+
+Local<Object> Use(Environment* env, char* data, uint32_t length) {
   HandleScope scope(node_isolate);
 
   assert(length <= kMaxLength);
 
   Local<Value> arg = Uint32::NewFromUnsigned(length, node_isolate);
-  Local<Object> obj = NewInstance(p_buffer_fn, 1, &arg);
+  Local<Object> obj = env->buffer_constructor_function()->NewInstance(1, &arg);
 
   smalloc::Alloc(obj, data, length);
 
@@ -534,12 +564,13 @@ void ByteLength(const FunctionCallbackInfo<Value> &args) {
 
 // pass Buffer object to load prototype methods
 void SetupBufferJS(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   assert(args[0]->IsFunction());
 
   Local<Function> bv = args[0].As<Function>();
-  p_buffer_fn.Reset(node_isolate, bv);
+  env->set_buffer_constructor_function(bv);
   Local<Value> proto_v =
       bv->Get(FIXED_ONE_BYTE_STRING(node_isolate, "prototype"));
 
@@ -588,10 +619,12 @@ void SetupBufferJS(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-void Initialize(Handle<Object> target) {
-  HandleScope scope(node_isolate);
-
-  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "setupBufferJS"),
+void Initialize(Handle<Object> target,
+                Handle<Value> unused,
+                Handle<Context> context) {
+  Environment* env = Environment::GetCurrent(context);
+  HandleScope handle_scope(env->isolate());
+  target->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "setupBufferJS"),
               FunctionTemplate::New(SetupBufferJS)->GetFunction());
 }
 
@@ -599,4 +632,4 @@ void Initialize(Handle<Object> target) {
 }  // namespace Buffer
 }  // namespace node
 
-NODE_MODULE(node_buffer, node::Buffer::Initialize)
+NODE_MODULE_CONTEXT_AWARE(node_buffer, node::Buffer::Initialize)
diff --git a/src/node_buffer.h b/src/node_buffer.h
index ca9a135e9d..78e6e42f6c 100644
--- a/src/node_buffer.h
+++ b/src/node_buffer.h
@@ -26,6 +26,10 @@
 #include "smalloc.h"
 #include "v8.h"
 
+#if defined(NODE_WANT_INTERNALS)
+#include "env.h"
+#endif  // defined(NODE_WANT_INTERNALS)
+
 namespace node {
 namespace Buffer {
 
@@ -56,6 +60,20 @@ NODE_EXTERN v8::Local<v8::Object> New(char* data,
 // TODO(trevnorris): should be New() for consistency
 NODE_EXTERN v8::Local<v8::Object> Use(char* data, uint32_t len);
 
+// Internal. Not for public consumption. We can't define these in
+// src/node_internals.h due to a circular dependency issue with
+// the smalloc.h and node_internals.h headers.
+#if defined(NODE_WANT_INTERNALS)
+v8::Local<v8::Object> New(Environment* env, size_t size);
+v8::Local<v8::Object> New(Environment* env, const char* data, size_t len);
+v8::Local<v8::Object> New(Environment* env,
+                          char* data,
+                          size_t length,
+                          smalloc::FreeCallback callback,
+                          void* hint);
+v8::Local<v8::Object> Use(Environment* env, char* data, uint32_t length);
+#endif  // defined(NODE_WANT_INTERNALS)
+
 }  // namespace Buffer
 }  // namespace node
 
diff --git a/src/node_contextify.cc b/src/node_contextify.cc
index 331dbdb6e9..132fa911de 100644
--- a/src/node_contextify.cc
+++ b/src/node_contextify.cc
@@ -22,6 +22,8 @@
 #include "node.h"
 #include "node_internals.h"
 #include "node_watchdog.h"
+#include "env.h"
+#include "env-inl.h"
 
 namespace node {
 
@@ -33,6 +35,7 @@ using v8::External;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
+using v8::Handle;
 using v8::HandleScope;
 using v8::Integer;
 using v8::Isolate;
@@ -51,18 +54,17 @@ using v8::Value;
 
 class ContextifyContext {
  private:
+  Environment* const env_;
   Persistent<Object> sandbox_;
-  Persistent<Object> proxy_global_;
   Persistent<Context> context_;
-  static Persistent<Function> data_wrapper_ctor;
+  Persistent<Object> proxy_global_;
 
  public:
-  explicit ContextifyContext(Local<Object> sandbox) :
-      sandbox_(node_isolate, sandbox) {
-    HandleScope scope(node_isolate);
-    Local<Context> v8_context = CreateV8Context();
-    context_.Reset(node_isolate, v8_context);
-    proxy_global_.Reset(node_isolate, v8_context->Global());
+  explicit ContextifyContext(Environment* env, Local<Object> sandbox)
+      : env_(env)
+      , sandbox_(env->isolate(), sandbox)
+      , context_(env->isolate(), CreateV8Context(env))
+      , proxy_global_(env->isolate(), context()->Global()) {
     sandbox_.MakeWeak(this, SandboxFreeCallback);
     sandbox_.MarkIndependent();
   }
@@ -75,21 +77,31 @@ class ContextifyContext {
   }
 
 
+  inline Environment* env() const {
+    return env_;
+  }
+
+
+  inline Local<Context> context() const {
+    return PersistentToLocal(env()->isolate(), context_);
+  }
+
+
   // This is an object that just keeps an internal pointer to this
   // ContextifyContext.  It's passed to the NamedPropertyHandler.  If we
   // pass the main JavaScript context object we're embedded in, then the
   // NamedPropertyHandler will store a reference to it forever and keep it
   // from getting gc'd.
-  Local<Value> CreateDataWrapper() {
+  Local<Value> CreateDataWrapper(Environment* env) {
     HandleScope scope(node_isolate);
-    Local<Function> ctor = PersistentToLocal(node_isolate, data_wrapper_ctor);
-    Local<Object> wrapper = ctor->NewInstance();
+    Local<Object> wrapper =
+        env->script_data_constructor_function()->NewInstance();
     NODE_WRAP(wrapper, this);
     return scope.Close(wrapper);
   }
 
 
-  Local<Context> CreateV8Context() {
+  Local<Context> CreateV8Context(Environment* env) {
     HandleScope scope(node_isolate);
     Local<FunctionTemplate> function_template = FunctionTemplate::New();
     function_template->SetHiddenPrototype(true);
@@ -104,19 +116,17 @@ class ContextifyContext {
                                              GlobalPropertyQueryCallback,
                                              GlobalPropertyDeleterCallback,
                                              GlobalPropertyEnumeratorCallback,
-                                             CreateDataWrapper());
+                                             CreateDataWrapper(env));
     object_template->SetAccessCheckCallbacks(GlobalPropertyNamedAccessCheck,
                                              GlobalPropertyIndexedAccessCheck);
     return scope.Close(Context::New(node_isolate, NULL, object_template));
   }
 
 
-  static void Init(Local<Object> target) {
-    HandleScope scope(node_isolate);
-
+  static void Init(Environment* env, Local<Object> target) {
     Local<FunctionTemplate> function_template = FunctionTemplate::New();
     function_template->InstanceTemplate()->SetInternalFieldCount(1);
-    data_wrapper_ctor.Reset(node_isolate, function_template->GetFunction());
+    env->set_script_data_constructor_function(function_template->GetFunction());
 
     NODE_SET_METHOD(target, "makeContext", MakeContext);
     NODE_SET_METHOD(target, "isContext", IsContext);
@@ -124,7 +134,8 @@ class ContextifyContext {
 
 
   static void MakeContext(const FunctionCallbackInfo<Value>& args) {
-    HandleScope scope(node_isolate);
+    Environment* env = Environment::GetCurrent(args.GetIsolate());
+    HandleScope handle_scope(args.GetIsolate());
 
     if (!args[0]->IsObject()) {
       return ThrowTypeError("sandbox argument must be an object.");
@@ -137,7 +148,7 @@ class ContextifyContext {
     // Don't allow contextifying a sandbox multiple times.
     assert(sandbox->GetHiddenValue(hidden_name).IsEmpty());
 
-    ContextifyContext* context = new ContextifyContext(sandbox);
+    ContextifyContext* context = new ContextifyContext(env, sandbox);
     Local<External> hidden_context = External::New(context);
     sandbox->SetHiddenValue(hidden_name, hidden_context);
   }
@@ -179,18 +190,6 @@ class ContextifyContext {
     return static_cast<ContextifyContext*>(context_external->Value());
   }
 
-  static Local<Context> V8ContextFromContextifiedSandbox(
-      const Local<Object>& sandbox) {
-    ContextifyContext* contextify_context =
-        ContextFromContextifiedSandbox(sandbox);
-    if (contextify_context == NULL) {
-      ThrowTypeError("sandbox argument must have been converted to a context.");
-      return Local<Context>();
-    }
-
-    return PersistentToLocal(node_isolate, contextify_context->context_);
-  }
-
 
   static bool GlobalPropertyNamedAccessCheck(Local<Object> host,
                                              Local<Value> key,
@@ -300,24 +299,21 @@ class ContextifyScript : ObjectWrap {
   Persistent<Script> script_;
 
  public:
-  static Persistent<FunctionTemplate> script_tmpl;
-
-  static void Init(Local<Object> target) {
+  static void Init(Environment* env, Local<Object> target) {
     HandleScope scope(node_isolate);
     Local<String> class_name =
         FIXED_ONE_BYTE_STRING(node_isolate, "ContextifyScript");
 
-    script_tmpl.Reset(node_isolate, FunctionTemplate::New(New));
-    Local<FunctionTemplate> lscript_tmpl =
-        PersistentToLocal(node_isolate, script_tmpl);
-    lscript_tmpl->InstanceTemplate()->SetInternalFieldCount(1);
-    lscript_tmpl->SetClassName(class_name);
-    NODE_SET_PROTOTYPE_METHOD(lscript_tmpl, "runInContext", RunInContext);
-    NODE_SET_PROTOTYPE_METHOD(lscript_tmpl,
+    Local<FunctionTemplate> script_tmpl = FunctionTemplate::New(New);
+    script_tmpl->InstanceTemplate()->SetInternalFieldCount(1);
+    script_tmpl->SetClassName(class_name);
+    NODE_SET_PROTOTYPE_METHOD(script_tmpl, "runInContext", RunInContext);
+    NODE_SET_PROTOTYPE_METHOD(script_tmpl,
                               "runInThisContext",
                               RunInThisContext);
 
-    target->Set(class_name, lscript_tmpl->GetFunction());
+    target->Set(class_name, script_tmpl->GetFunction());
+    env->set_script_context_constructor_template(script_tmpl);
   }
 
 
@@ -357,15 +353,16 @@ class ContextifyScript : ObjectWrap {
   }
 
 
-  static bool InstanceOf(const Local<Value>& value) {
+  static bool InstanceOf(Environment* env, const Local<Value>& value) {
     return !value.IsEmpty() &&
-        PersistentToLocal(node_isolate, script_tmpl)->HasInstance(value);
+           env->script_context_constructor_template()->HasInstance(value);
   }
 
 
   // args: [options]
   static void RunInThisContext(const FunctionCallbackInfo<Value>& args) {
-    HandleScope scope(node_isolate);
+    Environment* env = Environment::GetCurrent(args.GetIsolate());
+    HandleScope handle_scope(args.GetIsolate());
 
     // Assemble arguments
     TryCatch try_catch;
@@ -377,7 +374,7 @@ class ContextifyScript : ObjectWrap {
     }
 
     // Do the eval within this context
-    EvalMachine(timeout, display_errors, args, try_catch);
+    EvalMachine(env, timeout, display_errors, args, try_catch);
   }
 
   // args: sandbox, [options]
@@ -398,16 +395,20 @@ class ContextifyScript : ObjectWrap {
     }
 
     // Get the context from the sandbox
-    Local<Context> context =
-        ContextifyContext::V8ContextFromContextifiedSandbox(sandbox);
-    if (try_catch.HasCaught()) {
-      try_catch.ReThrow();
-      return;
+    ContextifyContext* contextify_context =
+        ContextifyContext::ContextFromContextifiedSandbox(sandbox);
+    if (contextify_context == NULL) {
+      return ThrowTypeError(
+          "sandbox argument must have been converted to a context.");
     }
 
     // Do the eval within the context
-    Context::Scope context_scope(context);
-    EvalMachine(timeout, display_errors, args, try_catch);
+    Context::Scope context_scope(contextify_context->context());
+    EvalMachine(contextify_context->env(),
+                timeout,
+                display_errors,
+                args,
+                try_catch);
   }
 
   static int64_t GetTimeoutArg(const FunctionCallbackInfo<Value>& args,
@@ -475,11 +476,12 @@ class ContextifyScript : ObjectWrap {
   }
 
 
-  static void EvalMachine(const int64_t timeout,
+  static void EvalMachine(Environment* env,
+                          const int64_t timeout,
                           const bool display_errors,
                           const FunctionCallbackInfo<Value>& args,
                           TryCatch& try_catch) {
-    if (!ContextifyScript::InstanceOf(args.This())) {
+    if (!ContextifyScript::InstanceOf(env, args.This())) {
       return ThrowTypeError(
           "Script methods can only be called on script instances.");
     }
@@ -521,15 +523,14 @@ class ContextifyScript : ObjectWrap {
 };
 
 
-Persistent<Function> ContextifyContext::data_wrapper_ctor;
-Persistent<FunctionTemplate> ContextifyScript::script_tmpl;
-
-void InitContextify(Local<Object> target) {
-  HandleScope scope(node_isolate);
-  ContextifyContext::Init(target);
-  ContextifyScript::Init(target);
+void InitContextify(Handle<Object> target,
+                    Handle<Value> unused,
+                    Handle<Context> context) {
+  Environment* env = Environment::GetCurrent(context);
+  ContextifyContext::Init(env, target);
+  ContextifyScript::Init(env, target);
 }
 
 }  // namespace node
 
-NODE_MODULE(node_contextify, node::InitContextify);
+NODE_MODULE_CONTEXT_AWARE(node_contextify, node::InitContextify);
diff --git a/src/node_crypto.cc b/src/node_crypto.cc
index ff90e91a46..9a3cfe9390 100644
--- a/src/node_crypto.cc
+++ b/src/node_crypto.cc
@@ -27,6 +27,8 @@
 #include "node_root_certs.h"
 #include "tls_wrap.h"  // TLSCallbacks
 
+#include "env.h"
+#include "env-inl.h"
 #include "string_bytes.h"
 #include "v8.h"
 
@@ -70,6 +72,7 @@ namespace crypto {
 
 using v8::Array;
 using v8::Boolean;
+using v8::Context;
 using v8::Exception;
 using v8::False;
 using v8::FunctionCallbackInfo;
@@ -95,27 +98,6 @@ struct ClearErrorOnReturn {
   ~ClearErrorOnReturn() { ERR_clear_error(); }
 };
 
-static Cached<String> subject_symbol;
-static Cached<String> subjectaltname_symbol;
-static Cached<String> modulus_symbol;
-static Cached<String> exponent_symbol;
-static Cached<String> issuer_symbol;
-static Cached<String> valid_from_symbol;
-static Cached<String> valid_to_symbol;
-static Cached<String> fingerprint_symbol;
-static Cached<String> name_symbol;
-static Cached<String> version_symbol;
-static Cached<String> ext_key_usage_symbol;
-static Cached<String> onhandshakestart_sym;
-static Cached<String> onhandshakedone_sym;
-static Cached<String> onclienthello_sym;
-static Cached<String> onnewsession_sym;
-static Cached<String> sessionid_sym;
-static Cached<String> servername_sym;
-static Cached<String> tls_ticket_sym;
-
-static Persistent<FunctionTemplate> secure_context_constructor;
-
 static uv_rwlock_t* locks;
 
 X509_STORE* root_cert_store;
@@ -203,12 +185,8 @@ void ThrowCryptoTypeError(unsigned long err) {
 }
 
 
-void SecureContext::Initialize(Handle<Object> target) {
-  HandleScope scope(node_isolate);
-
+void SecureContext::Initialize(Environment* env, Handle<Object> target) {
   Local<FunctionTemplate> t = FunctionTemplate::New(SecureContext::New);
-  secure_context_constructor.Reset(node_isolate, t);
-
   t->InstanceTemplate()->SetInternalFieldCount(1);
   t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "SecureContext"));
 
@@ -231,12 +209,14 @@ void SecureContext::Initialize(Handle<Object> target) {
 
   target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "SecureContext"),
               t->GetFunction());
+  env->set_secure_context_constructor_template(t);
 }
 
 
 void SecureContext::New(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
-  SecureContext* sc = new SecureContext();
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
+  SecureContext* sc = new SecureContext(env);
   sc->Wrap(args.This());
 }
 
@@ -750,12 +730,12 @@ void SecureContext::LoadPKCS12(const FunctionCallbackInfo<Value>& args) {
 
 void SecureContext::GetTicketKeys(const FunctionCallbackInfo<Value>& args) {
 #if !defined(OPENSSL_NO_TLSEXT) && defined(SSL_CTX_get_tlsext_ticket_keys)
-  HandleScope scope(node_isolate);
+  HandleScope handle_scope(args.GetIsolate());
 
   SecureContext* wrap;
   NODE_UNWRAP(args.This(), SecureContext, wrap);
 
-  Local<Object> buff = Buffer::New(48);
+  Local<Object> buff = Buffer::New(wrap->env(), 48);
   if (SSL_CTX_get_tlsext_ticket_keys(wrap->ctx_,
                                      Buffer::Data(buff),
                                      Buffer::Length(buff)) != 1) {
@@ -836,6 +816,7 @@ int SSLWrap<Base>::NewSessionCallback(SSL* s, SSL_SESSION* sess) {
   HandleScope scope(node_isolate);
 
   Base* w = static_cast<Base*>(SSL_get_app_data(s));
+  Environment* env = w->env();
 
   if (!w->session_callbacks_)
     return 0;
@@ -846,19 +827,19 @@ int SSLWrap<Base>::NewSessionCallback(SSL* s, SSL_SESSION* sess) {
     return 0;
 
   // Serialize session
-  Local<Object> buff = Buffer::New(size);
+  Local<Object> buff = Buffer::New(env, size);
   unsigned char* serialized = reinterpret_cast<unsigned char*>(
       Buffer::Data(buff));
   memset(serialized, 0, size);
   i2d_SSL_SESSION(sess, &serialized);
 
-  Local<Object> session = Buffer::New(reinterpret_cast<char*>(sess->session_id),
+  Local<Object> session = Buffer::New(env,
+                                      reinterpret_cast<char*>(sess->session_id),
                                       sess->session_id_length);
   Local<Value> argv[] = { session, buff };
-  if (onnewsession_sym.IsEmpty())
-    onnewsession_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onnewsession");
-  MakeCallback(w->handle(node_isolate),
-               onnewsession_sym,
+  MakeCallback(env,
+               w->handle(node_isolate),
+               env->onnewsession_string(),
                ARRAY_SIZE(argv),
                argv);
 
@@ -872,34 +853,28 @@ void SSLWrap<Base>::OnClientHello(void* arg,
   HandleScope scope(node_isolate);
 
   Base* w = static_cast<Base*>(arg);
-
-  if (onclienthello_sym.IsEmpty())
-    onclienthello_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onclienthello");
-  if (sessionid_sym.IsEmpty())
-    sessionid_sym = FIXED_ONE_BYTE_STRING(node_isolate, "sessionId");
-  if (servername_sym.IsEmpty())
-    servername_sym = FIXED_ONE_BYTE_STRING(node_isolate, "servername");
-  if (tls_ticket_sym.IsEmpty())
-    tls_ticket_sym = FIXED_ONE_BYTE_STRING(node_isolate, "tlsTicket");
+  Environment* env = w->env();
 
   Local<Object> hello_obj = Object::New();
   Local<Object> buff = Buffer::New(
+      env,
       reinterpret_cast<const char*>(hello.session_id()),
-                                    hello.session_size());
-  hello_obj->Set(sessionid_sym, buff);
+      hello.session_size());
+  hello_obj->Set(env->session_id_string(), buff);
   if (hello.servername() == NULL) {
-    hello_obj->Set(servername_sym, String::Empty(node_isolate));
+    hello_obj->Set(env->servername_string(), String::Empty(node_isolate));
   } else {
     Local<String> servername = OneByteString(node_isolate,
                                              hello.servername(),
                                              hello.servername_size());
-    hello_obj->Set(servername_sym, servername);
+    hello_obj->Set(env->servername_string(), servername);
   }
-  hello_obj->Set(tls_ticket_sym, Boolean::New(hello.has_ticket()));
+  hello_obj->Set(env->tls_ticket_string(), Boolean::New(hello.has_ticket()));
 
   Local<Value> argv[] = { hello_obj };
-  MakeCallback(w->handle(node_isolate),
-               onclienthello_sym,
+  MakeCallback(env,
+               w->handle(node_isolate),
+               env->onclienthello_string(),
                ARRAY_SIZE(argv),
                argv);
 }
@@ -912,6 +887,7 @@ void SSLWrap<Base>::GetPeerCertificate(
   HandleScope scope(node_isolate);
 
   Base* w = ObjectWrap::Unwrap<Base>(args.This());
+  Environment* env = w->env();
 
   Local<Object> info = Object::New();
   X509* peer_cert = SSL_get_peer_certificate(w->ssl_);
@@ -923,7 +899,7 @@ void SSLWrap<Base>::GetPeerCertificate(
                            0,
                            X509_NAME_FLAGS) > 0) {
       BIO_get_mem_ptr(bio, &mem);
-      info->Set(subject_symbol,
+      info->Set(env->subject_string(),
                 OneByteString(node_isolate, mem->data, mem->length));
     }
     (void) BIO_reset(bio);
@@ -931,7 +907,7 @@ void SSLWrap<Base>::GetPeerCertificate(
     X509_NAME* issuer_name = X509_get_issuer_name(peer_cert);
     if (X509_NAME_print_ex(bio, issuer_name, 0, X509_NAME_FLAGS) > 0) {
       BIO_get_mem_ptr(bio, &mem);
-      info->Set(issuer_symbol,
+      info->Set(env->issuer_string(),
                 OneByteString(node_isolate, mem->data, mem->length));
     }
     (void) BIO_reset(bio);
@@ -948,7 +924,7 @@ void SSLWrap<Base>::GetPeerCertificate(
       assert(rv == 1);
 
       BIO_get_mem_ptr(bio, &mem);
-      info->Set(subjectaltname_symbol,
+      info->Set(env->subjectaltname_string(),
                 OneByteString(node_isolate, mem->data, mem->length));
 
       (void) BIO_reset(bio);
@@ -962,13 +938,13 @@ void SSLWrap<Base>::GetPeerCertificate(
     if (rsa != NULL) {
         BN_print(bio, rsa->n);
         BIO_get_mem_ptr(bio, &mem);
-        info->Set(modulus_symbol,
+        info->Set(env->modulus_string(),
                   OneByteString(node_isolate, mem->data, mem->length));
         (void) BIO_reset(bio);
 
         BN_print(bio, rsa->e);
         BIO_get_mem_ptr(bio, &mem);
-        info->Set(exponent_symbol,
+        info->Set(env->exponent_string(),
                   OneByteString(node_isolate, mem->data, mem->length));
         (void) BIO_reset(bio);
     }
@@ -984,13 +960,13 @@ void SSLWrap<Base>::GetPeerCertificate(
 
     ASN1_TIME_print(bio, X509_get_notBefore(peer_cert));
     BIO_get_mem_ptr(bio, &mem);
-    info->Set(valid_from_symbol,
+    info->Set(env->valid_from_string(),
               OneByteString(node_isolate, mem->data, mem->length));
     (void) BIO_reset(bio);
 
     ASN1_TIME_print(bio, X509_get_notAfter(peer_cert));
     BIO_get_mem_ptr(bio, &mem);
-    info->Set(valid_to_symbol,
+    info->Set(env->valid_to_string(),
               OneByteString(node_isolate, mem->data, mem->length));
     BIO_free_all(bio);
 
@@ -1013,7 +989,8 @@ void SSLWrap<Base>::GetPeerCertificate(
         fingerprint[0] = '\0';
       }
 
-      info->Set(fingerprint_symbol, OneByteString(node_isolate, fingerprint));
+      info->Set(env->fingerprint_string(),
+                OneByteString(node_isolate, fingerprint));
     }
 
     STACK_OF(ASN1_OBJECT)* eku = static_cast<STACK_OF(ASN1_OBJECT)*>(
@@ -1029,7 +1006,7 @@ void SSLWrap<Base>::GetPeerCertificate(
       }
 
       sk_ASN1_OBJECT_pop_free(eku, ASN1_OBJECT_free);
-      info->Set(ext_key_usage_symbol, ext_key_usage);
+      info->Set(env->ext_key_usage_string(), ext_key_usage);
     }
 
     X509_free(peer_cert);
@@ -1103,6 +1080,7 @@ void SSLWrap<Base>::LoadSession(const FunctionCallbackInfo<Value>& args) {
   HandleScope scope(node_isolate);
 
   Base* w = ObjectWrap::Unwrap<Base>(args.This());
+  Environment* env = w->env();
 
   if (args.Length() >= 1 && Buffer::HasInstance(args[0])) {
     ssize_t slen = Buffer::Length(args[0]);
@@ -1118,12 +1096,10 @@ void SSLWrap<Base>::LoadSession(const FunctionCallbackInfo<Value>& args) {
 
     Local<Object> info = Object::New();
 #ifndef OPENSSL_NO_TLSEXT
-    if (servername_sym.IsEmpty())
-      servername_sym = FIXED_ONE_BYTE_STRING(node_isolate, "servername");
     if (sess->tlsext_hostname == NULL) {
-      info->Set(servername_sym, False(node_isolate));
+      info->Set(env->servername_string(), False(node_isolate));
     } else {
-      info->Set(servername_sym,
+      info->Set(env->servername_string(),
                 OneByteString(node_isolate, sess->tlsext_hostname));
     }
 #endif
@@ -1255,6 +1231,7 @@ void SSLWrap<Base>::GetCurrentCipher(const FunctionCallbackInfo<Value>& args) {
   HandleScope scope(node_isolate);
 
   Base* w = ObjectWrap::Unwrap<Base>(args.This());
+  Environment* env = w->env();
 
   OPENSSL_CONST SSL_CIPHER* c = SSL_get_current_cipher(w->ssl_);
   if (c == NULL)
@@ -1262,9 +1239,9 @@ void SSLWrap<Base>::GetCurrentCipher(const FunctionCallbackInfo<Value>& args) {
 
   Local<Object> info = Object::New();
   const char* cipher_name = SSL_CIPHER_get_name(c);
-  info->Set(name_symbol, OneByteString(node_isolate, cipher_name));
+  info->Set(env->name_string(), OneByteString(node_isolate, cipher_name));
   const char* cipher_version = SSL_CIPHER_get_version(c);
-  info->Set(version_symbol, OneByteString(node_isolate, cipher_version));
+  info->Set(env->version_string(), OneByteString(node_isolate, cipher_version));
   args.GetReturnValue().Set(info);
 }
 
@@ -1539,9 +1516,7 @@ void Connection::SetShutdownFlags() {
 }
 
 
-void Connection::Initialize(Handle<Object> target) {
-  HandleScope scope(node_isolate);
-
+void Connection::Initialize(Environment* env, Handle<Object> target) {
   Local<FunctionTemplate> t = FunctionTemplate::New(Connection::New);
   t->InstanceTemplate()->SetInternalFieldCount(1);
   t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Connection"));
@@ -1629,6 +1604,7 @@ int Connection::SelectSNIContextCallback_(SSL *s, int *ad, void* arg) {
   HandleScope scope(node_isolate);
 
   Connection* conn = static_cast<Connection*>(SSL_get_app_data(s));
+  Environment* env = conn->env();
 
   const char* servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
 
@@ -1640,11 +1616,15 @@ int Connection::SelectSNIContextCallback_(SSL *s, int *ad, void* arg) {
     if (!conn->sniObject_.IsEmpty()) {
       conn->sniContext_.Dispose();
 
+      Local<Object> sni_object =
+          PersistentToLocal(node_isolate, conn->sniObject_);
       Local<Value> arg = PersistentToLocal(node_isolate, conn->servername_);
-      Local<Value> ret = MakeCallback(conn->sniObject_, "onselect", 1, &arg);
+      Local<Value> ret = MakeCallback(env, sni_object, "onselect", 1, &arg);
 
       // If ret is SecureContext
-      if (HasInstance(secure_context_constructor, ret)) {
+      Local<FunctionTemplate> secure_context_constructor_template =
+          env->secure_context_constructor_template();
+      if (secure_context_constructor_template->HasInstance(ret)) {
         conn->sniContext_.Reset(node_isolate, ret);
         SecureContext* sc = ObjectWrap::Unwrap<SecureContext>(ret.As<Object>());
         SSL_set_SSL_CTX(s, sc->ctx_);
@@ -1666,12 +1646,13 @@ void Connection::New(const FunctionCallbackInfo<Value>& args) {
   }
 
   SecureContext* sc = ObjectWrap::Unwrap<SecureContext>(args[0]->ToObject());
+  Environment* env = sc->env();
 
   bool is_server = args[1]->BooleanValue();
 
-  Connection* conn = new Connection(
-      sc,
-      is_server ? SSLWrap<Connection>::kServer : SSLWrap<Connection>::kClient);
+  SSLWrap<Connection>::Kind kind =
+      is_server ? SSLWrap<Connection>::kServer : SSLWrap<Connection>::kClient;
+  Connection* conn = new Connection(env, sc, kind);
   conn->Wrap(args.This());
 
   conn->ssl_ = SSL_new(sc->ctx_);
@@ -1746,26 +1727,27 @@ void Connection::New(const FunctionCallbackInfo<Value>& args) {
 
 
 void Connection::SSLInfoCallback(const SSL *ssl_, int where, int ret) {
+  if (!(where & (SSL_CB_HANDSHAKE_START | SSL_CB_HANDSHAKE_DONE)))
+    return;
+
   // Be compatible with older versions of OpenSSL. SSL_get_app_data() wants
   // a non-const SSL* in OpenSSL <= 0.9.7e.
   SSL* ssl = const_cast<SSL*>(ssl_);
+  Connection* conn = static_cast<Connection*>(SSL_get_app_data(ssl));
+  Environment* env = conn->env();
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
+
   if (where & SSL_CB_HANDSHAKE_START) {
-    HandleScope scope(node_isolate);
-    Connection* conn = static_cast<Connection*>(SSL_get_app_data(ssl));
-    if (onhandshakestart_sym.IsEmpty()) {
-      onhandshakestart_sym =
-          FIXED_ONE_BYTE_STRING(node_isolate, "onhandshakestart");
-    }
-    MakeCallback(conn->handle(node_isolate), onhandshakestart_sym, 0, NULL);
+    MakeCallback(env,
+                 conn->handle(node_isolate),
+                 env->onhandshakestart_string());
   }
+
   if (where & SSL_CB_HANDSHAKE_DONE) {
-    HandleScope scope(node_isolate);
-    Connection* conn = static_cast<Connection*>(SSL_get_app_data(ssl));
-    if (onhandshakedone_sym.IsEmpty()) {
-      onhandshakedone_sym =
-          FIXED_ONE_BYTE_STRING(node_isolate, "onhandshakedone");
-    }
-    MakeCallback(conn->handle(node_isolate), onhandshakedone_sym, 0, NULL);
+    MakeCallback(env,
+                 conn->handle(node_isolate),
+                 env->onhandshakedone_string());
   }
 }
 
@@ -2060,9 +2042,7 @@ void Connection::SetSNICallback(const FunctionCallbackInfo<Value>& args) {
 #endif
 
 
-void CipherBase::Initialize(Handle<Object> target) {
-  HandleScope scope(node_isolate);
-
+void CipherBase::Initialize(Environment* env, Handle<Object> target) {
   Local<FunctionTemplate> t = FunctionTemplate::New(New);
 
   t->InstanceTemplate()->SetInternalFieldCount(1);
@@ -2215,7 +2195,8 @@ bool CipherBase::Update(const char* data,
 
 
 void CipherBase::Update(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   CipherBase* cipher = ObjectWrap::Unwrap<CipherBase>(args.This());
 
@@ -2247,7 +2228,7 @@ void CipherBase::Update(const FunctionCallbackInfo<Value>& args) {
     return ThrowCryptoTypeError(ERR_get_error());
   }
 
-  Local<Object> buf = Buffer::New(reinterpret_cast<char*>(out), out_len);
+  Local<Object> buf = Buffer::New(env, reinterpret_cast<char*>(out), out_len);
   if (out) delete[] out;
 
   args.GetReturnValue().Set(buf);
@@ -2280,7 +2261,8 @@ bool CipherBase::Final(unsigned char** out, int *out_len) {
 
 
 void CipherBase::Final(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   CipherBase* cipher = ObjectWrap::Unwrap<CipherBase>(args.This());
 
@@ -2298,13 +2280,11 @@ void CipherBase::Final(const FunctionCallbackInfo<Value>& args) {
   }
 
   args.GetReturnValue().Set(
-      Buffer::New(reinterpret_cast<char*>(out_value), out_len));
+      Buffer::New(env, reinterpret_cast<char*>(out_value), out_len));
 }
 
 
-void Hmac::Initialize(v8::Handle<v8::Object> target) {
-  HandleScope scope(node_isolate);
-
+void Hmac::Initialize(Environment* env, v8::Handle<v8::Object> target) {
   Local<FunctionTemplate> t = FunctionTemplate::New(New);
 
   t->InstanceTemplate()->SetInternalFieldCount(1);
@@ -2434,9 +2414,7 @@ void Hmac::HmacDigest(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-void Hash::Initialize(v8::Handle<v8::Object> target) {
-  HandleScope scope(node_isolate);
-
+void Hash::Initialize(Environment* env, v8::Handle<v8::Object> target) {
   Local<FunctionTemplate> t = FunctionTemplate::New(New);
 
   t->InstanceTemplate()->SetInternalFieldCount(1);
@@ -2543,9 +2521,7 @@ void Hash::HashDigest(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-void Sign::Initialize(v8::Handle<v8::Object> target) {
-  HandleScope scope(node_isolate);
-
+void Sign::Initialize(Environment* env, v8::Handle<v8::Object> target) {
   Local<FunctionTemplate> t = FunctionTemplate::New(New);
 
   t->InstanceTemplate()->SetInternalFieldCount(1);
@@ -2688,9 +2664,7 @@ void Sign::SignFinal(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-void Verify::Initialize(v8::Handle<v8::Object> target) {
-  HandleScope scope(node_isolate);
-
+void Verify::Initialize(Environment* env, v8::Handle<v8::Object> target) {
   Local<FunctionTemplate> t = FunctionTemplate::New(New);
 
   t->InstanceTemplate()->SetInternalFieldCount(1);
@@ -2891,9 +2865,7 @@ void Verify::VerifyFinal(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-void DiffieHellman::Initialize(v8::Handle<v8::Object> target) {
-  HandleScope scope(node_isolate);
-
+void DiffieHellman::Initialize(Environment* env, Handle<Object> target) {
   Local<FunctionTemplate> t = FunctionTemplate::New(New);
 
   t->InstanceTemplate()->SetInternalFieldCount(1);
@@ -3244,8 +3216,10 @@ bool DiffieHellman::VerifyContext() {
 }
 
 
+// TODO(bnoordhuis) Turn into proper RAII class.
 struct pbkdf2_req {
   uv_work_t work_req;
+  Environment* env;
   int err;
   char* pass;
   size_t passlen;
@@ -3299,7 +3273,9 @@ void EIO_PBKDF2After(pbkdf2_req* req, Local<Value> argv[2]) {
 void EIO_PBKDF2After(uv_work_t* work_req, int status) {
   assert(status == 0);
   pbkdf2_req* req = container_of(work_req, pbkdf2_req, work_req);
-  HandleScope scope(node_isolate);
+  Environment* env = req->env;
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
   // Create a new Local that's associated with the current HandleScope.
   // PersistentToLocal() returns a handle that gets zeroed when we call
   // Dispose() so don't use that.
@@ -3307,12 +3283,13 @@ void EIO_PBKDF2After(uv_work_t* work_req, int status) {
   req->obj.Dispose();
   Local<Value> argv[2];
   EIO_PBKDF2After(req, argv);
-  MakeCallback(obj, "ondone", ARRAY_SIZE(argv), argv);
+  MakeCallback(env, obj, "ondone", ARRAY_SIZE(argv), argv);
 }
 
 
 void PBKDF2(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   const char* type_error = NULL;
   char* pass = NULL;
@@ -3375,6 +3352,7 @@ void PBKDF2(const FunctionCallbackInfo<Value>& args) {
   }
 
   req = new pbkdf2_req;
+  req->env = env;
   req->err = 0;
   req->pass = pass;
   req->passlen = passlen;
@@ -3387,9 +3365,11 @@ void PBKDF2(const FunctionCallbackInfo<Value>& args) {
   if (args[4]->IsFunction()) {
     Local<Object> obj = Object::New();
     obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "ondone"), args[4]);
-    obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "domain"), GetDomain());
+    if (env->in_domain()) {
+      obj->Set(env->domain_string(), env->domain_array()->Get(0));
+    }
     req->obj.Reset(node_isolate, obj);
-    uv_queue_work(uv_default_loop(),
+    uv_queue_work(env->event_loop(),
                   &req->work_req,
                   EIO_PBKDF2,
                   EIO_PBKDF2After);
@@ -3411,8 +3391,10 @@ void PBKDF2(const FunctionCallbackInfo<Value>& args) {
 }
 
 
+// TODO(bnoordhuis) Turn into proper RAII class.
 struct RandomBytesRequest {
   ~RandomBytesRequest();
+  Environment* env_;
   Persistent<Object> obj_;
   unsigned long error_;  // openssl error code or zero
   uv_work_t work_req_;
@@ -3474,17 +3456,21 @@ void RandomBytesAfter(uv_work_t* work_req, int status) {
   RandomBytesRequest* req = container_of(work_req,
                                          RandomBytesRequest,
                                          work_req_);
-  HandleScope scope(node_isolate);
+  Environment* env = req->env_;
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
   Local<Value> argv[2];
   RandomBytesCheck(req, argv);
-  MakeCallback(req->obj_, "ondone", ARRAY_SIZE(argv), argv);
+  Local<Object> obj = PersistentToLocal(node_isolate, req->obj_);
+  MakeCallback(env, obj, "ondone", ARRAY_SIZE(argv), argv);
   delete req;
 }
 
 
 template <bool pseudoRandom>
 void RandomBytes(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   // maybe allow a buffer to write to? cuts down on object creation
   // when generating random data in a loop
@@ -3498,6 +3484,7 @@ void RandomBytes(const FunctionCallbackInfo<Value>& args) {
   }
 
   RandomBytesRequest* req = new RandomBytesRequest();
+  req->env_ = env;
   req->error_ = 0;
   req->size_ = size;
   req->data_ = static_cast<char*>(malloc(size));
@@ -3511,10 +3498,12 @@ void RandomBytes(const FunctionCallbackInfo<Value>& args) {
   if (args[1]->IsFunction()) {
     Local<Object> obj = Object::New();
     obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "ondone"), args[1]);
-    obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "domain"), GetDomain());
+    if (env->in_domain()) {
+      obj->Set(env->domain_string(), env->domain_array()->Get(0));
+    }
     req->obj_.Reset(node_isolate, obj);
 
-    uv_queue_work(uv_default_loop(),
+    uv_queue_work(env->event_loop(),
                   &req->work_req_,
                   RandomBytesWork<pseudoRandom>,
                   RandomBytesAfter);
@@ -3588,9 +3577,7 @@ void GetHashes(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-void InitCrypto(Handle<Object> target) {
-  HandleScope scope(node_isolate);
-
+void InitCryptoOnce() {
   SSL_library_init();
   OpenSSL_add_all_algorithms();
   OpenSSL_add_all_digests();
@@ -3601,7 +3588,7 @@ void InitCrypto(Handle<Object> target) {
   CRYPTO_set_locking_callback(crypto_lock_cb);
   CRYPTO_THREADID_set_callback(crypto_threadid_cb);
 
-  // Turn off compression. Saves memory - do it in userland.
+  // Turn off compression. Saves memory and protects against BEAST attacks.
 #if !defined(OPENSSL_NO_COMP)
 #if OPENSSL_VERSION_NUMBER < 0x00908000L
   STACK_OF(SSL_COMP)* comp_methods = SSL_COMP_get_compression_method();
@@ -3611,15 +3598,25 @@ void InitCrypto(Handle<Object> target) {
   sk_SSL_COMP_zero(comp_methods);
   assert(sk_SSL_COMP_num(comp_methods) == 0);
 #endif
+}
+
 
-  SecureContext::Initialize(target);
-  Connection::Initialize(target);
-  CipherBase::Initialize(target);
-  DiffieHellman::Initialize(target);
-  Hmac::Initialize(target);
-  Hash::Initialize(target);
-  Sign::Initialize(target);
-  Verify::Initialize(target);
+// FIXME(bnoordhuis) Handle global init correctly.
+void InitCrypto(Handle<Object> target,
+                Handle<Value> unused,
+                Handle<Context> context) {
+  static uv_once_t init_once = UV_ONCE_INIT;
+  uv_once(&init_once, InitCryptoOnce);
+
+  Environment* env = Environment::GetCurrent(context);
+  SecureContext::Initialize(env, target);
+  Connection::Initialize(env, target);
+  CipherBase::Initialize(env, target);
+  DiffieHellman::Initialize(env, target);
+  Hmac::Initialize(env, target);
+  Hash::Initialize(env, target);
+  Sign::Initialize(env, target);
+  Verify::Initialize(env, target);
 
   NODE_SET_METHOD(target, "PBKDF2", PBKDF2);
   NODE_SET_METHOD(target, "randomBytes", RandomBytes<false>);
@@ -3627,21 +3624,9 @@ void InitCrypto(Handle<Object> target) {
   NODE_SET_METHOD(target, "getSSLCiphers", GetSSLCiphers);
   NODE_SET_METHOD(target, "getCiphers", GetCiphers);
   NODE_SET_METHOD(target, "getHashes", GetHashes);
-
-  subject_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "subject");
-  issuer_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "issuer");
-  valid_from_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "valid_from");
-  valid_to_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "valid_to");
-  subjectaltname_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "subjectaltname");
-  modulus_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "modulus");
-  exponent_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "exponent");
-  fingerprint_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "fingerprint");
-  name_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "name");
-  version_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "version");
-  ext_key_usage_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "ext_key_usage");
 }
 
 }  // namespace crypto
 }  // namespace node
 
-NODE_MODULE(node_crypto, node::crypto::InitCrypto)
+NODE_MODULE_CONTEXT_AWARE(node_crypto, node::crypto::InitCrypto)
diff --git a/src/node_crypto.h b/src/node_crypto.h
index b1c2c7fb07..2ae8794031 100644
--- a/src/node_crypto.h
+++ b/src/node_crypto.h
@@ -31,6 +31,7 @@
 #include "node_buffer.h"
 #endif
 
+#include "env.h"
 #include "v8.h"
 
 #include <openssl/ssl.h>
@@ -58,10 +59,14 @@ class Connection;
 
 class SecureContext : ObjectWrap {
  public:
-  static void Initialize(v8::Handle<v8::Object> target);
+  static void Initialize(Environment* env, v8::Handle<v8::Object> target);
+
+  inline Environment* env() const {
+    return env_;
+  }
 
-  SSL_CTX* ctx_;
   X509_STORE* ca_store_;
+  SSL_CTX* ctx_;
 
   static const int kMaxSessionSize = 10 * 1024;
 
@@ -85,9 +90,11 @@ class SecureContext : ObjectWrap {
   static void GetTicketKeys(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void SetTicketKeys(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  SecureContext() : ObjectWrap() {
-    ctx_ = NULL;
-    ca_store_ = NULL;
+  explicit SecureContext(Environment* env)
+      : ObjectWrap()
+      , ca_store_(NULL)
+      , ctx_(NULL)
+      , env_(env) {
   }
 
   void FreeCTXMem() {
@@ -112,6 +119,7 @@ class SecureContext : ObjectWrap {
   }
 
  private:
+  Environment* const env_;
 };
 
 template <class Base>
@@ -122,9 +130,11 @@ class SSLWrap {
     kServer
   };
 
-  SSLWrap(SecureContext* sc, Kind kind) : kind_(kind),
-                                          next_sess_(NULL),
-                                          session_callbacks_(false) {
+  SSLWrap(Environment* env, SecureContext* sc, Kind kind)
+      : env_(env)
+      , kind_(kind)
+      , next_sess_(NULL)
+      , session_callbacks_(false) {
     ssl_ = SSL_new(sc->ctx_);
     assert(ssl_ != NULL);
   }
@@ -190,6 +200,11 @@ class SSLWrap {
                                      void* arg);
 #endif  // OPENSSL_NPN_NEGOTIATED
 
+  inline Environment* env() const {
+    return env_;
+  }
+
+  Environment* const env_;
   Kind kind_;
   SSL_SESSION* next_sess_;
   SSL* ssl_;
@@ -206,7 +221,7 @@ class SSLWrap {
 
 class Connection : public SSLWrap<Connection>, public ObjectWrap {
  public:
-  static void Initialize(v8::Handle<v8::Object> target);
+  static void Initialize(Environment* env, v8::Handle<v8::Object> target);
 
 #ifdef OPENSSL_NPN_NEGOTIATED
   v8::Persistent<v8::Object> npnProtos_;
@@ -263,10 +278,13 @@ class Connection : public SSLWrap<Connection>, public ObjectWrap {
     return conn;
   }
 
-  Connection(SecureContext* sc, SSLWrap<Connection>::Kind kind)
-      : SSLWrap<Connection>(sc, kind),
-        hello_offset_(0) {
-    bio_read_ = bio_write_ = NULL;
+  Connection(Environment* env,
+             SecureContext* sc,
+             SSLWrap<Connection>::Kind kind)
+      : SSLWrap<Connection>(env, sc, kind)
+      , bio_read_(NULL)
+      , bio_write_(NULL)
+      , hello_offset_(0) {
     hello_parser_.Start(SSLWrap<Connection>::OnClientHello,
                         OnClientHelloParseEnd,
                         this);
@@ -296,7 +314,7 @@ class Connection : public SSLWrap<Connection>, public ObjectWrap {
 
 class CipherBase : public ObjectWrap {
  public:
-  static void Initialize(v8::Handle<v8::Object> target);
+  static void Initialize(Environment* env, v8::Handle<v8::Object> target);
 
  protected:
   enum CipherKind {
@@ -340,7 +358,7 @@ class CipherBase : public ObjectWrap {
 
 class Hmac : public ObjectWrap {
  public:
-  static void Initialize(v8::Handle<v8::Object> target);
+  static void Initialize(Environment* env, v8::Handle<v8::Object> target);
 
  protected:
   void HmacInit(const char* hash_type, const char* key, int key_len);
@@ -368,7 +386,7 @@ class Hmac : public ObjectWrap {
 
 class Hash : public ObjectWrap {
  public:
-  static void Initialize(v8::Handle<v8::Object> target);
+  static void Initialize(Environment* env, v8::Handle<v8::Object> target);
 
   bool HashInit(const char* hash_type);
   bool HashUpdate(const char* data, int len);
@@ -394,7 +412,7 @@ class Hash : public ObjectWrap {
 
 class Sign : public ObjectWrap {
  public:
-  static void Initialize(v8::Handle<v8::Object> target);
+  static void Initialize(Environment* env, v8::Handle<v8::Object> target);
 
   void SignInit(const char* sign_type);
   bool SignUpdate(const char* data, int len);
@@ -425,7 +443,7 @@ class Sign : public ObjectWrap {
 
 class Verify : public ObjectWrap {
  public:
-  static void Initialize(v8::Handle<v8::Object> target);
+  static void Initialize(Environment* env, v8::Handle<v8::Object> target);
 
   void VerifyInit(const char* verify_type);
   bool VerifyUpdate(const char* data, int len);
@@ -456,7 +474,7 @@ class Verify : public ObjectWrap {
 
 class DiffieHellman : public ObjectWrap {
  public:
-  static void Initialize(v8::Handle<v8::Object> target);
+  static void Initialize(Environment* env, v8::Handle<v8::Object> target);
 
   bool Init(int primeLength);
   bool Init(const char* p, int p_len);
diff --git a/src/node_file.cc b/src/node_file.cc
index c29c0fda50..fa49dd4bcc 100644
--- a/src/node_file.cc
+++ b/src/node_file.cc
@@ -24,6 +24,9 @@
 #include "node_buffer.h"
 #include "node_internals.h"
 #include "node_stat_watcher.h"
+
+#include "env.h"
+#include "env-inl.h"
 #include "req_wrap.h"
 #include "string_bytes.h"
 
@@ -42,6 +45,7 @@
 namespace node {
 
 using v8::Array;
+using v8::Context;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
@@ -51,7 +55,6 @@ using v8::Integer;
 using v8::Local;
 using v8::Number;
 using v8::Object;
-using v8::Persistent;
 using v8::String;
 using v8::Value;
 
@@ -63,8 +66,9 @@ using v8::Value;
 
 class FSReqWrap: public ReqWrap<uv_fs_t> {
  public:
-  explicit FSReqWrap(const char* syscall, char* data = NULL)
-    : syscall_(syscall)
+  FSReqWrap(Environment* env, const char* syscall, char* data = NULL)
+    : ReqWrap<uv_fs_t>(env)
+    , syscall_(syscall)
     , data_(data) {
   }
 
@@ -82,9 +86,6 @@ class FSReqWrap: public ReqWrap<uv_fs_t> {
 };
 
 
-static Cached<String> oncomplete_sym;
-
-
 #define ASSERT_OFFSET(a) \
   if (!(a)->IsUndefined() && !(a)->IsNull() && !IsInt64((a)->NumberValue())) { \
     return ThrowTypeError("Not an integer"); \
@@ -102,12 +103,14 @@ static inline int IsInt64(double x) {
 
 
 static void After(uv_fs_t *req) {
-  HandleScope scope(node_isolate);
-
   FSReqWrap* req_wrap = static_cast<FSReqWrap*>(req->data);
   assert(&req_wrap->req_ == req);
   req_wrap->ReleaseEarly();  // Free memory that's no longer used now.
 
+  Environment* env = req_wrap->env();
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
+
   // there is always at least one argument. "error"
   int argc = 1;
 
@@ -168,7 +171,8 @@ static void After(uv_fs_t *req) {
       case UV_FS_STAT:
       case UV_FS_LSTAT:
       case UV_FS_FSTAT:
-        argv[1] = BuildStatsObject(static_cast<const uv_stat_t*>(req->ptr));
+        argv[1] = BuildStatsObject(env,
+                                   static_cast<const uv_stat_t*>(req->ptr));
         break;
 
       case UV_FS_READLINK:
@@ -209,7 +213,7 @@ static void After(uv_fs_t *req) {
     }
   }
 
-  MakeCallback(req_wrap->object(), oncomplete_sym, argc, argv);
+  MakeCallback(env, req_wrap->object(), env->oncomplete_string(), argc, argv);
 
   uv_fs_req_cleanup(&req_wrap->req_);
   delete req_wrap;
@@ -227,27 +231,31 @@ struct fs_req_wrap {
 };
 
 
-#define ASYNC_CALL(func, callback, ...)                           \
-  FSReqWrap* req_wrap = new FSReqWrap(#func);                     \
-  int err = uv_fs_ ## func(uv_default_loop(), &req_wrap->req_,    \
-      __VA_ARGS__, After);                                        \
-  req_wrap->object()->Set(oncomplete_sym, callback);              \
-  req_wrap->Dispatched();                                         \
-  if (err < 0) {                                                  \
-    uv_fs_t* req = &req_wrap->req_;                               \
-    req->result = err;                                            \
-    req->path = NULL;                                             \
-    After(req);                                                   \
-  }                                                               \
+#define ASYNC_CALL(func, callback, ...)                                       \
+  Environment* env = Environment::GetCurrent(args.GetIsolate());              \
+  FSReqWrap* req_wrap = new FSReqWrap(env, #func);                            \
+  int err = uv_fs_ ## func(env->event_loop(),                                 \
+                           &req_wrap->req_,                                   \
+                           __VA_ARGS__,                                       \
+                           After);                                            \
+  req_wrap->object()->Set(env->oncomplete_string(), callback);                \
+  req_wrap->Dispatched();                                                     \
+  if (err < 0) {                                                              \
+    uv_fs_t* req = &req_wrap->req_;                                           \
+    req->result = err;                                                        \
+    req->path = NULL;                                                         \
+    After(req);                                                               \
+  }                                                                           \
   args.GetReturnValue().Set(req_wrap->persistent());
 
-#define SYNC_CALL(func, path, ...)                                \
-  fs_req_wrap req_wrap;                                           \
-  int err = uv_fs_ ## func(uv_default_loop(),                     \
-                           &req_wrap.req,                         \
-                           __VA_ARGS__,                           \
-                           NULL);                                 \
-  if (err < 0) return ThrowUVException(err, #func, NULL, path);   \
+#define SYNC_CALL(func, path, ...)                                            \
+  fs_req_wrap req_wrap;                                                       \
+  Environment* env = Environment::GetCurrent(args.GetIsolate());              \
+  int err = uv_fs_ ## func(env->event_loop(),                                 \
+                           &req_wrap.req,                                     \
+                           __VA_ARGS__,                                       \
+                           NULL);                                             \
+  if (err < 0) return ThrowUVException(err, #func, NULL, path);               \
 
 #define SYNC_REQ req_wrap.req
 
@@ -271,47 +279,16 @@ static void Close(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-static Persistent<Function> stats_constructor;
-
-static Cached<String> dev_symbol;
-static Cached<String> ino_symbol;
-static Cached<String> mode_symbol;
-static Cached<String> nlink_symbol;
-static Cached<String> uid_symbol;
-static Cached<String> gid_symbol;
-static Cached<String> rdev_symbol;
-static Cached<String> size_symbol;
-static Cached<String> blksize_symbol;
-static Cached<String> blocks_symbol;
-static Cached<String> atime_symbol;
-static Cached<String> mtime_symbol;
-static Cached<String> ctime_symbol;
-static Cached<String> birthtime_symbol;
-
-Local<Object> BuildStatsObject(const uv_stat_t* s) {
-  HandleScope scope(node_isolate);
+Local<Object> BuildStatsObject(Environment* env, const uv_stat_t* s) {
+  // If you hit this assertion, you forgot to enter the v8::Context first.
+  assert(env->context() == env->isolate()->GetCurrentContext());
 
-  if (dev_symbol.IsEmpty()) {
-    dev_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "dev");
-    ino_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "ino");
-    mode_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "mode");
-    nlink_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "nlink");
-    uid_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "uid");
-    gid_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "gid");
-    rdev_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "rdev");
-    size_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "size");
-    blksize_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "blksize");
-    blocks_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "blocks");
-    atime_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "atime");
-    mtime_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "mtime");
-    ctime_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "ctime");
-    birthtime_symbol = FIXED_ONE_BYTE_STRING(node_isolate, "birthtime");
-  }
+  HandleScope handle_scope(env->isolate());
 
-  Local<Function> constructor =
-      PersistentToLocal(node_isolate, stats_constructor);
-  Local<Object> stats = constructor->NewInstance();
-  if (stats.IsEmpty()) return Local<Object>();
+  Local<Object> stats = env->stats_constructor_function()->NewInstance();
+  if (stats.IsEmpty()) {
+    return Local<Object>();
+  }
 
   // The code below is very nasty-looking but it prevents a segmentation fault
   // when people run JS code like the snippet below. It's apparently more
@@ -328,7 +305,7 @@ Local<Object> BuildStatsObject(const uv_stat_t* s) {
   {                                                                           \
     Local<Value> val = Integer::New(s->st_##name, node_isolate);              \
     if (val.IsEmpty()) return Local<Object>();                                \
-    stats->Set(name##_symbol, val);                                           \
+    stats->Set(env->name ## _string(), val);                                  \
   }
   X(dev)
   X(mode)
@@ -345,7 +322,7 @@ Local<Object> BuildStatsObject(const uv_stat_t* s) {
   {                                                                           \
     Local<Value> val = Number::New(static_cast<double>(s->st_##name));        \
     if (val.IsEmpty()) return Local<Object>();                                \
-    stats->Set(name##_symbol, val);                                           \
+    stats->Set(env->name ## _string(), val);                                  \
   }
   X(ino)
   X(size)
@@ -360,7 +337,7 @@ Local<Object> BuildStatsObject(const uv_stat_t* s) {
     msecs += static_cast<double>(s->st_##rec.tv_nsec / 1000000);              \
     Local<Value> val = v8::Date::New(msecs);                                  \
     if (val.IsEmpty()) return Local<Object>();                                \
-    stats->Set(name##_symbol, val);                                           \
+    stats->Set(env->name ## _string(), val);                                  \
   }
   X(atime, atim)
   X(mtime, mtim)
@@ -368,7 +345,7 @@ Local<Object> BuildStatsObject(const uv_stat_t* s) {
   X(birthtime, birthtim)
 #undef X
 
-  return scope.Close(stats);
+  return handle_scope.Close(stats);
 }
 
 static void Stat(const FunctionCallbackInfo<Value>& args) {
@@ -384,7 +361,7 @@ static void Stat(const FunctionCallbackInfo<Value>& args) {
   } else {
     SYNC_CALL(stat, *path, *path)
     args.GetReturnValue().Set(
-        BuildStatsObject(static_cast<const uv_stat_t*>(SYNC_REQ.ptr)));
+        BuildStatsObject(env, static_cast<const uv_stat_t*>(SYNC_REQ.ptr)));
   }
 }
 
@@ -401,7 +378,7 @@ static void LStat(const FunctionCallbackInfo<Value>& args) {
   } else {
     SYNC_CALL(lstat, *path, *path)
     args.GetReturnValue().Set(
-        BuildStatsObject(static_cast<const uv_stat_t*>(SYNC_REQ.ptr)));
+        BuildStatsObject(env, static_cast<const uv_stat_t*>(SYNC_REQ.ptr)));
   }
 }
 
@@ -419,7 +396,7 @@ static void FStat(const FunctionCallbackInfo<Value>& args) {
   } else {
     SYNC_CALL(fstat, 0, fd)
     args.GetReturnValue().Set(
-        BuildStatsObject(static_cast<const uv_stat_t*>(SYNC_REQ.ptr)));
+        BuildStatsObject(env, static_cast<const uv_stat_t*>(SYNC_REQ.ptr)));
   }
 }
 
@@ -719,7 +696,8 @@ static void WriteBuffer(const FunctionCallbackInfo<Value>& args) {
 //             if null, write from the current position
 // 3 enc       encoding of string
 static void WriteString(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   if (!args[0]->IsInt32())
     return ThrowTypeError("First argument must be file descriptor");
@@ -753,15 +731,15 @@ static void WriteString(const FunctionCallbackInfo<Value>& args) {
     return args.GetReturnValue().Set(SYNC_RESULT);
   }
 
-  FSReqWrap* req_wrap = new FSReqWrap("write", must_free ? buf : NULL);
-  int err = uv_fs_write(uv_default_loop(),
+  FSReqWrap* req_wrap = new FSReqWrap(env, "write", must_free ? buf : NULL);
+  int err = uv_fs_write(env->event_loop(),
                         &req_wrap->req_,
                         fd,
                         buf,
                         len,
                         pos,
                         After);
-  req_wrap->object()->Set(oncomplete_sym, cb);
+  req_wrap->object()->Set(env->oncomplete_string(), cb);
   req_wrap->Dispatched();
   if (err < 0) {
     uv_fs_t* req = &req_wrap->req_;
@@ -972,8 +950,15 @@ static void FUTimes(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-void File::Initialize(Handle<Object> target) {
-  HandleScope scope(node_isolate);
+void InitFs(Handle<Object> target,
+            Handle<Value> unused,
+            Handle<Context> context) {
+  Environment* env = Environment::GetCurrent(context);
+
+  // Initialize the stats object
+  Local<Function> constructor = FunctionTemplate::New()->GetFunction();
+  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Stats"), constructor);
+  env->set_stats_constructor_function(constructor);
 
   NODE_SET_METHOD(target, "close", Close);
   NODE_SET_METHOD(target, "open", Open);
@@ -1005,23 +990,10 @@ void File::Initialize(Handle<Object> target) {
 
   NODE_SET_METHOD(target, "utimes", UTimes);
   NODE_SET_METHOD(target, "futimes", FUTimes);
-}
-
-void InitFs(Handle<Object> target) {
-  HandleScope scope(node_isolate);
-
-  // Initialize the stats object
-  Local<Function> constructor = FunctionTemplate::New()->GetFunction();
-  target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Stats"), constructor);
-  stats_constructor.Reset(node_isolate, constructor);
-
-  File::Initialize(target);
-
-  oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
 
   StatWatcher::Initialize(target);
 }
 
 }  // end namespace node
 
-NODE_MODULE(node_fs, node::InitFs)
+NODE_MODULE_CONTEXT_AWARE(node_fs, node::InitFs)
diff --git a/src/node_file.h b/src/node_file.h
index 0a5d270101..dc5deedb0a 100644
--- a/src/node_file.h
+++ b/src/node_file.h
@@ -27,11 +27,6 @@
 
 namespace node {
 
-class File {
- public:
-  static void Initialize(v8::Handle<v8::Object> target);
-};
-
 void InitFs(v8::Handle<v8::Object> target);
 
 }  // namespace node
diff --git a/src/node_http_parser.cc b/src/node_http_parser.cc
index 80485ec05f..80046a9b7b 100644
--- a/src/node_http_parser.cc
+++ b/src/node_http_parser.cc
@@ -22,6 +22,9 @@
 #include "node.h"
 #include "node_buffer.h"
 #include "node_http_parser.h"
+
+#include "env.h"
+#include "env-inl.h"
 #include "v8.h"
 
 #include <stdlib.h>  // free()
@@ -48,6 +51,7 @@
 namespace node {
 
 using v8::Array;
+using v8::Context;
 using v8::Exception;
 using v8::Function;
 using v8::FunctionCallbackInfo;
@@ -65,32 +69,6 @@ const uint32_t kOnHeadersComplete = 1;
 const uint32_t kOnBody = 2;
 const uint32_t kOnMessageComplete = 3;
 
-static Cached<String> method_sym;
-static Cached<String> status_code_sym;
-static Cached<String> http_version_sym;
-static Cached<String> version_major_sym;
-static Cached<String> version_minor_sym;
-static Cached<String> should_keep_alive_sym;
-static Cached<String> upgrade_sym;
-static Cached<String> headers_sym;
-static Cached<String> url_sym;
-
-static Cached<String> unknown_method_sym;
-
-#define X(num, name, string) static Cached<String> name##_sym;
-HTTP_METHOD_MAP(X)
-#undef X
-
-static struct http_parser_settings settings;
-
-
-// This is a hack to get the current_buffer to the callbacks with the least
-// amount of overhead. Nothing else will run while http_parser_execute()
-// runs, therefore this pointer can be set and used for the execution.
-static Local<Value>* current_buffer;
-static char* current_buffer_data;
-static size_t current_buffer_len;
-
 
 #define HTTP_CB(name)                                                         \
   static int name(http_parser* p_) {                                          \
@@ -108,14 +86,30 @@ static size_t current_buffer_len;
   int name##_(const char* at, size_t length)
 
 
-static inline Handle<String>
-method_to_str(unsigned short m) {
-  switch (m) {
-#define X(num, name, string) case HTTP_##name: return name##_sym;
-  HTTP_METHOD_MAP(X)
-#undef X
+// Call this function only when there is a valid HandleScope on the stack
+// somewhere.
+inline Local<String> MethodToString(Environment* env, uint32_t method) {
+  // XXX(bnoordhuis) Predicated on the observation that 99.9% of all HTTP
+  // requests are either GET, HEAD or POST. I threw in DELETE and PUT for
+  // good measure.
+  switch (method) {
+    case HTTP_DELETE: return env->DELETE_string();
+    case HTTP_GET: return env->GET_string();
+    case HTTP_HEAD: return env->HEAD_string();
+    case HTTP_POST: return env->POST_string();
+    case HTTP_PUT: return env->PUT_string();
   }
-  return unknown_method_sym;
+
+  switch (method) {
+#define V(num, name, string)                                                  \
+    case HTTP_ ## name:                                                       \
+      return FIXED_ONE_BYTE_STRING(node_isolate, #string);
+    HTTP_METHOD_MAP(V)
+#undef V
+  }
+
+  // Unreachable, http_parser parses only a restricted set of request methods.
+  return FIXED_ONE_BYTE_STRING(node_isolate, "UNKNOWN_METHOD");
 }
 
 
@@ -193,7 +187,11 @@ struct StringPtr {
 
 class Parser : public ObjectWrap {
  public:
-  explicit Parser(enum http_parser_type type) : ObjectWrap() {
+  Parser(Environment* env, enum http_parser_type type)
+      : ObjectWrap()
+      , env_(env)
+      , current_buffer_len_(0)
+      , current_buffer_data_(NULL) {
     Init(type);
   }
 
@@ -267,34 +265,35 @@ class Parser : public ObjectWrap {
       Flush();
     } else {
       // Fast case, pass headers and URL to JS land.
-      message_info->Set(headers_sym, CreateHeaders());
+      message_info->Set(env()->headers_string(), CreateHeaders());
       if (parser_.type == HTTP_REQUEST)
-        message_info->Set(url_sym, url_.ToString());
+        message_info->Set(env()->url_string(), url_.ToString());
     }
     num_fields_ = num_values_ = 0;
 
     // METHOD
     if (parser_.type == HTTP_REQUEST) {
-      message_info->Set(method_sym, method_to_str(parser_.method));
+      message_info->Set(env()->method_string(),
+                        MethodToString(env(), parser_.method));
     }
 
     // STATUS
     if (parser_.type == HTTP_RESPONSE) {
-      message_info->Set(status_code_sym,
+      message_info->Set(env()->status_code_string(),
                         Integer::New(parser_.status_code, node_isolate));
     }
 
     // VERSION
-    message_info->Set(version_major_sym,
+    message_info->Set(env()->version_major_string(),
                       Integer::New(parser_.http_major, node_isolate));
-    message_info->Set(version_minor_sym,
+    message_info->Set(env()->version_minor_string(),
                       Integer::New(parser_.http_minor, node_isolate));
 
-    message_info->Set(should_keep_alive_sym,
+    message_info->Set(env()->should_keep_alive_string(),
                       http_should_keep_alive(&parser_) ? True(node_isolate)
                                                        : False(node_isolate));
 
-    message_info->Set(upgrade_sym,
+    message_info->Set(env()->upgrade_string(),
                       parser_.upgrade ? True(node_isolate)
                                       : False(node_isolate));
 
@@ -321,9 +320,9 @@ class Parser : public ObjectWrap {
       return 0;
 
     Local<Value> argv[3] = {
-      *current_buffer,
-      Integer::New(at - current_buffer_data, node_isolate),
-      Integer::New(length, node_isolate)
+      current_buffer_,
+      Integer::NewFromUnsigned(at - current_buffer_data_, node_isolate),
+      Integer::NewFromUnsigned(length, node_isolate)
     };
 
     Local<Value> r = cb.As<Function>()->Call(obj, ARRAY_SIZE(argv), argv);
@@ -361,13 +360,14 @@ class Parser : public ObjectWrap {
 
 
   static void New(const FunctionCallbackInfo<Value>& args) {
-    HandleScope scope(node_isolate);
+    Environment* env = Environment::GetCurrent(args.GetIsolate());
+    HandleScope handle_scope(args.GetIsolate());
 
     http_parser_type type =
         static_cast<http_parser_type>(args[0]->Int32Value());
 
     assert(type == HTTP_REQUEST || type == HTTP_RESPONSE);
-    Parser* parser = new Parser(type);
+    Parser* parser = new Parser(env, type);
     parser->Wrap(args.This());
   }
 
@@ -390,28 +390,21 @@ class Parser : public ObjectWrap {
     HandleScope scope(node_isolate);
 
     Parser* parser = ObjectWrap::Unwrap<Parser>(args.This());
+    assert(parser->current_buffer_.IsEmpty());
+    assert(parser->current_buffer_len_ == 0);
+    assert(parser->current_buffer_data_ == NULL);
+    assert(Buffer::HasInstance(args[0]) == true);
 
-    assert(!current_buffer);
-    assert(!current_buffer_data);
-
-    if (current_buffer) {
-      return ThrowTypeError("Already parsing a buffer");
-    }
-
-    Local<Value> buffer_v = args[0];
-
-    if (!Buffer::HasInstance(buffer_v)) {
-      return ThrowTypeError("Argument should be a buffer");
-    }
-
-    Local<Object> buffer_obj = buffer_v->ToObject();
-    char *buffer_data = Buffer::Data(buffer_obj);
+    Local<Object> buffer_obj = args[0].As<Object>();
+    char* buffer_data = Buffer::Data(buffer_obj);
     size_t buffer_len = Buffer::Length(buffer_obj);
 
-    // Assign 'buffer_' while we parse. The callbacks will access that varible.
-    current_buffer = &buffer_v;
-    current_buffer_data = buffer_data;
-    current_buffer_len = buffer_len;
+    // This is a hack to get the current_buffer to the callbacks with the least
+    // amount of overhead. Nothing else will run while http_parser_execute()
+    // runs, therefore this pointer can be set and used for the execution.
+    parser->current_buffer_ = buffer_obj;
+    parser->current_buffer_len_ = buffer_len;
+    parser->current_buffer_data_ = buffer_data;
     parser->got_exception_ = false;
 
     size_t nparsed =
@@ -420,9 +413,9 @@ class Parser : public ObjectWrap {
     parser->Save();
 
     // Unassign the 'buffer_' variable
-    assert(current_buffer);
-    current_buffer = NULL;
-    current_buffer_data = NULL;
+    parser->current_buffer_.Clear();
+    parser->current_buffer_len_ = 0;
+    parser->current_buffer_data_ = NULL;
 
     // If there was an exception in one of the callbacks
     if (parser->got_exception_) return;
@@ -439,6 +432,7 @@ class Parser : public ObjectWrap {
       obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "bytesParsed"), nparsed_obj);
       obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "code"),
                OneByteString(node_isolate, http_errno_name(err)));
+
       args.GetReturnValue().Set(e);
     } else {
       args.GetReturnValue().Set(nparsed_obj);
@@ -451,7 +445,7 @@ class Parser : public ObjectWrap {
 
     Parser* parser = ObjectWrap::Unwrap<Parser>(args.This());
 
-    assert(!current_buffer);
+    assert(parser->current_buffer_.IsEmpty());
     parser->got_exception_ = false;
 
     int rv = http_parser_execute(&(parser->parser_), &settings, NULL, 0);
@@ -468,19 +462,23 @@ class Parser : public ObjectWrap {
                Integer::New(0, node_isolate));
       obj->Set(FIXED_ONE_BYTE_STRING(node_isolate, "code"),
                OneByteString(node_isolate, http_errno_name(err)));
+
       args.GetReturnValue().Set(e);
     }
   }
 
 
   static void Reinitialize(const FunctionCallbackInfo<Value>& args) {
-    HandleScope scope(node_isolate);
+    Environment* env = Environment::GetCurrent(args.GetIsolate());
+    HandleScope handle_scope(args.GetIsolate());
 
     http_parser_type type =
         static_cast<http_parser_type>(args[0]->Int32Value());
 
     assert(type == HTTP_REQUEST || type == HTTP_RESPONSE);
     Parser* parser = ObjectWrap::Unwrap<Parser>(args.This());
+    // Should always be called from the same context.
+    assert(env == parser->env());
     parser->Init(type);
   }
 
@@ -536,6 +534,12 @@ class Parser : public ObjectWrap {
   }
 
 
+  inline Environment* env() const {
+    return env_;
+  }
+
+
+  Environment* const env_;
   http_parser parser_;
   StringPtr fields_[32];  // header fields
   StringPtr values_[32];  // header values
@@ -544,12 +548,27 @@ class Parser : public ObjectWrap {
   int num_values_;
   bool have_flushed_;
   bool got_exception_;
+  Local<Object> current_buffer_;
+  size_t current_buffer_len_;
+  char* current_buffer_data_;
+  static const struct http_parser_settings settings;
 };
 
 
-void InitHttpParser(Handle<Object> target) {
-  HandleScope scope(node_isolate);
+const struct http_parser_settings Parser::settings = {
+  Parser::on_message_begin,
+  Parser::on_url,
+  Parser::on_header_field,
+  Parser::on_header_value,
+  Parser::on_headers_complete,
+  Parser::on_body,
+  Parser::on_message_complete
+};
+
 
+void InitHttpParser(Handle<Object> target,
+                    Handle<Value> unused,
+                    Handle<Context> context) {
   Local<FunctionTemplate> t = FunctionTemplate::New(Parser::New);
   t->InstanceTemplate()->SetInternalFieldCount(1);
   t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "HTTPParser"));
@@ -573,33 +592,8 @@ void InitHttpParser(Handle<Object> target) {
 
   target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "HTTPParser"),
               t->GetFunction());
-
-#define X(num, name, string)                                                  \
-  name ## _sym = OneByteString(node_isolate, #string);
-  HTTP_METHOD_MAP(X)
-#undef X
-  unknown_method_sym = FIXED_ONE_BYTE_STRING(node_isolate, "UNKNOWN_METHOD");
-
-  method_sym = FIXED_ONE_BYTE_STRING(node_isolate, "method");
-  status_code_sym = FIXED_ONE_BYTE_STRING(node_isolate, "statusCode");
-  http_version_sym = FIXED_ONE_BYTE_STRING(node_isolate, "httpVersion");
-  version_major_sym = FIXED_ONE_BYTE_STRING(node_isolate, "versionMajor");
-  version_minor_sym = FIXED_ONE_BYTE_STRING(node_isolate, "versionMinor");
-  should_keep_alive_sym =
-      FIXED_ONE_BYTE_STRING(node_isolate, "shouldKeepAlive");
-  upgrade_sym = FIXED_ONE_BYTE_STRING(node_isolate, "upgrade");
-  headers_sym = FIXED_ONE_BYTE_STRING(node_isolate, "headers");
-  url_sym = FIXED_ONE_BYTE_STRING(node_isolate, "url");
-
-  settings.on_message_begin    = Parser::on_message_begin;
-  settings.on_url              = Parser::on_url;
-  settings.on_header_field     = Parser::on_header_field;
-  settings.on_header_value     = Parser::on_header_value;
-  settings.on_headers_complete = Parser::on_headers_complete;
-  settings.on_body             = Parser::on_body;
-  settings.on_message_complete = Parser::on_message_complete;
 }
 
 }  // namespace node
 
-NODE_MODULE(node_http_parser, node::InitHttpParser)
+NODE_MODULE_CONTEXT_AWARE(node_http_parser, node::InitHttpParser)
diff --git a/src/node_internals.h b/src/node_internals.h
index ba110a51c8..141bd92ff0 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -22,15 +22,16 @@
 #ifndef SRC_NODE_INTERNALS_H_
 #define SRC_NODE_INTERNALS_H_
 
+#include "env.h"
+#include "util.h"
+#include "util-inl.h"
+#include "uv.h"
 #include "v8.h"
 
 #include <assert.h>
 #include <stdint.h>
 #include <stdlib.h>
 
-#define FIXED_ONE_BYTE_STRING(isolate, string)                                \
-  (node::OneByteString((isolate), (string), sizeof(string) - 1))
-
 struct sockaddr;
 
 namespace node {
@@ -38,36 +39,6 @@ namespace node {
 // Defined in node.cc
 extern v8::Isolate* node_isolate;
 
-// Defined in node.cc at startup.
-extern v8::Persistent<v8::Object> process_p;
-
-template <typename TypeName>
-class CachedBase {
- public:
-  CachedBase();
-  operator v8::Handle<TypeName>() const;
-  void operator=(v8::Handle<TypeName> that);  // Can only assign once.
-  bool IsEmpty() const;
- private:
-  CachedBase(const CachedBase&);
-  void operator=(const CachedBase&);
-  v8::Persistent<TypeName> handle_;
-};
-
-template <typename TypeName>
-class Cached : public CachedBase<TypeName> {
- public:
-  operator v8::Handle<v8::Value>() const;
-  void operator=(v8::Handle<TypeName> that);
-};
-
-template <>
-class Cached<v8::Value> : public CachedBase<v8::Value> {
- public:
-  operator v8::Handle<v8::Value>() const;
-  void operator=(v8::Handle<v8::Value> that);
-};
-
 // If persistent.IsWeak() == false, then do not call persistent.Dispose()
 // while the returned Local<T> is still in scope, it will destroy the
 // reference to the object.
@@ -76,55 +47,41 @@ inline v8::Local<TypeName> PersistentToLocal(
     v8::Isolate* isolate,
     const v8::Persistent<TypeName>& persistent);
 
-v8::Handle<v8::Value> MakeCallback(
-    const v8::Handle<v8::Object> recv,
-    uint32_t index,
-    int argc,
-    v8::Handle<v8::Value>* argv);
-
-template <typename TypeName>
-v8::Handle<v8::Value> MakeCallback(
-    const v8::Persistent<v8::Object>& recv,
-    const TypeName method,
-    int argc,
-    v8::Handle<v8::Value>* argv);
-
-template <typename TypeName>
-v8::Handle<v8::Value> MakeCallback(
-    const v8::Persistent<v8::Object>& recv,
-    const Cached<TypeName>& method,
-    int argc,
-    v8::Handle<v8::Value>* argv);
-
-inline bool HasInstance(
-    const v8::Persistent<v8::FunctionTemplate>& function_template,
-    v8::Handle<v8::Value> value);
-
-inline v8::Local<v8::Object> NewInstance(
-    const v8::Persistent<v8::Function>& ctor,
-    int argc = 0,
-    v8::Handle<v8::Value>* argv = NULL);
-
-// Convenience wrapper around v8::String::NewFromOneByte().
-inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
-                                           const char* data,
-                                           int length = -1);
-
-// For the people that compile with -funsigned-char.
-inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
-                                           const signed char* data,
-                                           int length = -1);
-
-inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
-                                           const unsigned char* data,
-                                           int length = -1);
+// Call with valid HandleScope and while inside Context scope.
+v8::Handle<v8::Value> MakeCallback(Environment* env,
+                                   const v8::Handle<v8::Object> object,
+                                   const char* method,
+                                   int argc = 0,
+                                   v8::Handle<v8::Value>* argv = NULL);
+
+// Call with valid HandleScope and while inside Context scope.
+v8::Handle<v8::Value> MakeCallback(Environment* env,
+                                   const v8::Handle<v8::Object> object,
+                                   uint32_t index,
+                                   int argc = 0,
+                                   v8::Handle<v8::Value>* argv = NULL);
+
+// Call with valid HandleScope and while inside Context scope.
+v8::Handle<v8::Value> MakeCallback(Environment* env,
+                                   const v8::Handle<v8::Object> object,
+                                   const v8::Handle<v8::String> symbol,
+                                   int argc = 0,
+                                   v8::Handle<v8::Value>* argv = NULL);
+
+// Call with valid HandleScope and while inside Context scope.
+v8::Handle<v8::Value> MakeCallback(Environment* env,
+                                   const v8::Handle<v8::Object> object,
+                                   const v8::Handle<v8::Function> callback,
+                                   int argc = 0,
+                                   v8::Handle<v8::Value>* argv = NULL);
 
 // Convert a struct sockaddr to a { address: '1.2.3.4', port: 1234 } JS object.
 // Sets address and port properties on the info object and returns it.
 // If |info| is omitted, a new object is returned.
 v8::Local<v8::Object> AddressToJS(
+    Environment* env,
     const sockaddr* addr,
-    v8::Handle<v8::Object> info = v8::Handle<v8::Object>());
+    v8::Local<v8::Object> info = v8::Handle<v8::Object>());
 
 #ifdef _WIN32
 // emulate snprintf() on windows, _snprintf() doesn't zero-terminate the buffer
@@ -213,6 +170,8 @@ inline static void ThrowUVException(int errorno,
 
 NO_RETURN void FatalError(const char* location, const char* message);
 
+v8::Local<v8::Object> BuildStatsObject(Environment* env, const uv_stat_t* s);
+
 #define NODE_WRAP(Object, Pointer)                                             \
   do {                                                                         \
     assert(!Object.IsEmpty());                                                 \
@@ -286,125 +245,6 @@ inline MUST_USE_RESULT bool ParseArrayIndex(v8::Handle<v8::Value> arg,
   return true;
 }
 
-template <class TypeName>
-inline v8::Local<TypeName> PersistentToLocal(
-    v8::Isolate* isolate,
-    const v8::Persistent<TypeName>& persistent) {
-  if (persistent.IsWeak()) {
-    return v8::Local<TypeName>::New(isolate, persistent);
-  } else {
-    return *reinterpret_cast<v8::Local<TypeName>*>(
-        const_cast<v8::Persistent<TypeName>*>(&persistent));
-  }
-}
-
-template <typename TypeName>
-CachedBase<TypeName>::CachedBase() {
-}
-
-template <typename TypeName>
-CachedBase<TypeName>::operator v8::Handle<TypeName>() const {
-  return PersistentToLocal(node_isolate, handle_);
-}
-
-template <typename TypeName>
-void CachedBase<TypeName>::operator=(v8::Handle<TypeName> that) {
-  assert(handle_.IsEmpty() == true);  // Can only assign once.
-  handle_.Reset(node_isolate, that);
-}
-
-template <typename TypeName>
-bool CachedBase<TypeName>::IsEmpty() const {
-  return handle_.IsEmpty();
-}
-
-template <typename TypeName>
-Cached<TypeName>::operator v8::Handle<v8::Value>() const {
-  return CachedBase<TypeName>::operator v8::Handle<TypeName>();
-}
-
-template <typename TypeName>
-void Cached<TypeName>::operator=(v8::Handle<TypeName> that) {
-  CachedBase<TypeName>::operator=(that);
-}
-
-inline Cached<v8::Value>::operator v8::Handle<v8::Value>() const {
-  return CachedBase<v8::Value>::operator v8::Handle<v8::Value>();
-}
-
-inline void Cached<v8::Value>::operator=(v8::Handle<v8::Value> that) {
-  CachedBase<v8::Value>::operator=(that);
-}
-
-template <typename TypeName>
-v8::Handle<v8::Value> MakeCallback(
-    const v8::Persistent<v8::Object>& recv,
-    const TypeName method,
-    int argc,
-    v8::Handle<v8::Value>* argv) {
-  v8::Local<v8::Object> recv_obj = PersistentToLocal(node_isolate, recv);
-  return MakeCallback(recv_obj, method, argc, argv);
-}
-
-template <typename TypeName>
-v8::Handle<v8::Value> MakeCallback(
-    const v8::Persistent<v8::Object>& recv,
-    const Cached<TypeName>& method,
-    int argc,
-    v8::Handle<v8::Value>* argv) {
-  const v8::Handle<TypeName> handle = method;
-  return MakeCallback(recv, handle, argc, argv);
-}
-
-inline bool HasInstance(
-    const v8::Persistent<v8::FunctionTemplate>& function_template,
-    v8::Handle<v8::Value> value) {
-  if (function_template.IsEmpty()) return false;
-  v8::Local<v8::FunctionTemplate> function_template_handle =
-      PersistentToLocal(node_isolate, function_template);
-  return function_template_handle->HasInstance(value);
-}
-
-inline v8::Local<v8::Object> NewInstance(
-    const v8::Persistent<v8::Function>& ctor,
-    int argc,
-    v8::Handle<v8::Value>* argv) {
-  v8::Local<v8::Function> constructor_handle =
-      PersistentToLocal(node_isolate, ctor);
-  return constructor_handle->NewInstance(argc, argv);
-}
-
-inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
-                                           const char* data,
-                                           int length) {
-  return v8::String::NewFromOneByte(isolate,
-                                    reinterpret_cast<const uint8_t*>(data),
-                                    v8::String::kNormalString,
-                                    length);
-}
-
-inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
-                                           const signed char* data,
-                                           int length) {
-  return v8::String::NewFromOneByte(isolate,
-                                    reinterpret_cast<const uint8_t*>(data),
-                                    v8::String::kNormalString,
-                                    length);
-}
-
-inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
-                                           const unsigned char* data,
-                                           int length) {
-  return v8::String::NewFromOneByte(isolate,
-                                    reinterpret_cast<const uint8_t*>(data),
-                                    v8::String::kNormalString,
-                                    length);
-}
-
-bool InDomain();
-
-v8::Handle<v8::Value> GetDomain();
-
 }  // namespace node
 
 #endif  // SRC_NODE_INTERNALS_H_
diff --git a/src/node_os.cc b/src/node_os.cc
index 36506fc6ed..e3d9971e3e 100644
--- a/src/node_os.cc
+++ b/src/node_os.cc
@@ -46,6 +46,7 @@ namespace node {
 namespace os {
 
 using v8::Array;
+using v8::Context;
 using v8::FunctionCallbackInfo;
 using v8::Handle;
 using v8::HandleScope;
@@ -275,9 +276,9 @@ static void GetInterfaceAddresses(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-void Initialize(Handle<Object> target) {
-  HandleScope scope(node_isolate);
-
+void Initialize(Handle<Object> target,
+                Handle<Value> unused,
+                Handle<Context> context) {
   NODE_SET_METHOD(target, "getEndianness", GetEndianness);
   NODE_SET_METHOD(target, "getHostname", GetHostname);
   NODE_SET_METHOD(target, "getLoadAvg", GetLoadAvg);
@@ -293,4 +294,4 @@ void Initialize(Handle<Object> target) {
 }  // namespace os
 }  // namespace node
 
-NODE_MODULE(node_os, node::os::Initialize)
+NODE_MODULE_CONTEXT_AWARE(node_os, node::os::Initialize)
diff --git a/src/node_stat_watcher.cc b/src/node_stat_watcher.cc
index fb3cf4f8aa..1cd13c0847 100644
--- a/src/node_stat_watcher.cc
+++ b/src/node_stat_watcher.cc
@@ -20,6 +20,8 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include "node_stat_watcher.h"
+#include "env.h"
+#include "env-inl.h"
 
 #include <assert.h>
 #include <string.h>
@@ -27,6 +29,7 @@
 
 namespace node {
 
+using v8::Context;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::Handle;
@@ -37,9 +40,6 @@ using v8::Object;
 using v8::String;
 using v8::Value;
 
-static Cached<String> onchange_sym;
-static Cached<String> onstop_sym;
-
 
 void StatWatcher::Initialize(Handle<Object> target) {
   HandleScope scope(node_isolate);
@@ -61,9 +61,11 @@ static void Delete(uv_handle_t* handle) {
 }
 
 
-StatWatcher::StatWatcher() : ObjectWrap(),
-                             watcher_(new uv_fs_poll_t) {
-  uv_fs_poll_init(uv_default_loop(), watcher_);
+StatWatcher::StatWatcher(Environment* env)
+    : ObjectWrap()
+    , watcher_(new uv_fs_poll_t)
+    , env_(env) {
+  uv_fs_poll_init(env->event_loop(), watcher_);
   watcher_->data = static_cast<void*>(this);
 }
 
@@ -80,16 +82,17 @@ void StatWatcher::Callback(uv_fs_poll_t* handle,
                            const uv_stat_t* curr) {
   StatWatcher* wrap = static_cast<StatWatcher*>(handle->data);
   assert(wrap->watcher_ == handle);
-  HandleScope scope(node_isolate);
-  Local<Value> argv[3];
-  argv[0] = BuildStatsObject(curr);
-  argv[1] = BuildStatsObject(prev);
-  argv[2] = Integer::New(status, node_isolate);
-  if (onchange_sym.IsEmpty()) {
-    onchange_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onchange");
-  }
-  MakeCallback(wrap->handle(node_isolate),
-               onchange_sym,
+  Environment* env = wrap->env();
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
+  Local<Value> argv[] = {
+    BuildStatsObject(env, curr),
+    BuildStatsObject(env, prev),
+    Integer::New(status, node_isolate)
+  };
+  MakeCallback(env,
+               wrap->handle(node_isolate),
+               env->onchange_string(),
                ARRAY_SIZE(argv),
                argv);
 }
@@ -97,8 +100,9 @@ void StatWatcher::Callback(uv_fs_poll_t* handle,
 
 void StatWatcher::New(const FunctionCallbackInfo<Value>& args) {
   assert(args.IsConstructCall());
-  HandleScope scope(node_isolate);
-  StatWatcher* s = new StatWatcher();
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
+  StatWatcher* s = new StatWatcher(env);
   s->Wrap(args.This());
 }
 
@@ -119,12 +123,11 @@ void StatWatcher::Start(const FunctionCallbackInfo<Value>& args) {
 
 
 void StatWatcher::Stop(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
   StatWatcher* wrap = ObjectWrap::Unwrap<StatWatcher>(args.This());
-  if (onstop_sym.IsEmpty()) {
-    onstop_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onstop");
-  }
-  MakeCallback(wrap->handle(node_isolate), onstop_sym, 0, NULL);
+  Environment* env = wrap->env();
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
+  MakeCallback(env, wrap->handle(node_isolate), env->onstop_string());
   wrap->Stop();
 }
 
diff --git a/src/node_stat_watcher.h b/src/node_stat_watcher.h
index 082608f76a..fd38c8b42f 100644
--- a/src/node_stat_watcher.h
+++ b/src/node_stat_watcher.h
@@ -22,17 +22,21 @@
 #ifndef SRC_NODE_STAT_WATCHER_H_
 #define SRC_NODE_STAT_WATCHER_H_
 
-#include "node.h"
+#include "node_object_wrap.h"
+
+#include "env.h"
 #include "uv.h"
+#include "v8.h"
 
 namespace node {
 
 class StatWatcher : ObjectWrap {
  public:
   static void Initialize(v8::Handle<v8::Object> target);
+  inline Environment* env() const { return env_; }
 
  protected:
-  StatWatcher();
+  explicit StatWatcher(Environment* env);
   virtual ~StatWatcher();
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -47,6 +51,7 @@ class StatWatcher : ObjectWrap {
   void Stop();
 
   uv_fs_poll_t* watcher_;
+  Environment* const env_;
 };
 
 }  // namespace node
diff --git a/src/node_version.h b/src/node_version.h
index e02b932523..a355cfac53 100644
--- a/src/node_version.h
+++ b/src/node_version.h
@@ -64,6 +64,6 @@
  * an API is broken in the C++ side, including in v8 or
  * other dependencies.
  */
-#define NODE_MODULE_VERSION 0x000C /* v0.12 */
+#define NODE_MODULE_VERSION 13 /* v0.12 */
 
 #endif  /* SRC_NODE_VERSION_H_ */
diff --git a/src/node_wrap.h b/src/node_wrap.h
index 8839a7a50b..0f56f6ddf7 100644
--- a/src/node_wrap.h
+++ b/src/node_wrap.h
@@ -22,38 +22,39 @@
 #ifndef SRC_NODE_WRAP_H_
 #define SRC_NODE_WRAP_H_
 
-#include "v8.h"
-#include "uv.h"
-
+#include "env.h"
+#include "env-inl.h"
 #include "pipe_wrap.h"
-#include "tty_wrap.h"
 #include "tcp_wrap.h"
+#include "tty_wrap.h"
 #include "udp_wrap.h"
+#include "uv.h"
+#include "v8.h"
 
 namespace node {
 
-extern v8::Persistent<v8::FunctionTemplate> pipeConstructorTmpl;
-extern v8::Persistent<v8::FunctionTemplate> ttyConstructorTmpl;
-extern v8::Persistent<v8::FunctionTemplate> tcpConstructorTmpl;
-
-#define WITH_GENERIC_STREAM(obj, BODY)                    \
-    do {                                                  \
-      if (HasInstance(tcpConstructorTmpl, obj)) {         \
-        TCPWrap* const wrap = TCPWrap::Unwrap(obj);       \
-        BODY                                              \
-      } else if (HasInstance(ttyConstructorTmpl, obj)) {  \
-        TTYWrap* const wrap = TTYWrap::Unwrap(obj);       \
-        BODY                                              \
-      } else if (HasInstance(pipeConstructorTmpl, obj)) { \
-        PipeWrap* const wrap = PipeWrap::Unwrap(obj);     \
-        BODY                                              \
-      }                                                   \
+#define WITH_GENERIC_STREAM(env, obj, BODY)                                   \
+    do {                                                                      \
+      if (env->tcp_constructor_template().IsEmpty() == false &&               \
+          env->tcp_constructor_template()->HasInstance(obj)) {                \
+        TCPWrap* const wrap = TCPWrap::Unwrap(obj);                           \
+        BODY                                                                  \
+      } else if (env->tty_constructor_template().IsEmpty() == false &&        \
+                 env->tty_constructor_template()->HasInstance(obj)) {         \
+        TTYWrap* const wrap = TTYWrap::Unwrap(obj);                           \
+        BODY                                                                  \
+      } else if (env->pipe_constructor_template().IsEmpty() == false &&       \
+                 env->pipe_constructor_template()->HasInstance(obj)) {        \
+        PipeWrap* const wrap = PipeWrap::Unwrap(obj);                         \
+        BODY                                                                  \
+      }                                                                       \
     } while (0)
 
-inline uv_stream_t* HandleToStream(v8::Local<v8::Object> obj) {
+inline uv_stream_t* HandleToStream(Environment* env,
+                                   v8::Local<v8::Object> obj) {
   v8::HandleScope scope(node_isolate);
 
-  WITH_GENERIC_STREAM(obj, {
+  WITH_GENERIC_STREAM(env, obj, {
     return reinterpret_cast<uv_stream_t*>(wrap->UVHandle());
   });
 
diff --git a/src/node_zlib.cc b/src/node_zlib.cc
index 91bfb0dd3d..ebc9d2b916 100644
--- a/src/node_zlib.cc
+++ b/src/node_zlib.cc
@@ -21,6 +21,9 @@
 
 #include "node.h"
 #include "node_buffer.h"
+
+#include "env.h"
+#include "env-inl.h"
 #include "v8.h"
 #include "zlib.h"
 
@@ -31,6 +34,7 @@
 
 namespace node {
 
+using v8::Context;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::Handle;
@@ -42,9 +46,6 @@ using v8::Object;
 using v8::String;
 using v8::Value;
 
-static Cached<String> callback_sym;
-static Cached<String> onerror_sym;
-
 enum node_zlib_mode {
   NONE,
   DEFLATE,
@@ -66,19 +67,21 @@ void InitZlib(v8::Handle<v8::Object> target);
 class ZCtx : public ObjectWrap {
  public:
 
-  explicit ZCtx(node_zlib_mode mode) : ObjectWrap(),
-                                       init_done_(false),
-                                       level_(0),
-                                       windowBits_(0),
-                                       memLevel_(0),
-                                       strategy_(0),
-                                       err_(0),
-                                       dictionary_(NULL),
-                                       dictionary_len_(0),
-                                       flush_(0),
-                                       chunk_size_(0),
-                                       write_in_progress_(false),
-                                       mode_(mode) {
+  ZCtx(Environment* env, node_zlib_mode mode)
+      : ObjectWrap()
+      , chunk_size_(0)
+      , dictionary_(NULL)
+      , dictionary_len_(0)
+      , env_(env)
+      , err_(0)
+      , flush_(0)
+      , init_done_(false)
+      , level_(0)
+      , memLevel_(0)
+      , mode_(mode)
+      , strategy_(0)
+      , windowBits_(0)
+      , write_in_progress_(false) {
   }
 
 
@@ -87,6 +90,10 @@ class ZCtx : public ObjectWrap {
   }
 
 
+  inline Environment* env() const {
+    return env_;
+  }
+
   void Close() {
     assert(!write_in_progress_ && "write in progress");
     assert(init_done_ && "close before init");
@@ -182,7 +189,7 @@ class ZCtx : public ObjectWrap {
     // set this so that later on, I can easily tell how much was written.
     ctx->chunk_size_ = out_len;
 
-    uv_queue_work(uv_default_loop(),
+    uv_queue_work(ctx->env()->event_loop(),
                   work_req,
                   ZCtx::Process,
                   ZCtx::After);
@@ -245,8 +252,11 @@ class ZCtx : public ObjectWrap {
   static void After(uv_work_t* work_req, int status) {
     assert(status == 0);
 
-    HandleScope scope(node_isolate);
-    ZCtx *ctx = container_of(work_req, ZCtx, work_req_);
+    ZCtx* ctx = container_of(work_req, ZCtx, work_req_);
+    Environment* env = ctx->env();
+
+    Context::Scope context_scope(env->context());
+    HandleScope handle_scope(env->isolate());
 
     // Acceptable error states depend on the type of zlib stream.
     switch (ctx->err_) {
@@ -275,29 +285,29 @@ class ZCtx : public ObjectWrap {
 
     // call the write() cb
     Local<Object> handle = ctx->handle(node_isolate);
-    assert(handle->Get(callback_sym)->IsFunction() && "Invalid callback");
     Local<Value> args[2] = { avail_in, avail_out };
-    MakeCallback(handle, callback_sym, ARRAY_SIZE(args), args);
+    MakeCallback(env, handle, env->callback_string(), ARRAY_SIZE(args), args);
 
     ctx->Unref();
   }
 
-  static void Error(ZCtx *ctx, const char *msg_) {
-    const char *msg;
+  static void Error(ZCtx* ctx, const char* message) {
+    Environment* env = ctx->env();
+
+    // If you hit this assertion, you forgot to enter the v8::Context first.
+    assert(env->context() == env->isolate()->GetCurrentContext());
+
     if (ctx->strm_.msg != NULL) {
-      msg = ctx->strm_.msg;
-    } else {
-      msg = msg_;
+      message = ctx->strm_.msg;
     }
 
     Local<Object> handle = ctx->handle(node_isolate);
-    assert(handle->Get(onerror_sym)->IsFunction() && "Invalid error handler");
     HandleScope scope(node_isolate);
     Local<Value> args[2] = {
-      OneByteString(node_isolate, msg),
+      OneByteString(node_isolate, message),
       Number::New(ctx->err_)
     };
-    MakeCallback(handle, onerror_sym, ARRAY_SIZE(args), args);
+    MakeCallback(env, handle, env->onerror_string(), ARRAY_SIZE(args), args);
 
     // no hope of rescue.
     ctx->write_in_progress_ = false;
@@ -305,7 +315,9 @@ class ZCtx : public ObjectWrap {
   }
 
   static void New(const FunctionCallbackInfo<Value>& args) {
-    HandleScope scope(node_isolate);
+    Environment* env = Environment::GetCurrent(args.GetIsolate());
+    HandleScope handle_scope(args.GetIsolate());
+
     if (args.Length() < 1 || !args[0]->IsInt32()) {
       return ThrowTypeError("Bad argument");
     }
@@ -315,7 +327,7 @@ class ZCtx : public ObjectWrap {
       return ThrowTypeError("Bad argument");
     }
 
-    ZCtx *ctx = new ZCtx(mode);
+    ZCtx* ctx = new ZCtx(env, mode);
     ctx->Wrap(args.This());
   }
 
@@ -506,33 +518,27 @@ class ZCtx : public ObjectWrap {
   static const int kDeflateContextSize = 16384;  // approximate
   static const int kInflateContextSize = 10240;  // approximate
 
+  int chunk_size_;
+  Bytef* dictionary_;
+  size_t dictionary_len_;
+  Environment* const env_;
+  int err_;
+  int flush_;
   bool init_done_;
-
-  z_stream strm_;
   int level_;
-  int windowBits_;
   int memLevel_;
+  node_zlib_mode mode_;
   int strategy_;
-
-  int err_;
-
-  Bytef* dictionary_;
-  size_t dictionary_len_;
-
-  int flush_;
-
-  int chunk_size_;
-
-  bool write_in_progress_;
-
+  z_stream strm_;
+  int windowBits_;
   uv_work_t work_req_;
-  node_zlib_mode mode_;
+  bool write_in_progress_;
 };
 
 
-void InitZlib(Handle<Object> target) {
-  HandleScope scope(node_isolate);
-
+void InitZlib(Handle<Object> target,
+              Handle<Value> unused,
+              Handle<Context> context) {
   Local<FunctionTemplate> z = FunctionTemplate::New(ZCtx::New);
 
   z->InstanceTemplate()->SetInternalFieldCount(1);
@@ -546,9 +552,6 @@ void InitZlib(Handle<Object> target) {
   z->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Zlib"));
   target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Zlib"), z->GetFunction());
 
-  callback_sym = FIXED_ONE_BYTE_STRING(node_isolate, "callback");
-  onerror_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onerror");
-
   // valid flush values.
   NODE_DEFINE_CONSTANT(target, Z_NO_FLUSH);
   NODE_DEFINE_CONSTANT(target, Z_PARTIAL_FLUSH);
@@ -593,4 +596,4 @@ void InitZlib(Handle<Object> target) {
 
 }  // namespace node
 
-NODE_MODULE(node_zlib, node::InitZlib)
+NODE_MODULE_CONTEXT_AWARE(node_zlib, node::InitZlib)
diff --git a/src/pipe_wrap.cc b/src/pipe_wrap.cc
index 97375ab847..805e69b668 100644
--- a/src/pipe_wrap.cc
+++ b/src/pipe_wrap.cc
@@ -20,16 +20,22 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include "pipe_wrap.h"
+
+#include "env.h"
+#include "env-inl.h"
+#include "handle_wrap.h"
 #include "node.h"
 #include "node_buffer.h"
-#include "handle_wrap.h"
 #include "node_wrap.h"
 #include "req_wrap.h"
 #include "stream_wrap.h"
+#include "util-inl.h"
+#include "util.h"
 
 namespace node {
 
 using v8::Boolean;
+using v8::Context;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
@@ -38,17 +44,11 @@ using v8::HandleScope;
 using v8::Integer;
 using v8::Local;
 using v8::Object;
-using v8::Persistent;
 using v8::PropertyAttribute;
 using v8::String;
 using v8::Undefined;
 using v8::Value;
 
-static Persistent<Function> pipeConstructor;
-static Cached<String> onconnection_sym;
-static Cached<String> oncomplete_sym;
-
-
 // TODO(bnoordhuis) share with TCPWrap?
 typedef class ReqWrap<uv_connect_t> ConnectWrap;
 
@@ -58,10 +58,14 @@ uv_pipe_t* PipeWrap::UVHandle() {
 }
 
 
-Local<Object> PipeWrap::Instantiate() {
-  HandleScope scope(node_isolate);
-  assert(!pipeConstructor.IsEmpty());
-  return scope.Close(NewInstance(pipeConstructor));
+Local<Object> PipeWrap::Instantiate(Environment* env) {
+  HandleScope handle_scope(env->isolate());
+  assert(!env->pipe_constructor_template().IsEmpty());
+  Local<Function> constructor = env->pipe_constructor_template()->GetFunction();
+  assert(!constructor.IsEmpty());
+  Local<Object> instance = constructor->NewInstance();
+  assert(!instance.IsEmpty());
+  return handle_scope.Close(instance);
 }
 
 
@@ -72,14 +76,13 @@ PipeWrap* PipeWrap::Unwrap(Local<Object> obj) {
 }
 
 
-void PipeWrap::Initialize(Handle<Object> target) {
-  StreamWrap::Initialize(target);
-
-  HandleScope scope(node_isolate);
+void PipeWrap::Initialize(Handle<Object> target,
+                          Handle<Value> unused,
+                          Handle<Context> context) {
+  Environment* env = Environment::GetCurrent(context);
 
   Local<FunctionTemplate> t = FunctionTemplate::New(New);
   t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Pipe"));
-
   t->InstanceTemplate()->SetInternalFieldCount(1);
 
   enum PropertyAttribute attributes =
@@ -115,9 +118,8 @@ void PipeWrap::Initialize(Handle<Object> target) {
   NODE_SET_PROTOTYPE_METHOD(t, "setPendingInstances", SetPendingInstances);
 #endif
 
-  pipeConstructorTmpl.Reset(node_isolate, t);
-  pipeConstructor.Reset(node_isolate, t->GetFunction());
   target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Pipe"), t->GetFunction());
+  env->set_pipe_constructor_template(t);
 }
 
 
@@ -126,16 +128,15 @@ void PipeWrap::New(const FunctionCallbackInfo<Value>& args) {
   // Therefore we assert that we are not trying to call this as a
   // normal function.
   assert(args.IsConstructCall());
-
-  HandleScope scope(node_isolate);
-  PipeWrap* wrap = new PipeWrap(args.This(), args[0]->IsTrue());
-  assert(wrap);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
+  new PipeWrap(env, args.This(), args[0]->IsTrue());
 }
 
 
-PipeWrap::PipeWrap(Handle<Object> object, bool ipc)
-    : StreamWrap(object, reinterpret_cast<uv_stream_t*>(&handle_)) {
-  int r = uv_pipe_init(uv_default_loop(), &handle_, ipc);
+PipeWrap::PipeWrap(Environment* env, Handle<Object> object, bool ipc)
+    : StreamWrap(env, object, reinterpret_cast<uv_stream_t*>(&handle_)) {
+  int r = uv_pipe_init(env->event_loop(), &handle_, ipc);
   assert(r == 0);  // How do we proxy this error up to javascript?
                    // Suggestion: uv_pipe_init() returns void.
   UpdateWriteQueueSize();
@@ -184,11 +185,13 @@ void PipeWrap::Listen(const FunctionCallbackInfo<Value>& args) {
 
 // TODO(bnoordhuis) maybe share with TCPWrap?
 void PipeWrap::OnConnection(uv_stream_t* handle, int status) {
-  HandleScope scope(node_isolate);
-
   PipeWrap* pipe_wrap = static_cast<PipeWrap*>(handle->data);
   assert(&pipe_wrap->handle_ == reinterpret_cast<uv_pipe_t*>(handle));
 
+  Environment* env = pipe_wrap->env();
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
+
   // We should not be getting this callback if someone as already called
   // uv_close() on the handle.
   assert(pipe_wrap->persistent().IsEmpty() == false);
@@ -199,12 +202,17 @@ void PipeWrap::OnConnection(uv_stream_t* handle, int status) {
   };
 
   if (status != 0) {
-    MakeCallback(pipe_wrap->object(), "onconnection", ARRAY_SIZE(argv), argv);
+    MakeCallback(env,
+                 pipe_wrap->object(),
+                 env->onconnection_string(),
+                 ARRAY_SIZE(argv),
+                 argv);
     return;
   }
 
   // Instanciate the client javascript object and handle.
-  Local<Object> client_obj = NewInstance(pipeConstructor);
+  Local<Object> client_obj =
+      env->pipe_constructor_template()->GetFunction()->NewInstance();
 
   // Unwrap the client javascript object.
   PipeWrap* wrap;
@@ -215,18 +223,22 @@ void PipeWrap::OnConnection(uv_stream_t* handle, int status) {
 
   // Successful accept. Call the onconnection callback in JavaScript land.
   argv[1] = client_obj;
-  if (onconnection_sym.IsEmpty()) {
-    onconnection_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onconnection");
-  }
-  MakeCallback(pipe_wrap->object(), onconnection_sym, ARRAY_SIZE(argv), argv);
+  MakeCallback(env,
+               pipe_wrap->object(),
+               env->onconnection_string(),
+               ARRAY_SIZE(argv),
+               argv);
 }
 
 // TODO(bnoordhuis) Maybe share this with TCPWrap?
 void PipeWrap::AfterConnect(uv_connect_t* req, int status) {
   ConnectWrap* req_wrap = static_cast<ConnectWrap*>(req->data);
   PipeWrap* wrap = static_cast<PipeWrap*>(req->handle->data);
+  assert(req_wrap->env() == wrap->env());
+  Environment* env = wrap->env();
 
-  HandleScope scope(node_isolate);
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
 
   // The wrap and request objects should still be there.
   assert(req_wrap->persistent().IsEmpty() == false);
@@ -250,10 +262,11 @@ void PipeWrap::AfterConnect(uv_connect_t* req, int status) {
     Boolean::New(writable)
   };
 
-  if (oncomplete_sym.IsEmpty()) {
-    oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
-  }
-  MakeCallback(req_wrap_obj, oncomplete_sym, ARRAY_SIZE(argv), argv);
+  MakeCallback(env,
+               req_wrap_obj,
+               env->oncomplete_string(),
+               ARRAY_SIZE(argv),
+               argv);
 
   delete req_wrap;
 }
@@ -272,7 +285,8 @@ void PipeWrap::Open(const FunctionCallbackInfo<Value>& args) {
 
 
 void PipeWrap::Connect(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope scope(args.GetIsolate());
 
   PipeWrap* wrap;
   NODE_UNWRAP(args.This(), PipeWrap, wrap);
@@ -283,7 +297,7 @@ void PipeWrap::Connect(const FunctionCallbackInfo<Value>& args) {
   Local<Object> req_wrap_obj = args[0].As<Object>();
   String::AsciiValue name(args[1]);
 
-  ConnectWrap* req_wrap = new ConnectWrap(req_wrap_obj);
+  ConnectWrap* req_wrap = new ConnectWrap(env, req_wrap_obj);
   uv_pipe_connect(&req_wrap->req_,
                   &wrap->handle_,
                   *name,
@@ -296,4 +310,4 @@ void PipeWrap::Connect(const FunctionCallbackInfo<Value>& args) {
 
 }  // namespace node
 
-NODE_MODULE(node_pipe_wrap, node::PipeWrap::Initialize)
+NODE_MODULE_CONTEXT_AWARE(node_pipe_wrap, node::PipeWrap::Initialize)
diff --git a/src/pipe_wrap.h b/src/pipe_wrap.h
index 944835774d..89330fc724 100644
--- a/src/pipe_wrap.h
+++ b/src/pipe_wrap.h
@@ -21,6 +21,8 @@
 
 #ifndef SRC_PIPE_WRAP_H_
 #define SRC_PIPE_WRAP_H_
+
+#include "env.h"
 #include "stream_wrap.h"
 
 namespace node {
@@ -29,12 +31,14 @@ class PipeWrap : public StreamWrap {
  public:
   uv_pipe_t* UVHandle();
 
-  static v8::Local<v8::Object> Instantiate();
+  static v8::Local<v8::Object> Instantiate(Environment* env);
   static PipeWrap* Unwrap(v8::Local<v8::Object> obj);
-  static void Initialize(v8::Handle<v8::Object> target);
+  static void Initialize(v8::Handle<v8::Object> target,
+                         v8::Handle<v8::Value> unused,
+                         v8::Handle<v8::Context> context);
 
  private:
-  PipeWrap(v8::Handle<v8::Object> object, bool ipc);
+  PipeWrap(Environment* env, v8::Handle<v8::Object> object, bool ipc);
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Bind(const v8::FunctionCallbackInfo<v8::Value>& args);
diff --git a/src/process_wrap.cc b/src/process_wrap.cc
index 1784a163da..bff4e0ba86 100644
--- a/src/process_wrap.cc
+++ b/src/process_wrap.cc
@@ -19,7 +19,8 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-#include "node.h"
+#include "env.h"
+#include "env-inl.h"
 #include "handle_wrap.h"
 #include "node_wrap.h"
 
@@ -29,6 +30,7 @@
 namespace node {
 
 using v8::Array;
+using v8::Context;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
@@ -41,13 +43,11 @@ using v8::Object;
 using v8::String;
 using v8::Value;
 
-static Cached<String> onexit_sym;
-
 class ProcessWrap : public HandleWrap {
  public:
-  static void Initialize(Handle<Object> target) {
-    HandleScope scope(node_isolate);
-
+  static void Initialize(Handle<Object> target,
+                         Handle<Value> unused,
+                         Handle<Context> context) {
     Local<FunctionTemplate> constructor = FunctionTemplate::New(New);
     constructor->InstanceTemplate()->SetInternalFieldCount(1);
     constructor->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Process"));
@@ -70,22 +70,25 @@ class ProcessWrap : public HandleWrap {
     // Therefore we assert that we are not trying to call this as a
     // normal function.
     assert(args.IsConstructCall());
-    HandleScope scope(node_isolate);
-    new ProcessWrap(args.This());
+    Environment* env = Environment::GetCurrent(args.GetIsolate());
+    HandleScope handle_scope(args.GetIsolate());
+    new ProcessWrap(env, args.This());
   }
 
-  explicit ProcessWrap(Handle<Object> object)
-      : HandleWrap(object, reinterpret_cast<uv_handle_t*>(&process_)) {
+  ProcessWrap(Environment* env, Handle<Object> object)
+      : HandleWrap(env, object, reinterpret_cast<uv_handle_t*>(&process_)) {
   }
 
   ~ProcessWrap() {
   }
 
-  static void ParseStdioOptions(Local<Object> js_options,
+  static void ParseStdioOptions(Environment* env,
+                                Local<Object> js_options,
                                 uv_process_options_t* options) {
     Local<String> stdio_key =
         FIXED_ONE_BYTE_STRING(node_isolate, "stdio");
     Local<Array> stdios = js_options->Get(stdio_key).As<Array>();
+
     uint32_t len = stdios->Length();
     options->stdio = new uv_stdio_container_t[len];
     options->stdio_count = len;
@@ -110,7 +113,7 @@ class ProcessWrap : public HandleWrap {
         Local<String> handle_key =
             FIXED_ONE_BYTE_STRING(node_isolate, "handle");
         Local<Object> handle = stdio->Get(handle_key).As<Object>();
-        uv_stream_t* stream = HandleToStream(handle);
+        uv_stream_t* stream = HandleToStream(env, handle);
         assert(stream != NULL);
 
         options->stdio[i].flags = UV_INHERIT_STREAM;
@@ -118,7 +121,6 @@ class ProcessWrap : public HandleWrap {
       } else {
         Local<String> fd_key = FIXED_ONE_BYTE_STRING(node_isolate, "fd");
         int fd = static_cast<int>(stdio->Get(fd_key)->IntegerValue());
-
         options->stdio[i].flags = UV_INHERIT_FD;
         options->stdio[i].data.fd = fd;
       }
@@ -126,7 +128,8 @@ class ProcessWrap : public HandleWrap {
   }
 
   static void Spawn(const FunctionCallbackInfo<Value>& args) {
-    HandleScope scope(node_isolate);
+    Environment* env = Environment::GetCurrent(args.GetIsolate());
+    HandleScope handle_scope(args.GetIsolate());
 
     ProcessWrap* wrap;
     NODE_UNWRAP(args.This(), ProcessWrap, wrap);
@@ -216,7 +219,7 @@ class ProcessWrap : public HandleWrap {
     }
 
     // options.stdio
-    ParseStdioOptions(js_options, &options);
+    ParseStdioOptions(env, js_options, &options);
 
     // options.windows_verbatim_arguments
     Local<String> windows_verbatim_arguments_key =
@@ -232,7 +235,7 @@ class ProcessWrap : public HandleWrap {
       options.flags |= UV_PROCESS_DETACHED;
     }
 
-    int err = uv_spawn(uv_default_loop(), &wrap->process_, &options);
+    int err = uv_spawn(env->event_loop(), &wrap->process_, &options);
 
     if (err == 0) {
       assert(wrap->process_.data == wrap);
@@ -268,22 +271,24 @@ class ProcessWrap : public HandleWrap {
   static void OnExit(uv_process_t* handle,
                      int64_t exit_status,
                      int term_signal) {
-    HandleScope scope(node_isolate);
-
     ProcessWrap* wrap = static_cast<ProcessWrap*>(handle->data);
-    assert(wrap);
+    assert(wrap != NULL);
     assert(&wrap->process_ == handle);
 
+    Environment* env = wrap->env();
+    Context::Scope context_scope(env->context());
+    HandleScope handle_scope(env->isolate());
+
     Local<Value> argv[] = {
       Number::New(node_isolate, static_cast<double>(exit_status)),
       OneByteString(node_isolate, signo_string(term_signal))
     };
 
-    if (onexit_sym.IsEmpty()) {
-      onexit_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onexit");
-    }
-
-    MakeCallback(wrap->object(), onexit_sym, ARRAY_SIZE(argv), argv);
+    MakeCallback(env,
+                 wrap->object(),
+                 env->onexit_string(),
+                 ARRAY_SIZE(argv),
+                 argv);
   }
 
   uv_process_t process_;
@@ -292,4 +297,4 @@ class ProcessWrap : public HandleWrap {
 
 }  // namespace node
 
-NODE_MODULE(node_process_wrap, node::ProcessWrap::Initialize)
+NODE_MODULE_CONTEXT_AWARE(node_process_wrap, node::ProcessWrap::Initialize)
diff --git a/src/req_wrap.h b/src/req_wrap.h
index 44749a3004..8a701e5158 100644
--- a/src/req_wrap.h
+++ b/src/req_wrap.h
@@ -22,29 +22,31 @@
 #ifndef SRC_REQ_WRAP_H_
 #define SRC_REQ_WRAP_H_
 
-#include "node.h"
-#include "node_internals.h"
+#include "env.h"
+#include "env-inl.h"
 #include "queue.h"
+#include "util.h"
 
 namespace node {
 
 // defined in node.cc
-extern Cached<v8::String> process_symbol;
-extern Cached<v8::String> domain_symbol;
 extern QUEUE req_wrap_queue;
 
 template <typename T>
 class ReqWrap {
  public:
-  ReqWrap(v8::Handle<v8::Object> object = v8::Handle<v8::Object>()) {
-    v8::HandleScope scope(node_isolate);
-    if (object.IsEmpty()) object = v8::Object::New();
-    persistent().Reset(node_isolate, object);
-
-    if (InDomain()) {
-      v8::Local<v8::Value> domain = GetDomain();
-      if (domain->IsObject())
-        object->Set(domain_symbol, domain);
+  ReqWrap(Environment* env,
+          v8::Handle<v8::Object> object = v8::Handle<v8::Object>())
+      : env_(env) {
+    v8::HandleScope handle_scope(env->isolate());
+
+    if (object.IsEmpty()) {
+      object = v8::Object::New();
+    }
+    persistent().Reset(env->isolate(), object);
+
+    if (env->in_domain()) {
+      object->Set(env->domain_string(), env->domain_array()->Get(0));
     }
 
     QUEUE_INSERT_TAIL(&req_wrap_queue, &req_wrap_queue_);
@@ -64,17 +66,25 @@ class ReqWrap {
     req_.data = this;
   }
 
+  inline Environment* env() const {
+    return env_;
+  }
+
   inline v8::Local<v8::Object> object() {
-    return PersistentToLocal(node_isolate, persistent());
+    return PersistentToLocal(env()->isolate(), persistent());
   }
 
   inline v8::Persistent<v8::Object>& persistent() {
     return object_;
   }
 
-  v8::Persistent<v8::Object> object_;
+  // TODO(bnoordhuis) Make these private.
   QUEUE req_wrap_queue_;
   T req_;  // *must* be last, GetActiveRequests() in node.cc depends on it
+
+ private:
+  v8::Persistent<v8::Object> object_;
+  Environment* const env_;
 };
 
 
diff --git a/src/signal_wrap.cc b/src/signal_wrap.cc
index b9f6d49ff1..a0d62e84a9 100644
--- a/src/signal_wrap.cc
+++ b/src/signal_wrap.cc
@@ -19,12 +19,14 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-#include "node.h"
+#include "env.h"
+#include "env-inl.h"
 #include "handle_wrap.h"
-
+#include "v8.h"
 
 namespace node {
 
+using v8::Context;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
@@ -33,17 +35,13 @@ using v8::HandleScope;
 using v8::Integer;
 using v8::Local;
 using v8::Object;
-using v8::String;
 using v8::Value;
 
-static Cached<String> onsignal_sym;
-
-
 class SignalWrap : public HandleWrap {
  public:
-  static void Initialize(Handle<Object> target) {
-    HandleScope scope(node_isolate);
-
+  static void Initialize(Handle<Object> target,
+                         Handle<Value> unused,
+                         Handle<Context> context) {
     Local<FunctionTemplate> constructor = FunctionTemplate::New(New);
     constructor->InstanceTemplate()->SetInternalFieldCount(1);
     constructor->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Signal"));
@@ -54,8 +52,6 @@ class SignalWrap : public HandleWrap {
     NODE_SET_PROTOTYPE_METHOD(constructor, "start", Start);
     NODE_SET_PROTOTYPE_METHOD(constructor, "stop", Stop);
 
-    onsignal_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onsignal");
-
     target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "Signal"),
                 constructor->GetFunction());
   }
@@ -66,14 +62,14 @@ class SignalWrap : public HandleWrap {
     // Therefore we assert that we are not trying to call this as a
     // normal function.
     assert(args.IsConstructCall());
-
-    HandleScope scope(node_isolate);
-    new SignalWrap(args.This());
+    Environment* env = Environment::GetCurrent(args.GetIsolate());
+    HandleScope handle_scope(args.GetIsolate());
+    new SignalWrap(env, args.This());
   }
 
-  explicit SignalWrap(Handle<Object> object)
-      : HandleWrap(object, reinterpret_cast<uv_handle_t*>(&handle_)) {
-    int r = uv_signal_init(uv_default_loop(), &handle_);
+  SignalWrap(Environment* env, Handle<Object> object)
+      : HandleWrap(env, object, reinterpret_cast<uv_handle_t*>(&handle_)) {
+    int r = uv_signal_init(env->event_loop(), &handle_);
     assert(r == 0);
   }
 
@@ -100,13 +96,12 @@ class SignalWrap : public HandleWrap {
   }
 
   static void OnSignal(uv_signal_t* handle, int signum) {
-    HandleScope scope(node_isolate);
-
     SignalWrap* wrap = container_of(handle, SignalWrap, handle_);
-    assert(wrap);
-
-    Local<Value> argv[1] = { Integer::New(signum, node_isolate) };
-    MakeCallback(wrap->object(), onsignal_sym, ARRAY_SIZE(argv), argv);
+    Environment* env = wrap->env();
+    Context::Scope context_scope(env->context());
+    HandleScope handle_scope(env->isolate());
+    Local<Value> arg = Integer::New(signum, env->isolate());
+    MakeCallback(env, wrap->object(), env->onsignal_string(), 1, &arg);
   }
 
   uv_signal_t handle_;
@@ -116,4 +111,4 @@ class SignalWrap : public HandleWrap {
 }  // namespace node
 
 
-NODE_MODULE(node_signal_wrap, node::SignalWrap::Initialize)
+NODE_MODULE_CONTEXT_AWARE(node_signal_wrap, node::SignalWrap::Initialize)
diff --git a/src/smalloc.cc b/src/smalloc.cc
index 07eecb9427..62a57fada9 100644
--- a/src/smalloc.cc
+++ b/src/smalloc.cc
@@ -20,11 +20,12 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include "smalloc.h"
-#include "node.h"
-#include "node_internals.h"
 
-#include "v8.h"
+#include "env.h"
+#include "env-inl.h"
+#include "node_internals.h"
 #include "v8-profiler.h"
+#include "v8.h"
 
 #include <string.h>
 #include <assert.h>
@@ -34,6 +35,7 @@
 namespace node {
 namespace smalloc {
 
+using v8::Context;
 using v8::External;
 using v8::ExternalArrayType;
 using v8::FunctionCallbackInfo;
@@ -45,7 +47,6 @@ using v8::Local;
 using v8::Object;
 using v8::Persistent;
 using v8::RetainedObjectInfo;
-using v8::String;
 using v8::Uint32;
 using v8::Value;
 using v8::kExternalUnsignedByteArray;
@@ -64,9 +65,6 @@ void TargetFreeCallback(Isolate* isolate,
                         Persistent<Object>* target,
                         CallbackInfo* arg);
 
-Cached<String> smalloc_sym;
-static bool using_alloc_cb;
-
 
 // return size of external array type, or 0 if unrecognized
 size_t ExternalArraySize(enum ExternalArrayType type) {
@@ -299,10 +297,11 @@ void AllocDispose(const FunctionCallbackInfo<Value>& args) {
 
 
 void AllocDispose(Handle<Object> obj) {
-  HandleScope handle_scope(node_isolate);
+  Environment* env = Environment::GetCurrent(node_isolate);
+  HandleScope handle_scope(env->isolate());
 
-  if (using_alloc_cb) {
-    Local<Value> ext_v = obj->GetHiddenValue(smalloc_sym);
+  if (env->using_smalloc_alloc_cb()) {
+    Local<Value> ext_v = obj->GetHiddenValue(env->smalloc_p_string());
     if (ext_v->IsExternal()) {
       Local<External> ext = ext_v.As<External>();
       CallbackInfo* cb_info = static_cast<CallbackInfo*>(ext->Value());
@@ -361,16 +360,14 @@ void Alloc(Handle<Object> obj,
            enum ExternalArrayType type) {
   assert(!obj->HasIndexedPropertiesInExternalArrayData());
 
-  if (smalloc_sym.IsEmpty()) {
-    smalloc_sym = FIXED_ONE_BYTE_STRING(node_isolate, "_smalloc_p");
-    using_alloc_cb = true;
-  }
+  Environment* env = Environment::GetCurrent(node_isolate);
+  env->set_using_smalloc_alloc_cb(true);
 
   CallbackInfo* cb_info = new CallbackInfo;
   cb_info->cb = fn;
   cb_info->hint = hint;
   cb_info->p_obj.Reset(node_isolate, obj);
-  obj->SetHiddenValue(smalloc_sym, External::New(cb_info));
+  obj->SetHiddenValue(env->smalloc_p_string(), External::New(cb_info));
 
   node_isolate->AdjustAmountOfExternalAllocatedMemory(length +
                                                       sizeof(*cb_info));
@@ -462,7 +459,11 @@ RetainedObjectInfo* WrapperInfo(uint16_t class_id, Handle<Value> wrapper) {
 }
 
 
-void Initialize(Handle<Object> exports) {
+void Initialize(Handle<Object> exports,
+                Handle<Value> unused,
+                Handle<Context> context) {
+  Environment* env = Environment::GetCurrent(context);
+
   NODE_SET_METHOD(exports, "copyOnto", CopyOnto);
   NODE_SET_METHOD(exports, "sliceOnto", SliceOnto);
 
@@ -470,13 +471,9 @@ void Initialize(Handle<Object> exports) {
   NODE_SET_METHOD(exports, "dispose", AllocDispose);
 
   exports->Set(FIXED_ONE_BYTE_STRING(node_isolate, "kMaxLength"),
-               Uint32::NewFromUnsigned(kMaxLength, node_isolate));
-
-  // for performance, begin checking if allocation object may contain
-  // callbacks if at least one has been set.
-  using_alloc_cb = false;
+               Uint32::NewFromUnsigned(kMaxLength, env->isolate()));
 
-  HeapProfiler* heap_profiler = node_isolate->GetHeapProfiler();
+  HeapProfiler* heap_profiler = env->isolate()->GetHeapProfiler();
   heap_profiler->SetWrapperClassInfoProvider(ALLOC_ID, WrapperInfo);
 }
 
@@ -484,4 +481,4 @@ void Initialize(Handle<Object> exports) {
 }  // namespace smalloc
 }  // namespace node
 
-NODE_MODULE(node_smalloc, node::smalloc::Initialize)
+NODE_MODULE_CONTEXT_AWARE(node_smalloc, node::smalloc::Initialize)
diff --git a/src/stream_wrap.cc b/src/stream_wrap.cc
index 6a5ff168d4..49a2f90f46 100644
--- a/src/stream_wrap.cc
+++ b/src/stream_wrap.cc
@@ -20,10 +20,11 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include "stream_wrap.h"
-#include "node.h"
+#include "env-inl.h"
+#include "env.h"
+#include "handle_wrap.h"
 #include "node_buffer.h"
 #include "node_counters.h"
-#include "handle_wrap.h"
 #include "pipe_wrap.h"
 #include "req_wrap.h"
 #include "tcp_wrap.h"
@@ -36,6 +37,7 @@
 namespace node {
 
 using v8::Array;
+using v8::Context;
 using v8::FunctionCallbackInfo;
 using v8::Handle;
 using v8::HandleScope;
@@ -49,31 +51,13 @@ using v8::Undefined;
 using v8::Value;
 
 
-static Cached<String> bytes_sym;
-static Cached<String> write_queue_size_sym;
-static Cached<String> onread_sym;
-static Cached<String> oncomplete_sym;
-static Cached<String> handle_sym;
-static bool initialized;
-
-
-void StreamWrap::Initialize(Handle<Object> target) {
-  if (initialized) return;
-  initialized = true;
-
-  HandleScope scope(node_isolate);
-  bytes_sym = FIXED_ONE_BYTE_STRING(node_isolate, "bytes");
-  write_queue_size_sym = FIXED_ONE_BYTE_STRING(node_isolate, "writeQueueSize");
-  onread_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onread");
-  oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
-}
-
-
-StreamWrap::StreamWrap(Handle<Object> object, uv_stream_t* stream)
-    : HandleWrap(object, reinterpret_cast<uv_handle_t*>(stream)),
-      stream_(stream),
-      default_callbacks_(this),
-      callbacks_(&default_callbacks_) {
+StreamWrap::StreamWrap(Environment* env,
+                       Local<Object> object,
+                       uv_stream_t* stream)
+    : HandleWrap(env, object, reinterpret_cast<uv_handle_t*>(stream))
+    , stream_(stream)
+    , default_callbacks_(this)
+    , callbacks_(&default_callbacks_) {
 }
 
 
@@ -95,7 +79,7 @@ void StreamWrap::UpdateWriteQueueSize() {
   HandleScope scope(node_isolate);
   Local<Integer> write_queue_size =
       Integer::NewFromUnsigned(stream()->write_queue_size, node_isolate);
-  object()->Set(write_queue_size_sym, write_queue_size);
+  object()->Set(env()->write_queue_size_string(), write_queue_size);
 }
 
 
@@ -137,12 +121,12 @@ void StreamWrap::OnAlloc(uv_handle_t* handle,
 
 
 template <class WrapType, class UVType>
-static Local<Object> AcceptHandle(uv_stream_t* pipe) {
+static Local<Object> AcceptHandle(Environment* env, uv_stream_t* pipe) {
   HandleScope scope(node_isolate);
   Local<Object> wrap_obj;
   UVType* handle;
 
-  wrap_obj = WrapType::Instantiate();
+  wrap_obj = WrapType::Instantiate(env);
   if (wrap_obj.IsEmpty())
     return Local<Object>();
 
@@ -208,7 +192,8 @@ size_t StreamWrap::WriteBuffer(Handle<Value> val, uv_buf_t* buf) {
 
 
 void StreamWrap::WriteBuffer(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   StreamWrap* wrap;
   NODE_UNWRAP(args.This(), StreamWrap, wrap);
@@ -221,7 +206,8 @@ void StreamWrap::WriteBuffer(const FunctionCallbackInfo<Value>& args) {
 
   size_t length = Buffer::Length(buf_obj);
   char* storage = new char[sizeof(WriteWrap)];
-  WriteWrap* req_wrap = new(storage) WriteWrap(req_wrap_obj, wrap);
+  WriteWrap* req_wrap =
+      new(storage) WriteWrap(env, req_wrap_obj, wrap);
 
   uv_buf_t buf;
   WriteBuffer(buf_obj, &buf);
@@ -232,7 +218,8 @@ void StreamWrap::WriteBuffer(const FunctionCallbackInfo<Value>& args) {
                                        NULL,
                                        StreamWrap::AfterWrite);
   req_wrap->Dispatched();
-  req_wrap_obj->Set(bytes_sym, Integer::NewFromUnsigned(length, node_isolate));
+  req_wrap_obj->Set(env->bytes_string(),
+                    Integer::NewFromUnsigned(length, node_isolate));
 
   if (err) {
     req_wrap->~WriteWrap();
@@ -245,7 +232,8 @@ void StreamWrap::WriteBuffer(const FunctionCallbackInfo<Value>& args) {
 
 template <enum encoding encoding>
 void StreamWrap::WriteStringImpl(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
   int err;
 
   StreamWrap* wrap;
@@ -272,7 +260,8 @@ void StreamWrap::WriteStringImpl(const FunctionCallbackInfo<Value>& args) {
   }
 
   char* storage = new char[sizeof(WriteWrap) + storage_size + 15];
-  WriteWrap* req_wrap = new(storage) WriteWrap(req_wrap_obj, wrap);
+  WriteWrap* req_wrap =
+      new(storage) WriteWrap(env, req_wrap_obj, wrap);
 
   char* data = reinterpret_cast<char*>(ROUND_UP(
       reinterpret_cast<uintptr_t>(storage) + sizeof(WriteWrap), 16));
@@ -301,14 +290,10 @@ void StreamWrap::WriteStringImpl(const FunctionCallbackInfo<Value>& args) {
       HandleWrap* wrap;
       NODE_UNWRAP(send_handle_obj, HandleWrap, wrap);
       send_handle = wrap->GetHandle();
-
       // Reference StreamWrap instance to prevent it from being garbage
       // collected before `AfterWrite` is called.
-      if (handle_sym.IsEmpty()) {
-        handle_sym = FIXED_ONE_BYTE_STRING(node_isolate, "handle");
-      }
       assert(!req_wrap->persistent().IsEmpty());
-      req_wrap->object()->Set(handle_sym, send_handle_obj);
+      req_wrap->object()->Set(env->handle_string(), send_handle_obj);
     }
 
     err = wrap->callbacks()->DoWrite(
@@ -320,7 +305,8 @@ void StreamWrap::WriteStringImpl(const FunctionCallbackInfo<Value>& args) {
   }
 
   req_wrap->Dispatched();
-  req_wrap->object()->Set(bytes_sym, Number::New(node_isolate, data_size));
+  req_wrap->object()->Set(env->bytes_string(),
+                          Number::New(node_isolate, data_size));
 
   if (err) {
     req_wrap->~WriteWrap();
@@ -332,7 +318,8 @@ void StreamWrap::WriteStringImpl(const FunctionCallbackInfo<Value>& args) {
 
 
 void StreamWrap::Writev(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope;
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   StreamWrap* wrap;
   NODE_UNWRAP(args.This(), StreamWrap, wrap);
@@ -378,7 +365,8 @@ void StreamWrap::Writev(const FunctionCallbackInfo<Value>& args) {
 
   storage_size += sizeof(WriteWrap);
   char* storage = new char[storage_size];
-  WriteWrap* req_wrap = new(storage) WriteWrap(req_wrap_obj, wrap);
+  WriteWrap* req_wrap =
+      new(storage) WriteWrap(env, req_wrap_obj, wrap);
 
   uint32_t bytes = 0;
   size_t offset = sizeof(WriteWrap);
@@ -419,7 +407,8 @@ void StreamWrap::Writev(const FunctionCallbackInfo<Value>& args) {
     delete[] bufs;
 
   req_wrap->Dispatched();
-  req_wrap->object()->Set(bytes_sym, Number::New(node_isolate, bytes));
+  req_wrap->object()->Set(env->bytes_string(),
+                          Number::New(node_isolate, bytes));
 
   if (err) {
     req_wrap->~WriteWrap();
@@ -448,8 +437,10 @@ void StreamWrap::WriteUcs2String(const FunctionCallbackInfo<Value>& args) {
 void StreamWrap::AfterWrite(uv_write_t* req, int status) {
   WriteWrap* req_wrap = container_of(req, WriteWrap, req_);
   StreamWrap* wrap = req_wrap->wrap();
+  Environment* env = wrap->env();
 
-  HandleScope scope(node_isolate);
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
 
   // The wrap and request objects should still be there.
   assert(req_wrap->persistent().IsEmpty() == false);
@@ -457,11 +448,8 @@ void StreamWrap::AfterWrite(uv_write_t* req, int status) {
 
   // Unref handle property
   Local<Object> req_wrap_obj = req_wrap->object();
-  if (!handle_sym.IsEmpty()) {
-    req_wrap_obj->Delete(handle_sym);
-  }
-
-  wrap->callbacks()->AfterWrite(req_wrap);
+  req_wrap_obj->Delete(env->handle_string());
+  wrap->callbacks_->AfterWrite(req_wrap);
 
   Local<Value> argv[] = {
     Integer::New(status, node_isolate),
@@ -469,7 +457,11 @@ void StreamWrap::AfterWrite(uv_write_t* req, int status) {
     req_wrap_obj
   };
 
-  MakeCallback(req_wrap_obj, oncomplete_sym, ARRAY_SIZE(argv), argv);
+  MakeCallback(env,
+               req_wrap_obj,
+               env->oncomplete_string(),
+               ARRAY_SIZE(argv),
+               argv);
 
   req_wrap->~WriteWrap();
   delete[] reinterpret_cast<char*>(req_wrap);
@@ -477,7 +469,8 @@ void StreamWrap::AfterWrite(uv_write_t* req, int status) {
 
 
 void StreamWrap::Shutdown(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   StreamWrap* wrap;
   NODE_UNWRAP(args.This(), StreamWrap, wrap);
@@ -485,7 +478,7 @@ void StreamWrap::Shutdown(const FunctionCallbackInfo<Value>& args) {
   assert(args[0]->IsObject());
   Local<Object> req_wrap_obj = args[0].As<Object>();
 
-  ShutdownWrap* req_wrap = new ShutdownWrap(req_wrap_obj);
+  ShutdownWrap* req_wrap = new ShutdownWrap(env, req_wrap_obj);
   int err = wrap->callbacks()->DoShutdown(req_wrap, AfterShutdown);
   req_wrap->Dispatched();
   if (err) delete req_wrap;
@@ -496,12 +489,14 @@ void StreamWrap::Shutdown(const FunctionCallbackInfo<Value>& args) {
 void StreamWrap::AfterShutdown(uv_shutdown_t* req, int status) {
   ShutdownWrap* req_wrap = static_cast<ShutdownWrap*>(req->data);
   StreamWrap* wrap = static_cast<StreamWrap*>(req->handle->data);
+  Environment* env = wrap->env();
 
   // The wrap and request objects should still be there.
   assert(req_wrap->persistent().IsEmpty() == false);
   assert(wrap->persistent().IsEmpty() == false);
 
-  HandleScope scope(node_isolate);
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
 
   Local<Object> req_wrap_obj = req_wrap->object();
   Local<Value> argv[3] = {
@@ -510,7 +505,11 @@ void StreamWrap::AfterShutdown(uv_shutdown_t* req, int status) {
     req_wrap_obj
   };
 
-  MakeCallback(req_wrap_obj, oncomplete_sym, ARRAY_SIZE(argv), argv);
+  MakeCallback(env,
+               req_wrap_obj,
+               env->oncomplete_string(),
+               ARRAY_SIZE(argv),
+               argv);
 
   delete req_wrap;
 }
@@ -568,7 +567,9 @@ void StreamWrapCallbacks::DoRead(uv_stream_t* handle,
                                  ssize_t nread,
                                  const uv_buf_t* buf,
                                  uv_handle_type pending) {
-  HandleScope scope(node_isolate);
+  Environment* env = wrap()->env();
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
 
   Local<Value> argv[] = {
     Integer::New(nread, node_isolate),
@@ -579,7 +580,7 @@ void StreamWrapCallbacks::DoRead(uv_stream_t* handle,
   if (nread < 0)  {
     if (buf->base != NULL)
       free(buf->base);
-    MakeCallback(Self(), onread_sym, ARRAY_SIZE(argv), argv);
+    MakeCallback(env, Self(), env->onread_string(), ARRAY_SIZE(argv), argv);
     return;
   }
 
@@ -591,15 +592,15 @@ void StreamWrapCallbacks::DoRead(uv_stream_t* handle,
 
   char* base = static_cast<char*>(realloc(buf->base, nread));
   assert(static_cast<size_t>(nread) <= buf->len);
-  argv[1] = Buffer::Use(base, nread);
+  argv[1] = Buffer::Use(env, base, nread);
 
   Local<Object> pending_obj;
   if (pending == UV_TCP) {
-    pending_obj = AcceptHandle<TCPWrap, uv_tcp_t>(handle);
+    pending_obj = AcceptHandle<TCPWrap, uv_tcp_t>(env, handle);
   } else if (pending == UV_NAMED_PIPE) {
-    pending_obj = AcceptHandle<PipeWrap, uv_pipe_t>(handle);
+    pending_obj = AcceptHandle<PipeWrap, uv_pipe_t>(env, handle);
   } else if (pending == UV_UDP) {
-    pending_obj = AcceptHandle<UDPWrap, uv_udp_t>(handle);
+    pending_obj = AcceptHandle<UDPWrap, uv_udp_t>(env, handle);
   } else {
     assert(pending == UV_UNKNOWN_HANDLE);
   }
@@ -608,7 +609,11 @@ void StreamWrapCallbacks::DoRead(uv_stream_t* handle,
     argv[2] = pending_obj;
   }
 
-  MakeCallback(wrap()->object(), onread_sym, ARRAY_SIZE(argv), argv);
+  MakeCallback(env,
+               wrap()->object(),
+               env->onread_string(),
+               ARRAY_SIZE(argv),
+               argv);
 }
 
 
diff --git a/src/stream_wrap.h b/src/stream_wrap.h
index 6731fdbf75..26fb5d5ef6 100644
--- a/src/stream_wrap.h
+++ b/src/stream_wrap.h
@@ -22,11 +22,11 @@
 #ifndef SRC_STREAM_WRAP_H_
 #define SRC_STREAM_WRAP_H_
 
-#include "v8.h"
-#include "node.h"
+#include "env.h"
 #include "handle_wrap.h"
 #include "req_wrap.h"
 #include "string_bytes.h"
+#include "v8.h"
 
 namespace node {
 
@@ -37,8 +37,8 @@ typedef class ReqWrap<uv_shutdown_t> ShutdownWrap;
 
 class WriteWrap: public ReqWrap<uv_write_t> {
  public:
-  WriteWrap(v8::Local<v8::Object> obj, StreamWrap* wrap)
-      : ReqWrap<uv_write_t>(obj)
+  WriteWrap(Environment* env, v8::Local<v8::Object> obj, StreamWrap* wrap)
+      : ReqWrap<uv_write_t>(env, obj)
       , wrap_(wrap) {
   }
 
@@ -108,8 +108,6 @@ class StreamWrap : public HandleWrap {
       delete old;
   }
 
-  static void Initialize(v8::Handle<v8::Object> target);
-
   static void GetFD(v8::Local<v8::String>,
                     const v8::PropertyCallbackInfo<v8::Value>&);
 
@@ -148,7 +146,9 @@ class StreamWrap : public HandleWrap {
  protected:
   static size_t WriteBuffer(v8::Handle<v8::Value> val, uv_buf_t* buf);
 
-  StreamWrap(v8::Handle<v8::Object> object, uv_stream_t* stream);
+  StreamWrap(Environment* env,
+             v8::Local<v8::Object> object,
+             uv_stream_t* stream);
 
   ~StreamWrap() {
     if (callbacks_ != &default_callbacks_) {
diff --git a/src/tcp_wrap.cc b/src/tcp_wrap.cc
index e007056296..305ee1db2b 100644
--- a/src/tcp_wrap.cc
+++ b/src/tcp_wrap.cc
@@ -20,10 +20,12 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include "tcp_wrap.h"
-#include "node.h"
+
+#include "env.h"
+#include "env-inl.h"
+#include "handle_wrap.h"
 #include "node_buffer.h"
 #include "node_wrap.h"
-#include "handle_wrap.h"
 #include "req_wrap.h"
 #include "stream_wrap.h"
 
@@ -32,6 +34,7 @@
 
 namespace node {
 
+using v8::Context;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
@@ -40,40 +43,32 @@ using v8::HandleScope;
 using v8::Integer;
 using v8::Local;
 using v8::Object;
-using v8::Persistent;
 using v8::PropertyAttribute;
 using v8::String;
 using v8::Undefined;
 using v8::Value;
 
-static Persistent<Function> tcpConstructor;
-static Cached<String> oncomplete_sym;
-static Cached<String> onconnection_sym;
-
-
 typedef class ReqWrap<uv_connect_t> ConnectWrap;
 
 
-Local<Object> TCPWrap::Instantiate() {
-  // If this assert fire then process.binding('tcp_wrap') hasn't been
-  // called yet.
-  assert(tcpConstructor.IsEmpty() == false);
-
-  HandleScope scope(node_isolate);
-  Local<Object> obj = NewInstance(tcpConstructor);
-
-  return scope.Close(obj);
+Local<Object> TCPWrap::Instantiate(Environment* env) {
+  HandleScope handle_scope(env->isolate());
+  assert(env->tcp_constructor_template().IsEmpty() == false);
+  Local<Function> constructor = env->tcp_constructor_template()->GetFunction();
+  assert(constructor.IsEmpty() == false);
+  Local<Object> instance = constructor->NewInstance();
+  assert(instance.IsEmpty() == false);
+  return handle_scope.Close(instance);
 }
 
 
-void TCPWrap::Initialize(Handle<Object> target) {
-  StreamWrap::Initialize(target);
-
-  HandleScope scope(node_isolate);
+void TCPWrap::Initialize(Handle<Object> target,
+                         Handle<Value> unused,
+                         Handle<Context> context) {
+  Environment* env = Environment::GetCurrent(context);
 
   Local<FunctionTemplate> t = FunctionTemplate::New(New);
   t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "TCP"));
-
   t->InstanceTemplate()->SetInternalFieldCount(1);
 
   enum PropertyAttribute attributes =
@@ -119,12 +114,8 @@ void TCPWrap::Initialize(Handle<Object> target) {
                             SetSimultaneousAccepts);
 #endif
 
-  onconnection_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onconnection");
-  oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
-
-  tcpConstructorTmpl.Reset(node_isolate, t);
-  tcpConstructor.Reset(node_isolate, t->GetFunction());
   target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "TCP"), t->GetFunction());
+  env->set_tcp_constructor_template(t);
 }
 
 
@@ -145,15 +136,16 @@ void TCPWrap::New(const FunctionCallbackInfo<Value>& args) {
   // Therefore we assert that we are not trying to call this as a
   // normal function.
   assert(args.IsConstructCall());
-  HandleScope scope(node_isolate);
-  TCPWrap* wrap = new TCPWrap(args.This());
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
+  TCPWrap* wrap = new TCPWrap(env, args.This());
   assert(wrap);
 }
 
 
-TCPWrap::TCPWrap(Handle<Object> object)
-    : StreamWrap(object, reinterpret_cast<uv_stream_t*>(&handle_)) {
-  int r = uv_tcp_init(uv_default_loop(), &handle_);
+TCPWrap::TCPWrap(Environment* env, Handle<Object> object)
+    : StreamWrap(env, object, reinterpret_cast<uv_stream_t*>(&handle_)) {
+  int r = uv_tcp_init(env->event_loop(), &handle_);
   assert(r == 0);  // How do we proxy this error up to javascript?
                    // Suggestion: uv_tcp_init() returns void.
   UpdateWriteQueueSize();
@@ -166,7 +158,8 @@ TCPWrap::~TCPWrap() {
 
 
 void TCPWrap::GetSockName(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
   struct sockaddr_storage address;
 
   TCPWrap* wrap;
@@ -181,7 +174,7 @@ void TCPWrap::GetSockName(const FunctionCallbackInfo<Value>& args) {
                                &addrlen);
   if (err == 0) {
     const sockaddr* addr = reinterpret_cast<const sockaddr*>(&address);
-    AddressToJS(addr, out);
+    AddressToJS(env, addr, out);
   }
 
   args.GetReturnValue().Set(err);
@@ -189,7 +182,8 @@ void TCPWrap::GetSockName(const FunctionCallbackInfo<Value>& args) {
 
 
 void TCPWrap::GetPeerName(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
   struct sockaddr_storage address;
 
   TCPWrap* wrap;
@@ -204,7 +198,7 @@ void TCPWrap::GetPeerName(const FunctionCallbackInfo<Value>& args) {
                                &addrlen);
   if (err == 0) {
     const sockaddr* addr = reinterpret_cast<const sockaddr*>(&address);
-    AddressToJS(addr, out);
+    AddressToJS(env, addr, out);
   }
 
   args.GetReturnValue().Set(err);
@@ -311,10 +305,12 @@ void TCPWrap::Listen(const FunctionCallbackInfo<Value>& args) {
 
 
 void TCPWrap::OnConnection(uv_stream_t* handle, int status) {
-  HandleScope scope(node_isolate);
-
   TCPWrap* tcp_wrap = static_cast<TCPWrap*>(handle->data);
   assert(&tcp_wrap->handle_ == reinterpret_cast<uv_tcp_t*>(handle));
+  Environment* env = tcp_wrap->env();
+
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
 
   // We should not be getting this callback if someone as already called
   // uv_close() on the handle.
@@ -327,7 +323,7 @@ void TCPWrap::OnConnection(uv_stream_t* handle, int status) {
 
   if (status == 0) {
     // Instantiate the client javascript object and handle.
-    Local<Object> client_obj = Instantiate();
+    Local<Object> client_obj = Instantiate(env);
 
     // Unwrap the client javascript object.
     TCPWrap* wrap;
@@ -340,15 +336,22 @@ void TCPWrap::OnConnection(uv_stream_t* handle, int status) {
     argv[1] = client_obj;
   }
 
-  MakeCallback(tcp_wrap->object(), onconnection_sym, ARRAY_SIZE(argv), argv);
+  MakeCallback(env,
+               tcp_wrap->object(),
+               env->onconnection_string(),
+               ARRAY_SIZE(argv),
+               argv);
 }
 
 
 void TCPWrap::AfterConnect(uv_connect_t* req, int status) {
   ConnectWrap* req_wrap = static_cast<ConnectWrap*>(req->data);
   TCPWrap* wrap = static_cast<TCPWrap*>(req->handle->data);
+  assert(req_wrap->env() == wrap->env());
+  Environment* env = wrap->env();
 
-  HandleScope scope(node_isolate);
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
 
   // The wrap and request objects should still be there.
   assert(req_wrap->persistent().IsEmpty() == false);
@@ -362,14 +365,19 @@ void TCPWrap::AfterConnect(uv_connect_t* req, int status) {
     v8::True(node_isolate),
     v8::True(node_isolate)
   };
-  MakeCallback(req_wrap_obj, oncomplete_sym, ARRAY_SIZE(argv), argv);
+  MakeCallback(env,
+               req_wrap_obj,
+               env->oncomplete_string(),
+               ARRAY_SIZE(argv),
+               argv);
 
   delete req_wrap;
 }
 
 
 void TCPWrap::Connect(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   TCPWrap* wrap;
   NODE_UNWRAP(args.This(), TCPWrap, wrap);
@@ -386,7 +394,7 @@ void TCPWrap::Connect(const FunctionCallbackInfo<Value>& args) {
   int err = uv_ip4_addr(*ip_address, port, &addr);
 
   if (err == 0) {
-    ConnectWrap* req_wrap = new ConnectWrap(req_wrap_obj);
+    ConnectWrap* req_wrap = new ConnectWrap(env, req_wrap_obj);
     err = uv_tcp_connect(&req_wrap->req_,
                          &wrap->handle_,
                          reinterpret_cast<const sockaddr*>(&addr),
@@ -400,7 +408,8 @@ void TCPWrap::Connect(const FunctionCallbackInfo<Value>& args) {
 
 
 void TCPWrap::Connect6(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   TCPWrap* wrap;
   NODE_UNWRAP(args.This(), TCPWrap, wrap);
@@ -417,7 +426,7 @@ void TCPWrap::Connect6(const FunctionCallbackInfo<Value>& args) {
   int err = uv_ip6_addr(*ip_address, port, &addr);
 
   if (err == 0) {
-    ConnectWrap* req_wrap = new ConnectWrap(req_wrap_obj);
+    ConnectWrap* req_wrap = new ConnectWrap(env, req_wrap_obj);
     err = uv_tcp_connect(&req_wrap->req_,
                          &wrap->handle_,
                          reinterpret_cast<const sockaddr*>(&addr),
@@ -431,27 +440,15 @@ void TCPWrap::Connect6(const FunctionCallbackInfo<Value>& args) {
 
 
 // also used by udp_wrap.cc
-Local<Object> AddressToJS(const sockaddr* addr, Handle<Object> info) {
-  static Cached<String> address_sym;
-  static Cached<String> family_sym;
-  static Cached<String> port_sym;
-  static Cached<String> ipv4_sym;
-  static Cached<String> ipv6_sym;
-
+Local<Object> AddressToJS(Environment* env,
+                          const sockaddr* addr,
+                          Local<Object> info) {
   HandleScope scope(node_isolate);
   char ip[INET6_ADDRSTRLEN];
   const sockaddr_in *a4;
   const sockaddr_in6 *a6;
   int port;
 
-  if (address_sym.IsEmpty()) {
-    address_sym = FIXED_ONE_BYTE_STRING(node_isolate, "address");
-    family_sym = FIXED_ONE_BYTE_STRING(node_isolate, "family");
-    port_sym = FIXED_ONE_BYTE_STRING(node_isolate, "port");
-    ipv4_sym = FIXED_ONE_BYTE_STRING(node_isolate, "IPv4");
-    ipv6_sym = FIXED_ONE_BYTE_STRING(node_isolate, "IPv6");
-  }
-
   if (info.IsEmpty()) info = Object::New();
 
   switch (addr->sa_family) {
@@ -459,22 +456,22 @@ Local<Object> AddressToJS(const sockaddr* addr, Handle<Object> info) {
     a6 = reinterpret_cast<const sockaddr_in6*>(addr);
     uv_inet_ntop(AF_INET6, &a6->sin6_addr, ip, sizeof ip);
     port = ntohs(a6->sin6_port);
-    info->Set(address_sym, OneByteString(node_isolate, ip));
-    info->Set(family_sym, ipv6_sym);
-    info->Set(port_sym, Integer::New(port, node_isolate));
+    info->Set(env->address_string(), OneByteString(node_isolate, ip));
+    info->Set(env->family_string(), env->ipv6_string());
+    info->Set(env->port_string(), Integer::New(port, node_isolate));
     break;
 
   case AF_INET:
     a4 = reinterpret_cast<const sockaddr_in*>(addr);
     uv_inet_ntop(AF_INET, &a4->sin_addr, ip, sizeof ip);
     port = ntohs(a4->sin_port);
-    info->Set(address_sym, OneByteString(node_isolate, ip));
-    info->Set(family_sym, ipv4_sym);
-    info->Set(port_sym, Integer::New(port, node_isolate));
+    info->Set(env->address_string(), OneByteString(node_isolate, ip));
+    info->Set(env->family_string(), env->ipv4_string());
+    info->Set(env->port_string(), Integer::New(port, node_isolate));
     break;
 
   default:
-    info->Set(address_sym, String::Empty(node_isolate));
+    info->Set(env->address_string(), String::Empty(node_isolate));
   }
 
   return scope.Close(info);
@@ -483,4 +480,4 @@ Local<Object> AddressToJS(const sockaddr* addr, Handle<Object> info) {
 
 }  // namespace node
 
-NODE_MODULE(node_tcp_wrap, node::TCPWrap::Initialize)
+NODE_MODULE_CONTEXT_AWARE(node_tcp_wrap, node::TCPWrap::Initialize)
diff --git a/src/tcp_wrap.h b/src/tcp_wrap.h
index 374458b78d..b1fa4c7f8f 100644
--- a/src/tcp_wrap.h
+++ b/src/tcp_wrap.h
@@ -21,20 +21,24 @@
 
 #ifndef SRC_TCP_WRAP_H_
 #define SRC_TCP_WRAP_H_
+
+#include "env.h"
 #include "stream_wrap.h"
 
 namespace node {
 
 class TCPWrap : public StreamWrap {
  public:
-  static v8::Local<v8::Object> Instantiate();
+  static v8::Local<v8::Object> Instantiate(Environment* env);
   static TCPWrap* Unwrap(v8::Local<v8::Object> obj);
-  static void Initialize(v8::Handle<v8::Object> target);
+  static void Initialize(v8::Handle<v8::Object> target,
+                         v8::Handle<v8::Value> unused,
+                         v8::Handle<v8::Context> context);
 
   uv_tcp_t* UVHandle();
 
  private:
-  explicit TCPWrap(v8::Handle<v8::Object> object);
+  TCPWrap(Environment* env, v8::Handle<v8::Object> object);
   ~TCPWrap();
 
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
diff --git a/src/timer_wrap.cc b/src/timer_wrap.cc
index c9782d8713..76b95540f2 100644
--- a/src/timer_wrap.cc
+++ b/src/timer_wrap.cc
@@ -19,13 +19,15 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-#include "node.h"
+#include "env.h"
+#include "env-inl.h"
 #include "handle_wrap.h"
 
 #include <stdint.h>
 
 namespace node {
 
+using v8::Context;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
@@ -40,9 +42,9 @@ const uint32_t kOnTimeout = 0;
 
 class TimerWrap : public HandleWrap {
  public:
-  static void Initialize(Handle<Object> target) {
-    HandleScope scope(node_isolate);
-
+  static void Initialize(Handle<Object> target,
+                         Handle<Value> unused,
+                         Handle<Context> context) {
     Local<FunctionTemplate> constructor = FunctionTemplate::New(New);
     constructor->InstanceTemplate()->SetInternalFieldCount(1);
     constructor->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "Timer"));
@@ -71,13 +73,14 @@ class TimerWrap : public HandleWrap {
     // Therefore we assert that we are not trying to call this as a
     // normal function.
     assert(args.IsConstructCall());
-    HandleScope scope(node_isolate);
-    new TimerWrap(args.This());
+    Environment* env = Environment::GetCurrent(args.GetIsolate());
+    HandleScope handle_scope(args.GetIsolate());
+    new TimerWrap(env, args.This());
   }
 
-  explicit TimerWrap(Handle<Object> object)
-      : HandleWrap(object, reinterpret_cast<uv_handle_t*>(&handle_)) {
-    int r = uv_timer_init(uv_default_loop(), &handle_);
+  TimerWrap(Environment* env, Handle<Object> object)
+      : HandleWrap(env, object, reinterpret_cast<uv_handle_t*>(&handle_)) {
+    int r = uv_timer_init(env->event_loop(), &handle_);
     assert(r == 0);
   }
 
@@ -133,19 +136,19 @@ class TimerWrap : public HandleWrap {
   }
 
   static void OnTimeout(uv_timer_t* handle, int status) {
-    HandleScope scope(node_isolate);
-
     TimerWrap* wrap = static_cast<TimerWrap*>(handle->data);
-    assert(wrap);
-
+    Environment* env = wrap->env();
+    Context::Scope context_scope(env->context());
+    HandleScope handle_scope(env->isolate());
     Local<Value> argv[1] = { Integer::New(status, node_isolate) };
-    MakeCallback(wrap->object(), kOnTimeout, ARRAY_SIZE(argv), argv);
+    MakeCallback(env, wrap->object(), kOnTimeout, ARRAY_SIZE(argv), argv);
   }
 
   static void Now(const FunctionCallbackInfo<Value>& args) {
-    HandleScope scope(node_isolate);
-    uv_update_time(uv_default_loop());
-    double now = static_cast<double>(uv_now(uv_default_loop()));
+    Environment* env = Environment::GetCurrent(args.GetIsolate());
+    HandleScope handle_scope(args.GetIsolate());
+    uv_update_time(env->event_loop());
+    double now = static_cast<double>(uv_now(env->event_loop()));
     args.GetReturnValue().Set(now);
   }
 
@@ -155,4 +158,4 @@ class TimerWrap : public HandleWrap {
 
 }  // namespace node
 
-NODE_MODULE(node_timer_wrap, node::TimerWrap::Initialize)
+NODE_MODULE_CONTEXT_AWARE(node_timer_wrap, node::TimerWrap::Initialize)
diff --git a/src/tls_wrap.cc b/src/tls_wrap.cc
index cff2cded8c..e6afda6c0c 100644
--- a/src/tls_wrap.cc
+++ b/src/tls_wrap.cc
@@ -34,6 +34,7 @@ namespace node {
 using crypto::SSLWrap;
 using crypto::SecureContext;
 using v8::Boolean;
+using v8::Context;
 using v8::Exception;
 using v8::Function;
 using v8::FunctionCallbackInfo;
@@ -44,40 +45,20 @@ using v8::Integer;
 using v8::Local;
 using v8::Null;
 using v8::Object;
-using v8::Persistent;
 using v8::String;
 using v8::Value;
 
-static Cached<String> onread_sym;
-static Cached<String> onerror_sym;
-static Cached<String> onhandshakestart_sym;
-static Cached<String> onhandshakedone_sym;
-static Cached<String> onclienthello_sym;
-static Cached<String> subject_sym;
-static Cached<String> subjectaltname_sym;
-static Cached<String> modulus_sym;
-static Cached<String> exponent_sym;
-static Cached<String> issuer_sym;
-static Cached<String> valid_from_sym;
-static Cached<String> valid_to_sym;
-static Cached<String> fingerprint_sym;
-static Cached<String> name_sym;
-static Cached<String> version_sym;
-static Cached<String> ext_key_usage_sym;
-static Cached<String> sni_context_sym;
-
-static Persistent<Function> tlsWrap;
-
 static const int X509_NAME_FLAGS = ASN1_STRFLGS_ESC_CTRL
                                  | ASN1_STRFLGS_ESC_MSB
                                  | XN_FLAG_SEP_MULTILINE
                                  | XN_FLAG_FN_SN;
 
 
-TLSCallbacks::TLSCallbacks(Kind kind,
+TLSCallbacks::TLSCallbacks(Environment* env,
+                           Kind kind,
                            Handle<Object> sc,
                            StreamWrapCallbacks* old)
-    : SSLWrap<TLSCallbacks>(ObjectWrap::Unwrap<SecureContext>(sc), kind),
+    : SSLWrap<TLSCallbacks>(env, ObjectWrap::Unwrap<SecureContext>(sc), kind),
       StreamWrapCallbacks(old),
       enc_in_(NULL),
       enc_out_(NULL),
@@ -92,7 +73,7 @@ TLSCallbacks::TLSCallbacks(Kind kind,
   sc_ = ObjectWrap::Unwrap<SecureContext>(sc);
   sc_handle_.Reset(node_isolate, sc);
 
-  Local<Object> object = NewInstance(tlsWrap);
+  Local<Object> object = env->tls_wrap_constructor_function()->NewInstance();
   NODE_WRAP(object, this);
   persistent().Reset(node_isolate, object);
 
@@ -197,7 +178,8 @@ void TLSCallbacks::InitSSL() {
 
 
 void TLSCallbacks::Wrap(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   if (args.Length() < 1 || !args[0]->IsObject())
     return ThrowTypeError("First argument should be a StreamWrap instance");
@@ -212,8 +194,8 @@ void TLSCallbacks::Wrap(const FunctionCallbackInfo<Value>& args) {
                                   SSLWrap<TLSCallbacks>::kClient;
 
   TLSCallbacks* callbacks = NULL;
-  WITH_GENERIC_STREAM(stream, {
-    callbacks = new TLSCallbacks(kind, sc, wrap->callbacks());
+  WITH_GENERIC_STREAM(env, stream, {
+    callbacks = new TLSCallbacks(env, kind, sc, wrap->callbacks());
     wrap->OverrideCallbacks(callbacks);
   });
 
@@ -243,23 +225,32 @@ void TLSCallbacks::Start(const FunctionCallbackInfo<Value>& args) {
 
 
 void TLSCallbacks::SSLInfoCallback(const SSL* ssl_, int where, int ret) {
+  if (!(where & (SSL_CB_HANDSHAKE_START | SSL_CB_HANDSHAKE_DONE)))
+    return;
+
   // Be compatible with older versions of OpenSSL. SSL_get_app_data() wants
   // a non-const SSL* in OpenSSL <= 0.9.7e.
   SSL* ssl = const_cast<SSL*>(ssl_);
+  TLSCallbacks* c = static_cast<TLSCallbacks*>(SSL_get_app_data(ssl));
+  Environment* env = c->env();
+  // There should be a Context::Scope a few stack frames down.
+  assert(env->context() == env->isolate()->GetCurrentContext());
+  HandleScope handle_scope(env->isolate());
+  Local<Object> object = c->object(env->isolate());
+
   if (where & SSL_CB_HANDSHAKE_START) {
-    HandleScope scope(node_isolate);
-    TLSCallbacks* c = static_cast<TLSCallbacks*>(SSL_get_app_data(ssl));
-    Local<Object> object = c->object(node_isolate);
-    if (object->Has(onhandshakestart_sym))
-      MakeCallback(object, onhandshakestart_sym, 0, NULL);
+    Local<Value> callback = object->Get(env->onhandshakestart_string());
+    if (callback->IsFunction()) {
+      MakeCallback(env, object, callback.As<Function>());
+    }
   }
+
   if (where & SSL_CB_HANDSHAKE_DONE) {
-    HandleScope scope(node_isolate);
-    TLSCallbacks* c = static_cast<TLSCallbacks*>(SSL_get_app_data(ssl));
     c->established_ = true;
-    Local<Object> object = c->object(node_isolate);
-    if (object->Has(onhandshakedone_sym))
-      MakeCallback(object, onhandshakedone_sym, 0, NULL);
+    Local<Value> callback = object->Get(env->onhandshakedone_string());
+    if (callback->IsFunction()) {
+      MakeCallback(env, object, callback.As<Function>());
+    }
   }
 }
 
@@ -306,9 +297,8 @@ void TLSCallbacks::EncOut() {
 
 
 void TLSCallbacks::EncOutCb(uv_write_t* req, int status) {
-  HandleScope scope(node_isolate);
-
   TLSCallbacks* callbacks = static_cast<TLSCallbacks*>(req->data);
+  Environment* env = callbacks->env();
 
   // Handle error
   if (status) {
@@ -317,10 +307,16 @@ void TLSCallbacks::EncOutCb(uv_write_t* req, int status) {
       return;
 
     // Notify about error
+    Context::Scope context_scope(env->context());
+    HandleScope handle_scope(env->isolate());
     Local<Value> arg = String::Concat(
         FIXED_ONE_BYTE_STRING(node_isolate, "write cb error, status: "),
         Integer::New(status, node_isolate)->ToString());
-    MakeCallback(callbacks->object(node_isolate), onerror_sym, 1, &arg);
+    MakeCallback(env,
+                 callbacks->object(node_isolate),
+                 env->onerror_string(),
+                 1,
+                 &arg);
     callbacks->InvokeQueued(status);
     return;
   }
@@ -334,7 +330,7 @@ void TLSCallbacks::EncOutCb(uv_write_t* req, int status) {
 }
 
 
-Handle<Value> TLSCallbacks::GetSSLError(int status, int* err) {
+Local<Value> TLSCallbacks::GetSSLError(int status, int* err) {
   HandleScope scope(node_isolate);
 
   *err = SSL_get_error(ssl_, status);
@@ -365,7 +361,7 @@ Handle<Value> TLSCallbacks::GetSSLError(int status, int* err) {
         return scope.Close(exception);
       }
   }
-  return Handle<Value>();
+  return Local<Value>();
 }
 
 
@@ -374,7 +370,8 @@ void TLSCallbacks::ClearOut() {
   if (!hello_parser_.IsEnded())
     return;
 
-  HandleScope scope(node_isolate);
+  Context::Scope context_scope(env()->context());
+  HandleScope handle_scope(env()->isolate());
 
   assert(ssl_ != NULL);
 
@@ -385,9 +382,13 @@ void TLSCallbacks::ClearOut() {
     if (read > 0) {
       Local<Value> argv[] = {
         Integer::New(read, node_isolate),
-        Buffer::New(out, read)
+        Buffer::New(env(), out, read)
       };
-      MakeCallback(Self(), onread_sym, ARRAY_SIZE(argv), argv);
+      MakeCallback(env(),
+                   Self(),
+                   env()->onread_string(),
+                   ARRAY_SIZE(argv),
+                   argv);
     }
   } while (read > 0);
 
@@ -395,8 +396,13 @@ void TLSCallbacks::ClearOut() {
     int err;
     Handle<Value> argv = GetSSLError(read, &err);
 
-    if (!argv.IsEmpty())
-      MakeCallback(object(node_isolate), onerror_sym, 1, &argv);
+    if (!argv.IsEmpty()) {
+      MakeCallback(env(),
+                   object(node_isolate),
+                   env()->onerror_string(),
+                   1,
+                   &argv);
+    }
   }
 }
 
@@ -406,8 +412,6 @@ bool TLSCallbacks::ClearIn() {
   if (!hello_parser_.IsEnded())
     return false;
 
-  HandleScope scope(node_isolate);
-
   int written = 0;
   while (clear_in_->Length() > 0) {
     size_t avail = 0;
@@ -425,11 +429,19 @@ bool TLSCallbacks::ClearIn() {
     return true;
   }
 
+  Context::Scope context_scope(env()->context());
+  HandleScope handle_scope(env()->isolate());
+
   // Error or partial write
   int err;
   Handle<Value> argv = GetSSLError(written, &err);
-  if (!argv.IsEmpty())
-    MakeCallback(object(node_isolate), onerror_sym, 1, &argv);
+  if (!argv.IsEmpty()) {
+    MakeCallback(env(),
+                 object(node_isolate),
+                 env()->onerror_string(),
+                 1,
+                 &argv);
+  }
 
   return false;
 }
@@ -440,8 +452,6 @@ int TLSCallbacks::DoWrite(WriteWrap* w,
                           size_t count,
                           uv_stream_t* send_handle,
                           uv_write_cb cb) {
-  HandleScope scope(node_isolate);
-
   assert(send_handle == NULL);
 
   // Queue callback to execute it on next tick
@@ -489,9 +499,15 @@ int TLSCallbacks::DoWrite(WriteWrap* w,
 
   if (i != count) {
     int err;
+    Context::Scope context_scope(env()->context());
+    HandleScope handle_scope(env()->isolate());
     Handle<Value> argv = GetSSLError(written, &err);
     if (!argv.IsEmpty()) {
-      MakeCallback(object(node_isolate), onerror_sym, 1, &argv);
+      MakeCallback(env(),
+                   object(node_isolate),
+                   env()->onerror_string(),
+                   1,
+                   &argv);
       return -1;
     }
 
@@ -527,8 +543,10 @@ void TLSCallbacks::DoRead(uv_stream_t* handle,
   if (nread < 0)  {
     // Error should be emitted only after all data was read
     ClearOut();
+    Context::Scope context_scope(env()->context());
+    HandleScope handle_scope(env()->isolate());
     Local<Value> arg = Integer::New(nread, node_isolate);
-    MakeCallback(Self(), onread_sym, 1, &arg);
+    MakeCallback(env(), Self(), env()->onread_string(), 1, &arg);
     return;
   }
 
@@ -664,18 +682,16 @@ int TLSCallbacks::SelectSNIContextCallback(SSL* s, int* ad, void* arg) {
   HandleScope scope(node_isolate);
 
   TLSCallbacks* p = static_cast<TLSCallbacks*>(arg);
+  Environment* env = p->env();
 
   const char* servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
 
   if (servername != NULL) {
     // Call the SNI callback and use its return value as context
     Local<Object> object = p->object(node_isolate);
-    Local<Value> ctx;
-    if (object->Has(sni_context_sym)) {
-      ctx = object->Get(sni_context_sym);
-    }
+    Local<Value> ctx = object->Get(env->sni_context_string());
 
-    if (ctx.IsEmpty() || ctx->IsUndefined())
+    if (!ctx->IsObject())
       return SSL_TLSEXT_ERR_NOACK;
 
     p->sni_context_.Dispose();
@@ -690,8 +706,10 @@ int TLSCallbacks::SelectSNIContextCallback(SSL* s, int* ad, void* arg) {
 #endif  // SSL_CTRL_SET_TLSEXT_SERVERNAME_CB
 
 
-void TLSCallbacks::Initialize(Handle<Object> target) {
-  HandleScope scope(node_isolate);
+void TLSCallbacks::Initialize(Handle<Object> target,
+                              Handle<Value> unused,
+                              Handle<Context> context) {
+  Environment* env = Environment::GetCurrent(context);
 
   NODE_SET_METHOD(target, "wrap", TLSCallbacks::Wrap);
 
@@ -715,29 +733,9 @@ void TLSCallbacks::Initialize(Handle<Object> target) {
   NODE_SET_PROTOTYPE_METHOD(t, "setServername", SetServername);
 #endif  // SSL_CRT_SET_TLSEXT_SERVERNAME_CB
 
-  tlsWrap.Reset(node_isolate, t->GetFunction());
-
-  onread_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onread");
-  onerror_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onerror");
-  onhandshakestart_sym =
-      FIXED_ONE_BYTE_STRING(node_isolate, "onhandshakestart");
-  onhandshakedone_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onhandshakedone");
-  onclienthello_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onclienthello");
-
-  subject_sym = FIXED_ONE_BYTE_STRING(node_isolate, "subject");
-  issuer_sym = FIXED_ONE_BYTE_STRING(node_isolate, "issuer");
-  valid_from_sym = FIXED_ONE_BYTE_STRING(node_isolate, "valid_from");
-  valid_to_sym = FIXED_ONE_BYTE_STRING(node_isolate, "valid_to");
-  subjectaltname_sym = FIXED_ONE_BYTE_STRING(node_isolate, "subjectaltname");
-  modulus_sym = FIXED_ONE_BYTE_STRING(node_isolate, "modulus");
-  exponent_sym = FIXED_ONE_BYTE_STRING(node_isolate, "exponent");
-  fingerprint_sym = FIXED_ONE_BYTE_STRING(node_isolate, "fingerprint");
-  name_sym = FIXED_ONE_BYTE_STRING(node_isolate, "name");
-  version_sym = FIXED_ONE_BYTE_STRING(node_isolate, "version");
-  ext_key_usage_sym = FIXED_ONE_BYTE_STRING(node_isolate, "ext_key_usage");
-  sni_context_sym = FIXED_ONE_BYTE_STRING(node_isolate, "sni_context");
+  env->set_tls_wrap_constructor_function(t->GetFunction());
 }
 
 }  // namespace node
 
-NODE_MODULE(node_tls_wrap, node::TLSCallbacks::Initialize)
+NODE_MODULE_CONTEXT_AWARE(node_tls_wrap, node::TLSCallbacks::Initialize)
diff --git a/src/tls_wrap.h b/src/tls_wrap.h
index 83f54c3b92..d8f3997923 100644
--- a/src/tls_wrap.h
+++ b/src/tls_wrap.h
@@ -24,6 +24,8 @@
 
 #include "node.h"
 #include "node_crypto.h"  // SSLWrap
+
+#include "env.h"
 #include "queue.h"
 #include "stream_wrap.h"
 #include "v8.h"
@@ -42,7 +44,9 @@ namespace crypto {
 class TLSCallbacks : public crypto::SSLWrap<TLSCallbacks>,
                      public StreamWrapCallbacks {
  public:
-  static void Initialize(v8::Handle<v8::Object> target);
+  static void Initialize(v8::Handle<v8::Object> target,
+                         v8::Handle<v8::Value> unused,
+                         v8::Handle<v8::Context> context);
 
   int DoWrite(WriteWrap* w,
               uv_buf_t* bufs,
@@ -82,7 +86,10 @@ class TLSCallbacks : public crypto::SSLWrap<TLSCallbacks>,
     QUEUE member_;
   };
 
-  TLSCallbacks(Kind kind, v8::Handle<v8::Object> sc, StreamWrapCallbacks* old);
+  TLSCallbacks(Environment* env,
+               Kind kind,
+               v8::Handle<v8::Object> sc,
+               StreamWrapCallbacks* old);
   ~TLSCallbacks();
 
   static void SSLInfoCallback(const SSL* ssl_, int where, int ret);
@@ -99,7 +106,7 @@ class TLSCallbacks : public crypto::SSLWrap<TLSCallbacks>,
     EncOut();
   }
 
-  v8::Handle<v8::Value> GetSSLError(int status, int* err);
+  v8::Local<v8::Value> GetSSLError(int status, int* err);
   static void OnClientHelloParseEnd(void* arg);
 
   static void Wrap(const v8::FunctionCallbackInfo<v8::Value>& args);
diff --git a/src/tty_wrap.cc b/src/tty_wrap.cc
index 0b675e1bb8..aad19a7e60 100644
--- a/src/tty_wrap.cc
+++ b/src/tty_wrap.cc
@@ -20,9 +20,11 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include "tty_wrap.h"
-#include "node.h"
-#include "node_buffer.h"
+
+#include "env.h"
+#include "env-inl.h"
 #include "handle_wrap.h"
+#include "node_buffer.h"
 #include "node_wrap.h"
 #include "req_wrap.h"
 #include "stream_wrap.h"
@@ -30,6 +32,7 @@
 namespace node {
 
 using v8::Array;
+using v8::Context;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
@@ -43,14 +46,13 @@ using v8::String;
 using v8::Value;
 
 
-void TTYWrap::Initialize(Handle<Object> target) {
-  StreamWrap::Initialize(target);
-
-  HandleScope scope(node_isolate);
+void TTYWrap::Initialize(Handle<Object> target,
+                         Handle<Value> unused,
+                         Handle<Context> context) {
+  Environment* env = Environment::GetCurrent(context);
 
   Local<FunctionTemplate> t = FunctionTemplate::New(New);
   t->SetClassName(FIXED_ONE_BYTE_STRING(node_isolate, "TTY"));
-
   t->InstanceTemplate()->SetInternalFieldCount(1);
 
   enum PropertyAttribute attributes =
@@ -81,8 +83,8 @@ void TTYWrap::Initialize(Handle<Object> target) {
   NODE_SET_METHOD(target, "isTTY", IsTTY);
   NODE_SET_METHOD(target, "guessHandleType", GuessHandleType);
 
-  ttyConstructorTmpl.Reset(node_isolate, t);
   target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "TTY"), t->GetFunction());
+  env->set_tty_constructor_template(t);
 }
 
 
@@ -162,7 +164,8 @@ void TTYWrap::SetRawMode(const FunctionCallbackInfo<Value>& args) {
 
 
 void TTYWrap::New(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   // This constructor should not be exposed to public javascript.
   // Therefore we assert that we are not trying to call this as a
@@ -172,16 +175,16 @@ void TTYWrap::New(const FunctionCallbackInfo<Value>& args) {
   int fd = args[0]->Int32Value();
   assert(fd >= 0);
 
-  TTYWrap* wrap = new TTYWrap(args.This(), fd, args[1]->IsTrue());
+  TTYWrap* wrap = new TTYWrap(env, args.This(), fd, args[1]->IsTrue());
   wrap->UpdateWriteQueueSize();
 }
 
 
-TTYWrap::TTYWrap(Handle<Object> object, int fd, bool readable)
-    : StreamWrap(object, reinterpret_cast<uv_stream_t*>(&handle_)) {
-  uv_tty_init(uv_default_loop(), &handle_, fd, readable);
+TTYWrap::TTYWrap(Environment* env, Handle<Object> object, int fd, bool readable)
+    : StreamWrap(env, object, reinterpret_cast<uv_stream_t*>(&handle_)) {
+  uv_tty_init(env->event_loop(), &handle_, fd, readable);
 }
 
 }  // namespace node
 
-NODE_MODULE(node_tty_wrap, node::TTYWrap::Initialize)
+NODE_MODULE_CONTEXT_AWARE(node_tty_wrap, node::TTYWrap::Initialize)
diff --git a/src/tty_wrap.h b/src/tty_wrap.h
index 0475073fdc..4c69b4c88a 100644
--- a/src/tty_wrap.h
+++ b/src/tty_wrap.h
@@ -22,6 +22,7 @@
 #ifndef SRC_TTY_WRAP_H_
 #define SRC_TTY_WRAP_H_
 
+#include "env.h"
 #include "handle_wrap.h"
 #include "stream_wrap.h"
 
@@ -29,13 +30,18 @@ namespace node {
 
 class TTYWrap : public StreamWrap {
  public:
-  static void Initialize(v8::Handle<v8::Object> target);
+  static void Initialize(v8::Handle<v8::Object> target,
+                         v8::Handle<v8::Value> unused,
+                         v8::Handle<v8::Context> context);
   static TTYWrap* Unwrap(v8::Local<v8::Object> obj);
 
   uv_tty_t* UVHandle();
 
  private:
-  TTYWrap(v8::Handle<v8::Object> object, int fd, bool readable);
+  TTYWrap(Environment* env,
+          v8::Handle<v8::Object> object,
+          int fd,
+          bool readable);
 
   static void GuessHandleType(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void IsTTY(const v8::FunctionCallbackInfo<v8::Value>& args);
diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc
index 1e5d32269b..fd679ab4d8 100644
--- a/src/udp_wrap.cc
+++ b/src/udp_wrap.cc
@@ -20,7 +20,8 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include "udp_wrap.h"
-#include "node.h"
+#include "env.h"
+#include "env-inl.h"
 #include "node_buffer.h"
 #include "handle_wrap.h"
 #include "req_wrap.h"
@@ -30,6 +31,7 @@
 
 namespace node {
 
+using v8::Context;
 using v8::Function;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
@@ -38,7 +40,6 @@ using v8::HandleScope;
 using v8::Integer;
 using v8::Local;
 using v8::Object;
-using v8::Persistent;
 using v8::PropertyAttribute;
 using v8::PropertyCallbackInfo;
 using v8::String;
@@ -49,20 +50,17 @@ using v8::Value;
 
 class SendWrap : public ReqWrap<uv_udp_send_t> {
  public:
-  SendWrap(Local<Object> req_wrap_obj, bool have_callback);
+  SendWrap(Environment* env, Local<Object> req_wrap_obj, bool have_callback);
   inline bool have_callback() const;
  private:
   const bool have_callback_;
 };
 
 
-static Persistent<Function> constructor;
-static Cached<String> oncomplete_sym;
-static Cached<String> onmessage_sym;
-
-
-SendWrap::SendWrap(Local<Object> req_wrap_obj, bool have_callback)
-    : ReqWrap<uv_udp_send_t>(req_wrap_obj)
+SendWrap::SendWrap(Environment* env,
+                   Local<Object> req_wrap_obj,
+                   bool have_callback)
+    : ReqWrap<uv_udp_send_t>(env, req_wrap_obj)
     , have_callback_(have_callback) {
 }
 
@@ -72,9 +70,9 @@ inline bool SendWrap::have_callback() const {
 }
 
 
-UDPWrap::UDPWrap(Handle<Object> object)
-    : HandleWrap(object, reinterpret_cast<uv_handle_t*>(&handle_)) {
-  int r = uv_udp_init(uv_default_loop(), &handle_);
+UDPWrap::UDPWrap(Environment* env, Handle<Object> object)
+    : HandleWrap(env, object, reinterpret_cast<uv_handle_t*>(&handle_)) {
+  int r = uv_udp_init(env->event_loop(), &handle_);
   assert(r == 0);  // can't fail anyway
 }
 
@@ -83,11 +81,10 @@ UDPWrap::~UDPWrap() {
 }
 
 
-void UDPWrap::Initialize(Handle<Object> target) {
-  HandleScope scope(node_isolate);
-
-  oncomplete_sym = FIXED_ONE_BYTE_STRING(node_isolate, "oncomplete");
-  onmessage_sym = FIXED_ONE_BYTE_STRING(node_isolate, "onmessage");
+void UDPWrap::Initialize(Handle<Object> target,
+                         Handle<Value> unused,
+                         Handle<Context> context) {
+  Environment* env = Environment::GetCurrent(context);
 
   Local<FunctionTemplate> t = FunctionTemplate::New(New);
   t->InstanceTemplate()->SetInternalFieldCount(1);
@@ -120,15 +117,16 @@ void UDPWrap::Initialize(Handle<Object> target) {
   NODE_SET_PROTOTYPE_METHOD(t, "ref", HandleWrap::Ref);
   NODE_SET_PROTOTYPE_METHOD(t, "unref", HandleWrap::Unref);
 
-  constructor.Reset(node_isolate, t->GetFunction());
   target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "UDP"), t->GetFunction());
+  env->set_udp_constructor_function(t->GetFunction());
 }
 
 
 void UDPWrap::New(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
   assert(args.IsConstructCall());
-  new UDPWrap(args.This());
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
+  new UDPWrap(env, args.This());
 }
 
 
@@ -244,7 +242,8 @@ void UDPWrap::DropMembership(const FunctionCallbackInfo<Value>& args) {
 
 
 void UDPWrap::DoSend(const FunctionCallbackInfo<Value>& args, int family) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
 
   UDPWrap* wrap;
   NODE_UNWRAP(args.This(), UDPWrap, wrap);
@@ -269,7 +268,7 @@ void UDPWrap::DoSend(const FunctionCallbackInfo<Value>& args, int family) {
   assert(offset < Buffer::Length(buffer_obj));
   assert(length <= Buffer::Length(buffer_obj) - offset);
 
-  SendWrap* req_wrap = new SendWrap(req_wrap_obj, have_callback);
+  SendWrap* req_wrap = new SendWrap(env, req_wrap_obj, have_callback);
 
   uv_buf_t buf = uv_buf_init(Buffer::Data(buffer_obj) + offset,
                              length);
@@ -337,7 +336,9 @@ void UDPWrap::RecvStop(const FunctionCallbackInfo<Value>& args) {
 
 
 void UDPWrap::GetSockName(const FunctionCallbackInfo<Value>& args) {
-  HandleScope scope(node_isolate);
+  Environment* env = Environment::GetCurrent(args.GetIsolate());
+  HandleScope handle_scope(args.GetIsolate());
+
   struct sockaddr_storage address;
   UDPWrap* wrap;
   NODE_UNWRAP(args.This(), UDPWrap, wrap);
@@ -352,7 +353,7 @@ void UDPWrap::GetSockName(const FunctionCallbackInfo<Value>& args) {
 
   if (err == 0) {
     const sockaddr* addr = reinterpret_cast<const sockaddr*>(&address);
-    AddressToJS(addr, obj);
+    AddressToJS(env, addr, obj);
   }
 
   args.GetReturnValue().Set(err);
@@ -363,10 +364,12 @@ void UDPWrap::GetSockName(const FunctionCallbackInfo<Value>& args) {
 void UDPWrap::OnSend(uv_udp_send_t* req, int status) {
   SendWrap* req_wrap = static_cast<SendWrap*>(req->data);
   if (req_wrap->have_callback()) {
-    HandleScope scope(node_isolate);
+    Environment* env = req_wrap->env();
+    Context::Scope context_scope(env->context());
+    HandleScope handle_scope(env->isolate());
     Local<Object> req_wrap_obj = req_wrap->object();
     Local<Value> arg = Integer::New(status, node_isolate);
-    MakeCallback(req_wrap_obj, oncomplete_sym, 1, &arg);
+    MakeCallback(env, req_wrap_obj, env->oncomplete_string(), 1, &arg);
   }
   delete req_wrap;
 }
@@ -397,8 +400,11 @@ void UDPWrap::OnRecv(uv_udp_t* handle,
   }
 
   UDPWrap* wrap = static_cast<UDPWrap*>(handle->data);
+  Environment* env = wrap->env();
+
+  Context::Scope context_scope(env->context());
+  HandleScope handle_scope(env->isolate());
 
-  HandleScope scope(node_isolate);
   Local<Object> wrap_obj = wrap->object();
   Local<Value> argv[] = {
     Integer::New(nread, node_isolate),
@@ -410,14 +416,18 @@ void UDPWrap::OnRecv(uv_udp_t* handle,
   if (nread < 0) {
     if (buf->base != NULL)
       free(buf->base);
-    MakeCallback(wrap_obj, onmessage_sym, ARRAY_SIZE(argv), argv);
+    MakeCallback(env,
+                 wrap_obj,
+                 env->onmessage_string(),
+                 ARRAY_SIZE(argv),
+                 argv);
     return;
   }
 
   char* base = static_cast<char*>(realloc(buf->base, nread));
-  argv[2] = Buffer::Use(base, nread);
-  argv[3] = AddressToJS(addr);
-  MakeCallback(wrap_obj, onmessage_sym, ARRAY_SIZE(argv), argv);
+  argv[2] = Buffer::Use(env, base, nread);
+  argv[3] = AddressToJS(env, addr);
+  MakeCallback(env, wrap_obj, env->onmessage_string(), ARRAY_SIZE(argv), argv);
 }
 
 
@@ -428,10 +438,10 @@ UDPWrap* UDPWrap::Unwrap(Local<Object> obj) {
 }
 
 
-Local<Object> UDPWrap::Instantiate() {
+Local<Object> UDPWrap::Instantiate(Environment* env) {
   // If this assert fires then Initialize hasn't been called yet.
-  assert(constructor.IsEmpty() == false);
-  return NewInstance(constructor);
+  assert(env->udp_constructor_function().IsEmpty() == false);
+  return env->udp_constructor_function()->NewInstance();
 }
 
 
@@ -442,4 +452,4 @@ uv_udp_t* UDPWrap::UVHandle() {
 
 }  // namespace node
 
-NODE_MODULE(node_udp_wrap, node::UDPWrap::Initialize)
+NODE_MODULE_CONTEXT_AWARE(node_udp_wrap, node::UDPWrap::Initialize)
diff --git a/src/udp_wrap.h b/src/udp_wrap.h
index e0cfc7ba26..b9aa566be2 100644
--- a/src/udp_wrap.h
+++ b/src/udp_wrap.h
@@ -22,15 +22,19 @@
 #ifndef SRC_UDP_WRAP_H_
 #define SRC_UDP_WRAP_H_
 
-#include "node.h"
-#include "req_wrap.h"
+#include "env.h"
 #include "handle_wrap.h"
+#include "req_wrap.h"
+#include "uv.h"
+#include "v8.h"
 
 namespace node {
 
 class UDPWrap: public HandleWrap {
  public:
-  static void Initialize(v8::Handle<v8::Object> target);
+  static void Initialize(v8::Handle<v8::Object> target,
+                         v8::Handle<v8::Value> unused,
+                         v8::Handle<v8::Context> context);
   static void GetFD(v8::Local<v8::String>,
                     const v8::PropertyCallbackInfo<v8::Value>&);
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -50,11 +54,11 @@ class UDPWrap: public HandleWrap {
   static void SetTTL(const v8::FunctionCallbackInfo<v8::Value>& args);
   static UDPWrap* Unwrap(v8::Local<v8::Object> obj);
 
-  static v8::Local<v8::Object> Instantiate();
+  static v8::Local<v8::Object> Instantiate(Environment* env);
   uv_udp_t* UVHandle();
 
  private:
-  explicit UDPWrap(v8::Handle<v8::Object> object);
+  UDPWrap(Environment* env, v8::Handle<v8::Object> object);
   virtual ~UDPWrap();
 
   static void DoBind(const v8::FunctionCallbackInfo<v8::Value>& args,
diff --git a/src/util-inl.h b/src/util-inl.h
new file mode 100644
index 0000000000..1ea31d94db
--- /dev/null
+++ b/src/util-inl.h
@@ -0,0 +1,83 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SRC_UTIL_INL_H_
+#define SRC_UTIL_INL_H_
+
+#include "util.h"
+
+namespace node {
+
+template <class TypeName>
+inline v8::Local<TypeName> PersistentToLocal(
+    v8::Isolate* isolate,
+    const v8::Persistent<TypeName>& persistent) {
+  if (persistent.IsWeak()) {
+    return WeakPersistentToLocal(isolate, persistent);
+  } else {
+    return StrongPersistentToLocal(persistent);
+  }
+}
+
+template <class TypeName>
+inline v8::Local<TypeName> StrongPersistentToLocal(
+    const v8::Persistent<TypeName>& persistent) {
+  return *reinterpret_cast<v8::Local<TypeName>*>(
+      const_cast<v8::Persistent<TypeName>*>(&persistent));
+}
+
+template <class TypeName>
+inline v8::Local<TypeName> WeakPersistentToLocal(
+    v8::Isolate* isolate,
+    const v8::Persistent<TypeName>& persistent) {
+  return v8::Local<TypeName>::New(isolate, persistent);
+}
+
+inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
+                                           const char* data,
+                                           int length) {
+  return v8::String::NewFromOneByte(isolate,
+                                    reinterpret_cast<const uint8_t*>(data),
+                                    v8::String::kNormalString,
+                                    length);
+}
+
+inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
+                                           const signed char* data,
+                                           int length) {
+  return v8::String::NewFromOneByte(isolate,
+                                    reinterpret_cast<const uint8_t*>(data),
+                                    v8::String::kNormalString,
+                                    length);
+}
+
+inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
+                                           const unsigned char* data,
+                                           int length) {
+  return v8::String::NewFromOneByte(isolate,
+                                    reinterpret_cast<const uint8_t*>(data),
+                                    v8::String::kNormalString,
+                                    length);
+}
+
+}  // namespace node
+
+#endif  // SRC_UTIL_INL_H_
diff --git a/src/util.h b/src/util.h
new file mode 100644
index 0000000000..7e71f36c70
--- /dev/null
+++ b/src/util.h
@@ -0,0 +1,82 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SRC_UTIL_H_
+#define SRC_UTIL_H_
+
+#include "v8.h"
+#include <stddef.h>
+
+namespace node {
+
+#define OFFSET_OF(TypeName, Field)                                            \
+  (reinterpret_cast<uintptr_t>(&(reinterpret_cast<TypeName*>(8)->Field)) - 8)
+
+#define CONTAINER_OF(Pointer, TypeName, Field)                                \
+  reinterpret_cast<TypeName*>(                                                \
+      reinterpret_cast<uintptr_t>(Pointer) - OFFSET_OF(TypeName, Field))
+
+#define FIXED_ONE_BYTE_STRING(isolate, string)                                \
+  (node::OneByteString((isolate), (string), sizeof(string) - 1))
+
+#define DISALLOW_COPY_AND_ASSIGN(TypeName)                                    \
+  void operator=(const TypeName&);                                            \
+  TypeName(const TypeName&)
+
+// If persistent.IsWeak() == false, then do not call persistent.Dispose()
+// while the returned Local<T> is still in scope, it will destroy the
+// reference to the object.
+template <class TypeName>
+inline v8::Local<TypeName> PersistentToLocal(
+    v8::Isolate* isolate,
+    const v8::Persistent<TypeName>& persistent);
+
+// Unchecked conversion from a non-weak Persistent<T> to Local<TLocal<T>,
+// use with care!
+//
+// Do not call persistent.Dispose() while the returned Local<T> is still in
+// scope, it will destroy the reference to the object.
+template <class TypeName>
+inline v8::Local<TypeName> StrongPersistentToLocal(
+    const v8::Persistent<TypeName>& persistent);
+
+template <class TypeName>
+inline v8::Local<TypeName> WeakPersistentToLocal(
+    v8::Isolate* isolate,
+    const v8::Persistent<TypeName>& persistent);
+
+// Convenience wrapper around v8::String::NewFromOneByte().
+inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
+                                           const char* data,
+                                           int length = -1);
+
+// For the people that compile with -funsigned-char.
+inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
+                                           const signed char* data,
+                                           int length = -1);
+
+inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
+                                           const unsigned char* data,
+                                           int length = -1);
+
+}  // namespace node
+
+#endif  // SRC_UTIL_H_
diff --git a/src/uv.cc b/src/uv.cc
index 2da32d4b7e..2759d29671 100644
--- a/src/uv.cc
+++ b/src/uv.cc
@@ -25,6 +25,7 @@
 namespace node {
 namespace uv {
 
+using v8::Context;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::Handle;
@@ -44,8 +45,9 @@ void ErrName(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-void Initialize(Handle<Object> target) {
-  v8::HandleScope handle_scope(node_isolate);
+void Initialize(Handle<Object> target,
+                Handle<Value> unused,
+                Handle<Context> context) {
   target->Set(FIXED_ONE_BYTE_STRING(node_isolate, "errname"),
               FunctionTemplate::New(ErrName)->GetFunction());
 #define V(name, _)                                                            \
@@ -59,4 +61,4 @@ void Initialize(Handle<Object> target) {
 }  // namespace uv
 }  // namespace node
 
-NODE_MODULE(node_uv, node::uv::Initialize)
+NODE_MODULE_CONTEXT_AWARE(node_uv, node::uv::Initialize)