diff --git a/JavaScript-V8-Context.xsp b/JavaScript-V8-Context.xsp
index 75ba725..a3f4617 100644
--- a/JavaScript-V8-Context.xsp
+++ b/JavaScript-V8-Context.xsp
@@ -2,7 +2,8 @@
 
 %name{JavaScript::V8::Context} class V8Context
 {
-  %name{_new} V8Context(int time_limit, const char* flags, bool enable_blessing, const char* bless_prefix);
+  %name{_new} V8Context(int time_limit, const char* flags, bool enable_blessing, const char* bless_prefix)
+        %cleanup{% RETVAL->my_sv = SvRV(ST(0)); %};
 
   ~V8Context();
 
diff --git a/V8Context.cpp b/V8Context.cpp
index f6c1564..788ea86 100644
--- a/V8Context.cpp
+++ b/V8Context.cpp
@@ -1,4 +1,6 @@
 #include "V8Context.h"
+#include "V8Thread.h"
+#include "V8Util.h"
 
 #include <pthread.h>
 #include <time.h>
@@ -10,27 +12,14 @@
 #define INT32_MIN (-0x7fffffff-1)
 #endif
 
-#define L(...) fprintf(stderr, ##__VA_ARGS__)
-
 using namespace v8;
 using namespace std;
 
 int V8Context::number = 0;
 
 void set_perl_error(const TryCatch& try_catch) {
-    Handle<Message> msg = try_catch.Message();
-
-    char message[1024];
-    snprintf(
-        message,
-        1024,
-        "%s at %s:%d",
-        *(String::Utf8Value(try_catch.Exception())),
-        !msg.IsEmpty() ? *(String::AsciiValue(msg->GetScriptResourceName())) : "EVAL",
-        !msg.IsEmpty() ? msg->GetLineNumber() : 0
-    );
-
-    sv_setpv(ERRSV, message);
+    auto_ptr<string> message = error_message(try_catch);
+    sv_setpv(ERRSV, message->c_str());
     sv_utf8_upgrade(ERRSV);
 }
 
@@ -137,7 +126,7 @@ SV* SvMap::find(Handle<Object> object) {
 
 ObjectData::ObjectData(V8Context* context_, Handle<Object> object_, SV* sv_)
     : context(context_)
-    , object(Persistent<Object>::New(object_))
+    , object(Persistent<Object>::New(context_->isolate, object_))
     , sv(sv_)
 {
     if (!sv) return;
@@ -148,8 +137,12 @@ ObjectData::ObjectData(V8Context* context_, Handle<Object> object_, SV* sv_)
 }
 
 ObjectData::~ObjectData() {
-    if (context) context->remove_object(this);
-    object.Dispose();
+    {
+        Isolate::Scope isolate_scope(context->isolate);
+        Locker locker(context->isolate);
+        object.Dispose(context->isolate);
+    }
+    context->remove_object(this);
 }
 
 PerlObjectData::PerlObjectData(V8Context* context_, Handle<Object> object_, SV* sv_)
@@ -163,7 +156,7 @@ PerlObjectData::PerlObjectData(V8Context* context_, Handle<Object> object_, SV*
     add_size(calculate_size(sv));
     ptr = PTR2IV(sv);
 
-    object.MakeWeak(this, PerlObjectData::destroy);
+    object.MakeWeak(context_->isolate, this, PerlObjectData::destroy);
 }
 
 size_t PerlObjectData::size() {
@@ -196,7 +189,7 @@ int V8ObjectData::svt_free(pTHX_ SV* sv, MAGIC* mg) {
     return 0;
 };
 
-void PerlObjectData::destroy(Persistent<Value> object, void *data) {
+void PerlObjectData::destroy(Isolate* isolate, Persistent<Value> object, void *data) {
     delete static_cast<PerlObjectData*>(data);
 }
 
@@ -219,6 +212,20 @@ class V8FunctionData : public V8ObjectData {
     bool returns_list;
 };
 
+class PerlFunctionData;
+
+Handle<Object> MakeFunction(V8Context* context, PerlFunctionData* fd) {
+    Handle<Value> wrap(External::New(fd));
+
+    return Handle<Object>::Cast(
+        context->make_function->Call(
+            context->context->Global(),
+            1,
+            &wrap
+        )
+    );
+}
+
 class PerlFunctionData : public PerlObjectData {
 private:
     SV *rv;
@@ -229,22 +236,12 @@ class PerlFunctionData : public PerlObjectData {
 
 public:
     PerlFunctionData(V8Context* context_, SV *cv)
-        : PerlObjectData(
-              context_,
-              Handle<Object>::Cast(
-                  context_->make_function->Call(
-                      context_->context->Global(),
-                      1,
-                      &External::Wrap(this)
-                  )
-              ),
-              cv
-          )
-       , rv(cv ? newRV_noinc(cv) : NULL)
+        : PerlObjectData(context_, MakeFunction(context_, this), cv)
+        , rv(cv ? newRV_noinc(cv) : NULL)
     { }
 
     static Handle<Value> v8invoke(const Arguments& args) {
-        PerlFunctionData* data = static_cast<PerlFunctionData*>(External::Unwrap(args[0]));
+        PerlFunctionData* data = static_cast<PerlFunctionData*>(External::Cast(*(args[0]))->Value());
         return data->invoke(args);
     }
 };
@@ -301,11 +298,15 @@ V8Context::V8Context(
       bless_prefix(bless_prefix_),
       enable_blessing(enable_blessing_)
 {
+    isolate = Isolate::New();
+    Isolate::Scope isolate_scope(isolate);
+    Locker locker(isolate);
+    HandleScope handle_scope;
     V8::SetFlagsFromString(flags, strlen(flags));
-    context = Context::New();
-
+    context = Persistent<Context>::New(isolate, Context::New(isolate));
     Context::Scope context_scope(context);
-    HandleScope handle_scope;
+
+    V8Thread::install(context->Global());
 
     Local<FunctionTemplate> tmpl = FunctionTemplate::New(PerlFunctionData::v8invoke);
     context->Global()->Set(
@@ -324,40 +325,47 @@ V8Context::V8Context(
             "})"
         )
     );
-    make_function = Persistent<Function>::New(Handle<Function>::Cast(script->Run()));
+    make_function = Persistent<Function>::New(isolate, Handle<Function>::Cast(script->Run()));
 
-    string_wrap = Persistent<String>::New(String::New("wrap"));
+    string_wrap = Persistent<String>::New(isolate, String::New("wrap"));
+    string_to_js = Persistent<String>::New(isolate, String::New("to_js"));
 
     number++;
 }
 
 void V8Context::register_object(ObjectData* data) {
     seen_perl[data->ptr] = data;
-    data->object->SetHiddenValue(string_wrap, External::Wrap(data));
+    data->object->SetHiddenValue(string_wrap, External::New(data));
+    SvREFCNT_inc(my_sv);
 }
 
 void V8Context::remove_object(ObjectData* data) {
-    ObjectDataMap::iterator it = seen_perl.find(data->ptr);
-    if (it != seen_perl.end())
-        seen_perl.erase(it);
-    data->object->DeleteHiddenValue(string_wrap);
+    {
+        Isolate::Scope isolate_scope(isolate);
+        Locker locker(isolate);
+        ObjectDataMap::iterator it = seen_perl.find(data->ptr);
+        if (it != seen_perl.end())
+            seen_perl.erase(it);
+        data->object->DeleteHiddenValue(string_wrap);
+    }
+    SvREFCNT_dec(my_sv);
 }
 
 V8Context::~V8Context() {
-    for (ObjectDataMap::iterator it = seen_perl.begin(); it != seen_perl.end(); it++) {
-        it->second->context = NULL;
-    }
-    seen_perl.clear();
-
+    isolate->Enter();
+    while (!V8::IdleNotification()); // force garbage collection
     for (ObjectMap::iterator it = prototypes.begin(); it != prototypes.end(); it++) {
-      it->second.Dispose();
+      it->second.Dispose(isolate);
     }
-    context.Dispose();
-    while(!V8::IdleNotification()); // force garbage collection
+    context.Dispose(isolate);
+    isolate->Exit();
+    isolate->Dispose();
 }
 
 void
 V8Context::bind(const char *name, SV *thing) {
+    Isolate::Scope isolate_scope(isolate);
+    Locker locker(isolate);
     HandleScope scope;
     Context::Scope context_scope(context);
 
@@ -367,8 +375,9 @@ V8Context::bind(const char *name, SV *thing) {
 // I fucking hate pthreads, this lacks error handling, but hopefully works.
 class thread_canceller {
 public:
-    thread_canceller(int sec)
-        : sec_(sec)
+    thread_canceller(Isolate* isolate, int sec)
+        : isolate_(isolate)
+        , sec_(sec)
     {
         if (sec_) {
             pthread_cond_init(&cond_, NULL);
@@ -401,7 +410,7 @@ class thread_canceller {
         ts.tv_nsec = tv.tv_usec * 1000;
 
         if (pthread_cond_timedwait(&me->cond_, &me->mutex_, &ts) == ETIMEDOUT) {
-            V8::TerminateExecution();
+            V8::TerminateExecution(me->isolate_);
         }
         pthread_mutex_unlock(&me->mutex_);
     }
@@ -410,10 +419,13 @@ class thread_canceller {
     pthread_cond_t cond_;
     pthread_mutex_t mutex_;
     int sec_;
+    Isolate* isolate_;
 };
 
 SV*
 V8Context::eval(SV* source, SV* origin) {
+    Locker locker(isolate);
+    Isolate::Scope isolate_scope(isolate);
     HandleScope handle_scope;
     TryCatch try_catch;
     Context::Scope context_scope(context);
@@ -425,14 +437,14 @@ V8Context::eval(SV* source, SV* origin) {
 
     if (try_catch.HasCaught()) {
         set_perl_error(try_catch);
-        return &PL_sv_undef;
+        return newSV(0);
     } else {
-        thread_canceller canceller(time_limit_);
+        thread_canceller canceller(isolate, time_limit_);
         Handle<Value> val = script->Run();
 
         if (val.IsEmpty()) {
             set_perl_error(try_catch);
-            return &PL_sv_undef;
+            return newSV(0);
         } else {
             sv_setsv(ERRSV,&PL_sv_undef);
             return v82sv(val);
@@ -480,17 +492,17 @@ SV* V8Context::seen_v8(Handle<Object> object) {
     if (wrap.IsEmpty())
         return NULL;
 
-    ObjectData* data = (ObjectData*)External::Unwrap(wrap);
+    ObjectData* data = (ObjectData*)External::Cast(*wrap)->Value();
     return newRV(data->sv);
 }
 
 SV *
 V8Context::v82sv(Handle<Value> value, SvMap& seen) {
     if (value->IsUndefined())
-        return &PL_sv_undef;
+        return newSV(0);
 
     if (value->IsNull())
-        return &PL_sv_undef;
+        return newSV(0);
 
     if (value->IsInt32())
         return newSViv(value->Int32Value());
@@ -534,7 +546,7 @@ V8Context::v82sv(Handle<Value> value, SvMap& seen) {
     }
 
     warn("Unknown v8 value in v82sv");
-    return &PL_sv_undef;
+    return newSV(0);
 }
 
 SV *
@@ -544,16 +556,60 @@ V8Context::v82sv(Handle<Value> value) {
 }
 
 void
-V8Context::fill_prototype(Handle<Object> prototype, HV* stash) {
+V8Context::fill_prototype_isa(Handle<Object> prototype, HV* stash) {
+    if (AV *isa = mro_get_linear_isa(stash)) {
+        for (int i = 0; i <= av_len(isa); i++) {
+            SV **sv = av_fetch(isa, i, 0);
+            HV *stash = gv_stashsv(*sv, 0);
+            fill_prototype_stash(prototype, stash);
+        }
+    }
+}
+
+void
+V8Context::fill_prototype_stash(Handle<Object> prototype, HV* stash) {
     HE *he;
     while (he = hv_iternext(stash)) {
         SV *key = HeSVKEY_force(he);
-        Local<String> name = String::New(SvPV_nolen(key));
+        char *key_str = SvPV_nolen(key);
+        Local<String> name = String::New(key_str);
 
         if (prototype->Has(name))
             continue;
 
-        prototype->Set(name, (new PerlMethodData(this, SvPV_nolen(key)))->object);
+        PerlFunctionData* pfd
+            = name->Equals(string_to_js) // we want to_js() to be called as a package function
+            ? new PerlFunctionData(this, (SV*)GvCV(gv_fetchmethod(stash, key_str)))
+            : new PerlMethodData(this, key_str);
+
+        prototype->Set(name, pfd->object);
+    }
+}
+
+// parse string returned by $self->to_js() into function
+void
+V8Context::fixup_prototype(Handle<Object> prototype) {
+    Handle<Value> val = prototype->Get(string_to_js);
+
+    if (val.IsEmpty() || !val->IsFunction())
+        return;
+
+    TryCatch try_catch;
+
+    Handle<Value> to_js = Handle<Function>::Cast(val)->Call(context->Global(), 0, NULL);
+    Handle<Script> script = Script::Compile(to_js->ToString());
+
+    if (try_catch.HasCaught()) {
+        set_perl_error(try_catch);
+    } else {
+        Handle<Value> val = script->Run();
+
+        if (val.IsEmpty() || !val->IsFunction()) {
+            set_perl_error(try_catch);
+        }
+        else {
+            prototype->Set(string_to_js, val);
+        }
     }
 }
 
@@ -572,15 +628,9 @@ V8Context::get_prototype(SV *sv) {
         prototype = it->second;
     }
     else {
-        prototype = prototypes[pkg] = Persistent<Object>::New(Object::New());
-
-        if (AV *isa = mro_get_linear_isa(stash)) {
-            for (int i = 0; i <= av_len(isa); i++) {
-                SV **sv = av_fetch(isa, i, 0);
-                HV *stash = gv_stashsv(*sv, 0);
-                fill_prototype(prototype, stash);
-            }
-        }
+        prototype = prototypes[pkg] = Persistent<Object>::New(isolate, Object::New());
+        fill_prototype_isa(prototype, stash);
+        fixup_prototype(prototype);
     }
 
     return prototype;
@@ -622,11 +672,35 @@ V8Context::rv2v8(SV *rv, HandleMap& seen) {
 }
 
 Handle<Object>
-V8Context::blessed2object(SV *sv) {
+V8Context::blessed2object_to_js(PerlObjectData* pod) {
+    Handle<Value> to_js = pod->object->Get(string_to_js);
+    Handle<Object> object;
+
+    if (to_js.IsEmpty() || !to_js->IsFunction()) {
+        object = pod->object;
+    }
+    else {
+        Handle<Value> val = Handle<Function>::Cast(to_js)->Call(pod->object, 0, NULL);
+        object = Persistent<Object>::New(isolate, val->ToObject());
+
+        delete pod;
+    }
+
+    return object;
+}
+
+PerlObjectData*
+V8Context::blessed2object_convert(SV* sv) {
     Handle<Object> object = Object::New();
-    object->SetPrototype(get_prototype(sv));
+    Handle<Object> prototype = get_prototype(sv);
+    object->SetPrototype(prototype);
+
+    return new PerlObjectData(this, object, sv);
+}
 
-    return (new PerlObjectData(this, object, sv))->object;
+Handle<Object>
+V8Context::blessed2object(SV *sv) {
+    return blessed2object_to_js(blessed2object_convert(sv));
 }
 
 Handle<Array>
@@ -716,77 +790,100 @@ my_gv_setsv(pTHX_ GV* const gv, SV* const sv){
     #define DVAR dVAR;
 #endif
 
-#define SETUP_V8_CALL(ARGS_OFFSET) \
-    DVAR \
-    dXSARGS; \
-\
-    bool die = false; \
-    int count = 1; \
-\
-    { \
-        /* We have to do all this inside a block so that all the proper \
-         * destuctors are called if we need to croak. If we just croak in the \
-         * middle of the block, v8 will segfault at program exit. */ \
-        TryCatch        try_catch; \
-        HandleScope     scope; \
-        V8FunctionData* data = (V8FunctionData*)sv_object_data((SV*)cv); \
-        if (data->context) { \
-        V8Context      *self = data->context; \
-        Handle<Context> ctx  = self->context; \
-        Context::Scope  context_scope(ctx); \
-        Handle<Value>   argv[items - ARGS_OFFSET]; \
-\
-        for (I32 i = ARGS_OFFSET; i < items; i++) { \
-            argv[i - ARGS_OFFSET] = self->sv2v8(ST(i)); \
-        }
+inline bool call_is_method(OP* o) {
+    OP* cvop, *aop;
+    aop = cUNOPx(PL_op)->op_first;
 
-#define CONVERT_V8_RESULT(POP) \
-        if (try_catch.HasCaught()) { \
-            set_perl_error(try_catch); \
-            die = true; \
-        } \
-        else { \
-            if (data->returns_list && GIMME_V == G_ARRAY && result->IsArray()) { \
-                Handle<Array> array = Handle<Array>::Cast(result); \
-                if (GIMME_V == G_ARRAY) { \
-                    count = array->Length(); \
-                    EXTEND(SP, count - items); \
-                    for (int i = 0; i < count; i++) { \
-                        ST(i) = sv_2mortal(self->v82sv(array->Get(Integer::New(i)))); \
-                    } \
-                } \
-                else { \
-                    ST(0) = sv_2mortal(newSViv(array->Length())); \
-                } \
-            } \
-            else { \
-                ST(0) = sv_2mortal(self->v82sv(result)); \
-            } \
-        } \
-        } \
-        else {\
-            die = true; \
-            sv_setpv(ERRSV, "Fatal error: V8 context is no more"); \
-            sv_utf8_upgrade(ERRSV); \
-        } \
-    } \
-\
-    if (die) \
-        croak(NULL); \
-\
-XSRETURN(count);
+    if (!aop)
+        return false;
 
-XS(v8closure) {
-    SETUP_V8_CALL(0)
-    Handle<Value> result = Handle<Function>::Cast(data->object)->Call(ctx->Global(), items, argv);
-    CONVERT_V8_RESULT()
+    if (!aop->op_sibling)
+        aop = cUNOPx(aop)->op_first;
+
+    aop = aop->op_sibling;
+    for (cvop = aop; cvop->op_sibling; cvop = cvop->op_sibling) ;
+
+    return cvop->op_type == OP_METHOD || cvop->op_type == OP_METHOD_NAMED;
 }
 
-XS(v8method) {
-    SETUP_V8_CALL(1)
-    V8ObjectData* This = (V8ObjectData*)SvIV((SV*)SvRV(ST(0)));
-    Handle<Value> result = Handle<Function>::Cast(data->object)->Call(This->object, items - 1, argv);
-    CONVERT_V8_RESULT(POPs);
+XS(v8closure) {
+    DVAR
+    dXSARGS;
+
+    bool die = false;
+    int count = 1;
+
+    {
+        V8FunctionData* data = (V8FunctionData*)sv_object_data((SV*)cv);
+
+        /* We have to do all this inside a block so that all the proper
+         * destuctors are called if we need to croak. If we just croak in the
+         * middle of the block, v8 will segfault at program exit. */
+        if (data->context) {
+            V8Context*      self = data->context;
+            Isolate*        isolate = self->isolate;
+            Isolate::Scope  isolate_scope(isolate);
+            Locker          locker(isolate);
+
+            Handle<Context> ctx  = self->context;
+            Context::Scope  context_scope(ctx);
+            HandleScope     scope;
+            TryCatch        try_catch;
+
+            Handle<Object>  object;
+            Handle<Value>   argv[items];
+            Handle<Value>   *argv_ptr;
+
+            for (I32 i = 0; i < items; i++) {
+                argv[i] = self->sv2v8(ST(i));
+            }
+
+            if (call_is_method(PL_op)) {
+                object = (*argv)->ToObject();
+                argv_ptr = argv + 1;
+                items--;
+            }
+            else {
+                object = ctx->Global();
+                argv_ptr = argv;
+            }
+
+            Handle<Value> result = Handle<Function>::Cast(data->object)->Call(object, items, argv_ptr);
+
+            if (try_catch.HasCaught()) {
+                set_perl_error(try_catch);
+                die = true;
+            }
+            else {
+                if (data->returns_list && GIMME_V == G_ARRAY && result->IsArray()) {
+                    Handle<Array> array = Handle<Array>::Cast(result);
+                    if (GIMME_V == G_ARRAY) {
+                        count = array->Length();
+                        EXTEND(SP, count - items);
+                        for (int i = 0; i < count; i++) {
+                            ST(i) = sv_2mortal(self->v82sv(array->Get(Integer::New(i))));
+                        }
+                    }
+                    else {
+                        ST(0) = sv_2mortal(newSViv(array->Length()));
+                    }
+                }
+                else {
+                    ST(0) = sv_2mortal(self->v82sv(result));
+                }
+            }
+        }
+        else {
+            die = true;
+            sv_setpv(ERRSV, "Fatal error: V8 context is no more");
+            sv_utf8_upgrade(ERRSV);
+        }
+    }
+
+    if (die)
+        croak(NULL);
+
+    XSRETURN(count);
 }
 
 SV*
@@ -826,7 +923,7 @@ V8Context::object2blessed(Handle<Object> obj) {
 
             Local<Function> fn = Local<Function>::Cast(property);
 
-            CV *code = newXS(NULL, v8method, __FILE__);
+            CV *code = newXS(NULL, v8closure, __FILE__);
             V8ObjectData *data = new V8FunctionData(this, fn, (SV*)code);
 
             GV* gv = (GV*)*hv_fetch(stash, *String::AsciiValue(name), name->Length(), TRUE);
diff --git a/V8Context.h b/V8Context.h
index e25f87d..8ac28ad 100644
--- a/V8Context.h
+++ b/V8Context.h
@@ -86,7 +86,7 @@ class PerlObjectData : public ObjectData {
     virtual size_t size();
     void add_size(size_t bytes_);
 
-    static void destroy(Persistent<Value> object, void *data);
+    static void destroy(Isolate* isolate, Persistent<Value> object, void *data);
 };
 
 typedef map<int, ObjectData*> ObjectDataMap;
@@ -110,6 +110,7 @@ class V8Context {
         Handle<Value> sv2v8(SV*);
         SV*           v82sv(Handle<Value>);
 
+        Isolate *isolate;
         Persistent<Context> context;
 
         void register_object(ObjectData* data);
@@ -119,6 +120,8 @@ class V8Context {
 
         bool enable_wantarray;
 
+        SV* my_sv;
+
     private:
         Handle<Value>    sv2v8(SV*, HandleMap& seen);
         SV*              v82sv(Handle<Value>, SvMap& seen);
@@ -130,16 +133,21 @@ class V8Context {
         Handle<String>   sv2v8str(SV* sv);
         Handle<Object>   blessed2object(SV *sv);
 
+        PerlObjectData*  blessed2object_convert(SV *sv);
+        Handle<Object>   blessed2object_to_js(PerlObjectData* pod);
+
         SV* array2sv(Handle<Array>, SvMap& seen);
         SV* object2sv(Handle<Object>, SvMap& seen);
         SV* object2blessed(Handle<Object>);
         SV* function2sv(Handle<Function>);
 
         Persistent<String> string_wrap;
+        Persistent<String> string_to_js;
 
-        void fill_prototype(Handle<Object> prototype, HV* stash);
+        void fill_prototype_isa(Handle<Object> prototype, HV* stash);
+        void fill_prototype_stash(Handle<Object> prototype, HV* stash);
+        void fixup_prototype(Handle<Object> prototype);
         Handle<Object> get_prototype(SV* sv);
-
         ObjectMap prototypes;
 
         ObjectDataMap seen_perl;
diff --git a/V8Thread.cpp b/V8Thread.cpp
new file mode 100644
index 0000000..76705a3
--- /dev/null
+++ b/V8Thread.cpp
@@ -0,0 +1,147 @@
+#include "V8Thread.h"
+#include "V8Util.h"
+
+using namespace std;
+using namespace v8;
+
+typedef struct thread_data {
+    V8Thread *t;
+    const char* arg;
+} thread_data;
+
+void* __run(void *data_) {
+    thread_data *data = (thread_data*)data_;
+    pthread_exit(data->t->run(data->arg));
+}
+
+V8Thread::V8Thread(const char *code, const char *origin) {
+    isolate = Isolate::New();
+
+    Isolate::Scope isolate_scope(isolate);
+    Locker locker(isolate);
+    HandleScope handle_scope;
+    context = Persistent<Context>::New(isolate, Context::New(isolate));
+    Context::Scope context_scope(context);
+    TryCatch try_catch;
+
+    Handle<Script> script = Script::Compile(String::New(code), String::New(origin));
+
+    if (try_catch.HasCaught()) {
+        throw error_message(try_catch);
+        return;
+    }
+    Handle<Value> value = script->Run();
+
+
+    if (!value.IsEmpty() && value->IsFunction()) {
+        function = Persistent<Function>::New(isolate, Handle<Function>::Cast(value));
+    }
+    else {
+        throw auto_ptr<string>(new string("Not a function."));
+    }
+}
+
+void
+V8Thread::start(const char* arg) {
+    thread_data *data = new thread_data;
+    data->t = this;
+    data->arg = arg;
+    pthread_create(&thread, NULL, __run, (void*)data);
+}
+
+thread_status*
+V8Thread::run(const char* arg) {
+    Locker locker(isolate);
+    Isolate::Scope isolate_scope(isolate);
+    Context::Scope context_scope(context);
+    HandleScope scope;
+    TryCatch try_catch;
+
+    Handle<Value> arguments = String::New(arg);
+    Handle<Value> val = function->Call(context->Global(), 1, &arguments);
+
+    thread_status* status = new thread_status;
+ 
+    if (try_catch.HasCaught()) {
+        status->error = error_message(try_catch); 
+    }
+    else {
+        status->result = auto_ptr<string>(new string(*String::AsciiValue(val->ToString())));
+    }
+
+    return status;
+}
+
+thread_status*
+V8Thread::join() {
+    void *ptr;
+    pthread_join(thread, &ptr);
+    return (thread_status*)ptr;
+}
+  
+V8Thread::~V8Thread() {
+    isolate->Enter();
+    context.Dispose(isolate);
+    isolate->Exit();
+    isolate->Dispose();
+}
+
+Handle<Value>
+V8Thread::_create(const Arguments& args) {
+    HandleScope handle_scope;
+
+    try {
+        V8Thread* thread = new V8Thread(*String::AsciiValue(args[0]), *String::AsciiValue(args[1]));
+        args.This()->SetInternalField(0, External::New(thread));
+        Persistent<Object> self = Persistent<Object>::New(thread->isolate, args.Holder());
+        self.MakeWeak(thread->isolate, (void*)thread, V8Thread::_destroy);
+        return self;
+    } catch (auto_ptr<string> msg) {
+        ThrowException(Exception::Error(String::New(msg->c_str())));
+    }
+
+    return Undefined();
+}
+
+Handle<Value>
+V8Thread::_start(const Arguments& args) {
+    V8Thread* thread = (V8Thread*)External::Cast(*(args.This()->GetInternalField(0)))->Value();
+    thread->start(*String::AsciiValue(args[0]));
+    return Undefined();
+}
+
+Handle<Value>
+V8Thread::_join(const Arguments& args) {
+    V8Thread* thread = (V8Thread*)External::Cast(*(args.This()->GetInternalField(0)))->Value();
+    auto_ptr<thread_status> status(thread->join());
+
+    if (status->error.get()) {
+        ThrowException(Exception::Error(String::New(status->error->c_str())));
+        return Undefined();
+    }
+    else {
+        return String::New(status->result->c_str());
+    }
+}
+
+void
+V8Thread::_destroy(Isolate* isolate, Persistent<Value> object, void* data) {
+    delete static_cast<V8Thread*>(data);
+}
+
+void
+V8Thread::install(Handle<Object> global) {
+    Handle<FunctionTemplate> thread = FunctionTemplate::New(V8Thread::_create);
+    thread->InstanceTemplate()->SetInternalFieldCount(1);
+
+    thread->PrototypeTemplate()->Set(
+        String::New("start"),
+        FunctionTemplate::New(V8Thread::_start)->GetFunction()
+    );
+    thread->PrototypeTemplate()->Set(
+        String::New("join"),
+        FunctionTemplate::New(V8Thread::_join)->GetFunction()
+    );
+
+    global->Set(String::New("Thread"), thread->GetFunction());
+}
diff --git a/V8Thread.h b/V8Thread.h
new file mode 100644
index 0000000..290e6b3
--- /dev/null
+++ b/V8Thread.h
@@ -0,0 +1,36 @@
+#include <pthread.h>
+#include <iostream>
+#include <memory>
+#include <v8.h>
+
+using namespace std;
+using namespace v8;
+
+typedef struct thread_status {
+    auto_ptr<string> error;
+    auto_ptr<string> result;
+} thread_status;
+
+class V8Thread {
+
+private:
+    pthread_t thread;
+    Isolate *isolate;
+    Persistent<Context> context;
+    Persistent<Function> function;
+
+public:
+    V8Thread(const char *code, const char *origin);
+    ~V8Thread();
+
+    static void install(Handle<Object> global);
+
+    static Handle<Value> _create(const Arguments& args);
+    static Handle<Value> _start(const Arguments& args);
+    static Handle<Value> _join(const Arguments& args);
+    static void _destroy(Isolate* isolate, Persistent<Value> object, void* data);
+
+    void start(const char* code);
+    thread_status* run(const char* arg);
+    thread_status* join();
+};
diff --git a/V8Util.cpp b/V8Util.cpp
new file mode 100644
index 0000000..e1bb139
--- /dev/null
+++ b/V8Util.cpp
@@ -0,0 +1,20 @@
+#include "V8Util.h"
+
+using namespace std;
+using namespace v8;
+
+auto_ptr<string> error_message(const TryCatch& try_catch) {
+    Handle<Message> msg = try_catch.Message();
+
+    char message[1024];
+    snprintf(
+        message,
+        1024,
+        "%s at %s:%d",
+        *(String::Utf8Value(try_catch.Exception())),
+        !msg.IsEmpty() ? *(String::AsciiValue(msg->GetScriptResourceName())) : "EVAL",
+        !msg.IsEmpty() ? msg->GetLineNumber() : 0
+    );
+
+    return auto_ptr<string>(new string(message));
+}
diff --git a/V8Util.h b/V8Util.h
new file mode 100644
index 0000000..9e2fd6e
--- /dev/null
+++ b/V8Util.h
@@ -0,0 +1,15 @@
+#ifndef _V8Util_h_
+#define _V8Util_h_
+
+#include <v8.h>
+#include <memory>
+#include <string>
+
+#define L(...) fprintf(stderr, ##__VA_ARGS__)
+
+using namespace std;
+using namespace v8;
+
+auto_ptr<string> error_message(const TryCatch& try_catch);
+
+#endif
diff --git a/t/jsobj.t b/t/jsobj.t
index a2a1d13..e2c0843 100644
--- a/t/jsobj.t
+++ b/t/jsobj.t
@@ -2,6 +2,7 @@
 
 use Test::More;
 use JavaScript::V8;
+use Storable qw/ freeze thaw /;
 use Data::Dumper;
 
 use utf8;
@@ -56,6 +57,23 @@ Counter.prototype.previousValues.__perlReturnsList = true;
 
 Counter.prototype.__perlPackage = "Counter";
 
+Counter.prototype.STORABLE_freeze = function(obj, cloning) {
+    return JSON.stringify(obj);
+}
+
+Counter.prototype.STORABLE_attach = function(klass, cloning, serialized) {
+    var clone = new Counter();
+    var data = JSON.parse(serialized);
+    for (var k in data)
+        if (data.hasOwnProperty(k))
+            clone[k] = data[k];
+    return clone;
+}
+
+Counter.prototype.methodVsFunctionTest = function(arg) {
+    return [this, arg];
+}
+
 new Counter;
 END
 
@@ -123,8 +141,7 @@ like $@, qr{SomeError.*at counter\.js:\d+}, 'js method error propagates to perl'
         $context->eval('var c = new Counter(); c.set(77); c');
     };
 
-    eval { $c->get };
-    like $@, qr{context is no more}, 'object gracefully stops working if it outlives its context';
+    is $c->get, 77, 'live object keeps context alive';
 }
 
 {
@@ -136,4 +153,25 @@ like $@, qr{SomeError.*at counter\.js:\d+}, 'js method error propagates to perl'
     is_deeply [$c->previousValues], [1, 77, 78], 'method in list context';
 }
 
+
+{
+    my $context = JavaScript::V8::Context->new( enable_blessing => 1, enable_wantarray => 1 );
+
+    $context->eval($COUNTER_SRC);
+
+    my $c = $context->eval('var c = new Counter(); c.set(77); c.inc(); c.inc(); c');
+    is_deeply [thaw(freeze($c))->previousValues], [$c->previousValues], 'freeze/thaw work';
+
+    $context->eval('Z = 1');
+
+    my $pkg = ref $c;
+    # this is bound to global
+    is((eval "${pkg}::methodVsFunctionTest(1)")->[0]{Z}, 1, 'js function called as an package function');
+    is((eval "${pkg}::methodVsFunctionTest(1)")->[1], 1);
+
+    # this is bound to $c
+    is $c->methodVsFunctionTest(1)->[0], $c;
+    is $c->methodVsFunctionTest(1)->[1], 1;
+}
+
 done_testing;
diff --git a/t/plobj.t b/t/plobj.t
index 9b9ccd8..2286e34 100644
--- a/t/plobj.t
+++ b/t/plobj.t
@@ -8,7 +8,7 @@ use utf8;
 use strict;
 use warnings;
 
-my $context = JavaScript::V8::Context->new();
+my $context = JavaScript::V8::Context->new( flags => '--expose-gc' );
 
 $context->bind( 
     warn => sub { warn(@_) },
@@ -123,7 +123,7 @@ $context->set_flags_from_string("--expose-gc");
         $c->{on_destroy} = sub { $destroyed = 1 };
         $context->eval('(function(c) { return c.get() + 1; })')->($c);
     }
-    1 while !$context->idle_notification;
+    $context->eval('gc()');
 
     ok $destroyed, 'local js object is destroyed after perl scope is done';
 }
@@ -140,4 +140,43 @@ $context->set_flags_from_string("--expose-gc");
     is $context->eval('(function (c) { return c.zzz; })')->($c), "value to persist", 'perl functions are converted once';
 }
 
+{
+    {
+        package CounterCustom;
+
+        use base 'Counter';
+
+        sub to_js {
+            '
+            function Counter(obj) {
+                this.__value = obj.get();
+            };
+
+            Counter.prototype.value = function() {
+                return this.__value;
+            };
+
+            Counter.prototype.increase = function() {
+                return this.__value++;
+            };
+
+            (function() {
+                return new Counter(this);
+            })
+
+            '
+        }
+
+        1
+    }
+
+    my $c = CounterCustom->new;
+
+    $c->set(11);
+    $@ = undef;
+
+    is $context->eval('(function (c) { c.increase(); return c.value(); })')->($c), $c->get + 1;
+    is $context->eval('(function (c) { c.increase(); return c.value(); })')->($c), $c->get + 1;
+}
+
 done_testing;
diff --git a/t/thread.t b/t/thread.t
new file mode 100644
index 0000000..ea50b9d
--- /dev/null
+++ b/t/thread.t
@@ -0,0 +1,24 @@
+#!/usr/bin/perl
+
+use Test::More;
+use JavaScript::V8;
+use Data::Dumper;
+
+use utf8;
+use strict;
+use warnings;
+
+my $context = JavaScript::V8::Context->new( flags => '--expose-gc' );
+
+$context->bind( warn => sub {warn @_});
+my $res = $context->eval(<<'END');
+    var t = new Thread('(function(data) { var arg = JSON.parse(data); return arg + 1; })'); 
+    t.start(3);
+    t.join();
+END
+
+die $@ if $@;
+
+is $res, 4, 'basic threaded execution';
+
+done_testing;
diff --git a/t/zzmem_plojb2.t b/t/zzmem_plojb2.t
index 3bd64b8..5778fc5 100644
--- a/t/zzmem_plojb2.t
+++ b/t/zzmem_plojb2.t
@@ -19,7 +19,7 @@ sub new {
 package main;
 
 $context->eval('var DATA = []');
-for (1..100000) {
+for (1..200000) {
     print STDERR "$_\r";
     $context->eval('(function(data) { DATA.push(data); })')->(Test->new($_));
 }