diff --git a/.clang-format b/.clang-format
new file mode 100644
index 00000000..3f19e616
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1 @@
+BasedOnStyle: Chromium
diff --git a/context-macros.h b/context-macros.h
new file mode 100644
index 00000000..7d75d308
--- /dev/null
+++ b/context-macros.h
@@ -0,0 +1,20 @@
+#ifndef V8GO_CONTEXT_MACROS_H
+#define V8GO_CONTEXT_MACROS_H
+
+#include "deps/include/v8-context.h"
+#include "deps/include/v8-isolate.h"
+#include "deps/include/v8-local-handle.h"
+#include "deps/include/v8-locker.h"
+
+#include "context.h"
+
+#define LOCAL_CONTEXT(ctx)                              \
+  v8::Isolate* iso = ctx->iso;                          \
+  v8::Locker locker(iso);                               \
+  v8::Isolate::Scope isolate_scope(iso);                \
+  v8::HandleScope handle_scope(iso);                    \
+  v8::TryCatch try_catch(iso);                          \
+  v8::Local<v8::Context> local_ctx = ctx->ptr.Get(iso); \
+  v8::Context::Scope context_scope(local_ctx);
+
+#endif
diff --git a/context.cc b/context.cc
new file mode 100644
index 00000000..ccaaf2d8
--- /dev/null
+++ b/context.cc
@@ -0,0 +1,121 @@
+#include "deps/include/v8-template.h"
+
+#include "context-macros.h"
+#include "template.h"
+#include "unbound_script.h"
+#include "value.h"
+
+using namespace v8;
+
+ContextPtr NewContext(IsolatePtr iso,
+                      TemplatePtr global_template_ptr,
+                      int ref) {
+  Locker locker(iso);
+  Isolate::Scope isolate_scope(iso);
+  HandleScope handle_scope(iso);
+
+  Local<ObjectTemplate> global_template;
+  if (global_template_ptr != nullptr) {
+    global_template = global_template_ptr->ptr.Get(iso).As<ObjectTemplate>();
+  } else {
+    global_template = ObjectTemplate::New(iso);
+  }
+
+  // For function callbacks we need a reference to the context, but because of
+  // the complexities of C -> Go function pointers, we store a reference to the
+  // context as a simple integer identifier; this can then be used on the Go
+  // side to lookup the context in the context registry. We use slot 1 as slot 0
+  // has special meaning for the Chrome debugger.
+  Local<Context> local_ctx = Context::New(iso, nullptr, global_template);
+  local_ctx->SetEmbedderData(1, Integer::New(iso, ref));
+
+  m_ctx* ctx = new m_ctx;
+  ctx->ptr.Reset(iso, local_ctx);
+  ctx->iso = iso;
+  return ctx;
+}
+
+void ContextFree(ContextPtr ctx) {
+  if (ctx == nullptr) {
+    return;
+  }
+  ctx->ptr.Reset();
+
+  for (auto it = ctx->vals.begin(); it != ctx->vals.end(); ++it) {
+    auto value = it->second;
+    value->ptr.Reset();
+    delete value;
+  }
+  ctx->vals.clear();
+
+  for (m_unboundScript* us : ctx->unboundScripts) {
+    us->ptr.Reset();
+    delete us;
+  }
+
+  delete ctx;
+}
+
+m_value* tracked_value(m_ctx* ctx, m_value* val) {
+  // (rogchap) we track values against a context so that when the context is
+  // closed (either manually or GC'd by Go) we can also release all the
+  // values associated with the context;
+  if (val->id == 0) {
+    val->id = ++ctx->nextValId;
+    ctx->vals[val->id] = val;
+  }
+
+  return val;
+}
+
+ValuePtr ContextGlobal(ContextPtr ctx) {
+  LOCAL_CONTEXT(ctx);
+  m_value* val = new m_value;
+  val->id = 0;
+
+  val->iso = iso;
+  val->ctx = ctx;
+  val->ptr = Global<Value>(iso, local_ctx->Global());
+
+  return tracked_value(ctx, val);
+}
+
+int ContextRetainedValueCount(ContextPtr ctx) {
+  return ctx->vals.size();
+}
+
+RtnValue RunScript(ContextPtr ctx, const char* source, const char* origin) {
+  LOCAL_CONTEXT(ctx);
+
+  RtnValue rtn = {};
+
+  MaybeLocal<String> maybeSrc =
+      String::NewFromUtf8(iso, source, NewStringType::kNormal);
+  MaybeLocal<String> maybeOgn =
+      String::NewFromUtf8(iso, origin, NewStringType::kNormal);
+  Local<String> src, ogn;
+  if (!maybeSrc.ToLocal(&src) || !maybeOgn.ToLocal(&ogn)) {
+    rtn.error = ExceptionError(try_catch, iso, local_ctx);
+    return rtn;
+  }
+
+  ScriptOrigin script_origin(ogn);
+  Local<Script> script;
+  if (!Script::Compile(local_ctx, src, &script_origin).ToLocal(&script)) {
+    rtn.error = ExceptionError(try_catch, iso, local_ctx);
+    return rtn;
+  }
+  Local<Value> result;
+  if (!script->Run(local_ctx).ToLocal(&result)) {
+    rtn.error = ExceptionError(try_catch, iso, local_ctx);
+    return rtn;
+  }
+  m_value* val = new m_value;
+  val->id = 0;
+  val->iso = iso;
+  val->ctx = ctx;
+  val->ptr = Global<Value>(iso, result);
+
+  rtn.value = tracked_value(ctx, val);
+  return rtn;
+}
diff --git a/context.go b/context.go
index 1176d45f..ad7c8965 100644
--- a/context.go
+++ b/context.go
@@ -5,7 +5,7 @@
 package v8go
 
 // #include <stdlib.h>
-// #include "v8go.h"
+// #include "context.h"
 import "C"
 import (
 	"runtime"
diff --git a/context.h b/context.h
new file mode 100644
index 00000000..40eb4e9c
--- /dev/null
+++ b/context.h
@@ -0,0 +1,61 @@
+#ifndef V8GO_CONTEXT_H
+#define V8GO_CONTEXT_H
+
+#include "errors.h"
+#include "isolate.h"
+
+#ifdef __cplusplus
+
+#include "deps/include/v8-persistent-handle.h"
+
+#include <unordered_map>
+#include <vector>
+#include "value.h"
+
+namespace v8 {
+class Isolate;
+class Context;
+}  // namespace v8
+
+typedef v8::Isolate v8Isolate;
+typedef struct m_unboundScript m_unboundScript;
+
+struct m_ctx {
+  v8::Isolate* iso;
+  std::unordered_map<long, m_value*> vals;
+  std::vector<m_unboundScript*> unboundScripts;
+  v8::Persistent<v8::Context> ptr;
+  long nextValId;
+};
+typedef m_ctx* ContextPtr;
+
+extern m_value* tracked_value(m_ctx* ctx, m_value* val);
+
+extern "C" {
+#else
+typedef struct v8Isolate v8Isolate;
+#endif
+typedef v8Isolate* IsolatePtr;
+
+typedef struct m_value m_value;
+typedef m_value* ValuePtr;
+
+typedef struct m_template m_template;
+typedef m_template* TemplatePtr;
+
+extern ContextPtr NewContext(IsolatePtr iso_ptr,
+                             TemplatePtr global_template_ptr,
+                             int ref);
+extern int ContextRetainedValueCount(ContextPtr ctx);
+extern ValuePtr ContextGlobal(ContextPtr ctx_ptr);
+extern void ContextFree(ContextPtr ctx);
+extern RtnValue RunScript(ContextPtr ctx_ptr,
+                          const char* source,
+                          const char* origin);
+
+#ifdef __cplusplus
+}  // extern "C"
+
+#endif
+
+#endif
diff --git a/cpuprofile.go b/cpuprofile.go
index 4a1593cc..3dc57f78 100644
--- a/cpuprofile.go
+++ b/cpuprofile.go
@@ -6,6 +6,7 @@ package v8go
 
 /*
 #include "v8go.h"
+#include "errors.h"
 */
 import "C"
 import "time"
diff --git a/errors.cc b/errors.cc
new file mode 100644
index 00000000..df5a62a7
--- /dev/null
+++ b/errors.cc
@@ -0,0 +1,50 @@
+#include <sstream>
+
+#include "deps/include/v8-exception.h"
+#include "deps/include/v8-message.h"
+#include "deps/include/v8-primitive.h"
+
+#include "errors.h"
+#include "utils.h"
+
+using namespace v8;
+
+RtnError ExceptionError(TryCatch& try_catch, Isolate* iso, Local<Context> ctx) {
+  HandleScope handle_scope(iso);
+
+  RtnError rtn = {nullptr, nullptr, nullptr};
+
+  if (try_catch.HasTerminated()) {
+    rtn.msg =
+        CopyString("ExecutionTerminated: script execution has been terminated");
+    return rtn;
+  }
+
+  String::Utf8Value exception(iso, try_catch.Exception());
+  rtn.msg = CopyString(exception);
+
+  Local<Message> msg = try_catch.Message();
+  if (!msg.IsEmpty()) {
+    String::Utf8Value origin(iso, msg->GetScriptOrigin().ResourceName());
+    std::ostringstream sb;
+    sb << *origin;
+    Maybe<int> line = try_catch.Message()->GetLineNumber(ctx);
+    if (line.IsJust()) {
+      sb << ":" << line.ToChecked();
+    }
+    Maybe<int> start = try_catch.Message()->GetStartColumn(ctx);
+    if (start.IsJust()) {
+      sb << ":"
+         << start.ToChecked() + 1;  // + 1 to match output from stack trace
+    }
+    rtn.location = CopyString(sb.str());
+  }
+
+  Local<Value> mstack;
+  if (try_catch.StackTrace(ctx).ToLocal(&mstack)) {
+    String::Utf8Value stack(iso, mstack);
+    rtn.stack = CopyString(stack);
+  }
+
+  return rtn;
+}
diff --git a/errors.go b/errors.go
index 35cd69d9..acf43290 100644
--- a/errors.go
+++ b/errors.go
@@ -5,7 +5,7 @@
 package v8go
 
 // #include <stdlib.h>
-// #include "v8go.h"
+// #include "errors.h"
 import "C"
 import (
 	"fmt"
diff --git a/errors.h b/errors.h
new file mode 100644
index 00000000..364327c0
--- /dev/null
+++ b/errors.h
@@ -0,0 +1,49 @@
+#ifndef V8GO_ERRORS_H
+#define V8GO_ERRORS_H
+
+typedef struct {
+  const char* msg;
+  const char* location;
+  const char* stack;
+} RtnError;
+
+#ifdef __cplusplus
+
+#include "deps/include/v8-local-handle.h"
+
+namespace v8 {
+class Isolate;
+class Context;
+class TryCatch;
+}  // namespace v8
+
+extern "C" {
+
+extern RtnError ExceptionError(v8::TryCatch& try_catch,
+                               v8::Isolate* iso,
+                               v8::Local<v8::Context> ctx);
+#endif
+
+typedef struct m_value m_value;
+typedef m_value* ValuePtr;
+
+typedef enum {
+  ERROR_RANGE = 1,
+  ERROR_REFERENCE,
+  ERROR_SYNTAX,
+  ERROR_TYPE,
+  ERROR_WASM_COMPILE,
+  ERROR_WASM_LINK,
+  ERROR_WASM_RUNTIME,
+  ERROR_GENERIC,
+} ErrorTypeIndex;
+
+typedef struct {
+  ValuePtr value;
+  RtnError error;
+} RtnValue;
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/isolate-macros.h b/isolate-macros.h
new file mode 100644
index 00000000..cece58fc
--- /dev/null
+++ b/isolate-macros.h
@@ -0,0 +1,22 @@
+#ifndef V8GO_ISOLATE_MACROS_H
+#define V8GO_ISOLATE_MACROS_H
+
+#include "deps/include/v8-exception.h"
+#include "deps/include/v8-isolate.h"
+#include "deps/include/v8-locker.h"
+
+#include "context.h"
+#include "isolate.h"
+
+static inline m_ctx* isolateInternalContext(v8::Isolate* iso) {
+  return static_cast<m_ctx*>(iso->GetData(0));
+}
+
+#define ISOLATE_SCOPE(iso)           \
+  Locker locker(iso);                \
+  Isolate::Scope isolate_scope(iso); \
+  HandleScope handle_scope(iso);
+
+#define INTERNAL_CONTEXT(iso) m_ctx* ctx = static_cast<m_ctx*>(iso->GetData(0));
+
+#endif
diff --git a/isolate.cc b/isolate.cc
new file mode 100644
index 00000000..7402a2e5
--- /dev/null
+++ b/isolate.cc
@@ -0,0 +1,96 @@
+#include "deps/include/v8-context.h"
+#include "deps/include/v8-initialization.h"
+#include "deps/include/v8-locker.h"
+#include "deps/include/v8-platform.h"
+
+#include "context.h"
+#include "isolate.h"
+#include "libplatform/libplatform.h"
+
+using namespace v8;
+
+auto default_platform = platform::NewDefaultPlatform();
+ArrayBuffer::Allocator* default_allocator;
+
+extern "C" {
+
+/********** Isolate **********/
+
+#define ISOLATE_SCOPE(iso)           \
+  Locker locker(iso);                \
+  Isolate::Scope isolate_scope(iso); \
+  HandleScope handle_scope(iso);
+
+void Init() {
+#ifdef _WIN32
+  V8::InitializeExternalStartupData(".");
+#endif
+  V8::InitializePlatform(default_platform.get());
+  V8::Initialize();
+
+  default_allocator = ArrayBuffer::Allocator::NewDefaultAllocator();
+  return;
+}
+
+IsolatePtr NewIsolate() {
+  Isolate::CreateParams params;
+  params.array_buffer_allocator = default_allocator;
+  Isolate* iso = Isolate::New(params);
+  Locker locker(iso);
+  Isolate::Scope isolate_scope(iso);
+  HandleScope handle_scope(iso);
+
+  iso->SetCaptureStackTraceForUncaughtExceptions(true);
+
+  // Create a Context for internal use
+  m_ctx* ctx = new m_ctx;
+  ctx->ptr.Reset(iso, Context::New(iso));
+  ctx->iso = iso;
+  iso->SetData(0, ctx);
+
+  return iso;
+}
+
+void IsolatePerformMicrotaskCheckpoint(IsolatePtr iso) {
+  ISOLATE_SCOPE(iso)
+  iso->PerformMicrotaskCheckpoint();
+}
+
+void IsolateDispose(IsolatePtr iso) {
+  if (iso == nullptr) {
+    return;
+  }
+  auto ctx = static_cast<m_ctx*>(iso->GetData(0));
+  ContextFree(ctx);
+
+  iso->Dispose();
+}
+
+void IsolateTerminateExecution(IsolatePtr iso) {
+  iso->TerminateExecution();
+}
+
+int IsolateIsExecutionTerminating(IsolatePtr iso) {
+  return iso->IsExecutionTerminating();
+}
+
+IsolateHStatistics IsolationGetHeapStatistics(IsolatePtr iso) {
+  if (iso == nullptr) {
+    return IsolateHStatistics{0};
+  }
+  v8::HeapStatistics hs;
+  iso->GetHeapStatistics(&hs);
+
+  return IsolateHStatistics{hs.total_heap_size(),
+                            hs.total_heap_size_executable(),
+                            hs.total_physical_size(),
+                            hs.total_available_size(),
+                            hs.used_heap_size(),
+                            hs.heap_size_limit(),
+                            hs.malloced_memory(),
+                            hs.external_memory(),
+                            hs.peak_malloced_memory(),
+                            hs.number_of_native_contexts(),
+                            hs.number_of_detached_contexts()};
+}
+}
diff --git a/isolate.go b/isolate.go
index 5c147749..23db4f4e 100644
--- a/isolate.go
+++ b/isolate.go
@@ -5,7 +5,7 @@
 package v8go
 
 // #include <stdlib.h>
-// #include "v8go.h"
+// #include "isolate.h"
 import "C"
 
 import (
@@ -86,7 +86,10 @@ type CompileOptions struct {
 // If options contain a non-null CachedData, compilation of the script will use
 // that code cache.
 // error will be of type `JSError` if not nil.
-func (i *Isolate) CompileUnboundScript(source, origin string, opts CompileOptions) (*UnboundScript, error) {
+func (i *Isolate) CompileUnboundScript(
+	source, origin string,
+	opts CompileOptions,
+) (*UnboundScript, error) {
 	cSource := C.CString(source)
 	cOrigin := C.CString(origin)
 	defer C.free(unsafe.Pointer(cSource))
diff --git a/isolate.h b/isolate.h
new file mode 100644
index 00000000..a4604eb6
--- /dev/null
+++ b/isolate.h
@@ -0,0 +1,64 @@
+#ifndef V8GO_ISOLATE_H
+#define V8GO_ISOLATE_H
+
+#include "unbound_script.h"
+
+#ifdef __cplusplus
+
+namespace v8 {
+class Isolate;
+}
+typedef v8::Isolate v8Isolate;
+
+extern "C" {
+#else
+typedef struct v8Isolate v8Isolate;
+#endif
+
+typedef v8Isolate* IsolatePtr;
+
+typedef struct m_value m_value;
+typedef m_value* ValuePtr;
+
+// ScriptCompiler::CompileOptions values
+extern const int ScriptCompilerNoCompileOptions;
+extern const int ScriptCompilerConsumeCodeCache;
+extern const int ScriptCompilerEagerCompile;
+
+typedef struct {
+  ScriptCompilerCachedData cachedData;
+  int compileOption;
+} CompileOptions;
+
+typedef struct {
+  size_t total_heap_size;
+  size_t total_heap_size_executable;
+  size_t total_physical_size;
+  size_t total_available_size;
+  size_t used_heap_size;
+  size_t heap_size_limit;
+  size_t malloced_memory;
+  size_t external_memory;
+  size_t peak_malloced_memory;
+  size_t number_of_native_contexts;
+  size_t number_of_detached_contexts;
+} IsolateHStatistics;
+
+extern IsolatePtr NewIsolate();
+extern void IsolatePerformMicrotaskCheckpoint(IsolatePtr ptr);
+extern void IsolateDispose(IsolatePtr ptr);
+extern void IsolateTerminateExecution(IsolatePtr ptr);
+extern int IsolateIsExecutionTerminating(IsolatePtr ptr);
+extern IsolateHStatistics IsolationGetHeapStatistics(IsolatePtr ptr);
+
+extern ValuePtr IsolateThrowException(IsolatePtr iso, ValuePtr value);
+
+extern RtnUnboundScript IsolateCompileUnboundScript(IsolatePtr iso_ptr,
+                                                    const char* source,
+                                                    const char* origin,
+                                                    CompileOptions options);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+#endif
diff --git a/json.go b/json.go
index 37e73e19..c5e4878f 100644
--- a/json.go
+++ b/json.go
@@ -5,7 +5,7 @@
 package v8go
 
 // #include <stdlib.h>
-// #include "v8go.h"
+// #include "json.h"
 import "C"
 import (
 	"errors"
diff --git a/json.h b/json.h
new file mode 100644
index 00000000..954453c2
--- /dev/null
+++ b/json.h
@@ -0,0 +1,20 @@
+#ifndef V8GO_JSON_H
+#define V8GO_JSON_H
+
+#include "errors.h"
+
+#ifdef __cplusplus
+extern "C" {
+#else
+#endif
+
+typedef struct m_ctx m_ctx;
+typedef m_ctx* ContextPtr;
+
+extern RtnValue JSONParse(ContextPtr ctx_ptr, const char* str);
+const char* JSONStringify(ContextPtr ctx_ptr, ValuePtr val_ptr);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/symbol.cc b/symbol.cc
new file mode 100644
index 00000000..3b099376
--- /dev/null
+++ b/symbol.cc
@@ -0,0 +1,64 @@
+#include "symbol.h"
+#include "context.h"
+#include "isolate-macros.h"
+#include "utils.h"
+#include "value-macros.h"
+
+using namespace v8;
+
+ValuePtr BuiltinSymbol(IsolatePtr iso, SymbolIndex idx) {
+  ISOLATE_SCOPE(iso);
+  INTERNAL_CONTEXT(iso);
+  Local<Symbol> sym;
+  switch (idx) {
+    case SYMBOL_ASYNC_ITERATOR:
+      sym = Symbol::GetAsyncIterator(iso);
+      break;
+    case SYMBOL_HAS_INSTANCE:
+      sym = Symbol::GetHasInstance(iso);
+      break;
+    case SYMBOL_IS_CONCAT_SPREADABLE:
+      sym = Symbol::GetIsConcatSpreadable(iso);
+      break;
+    case SYMBOL_ITERATOR:
+      sym = Symbol::GetIterator(iso);
+      break;
+    case SYMBOL_MATCH:
+      sym = Symbol::GetMatch(iso);
+      break;
+    case SYMBOL_REPLACE:
+      sym = Symbol::GetReplace(iso);
+      break;
+    case SYMBOL_SEARCH:
+      sym = Symbol::GetSearch(iso);
+      break;
+    case SYMBOL_SPLIT:
+      sym = Symbol::GetSplit(iso);
+      break;
+    case SYMBOL_TO_PRIMITIVE:
+      sym = Symbol::GetToPrimitive(iso);
+      break;
+    case SYMBOL_TO_STRING_TAG:
+      sym = Symbol::GetToStringTag(iso);
+      break;
+    case SYMBOL_UNSCOPABLES:
+      sym = Symbol::GetUnscopables(iso);
+      break;
+    default:
+      return nullptr;
+  }
+  m_value* val = new m_value;
+  val->id = 0;
+  val->iso = iso;
+  val->ctx = ctx;
+  val->ptr = Global<Value>(iso, sym);
+  return tracked_value(ctx, val);
+}
+
+const char* SymbolDescription(ValuePtr ptr) {
+  LOCAL_VALUE(ptr);
+  Local<Symbol> sym = value.As<Symbol>();
+  Local<Value> descr = sym->Description(iso);
+  String::Utf8Value utf8(iso, descr);
+  return CopyString(utf8);
+}
diff --git a/symbol.go b/symbol.go
index 825d0b81..b47c8e1e 100644
--- a/symbol.go
+++ b/symbol.go
@@ -9,7 +9,7 @@ import (
 	"unsafe"
 
 	// #include <stdlib.h>
-	// #include "v8go.h"
+	// #include "symbol.h"
 	"C"
 )
 
@@ -18,8 +18,12 @@ type Symbol struct {
 	*Value
 }
 
-func SymbolAsyncIterator(iso *Isolate) *Symbol { return symbolByIndex(iso, C.SYMBOL_ASYNC_ITERATOR) }
-func SymbolHasInstance(iso *Isolate) *Symbol   { return symbolByIndex(iso, C.SYMBOL_HAS_INSTANCE) }
+func SymbolAsyncIterator(
+	iso *Isolate,
+) *Symbol {
+	return symbolByIndex(iso, C.SYMBOL_ASYNC_ITERATOR)
+}
+func SymbolHasInstance(iso *Isolate) *Symbol { return symbolByIndex(iso, C.SYMBOL_HAS_INSTANCE) }
 func SymbolIsConcatSpreadable(iso *Isolate) *Symbol {
 	return symbolByIndex(iso, C.SYMBOL_IS_CONCAT_SPREADABLE)
 }
diff --git a/symbol.h b/symbol.h
new file mode 100644
index 00000000..00ec0314
--- /dev/null
+++ b/symbol.h
@@ -0,0 +1,38 @@
+#ifndef V8GO_SYMBOL_H
+#define V8GO_SYMBOL_H
+
+#ifdef __cplusplus
+namespace v8 {
+class Isolate;
+}
+typedef v8::Isolate v8Isolate;
+extern "C" {
+#else
+typedef struct v8Isolate v8Isolate;
+#endif
+typedef v8Isolate* IsolatePtr;
+
+typedef struct m_value m_value;
+typedef m_value* ValuePtr;
+
+typedef enum {
+  SYMBOL_ASYNC_ITERATOR = 1,
+  SYMBOL_HAS_INSTANCE,
+  SYMBOL_IS_CONCAT_SPREADABLE,
+  SYMBOL_ITERATOR,
+  SYMBOL_MATCH,
+  SYMBOL_REPLACE,
+  SYMBOL_SEARCH,
+  SYMBOL_SPLIT,
+  SYMBOL_TO_PRIMITIVE,
+  SYMBOL_TO_STRING_TAG,
+  SYMBOL_UNSCOPABLES,
+} SymbolIndex;
+
+ValuePtr BuiltinSymbol(IsolatePtr iso_ptr, SymbolIndex idx);
+const char* SymbolDescription(ValuePtr ptr);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/template-macros.h b/template-macros.h
new file mode 100644
index 00000000..cf8cb6b4
--- /dev/null
+++ b/template-macros.h
@@ -0,0 +1,16 @@
+#ifndef V8GO_TEMPLATE_MACROS_H
+#define V8GO_TEMPLATE_MACROS_H
+
+#include "deps/include/v8-isolate.h"
+#include "deps/include/v8-local-handle.h"
+#include "deps/include/v8-locker.h"
+#include "deps/include/v8-template.h"
+
+#define LOCAL_TEMPLATE(tmpl_ptr)     \
+  Isolate* iso = tmpl_ptr->iso;      \
+  Locker locker(iso);                \
+  Isolate::Scope isolate_scope(iso); \
+  HandleScope handle_scope(iso);     \
+  Local<Template> tmpl = tmpl_ptr->ptr.Get(iso);
+
+#endif
diff --git a/template.h b/template.h
new file mode 100644
index 00000000..40df88b1
--- /dev/null
+++ b/template.h
@@ -0,0 +1,29 @@
+#ifndef V8GO_TEMPLATE_H
+#define V8GO_TEMPLATE_H
+#ifdef __cplusplus
+
+#include "deps/include/v8-persistent-handle.h"
+
+namespace v8 {
+class Isolate;
+class Template;
+}  // namespace v8
+
+struct m_template {
+  v8::Isolate* iso;
+  v8::Persistent<v8::Template> ptr;
+};
+
+extern "C" {
+#else
+
+typedef struct m_template m_template;
+
+#endif
+
+typedef m_template* TemplatePtr;
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+#endif
diff --git a/unbound_script.cc b/unbound_script.cc
new file mode 100644
index 00000000..7a30f4a8
--- /dev/null
+++ b/unbound_script.cc
@@ -0,0 +1,58 @@
+/********** UnboundScript & ScriptCompilerCachedData **********/
+
+#include "unbound_script.h"
+#include "context-macros.h"
+#include "isolate-macros.h"
+
+namespace v8 {
+class Isolate;
+}
+using namespace v8;
+
+ScriptCompilerCachedData* UnboundScriptCreateCodeCache(
+    Isolate* iso,
+    UnboundScriptPtr us_ptr) {
+  ISOLATE_SCOPE(iso);
+
+  Local<UnboundScript> unbound_script = us_ptr->ptr.Get(iso);
+
+  ScriptCompiler::CachedData* cached_data =
+      ScriptCompiler::CreateCodeCache(unbound_script);
+
+  ScriptCompilerCachedData* cd = new ScriptCompilerCachedData;
+  cd->ptr = cached_data;
+  cd->data = cached_data->data;
+  cd->length = cached_data->length;
+  cd->rejected = cached_data->rejected;
+  return cd;
+}
+
+void ScriptCompilerCachedDataDelete(ScriptCompilerCachedData* cached_data) {
+  delete cached_data->ptr;
+  delete cached_data;
+}
+
+// This can only run in contexts that belong to the same isolate
+// the script was compiled in
+RtnValue UnboundScriptRun(ContextPtr ctx, UnboundScriptPtr us_ptr) {
+  LOCAL_CONTEXT(ctx)
+
+  RtnValue rtn = {};
+
+  Local<UnboundScript> unbound_script = us_ptr->ptr.Get(iso);
+
+  Local<Script> script = unbound_script->BindToCurrentContext();
+  Local<Value> result;
+  if (!script->Run(local_ctx).ToLocal(&result)) {
+    rtn.error = ExceptionError(try_catch, iso, local_ctx);
+    return rtn;
+  }
+  m_value* val = new m_value;
+  val->id = 0;
+  val->iso = iso;
+  val->ctx = ctx;
+  val->ptr = Global<Value>(iso, result);
+
+  rtn.value = tracked_value(ctx, val);
+  return rtn;
+}
diff --git a/unbound_script.go b/unbound_script.go
index 2110ef91..e9dab252 100644
--- a/unbound_script.go
+++ b/unbound_script.go
@@ -5,7 +5,7 @@
 package v8go
 
 // #include <stdlib.h>
-// #include "v8go.h"
+// #include "unbound_script.h"
 import "C"
 import "unsafe"
 
diff --git a/unbound_script.h b/unbound_script.h
new file mode 100644
index 00000000..5de0a2eb
--- /dev/null
+++ b/unbound_script.h
@@ -0,0 +1,67 @@
+#ifndef V8GO_UNBOUND_SCRIPT_H
+#define V8GO_UNBOUND_SCRIPT_H
+
+#include <stdint.h>
+
+#include "errors.h"
+
+#ifdef __cplusplus
+
+// If we could forward declare v8::ScriptCompiler::CachedData, we wouldn't need
+// this include. But appears not to be possible.
+// https://stackoverflow.com/a/1021809/158483
+#include "deps/include/v8-script.h"
+
+namespace v8 {
+class UnboundScript;
+class Isolate;
+}  // namespace v8
+
+struct m_unboundScript {
+  v8::Persistent<v8::UnboundScript> ptr;
+};
+
+typedef v8::ScriptCompiler::CachedData* ScriptCompilerCachedDataPtr;
+typedef v8::Isolate v8Isolate;
+
+extern "C" {
+#else
+
+typedef struct v8ScriptCompilerCachedData v8ScriptCompilerCachedData;
+typedef const v8ScriptCompilerCachedData* ScriptCompilerCachedDataPtr;
+typedef struct v8Isolate v8Isolate;
+
+#endif
+
+typedef v8Isolate* IsolatePtr;
+
+typedef struct m_ctx m_ctx;
+typedef m_ctx* ContextPtr;
+
+typedef struct m_unboundScript m_unboundScript;
+typedef m_unboundScript* UnboundScriptPtr;
+
+typedef struct {
+  UnboundScriptPtr ptr;
+  int cachedDataRejected;
+  RtnError error;
+} RtnUnboundScript;
+
+typedef struct {
+  ScriptCompilerCachedDataPtr ptr;
+  const uint8_t* data;
+  int length;
+  int rejected;
+} ScriptCompilerCachedData;
+
+extern ScriptCompilerCachedData* UnboundScriptCreateCodeCache(
+    IsolatePtr iso_ptr,
+    UnboundScriptPtr us_ptr);
+extern void ScriptCompilerCachedDataDelete(
+    ScriptCompilerCachedData* cached_data);
+extern RtnValue UnboundScriptRun(ContextPtr ctx_ptr, UnboundScriptPtr us_ptr);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+#endif
diff --git a/utils.cc b/utils.cc
new file mode 100644
index 00000000..8f4ab50b
--- /dev/null
+++ b/utils.cc
@@ -0,0 +1,19 @@
+#include "utils.h"
+#include <stdio.h>
+
+using namespace v8;
+
+const char* CopyString(std::string str) {
+  int len = str.length();
+  char* mem = (char*)malloc(len + 1);
+  memcpy(mem, str.data(), len);
+  mem[len] = 0;
+  return mem;
+}
+
+const char* CopyString(String::Utf8Value& value) {
+  if (value.length() == 0) {
+    return nullptr;
+  }
+  return CopyString(std::string(*value, value.length()));
+}
diff --git a/utils.h b/utils.h
new file mode 100644
index 00000000..2a79ad1d
--- /dev/null
+++ b/utils.h
@@ -0,0 +1,6 @@
+#include <string>
+
+#include "deps/include/v8-primitive.h"
+
+extern const char* CopyString(std::string str);
+extern const char* CopyString(v8::String::Utf8Value& value);
diff --git a/v8go.cc b/v8go.cc
index 1564f755..7f16b9e7 100644
--- a/v8go.cc
+++ b/v8go.cc
@@ -8,116 +8,22 @@
 
 #include <cstdlib>
 #include <cstring>
-#include <iostream>
-#include <sstream>
-#include <string>
-#include <unordered_map>
-#include <vector>
+#include "utils.h"
 
 #include "_cgo_export.h"
 
-using namespace v8;
+#include "context-macros.h"
+#include "isolate-macros.h"
+#include "template-macros.h"
+#include "template.h"
+#include "value-macros.h"
 
-auto default_platform = platform::NewDefaultPlatform();
-ArrayBuffer::Allocator* default_allocator;
+using namespace v8;
 
 const int ScriptCompilerNoCompileOptions = ScriptCompiler::kNoCompileOptions;
 const int ScriptCompilerConsumeCodeCache = ScriptCompiler::kConsumeCodeCache;
 const int ScriptCompilerEagerCompile = ScriptCompiler::kEagerCompile;
 
-struct m_ctx {
-  Isolate* iso;
-  std::unordered_map<long, m_value*> vals;
-  std::vector<m_unboundScript*> unboundScripts;
-  Persistent<Context> ptr;
-  long nextValId;
-};
-
-struct m_value {
-  long id;
-  Isolate* iso;
-  m_ctx* ctx;
-  Global<Value> ptr;
-};
-
-struct m_template {
-  Isolate* iso;
-  Persistent<Template> ptr;
-};
-
-struct m_unboundScript {
-  Persistent<UnboundScript> ptr;
-};
-
-const char* CopyString(std::string str) {
-  int len = str.length();
-  char* mem = (char*)malloc(len + 1);
-  memcpy(mem, str.data(), len);
-  mem[len] = 0;
-  return mem;
-}
-
-const char* CopyString(String::Utf8Value& value) {
-  if (value.length() == 0) {
-    return nullptr;
-  }
-  return CopyString(std::string(*value, value.length()));
-}
-
-static RtnError ExceptionError(TryCatch& try_catch,
-                               Isolate* iso,
-                               Local<Context> ctx) {
-  HandleScope handle_scope(iso);
-
-  RtnError rtn = {nullptr, nullptr, nullptr};
-
-  if (try_catch.HasTerminated()) {
-    rtn.msg =
-        CopyString("ExecutionTerminated: script execution has been terminated");
-    return rtn;
-  }
-
-  String::Utf8Value exception(iso, try_catch.Exception());
-  rtn.msg = CopyString(exception);
-
-  Local<Message> msg = try_catch.Message();
-  if (!msg.IsEmpty()) {
-    String::Utf8Value origin(iso, msg->GetScriptOrigin().ResourceName());
-    std::ostringstream sb;
-    sb << *origin;
-    Maybe<int> line = try_catch.Message()->GetLineNumber(ctx);
-    if (line.IsJust()) {
-      sb << ":" << line.ToChecked();
-    }
-    Maybe<int> start = try_catch.Message()->GetStartColumn(ctx);
-    if (start.IsJust()) {
-      sb << ":"
-         << start.ToChecked() + 1;  // + 1 to match output from stack trace
-    }
-    rtn.location = CopyString(sb.str());
-  }
-
-  Local<Value> mstack;
-  if (try_catch.StackTrace(ctx).ToLocal(&mstack)) {
-    String::Utf8Value stack(iso, mstack);
-    rtn.stack = CopyString(stack);
-  }
-
-  return rtn;
-}
-
-m_value* tracked_value(m_ctx* ctx, m_value* val) {
-  // (rogchap) we track values against a context so that when the context is
-  // closed (either manually or GC'd by Go) we can also release all the
-  // values associated with the context;
-  if (val->id == 0) {
-    val->id = ++ctx->nextValId;
-    ctx->vals[val->id] = val;
-  }
-
-  return val;
-}
-
 m_unboundScript* tracked_unbound_script(m_ctx* ctx, m_unboundScript* us) {
   ctx->unboundScripts.push_back(us);
 
@@ -128,91 +34,10 @@ extern "C" {
 
 /********** Isolate **********/
 
-#define ISOLATE_SCOPE(iso)           \
-  Locker locker(iso);                \
-  Isolate::Scope isolate_scope(iso); \
-  HandleScope handle_scope(iso);
-
 #define ISOLATE_SCOPE_INTERNAL_CONTEXT(iso) \
   ISOLATE_SCOPE(iso);                       \
   m_ctx* ctx = isolateInternalContext(iso);
 
-void Init() {
-#ifdef _WIN32
-  V8::InitializeExternalStartupData(".");
-#endif
-  V8::InitializePlatform(default_platform.get());
-  V8::Initialize();
-
-  default_allocator = ArrayBuffer::Allocator::NewDefaultAllocator();
-  return;
-}
-
-IsolatePtr NewIsolate() {
-  Isolate::CreateParams params;
-  params.array_buffer_allocator = default_allocator;
-  Isolate* iso = Isolate::New(params);
-  Locker locker(iso);
-  Isolate::Scope isolate_scope(iso);
-  HandleScope handle_scope(iso);
-
-  iso->SetCaptureStackTraceForUncaughtExceptions(true);
-
-  // Create a Context for internal use
-  m_ctx* ctx = new m_ctx;
-  ctx->ptr.Reset(iso, Context::New(iso));
-  ctx->iso = iso;
-  iso->SetData(0, ctx);
-
-  return iso;
-}
-
-static inline m_ctx* isolateInternalContext(Isolate* iso) {
-  return static_cast<m_ctx*>(iso->GetData(0));
-}
-
-void IsolatePerformMicrotaskCheckpoint(IsolatePtr iso) {
-  ISOLATE_SCOPE(iso)
-  iso->PerformMicrotaskCheckpoint();
-}
-
-void IsolateDispose(IsolatePtr iso) {
-  if (iso == nullptr) {
-    return;
-  }
-  ContextFree(isolateInternalContext(iso));
-
-  iso->Dispose();
-}
-
-void IsolateTerminateExecution(IsolatePtr iso) {
-  iso->TerminateExecution();
-}
-
-int IsolateIsExecutionTerminating(IsolatePtr iso) {
-  return iso->IsExecutionTerminating();
-}
-
-IsolateHStatistics IsolationGetHeapStatistics(IsolatePtr iso) {
-  if (iso == nullptr) {
-    return IsolateHStatistics{0};
-  }
-  v8::HeapStatistics hs;
-  iso->GetHeapStatistics(&hs);
-
-  return IsolateHStatistics{hs.total_heap_size(),
-                            hs.total_heap_size_executable(),
-                            hs.total_physical_size(),
-                            hs.total_available_size(),
-                            hs.used_heap_size(),
-                            hs.heap_size_limit(),
-                            hs.malloced_memory(),
-                            hs.external_memory(),
-                            hs.peak_malloced_memory(),
-                            hs.number_of_native_contexts(),
-                            hs.number_of_detached_contexts()};
-}
-
 RtnUnboundScript IsolateCompileUnboundScript(IsolatePtr iso,
                                              const char* s,
                                              const char* o,
@@ -390,13 +215,6 @@ void CPUProfileDelete(CPUProfile* profile) {
 
 /********** Template **********/
 
-#define LOCAL_TEMPLATE(tmpl_ptr)     \
-  Isolate* iso = tmpl_ptr->iso;      \
-  Locker locker(iso);                \
-  Isolate::Scope isolate_scope(iso); \
-  HandleScope handle_scope(iso);     \
-  Local<Template> tmpl = tmpl_ptr->ptr.Get(iso);
-
 void TemplateFreeWrapper(TemplatePtr tmpl) {
   tmpl->ptr.Clear();  // Just does `val_ = 0;` without calling V8::DisposeGlobal
   delete tmpl;
@@ -593,154 +411,6 @@ RtnValue FunctionTemplateGetFunction(TemplatePtr ptr, ContextPtr ctx) {
 
 /********** Context **********/
 
-#define LOCAL_CONTEXT(ctx)                      \
-  Isolate* iso = ctx->iso;                      \
-  Locker locker(iso);                           \
-  Isolate::Scope isolate_scope(iso);            \
-  HandleScope handle_scope(iso);                \
-  TryCatch try_catch(iso);                      \
-  Local<Context> local_ctx = ctx->ptr.Get(iso); \
-  Context::Scope context_scope(local_ctx);
-
-ContextPtr NewContext(IsolatePtr iso,
-                      TemplatePtr global_template_ptr,
-                      int ref) {
-  Locker locker(iso);
-  Isolate::Scope isolate_scope(iso);
-  HandleScope handle_scope(iso);
-
-  Local<ObjectTemplate> global_template;
-  if (global_template_ptr != nullptr) {
-    global_template = global_template_ptr->ptr.Get(iso).As<ObjectTemplate>();
-  } else {
-    global_template = ObjectTemplate::New(iso);
-  }
-
-  // For function callbacks we need a reference to the context, but because of
-  // the complexities of C -> Go function pointers, we store a reference to the
-  // context as a simple integer identifier; this can then be used on the Go
-  // side to lookup the context in the context registry. We use slot 1 as slot 0
-  // has special meaning for the Chrome debugger.
-  Local<Context> local_ctx = Context::New(iso, nullptr, global_template);
-  local_ctx->SetEmbedderData(1, Integer::New(iso, ref));
-
-  m_ctx* ctx = new m_ctx;
-  ctx->ptr.Reset(iso, local_ctx);
-  ctx->iso = iso;
-  return ctx;
-}
-
-int ContextRetainedValueCount(ContextPtr ctx) {
-  return ctx->vals.size();
-}
-
-void ContextFree(ContextPtr ctx) {
-  if (ctx == nullptr) {
-    return;
-  }
-  ctx->ptr.Reset();
-
-  for (auto it = ctx->vals.begin(); it != ctx->vals.end(); ++it) {
-    auto value = it->second;
-    value->ptr.Reset();
-    delete value;
-  }
-  ctx->vals.clear();
-
-  for (m_unboundScript* us : ctx->unboundScripts) {
-    us->ptr.Reset();
-    delete us;
-  }
-
-  delete ctx;
-}
-
-RtnValue RunScript(ContextPtr ctx, const char* source, const char* origin) {
-  LOCAL_CONTEXT(ctx);
-
-  RtnValue rtn = {};
-
-  MaybeLocal<String> maybeSrc =
-      String::NewFromUtf8(iso, source, NewStringType::kNormal);
-  MaybeLocal<String> maybeOgn =
-      String::NewFromUtf8(iso, origin, NewStringType::kNormal);
-  Local<String> src, ogn;
-  if (!maybeSrc.ToLocal(&src) || !maybeOgn.ToLocal(&ogn)) {
-    rtn.error = ExceptionError(try_catch, iso, local_ctx);
-    return rtn;
-  }
-
-  ScriptOrigin script_origin(ogn);
-  Local<Script> script;
-  if (!Script::Compile(local_ctx, src, &script_origin).ToLocal(&script)) {
-    rtn.error = ExceptionError(try_catch, iso, local_ctx);
-    return rtn;
-  }
-  Local<Value> result;
-  if (!script->Run(local_ctx).ToLocal(&result)) {
-    rtn.error = ExceptionError(try_catch, iso, local_ctx);
-    return rtn;
-  }
-  m_value* val = new m_value;
-  val->id = 0;
-  val->iso = iso;
-  val->ctx = ctx;
-  val->ptr = Global<Value>(iso, result);
-
-  rtn.value = tracked_value(ctx, val);
-  return rtn;
-}
-
-/********** UnboundScript & ScriptCompilerCachedData **********/
-
-ScriptCompilerCachedData* UnboundScriptCreateCodeCache(
-    IsolatePtr iso,
-    UnboundScriptPtr us_ptr) {
-  ISOLATE_SCOPE(iso);
-
-  Local<UnboundScript> unbound_script = us_ptr->ptr.Get(iso);
-
-  ScriptCompiler::CachedData* cached_data =
-      ScriptCompiler::CreateCodeCache(unbound_script);
-
-  ScriptCompilerCachedData* cd = new ScriptCompilerCachedData;
-  cd->ptr = cached_data;
-  cd->data = cached_data->data;
-  cd->length = cached_data->length;
-  cd->rejected = cached_data->rejected;
-  return cd;
-}
-
-void ScriptCompilerCachedDataDelete(ScriptCompilerCachedData* cached_data) {
-  delete cached_data->ptr;
-  delete cached_data;
-}
-
-// This can only run in contexts that belong to the same isolate
-// the script was compiled in
-RtnValue UnboundScriptRun(ContextPtr ctx, UnboundScriptPtr us_ptr) {
-  LOCAL_CONTEXT(ctx)
-
-  RtnValue rtn = {};
-
-  Local<UnboundScript> unbound_script = us_ptr->ptr.Get(iso);
-
-  Local<Script> script = unbound_script->BindToCurrentContext();
-  Local<Value> result;
-  if (!script->Run(local_ctx).ToLocal(&result)) {
-    rtn.error = ExceptionError(try_catch, iso, local_ctx);
-    return rtn;
-  }
-  m_value* val = new m_value;
-  val->id = 0;
-  val->iso = iso;
-  val->ctx = ctx;
-  val->ptr = Global<Value>(iso, result);
-
-  rtn.value = tracked_value(ctx, val);
-  return rtn;
-}
-
 RtnValue JSONParse(ContextPtr ctx, const char* str) {
   LOCAL_CONTEXT(ctx);
   RtnValue rtn = {};
@@ -810,37 +480,6 @@ void ValueRelease(ValuePtr ptr) {
   delete ptr;
 }
 
-ValuePtr ContextGlobal(ContextPtr ctx) {
-  LOCAL_CONTEXT(ctx);
-  m_value* val = new m_value;
-  val->id = 0;
-
-  val->iso = iso;
-  val->ctx = ctx;
-  val->ptr = Global<Value>(iso, local_ctx->Global());
-
-  return tracked_value(ctx, val);
-}
-
-/********** Value **********/
-
-#define LOCAL_VALUE(val)                   \
-  Isolate* iso = val->iso;                 \
-  Locker locker(iso);                      \
-  Isolate::Scope isolate_scope(iso);       \
-  HandleScope handle_scope(iso);           \
-  TryCatch try_catch(iso);                 \
-  m_ctx* ctx = val->ctx;                   \
-  Local<Context> local_ctx;                \
-  if (ctx != nullptr) {                    \
-    local_ctx = ctx->ptr.Get(iso);         \
-  } else {                                 \
-    ctx = isolateInternalContext(iso);     \
-    local_ctx = ctx->ptr.Get(iso);         \
-  }                                        \
-  Context::Scope context_scope(local_ctx); \
-  Local<Value> value = val->ptr.Get(iso);
-
 ValuePtr NewValueInteger(IsolatePtr iso, int32_t v) {
   ISOLATE_SCOPE_INTERNAL_CONTEXT(iso);
   m_value* val = new m_value;
@@ -1564,64 +1203,6 @@ int ObjectDeleteIdx(ValuePtr ptr, uint32_t idx) {
   return obj->Delete(local_ctx, idx).ToChecked();
 }
 
-/********** Symbol **********/
-
-ValuePtr BuiltinSymbol(IsolatePtr iso, SymbolIndex idx) {
-  ISOLATE_SCOPE_INTERNAL_CONTEXT(iso);
-  Local<Symbol> sym;
-  switch (idx) {
-    case SYMBOL_ASYNC_ITERATOR:
-      sym = Symbol::GetAsyncIterator(iso);
-      break;
-    case SYMBOL_HAS_INSTANCE:
-      sym = Symbol::GetHasInstance(iso);
-      break;
-    case SYMBOL_IS_CONCAT_SPREADABLE:
-      sym = Symbol::GetIsConcatSpreadable(iso);
-      break;
-    case SYMBOL_ITERATOR:
-      sym = Symbol::GetIterator(iso);
-      break;
-    case SYMBOL_MATCH:
-      sym = Symbol::GetMatch(iso);
-      break;
-    case SYMBOL_REPLACE:
-      sym = Symbol::GetReplace(iso);
-      break;
-    case SYMBOL_SEARCH:
-      sym = Symbol::GetSearch(iso);
-      break;
-    case SYMBOL_SPLIT:
-      sym = Symbol::GetSplit(iso);
-      break;
-    case SYMBOL_TO_PRIMITIVE:
-      sym = Symbol::GetToPrimitive(iso);
-      break;
-    case SYMBOL_TO_STRING_TAG:
-      sym = Symbol::GetToStringTag(iso);
-      break;
-    case SYMBOL_UNSCOPABLES:
-      sym = Symbol::GetUnscopables(iso);
-      break;
-    default:
-      return nullptr;
-  }
-  m_value* val = new m_value;
-  val->id = 0;
-  val->iso = iso;
-  val->ctx = ctx;
-  val->ptr = Global<Value>(iso, sym);
-  return tracked_value(ctx, val);
-}
-
-const char* SymbolDescription(ValuePtr ptr) {
-  LOCAL_VALUE(ptr);
-  Local<Symbol> sym = value.As<Symbol>();
-  Local<Value> descr = sym->Description(iso);
-  String::Utf8Value utf8(iso, descr);
-  return CopyString(utf8);
-}
-
 /********** Promise **********/
 
 RtnValue NewPromiseResolver(ContextPtr ctx) {
diff --git a/v8go.h b/v8go.h
index c88091e6..8eb237db 100644
--- a/v8go.h
+++ b/v8go.h
@@ -4,23 +4,26 @@
 
 #ifndef V8GO_H
 #define V8GO_H
+
+#include "context.h"
+#include "errors.h"
+#include "isolate.h"
+#include "value.h"
+
 #ifdef __cplusplus
 
-#include "libplatform/libplatform.h"
-#include "v8-profiler.h"
-#include "v8.h"
+#include "deps/include/libplatform/libplatform.h"
+#include "deps/include/v8-profiler.h"
+#include "deps/include/v8.h"
 
-typedef v8::Isolate* IsolatePtr;
 typedef v8::CpuProfiler* CpuProfilerPtr;
 typedef v8::CpuProfile* CpuProfilePtr;
 typedef const v8::CpuProfileNode* CpuProfileNodePtr;
-typedef v8::ScriptCompiler::CachedData* ScriptCompilerCachedDataPtr;
 
 extern "C" {
 #else
+
 // Opaque to cgo, but useful to treat it as a pointer to a distinct type
-typedef struct v8Isolate v8Isolate;
-typedef v8Isolate* IsolatePtr;
 
 typedef struct v8CpuProfiler v8CpuProfiler;
 typedef v8CpuProfiler* CpuProfilerPtr;
@@ -31,10 +34,11 @@ typedef v8CpuProfile* CpuProfilePtr;
 typedef struct v8CpuProfileNode v8CpuProfileNode;
 typedef const v8CpuProfileNode* CpuProfileNodePtr;
 
-typedef struct v8ScriptCompilerCachedData v8ScriptCompilerCachedData;
-typedef const v8ScriptCompilerCachedData* ScriptCompilerCachedDataPtr;
 #endif
 
+#include "unbound_script.h"
+#include "value.h"
+
 // Opaque to both C and C++
 typedef struct v8BackingStore v8BackingStore;
 typedef v8BackingStore* BackingStorePtr;
@@ -42,69 +46,9 @@ typedef v8BackingStore* BackingStorePtr;
 #include <stddef.h>
 #include <stdint.h>
 
-// ScriptCompiler::CompileOptions values
-extern const int ScriptCompilerNoCompileOptions;
-extern const int ScriptCompilerConsumeCodeCache;
-extern const int ScriptCompilerEagerCompile;
-
-typedef struct m_ctx m_ctx;
-typedef struct m_value m_value;
 typedef struct m_template m_template;
-typedef struct m_unboundScript m_unboundScript;
 
-typedef m_ctx* ContextPtr;
-typedef m_value* ValuePtr;
 typedef m_template* TemplatePtr;
-typedef m_unboundScript* UnboundScriptPtr;
-
-typedef enum {
-  ERROR_RANGE = 1,
-  ERROR_REFERENCE,
-  ERROR_SYNTAX,
-  ERROR_TYPE,
-  ERROR_WASM_COMPILE,
-  ERROR_WASM_LINK,
-  ERROR_WASM_RUNTIME,
-  ERROR_GENERIC,
-} ErrorTypeIndex;
-
-typedef enum {
-  SYMBOL_ASYNC_ITERATOR = 1,
-  SYMBOL_HAS_INSTANCE,
-  SYMBOL_IS_CONCAT_SPREADABLE,
-  SYMBOL_ITERATOR,
-  SYMBOL_MATCH,
-  SYMBOL_REPLACE,
-  SYMBOL_SEARCH,
-  SYMBOL_SPLIT,
-  SYMBOL_TO_PRIMITIVE,
-  SYMBOL_TO_STRING_TAG,
-  SYMBOL_UNSCOPABLES,
-} SymbolIndex;
-
-typedef struct {
-  const char* msg;
-  const char* location;
-  const char* stack;
-} RtnError;
-
-typedef struct {
-  UnboundScriptPtr ptr;
-  int cachedDataRejected;
-  RtnError error;
-} RtnUnboundScript;
-
-typedef struct {
-  ScriptCompilerCachedDataPtr ptr;
-  const uint8_t* data;
-  int length;
-  int rejected;
-} ScriptCompilerCachedData;
-
-typedef struct {
-  ScriptCompilerCachedData cachedData;
-  int compileOption;
-} CompileOptions;
 
 typedef struct {
   CpuProfilerPtr ptr;
@@ -133,57 +77,7 @@ typedef struct {
   int64_t endTime;
 } CPUProfile;
 
-typedef struct {
-  ValuePtr value;
-  RtnError error;
-} RtnValue;
-
-typedef struct {
-  const char* data;
-  int length;
-  RtnError error;
-} RtnString;
-
-typedef struct {
-  size_t total_heap_size;
-  size_t total_heap_size_executable;
-  size_t total_physical_size;
-  size_t total_available_size;
-  size_t used_heap_size;
-  size_t heap_size_limit;
-  size_t malloced_memory;
-  size_t external_memory;
-  size_t peak_malloced_memory;
-  size_t number_of_native_contexts;
-  size_t number_of_detached_contexts;
-} IsolateHStatistics;
-
-typedef struct {
-  const uint64_t* word_array;
-  int word_count;
-  int sign_bit;
-} ValueBigInt;
-
 extern void Init();
-extern IsolatePtr NewIsolate();
-extern void IsolatePerformMicrotaskCheckpoint(IsolatePtr ptr);
-extern void IsolateDispose(IsolatePtr ptr);
-extern void IsolateTerminateExecution(IsolatePtr ptr);
-extern int IsolateIsExecutionTerminating(IsolatePtr ptr);
-extern IsolateHStatistics IsolationGetHeapStatistics(IsolatePtr ptr);
-
-extern ValuePtr IsolateThrowException(IsolatePtr iso, ValuePtr value);
-
-extern RtnUnboundScript IsolateCompileUnboundScript(IsolatePtr iso_ptr,
-                                                    const char* source,
-                                                    const char* origin,
-                                                    CompileOptions options);
-extern ScriptCompilerCachedData* UnboundScriptCreateCodeCache(
-    IsolatePtr iso_ptr,
-    UnboundScriptPtr us_ptr);
-extern void ScriptCompilerCachedDataDelete(
-    ScriptCompilerCachedData* cached_data);
-extern RtnValue UnboundScriptRun(ContextPtr ctx_ptr, UnboundScriptPtr us_ptr);
 
 extern CPUProfiler* NewCPUProfiler(IsolatePtr iso_ptr);
 extern void CPUProfilerDispose(CPUProfiler* ptr);
@@ -192,18 +86,6 @@ extern CPUProfile* CPUProfilerStopProfiling(CPUProfiler* ptr,
                                             const char* title);
 extern void CPUProfileDelete(CPUProfile* ptr);
 
-extern ContextPtr NewContext(IsolatePtr iso_ptr,
-                             TemplatePtr global_template_ptr,
-                             int ref);
-extern int ContextRetainedValueCount(ContextPtr ctx);
-extern void ContextFree(ContextPtr ptr);
-extern RtnValue RunScript(ContextPtr ctx_ptr,
-                          const char* source,
-                          const char* origin);
-extern RtnValue JSONParse(ContextPtr ctx_ptr, const char* str);
-const char* JSONStringify(ContextPtr ctx_ptr, ValuePtr val_ptr);
-extern ValuePtr ContextGlobal(ContextPtr ctx_ptr);
-
 extern void TemplateFreeWrapper(TemplatePtr ptr);
 extern void TemplateSetValue(TemplatePtr ptr,
                              const char* name,
@@ -232,89 +114,6 @@ extern TemplatePtr NewFunctionTemplate(IsolatePtr iso_ptr, int callback_ref);
 extern RtnValue FunctionTemplateGetFunction(TemplatePtr ptr,
                                             ContextPtr ctx_ptr);
 
-extern ValuePtr NewValueNull(IsolatePtr iso_ptr);
-extern ValuePtr NewValueUndefined(IsolatePtr iso_ptr);
-extern ValuePtr NewValueInteger(IsolatePtr iso_ptr, int32_t v);
-extern ValuePtr NewValueIntegerFromUnsigned(IsolatePtr iso_ptr, uint32_t v);
-extern RtnValue NewValueString(IsolatePtr iso_ptr, const char* v, int v_length);
-extern ValuePtr NewValueBoolean(IsolatePtr iso_ptr, int v);
-extern ValuePtr NewValueNumber(IsolatePtr iso_ptr, double v);
-extern ValuePtr NewValueBigInt(IsolatePtr iso_ptr, int64_t v);
-extern ValuePtr NewValueBigIntFromUnsigned(IsolatePtr iso_ptr, uint64_t v);
-extern RtnValue NewValueBigIntFromWords(IsolatePtr iso_ptr,
-                                        int sign_bit,
-                                        int word_count,
-                                        const uint64_t* words);
-extern ValuePtr NewValueError(IsolatePtr iso_ptr,
-                              ErrorTypeIndex idx,
-                              const char* message);
-void ValueRelease(ValuePtr ptr);
-extern RtnString ValueToString(ValuePtr ptr);
-const uint32_t* ValueToArrayIndex(ValuePtr ptr);
-int ValueToBoolean(ValuePtr ptr);
-int32_t ValueToInt32(ValuePtr ptr);
-int64_t ValueToInteger(ValuePtr ptr);
-double ValueToNumber(ValuePtr ptr);
-RtnString ValueToDetailString(ValuePtr ptr);
-uint32_t ValueToUint32(ValuePtr ptr);
-extern ValueBigInt ValueToBigInt(ValuePtr ptr);
-extern RtnValue ValueToObject(ValuePtr ptr);
-int ValueSameValue(ValuePtr ptr, ValuePtr otherPtr);
-int ValueIsUndefined(ValuePtr ptr);
-int ValueIsNull(ValuePtr ptr);
-int ValueIsNullOrUndefined(ValuePtr ptr);
-int ValueIsTrue(ValuePtr ptr);
-int ValueIsFalse(ValuePtr ptr);
-int ValueIsName(ValuePtr ptr);
-int ValueIsString(ValuePtr ptr);
-int ValueIsSymbol(ValuePtr ptr);
-int ValueIsFunction(ValuePtr ptr);
-int ValueIsObject(ValuePtr ptr);
-int ValueIsBigInt(ValuePtr ptr);
-int ValueIsBoolean(ValuePtr ptr);
-int ValueIsNumber(ValuePtr ptr);
-int ValueIsExternal(ValuePtr ptr);
-int ValueIsInt32(ValuePtr ptr);
-int ValueIsUint32(ValuePtr ptr);
-int ValueIsDate(ValuePtr ptr);
-int ValueIsArgumentsObject(ValuePtr ptr);
-int ValueIsBigIntObject(ValuePtr ptr);
-int ValueIsNumberObject(ValuePtr ptr);
-int ValueIsStringObject(ValuePtr ptr);
-int ValueIsSymbolObject(ValuePtr ptr);
-int ValueIsNativeError(ValuePtr ptr);
-int ValueIsRegExp(ValuePtr ptr);
-int ValueIsAsyncFunction(ValuePtr ptr);
-int ValueIsGeneratorFunction(ValuePtr ptr);
-int ValueIsGeneratorObject(ValuePtr ptr);
-int ValueIsPromise(ValuePtr ptr);
-int ValueIsMap(ValuePtr ptr);
-int ValueIsSet(ValuePtr ptr);
-int ValueIsMapIterator(ValuePtr ptr);
-int ValueIsSetIterator(ValuePtr ptr);
-int ValueIsWeakMap(ValuePtr ptr);
-int ValueIsWeakSet(ValuePtr ptr);
-int ValueIsArray(ValuePtr ptr);
-int ValueIsArrayBuffer(ValuePtr ptr);
-int ValueIsArrayBufferView(ValuePtr ptr);
-int ValueIsTypedArray(ValuePtr ptr);
-int ValueIsUint8Array(ValuePtr ptr);
-int ValueIsUint8ClampedArray(ValuePtr ptr);
-int ValueIsInt8Array(ValuePtr ptr);
-int ValueIsUint16Array(ValuePtr ptr);
-int ValueIsInt16Array(ValuePtr ptr);
-int ValueIsUint32Array(ValuePtr ptr);
-int ValueIsInt32Array(ValuePtr ptr);
-int ValueIsFloat32Array(ValuePtr ptr);
-int ValueIsFloat64Array(ValuePtr ptr);
-int ValueIsBigInt64Array(ValuePtr ptr);
-int ValueIsBigUint64Array(ValuePtr ptr);
-int ValueIsDataView(ValuePtr ptr);
-int ValueIsSharedArrayBuffer(ValuePtr ptr);
-int ValueIsProxy(ValuePtr ptr);
-int ValueIsWasmModuleObject(ValuePtr ptr);
-int ValueIsModuleNamespaceObject(ValuePtr ptr);
-
 const char* ExceptionGetMessageString(ValuePtr ptr);
 
 extern void ObjectSet(ValuePtr ptr, const char* key, ValuePtr val_ptr);
@@ -333,9 +132,6 @@ int ObjectDelete(ValuePtr ptr, const char* key);
 int ObjectDeleteAnyKey(ValuePtr ptr, ValuePtr key);
 int ObjectDeleteIdx(ValuePtr ptr, uint32_t idx);
 
-ValuePtr BuiltinSymbol(IsolatePtr iso_ptr, SymbolIndex idx);
-const char* SymbolDescription(ValuePtr ptr);
-
 extern RtnValue NewPromiseResolver(ContextPtr ctx_ptr);
 extern ValuePtr PromiseResolverGetPromise(ValuePtr ptr);
 int PromiseResolverResolve(ValuePtr ptr, ValuePtr val_ptr);
@@ -356,11 +152,6 @@ ValuePtr FunctionSourceMapUrl(ValuePtr ptr);
 const char* Version();
 extern void SetFlags(const char* flags);
 
-extern BackingStorePtr SharedArrayBufferGetBackingStore(ValuePtr ptr);
-extern void BackingStoreRelease(BackingStorePtr ptr);
-extern void* BackingStoreData(BackingStorePtr ptr);
-extern size_t BackingStoreByteLength(BackingStorePtr ptr);
-
 #ifdef __cplusplus
 }  // extern "C"
 #endif
diff --git a/value-macros.h b/value-macros.h
new file mode 100644
index 00000000..9fc2498b
--- /dev/null
+++ b/value-macros.h
@@ -0,0 +1,29 @@
+#ifndef V8GO_VALUE_MACROS_H
+#define V8GO_VALUE_MACROS_H
+
+#include "deps/include/v8-context.h"
+#include "deps/include/v8-exception.h"
+#include "deps/include/v8-isolate.h"
+#include "deps/include/v8-locker.h"
+
+#include "context.h"
+#include "isolate.h"
+
+#define LOCAL_VALUE(val)                   \
+  Isolate* iso = val->iso;                 \
+  Locker locker(iso);                      \
+  Isolate::Scope isolate_scope(iso);       \
+  HandleScope handle_scope(iso);           \
+  TryCatch try_catch(iso);                 \
+  m_ctx* ctx = val->ctx;                   \
+  Local<Context> local_ctx;                \
+  if (ctx != nullptr) {                    \
+    local_ctx = ctx->ptr.Get(iso);         \
+  } else {                                 \
+    ctx = isolateInternalContext(iso);     \
+    local_ctx = ctx->ptr.Get(iso);         \
+  }                                        \
+  Context::Scope context_scope(local_ctx); \
+  Local<Value> value = val->ptr.Get(iso);
+
+#endif
diff --git a/value.go b/value.go
index 0dfc7349..ddd22f54 100644
--- a/value.go
+++ b/value.go
@@ -5,7 +5,7 @@
 package v8go
 
 // #include <stdlib.h>
-// #include "v8go.h"
+// #include "value.h"
 import "C"
 import (
 	"errors"
diff --git a/value.h b/value.h
new file mode 100644
index 00000000..0632fa98
--- /dev/null
+++ b/value.h
@@ -0,0 +1,167 @@
+#ifndef V8GO_VALUE_H
+#define V8GO_VALUE_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "errors.h"
+
+#ifdef __cplusplus
+
+#include "deps/include/v8-persistent-handle.h"
+
+namespace v8 {
+class Isolate;
+class Value;
+}  // namespace v8
+
+typedef struct m_ctx m_ctx;
+
+struct m_value {
+  long id;
+  v8::Isolate* iso;
+  m_ctx* ctx;
+  v8::Global<v8::Value> ptr;
+};
+
+typedef v8::Isolate v8Isolate;
+
+extern "C" {
+#else
+
+typedef struct v8Isolate v8Isolate;
+typedef struct m_value m_value;
+
+#endif
+
+typedef m_value* ValuePtr;
+typedef v8Isolate* IsolatePtr;
+
+typedef struct v8BackingStore v8BackingStore;
+typedef v8BackingStore* BackingStorePtr;
+
+typedef struct {
+  const uint64_t* word_array;
+  int word_count;
+  int sign_bit;
+} ValueBigInt;
+
+typedef struct {
+  const char* data;
+  int length;
+  RtnError error;
+} RtnString;
+
+void ValueRelease(ValuePtr ptr);
+extern RtnString ValueToString(ValuePtr ptr);
+const uint32_t* ValueToArrayIndex(ValuePtr ptr);
+int ValueToBoolean(ValuePtr ptr);
+int32_t ValueToInt32(ValuePtr ptr);
+int64_t ValueToInteger(ValuePtr ptr);
+double ValueToNumber(ValuePtr ptr);
+RtnString ValueToDetailString(ValuePtr ptr);
+uint32_t ValueToUint32(ValuePtr ptr);
+extern ValueBigInt ValueToBigInt(ValuePtr ptr);
+extern RtnValue ValueToObject(ValuePtr ptr);
+int ValueSameValue(ValuePtr ptr, ValuePtr otherPtr);
+int ValueIsUndefined(ValuePtr ptr);
+int ValueIsNull(ValuePtr ptr);
+int ValueIsNullOrUndefined(ValuePtr ptr);
+int ValueIsTrue(ValuePtr ptr);
+int ValueIsFalse(ValuePtr ptr);
+int ValueIsName(ValuePtr ptr);
+int ValueIsString(ValuePtr ptr);
+int ValueIsSymbol(ValuePtr ptr);
+int ValueIsFunction(ValuePtr ptr);
+int ValueIsObject(ValuePtr ptr);
+int ValueIsBigInt(ValuePtr ptr);
+int ValueIsBoolean(ValuePtr ptr);
+int ValueIsNumber(ValuePtr ptr);
+int ValueIsExternal(ValuePtr ptr);
+int ValueIsInt32(ValuePtr ptr);
+int ValueIsUint32(ValuePtr ptr);
+int ValueIsDate(ValuePtr ptr);
+int ValueIsArgumentsObject(ValuePtr ptr);
+int ValueIsBigIntObject(ValuePtr ptr);
+int ValueIsNumberObject(ValuePtr ptr);
+int ValueIsStringObject(ValuePtr ptr);
+int ValueIsSymbolObject(ValuePtr ptr);
+int ValueIsNativeError(ValuePtr ptr);
+int ValueIsRegExp(ValuePtr ptr);
+int ValueIsAsyncFunction(ValuePtr ptr);
+int ValueIsGeneratorFunction(ValuePtr ptr);
+int ValueIsGeneratorObject(ValuePtr ptr);
+int ValueIsPromise(ValuePtr ptr);
+int ValueIsMap(ValuePtr ptr);
+int ValueIsSet(ValuePtr ptr);
+int ValueIsMapIterator(ValuePtr ptr);
+int ValueIsSetIterator(ValuePtr ptr);
+int ValueIsWeakMap(ValuePtr ptr);
+int ValueIsWeakSet(ValuePtr ptr);
+int ValueIsArray(ValuePtr ptr);
+int ValueIsArrayBuffer(ValuePtr ptr);
+int ValueIsArrayBufferView(ValuePtr ptr);
+int ValueIsTypedArray(ValuePtr ptr);
+int ValueIsUint8Array(ValuePtr ptr);
+int ValueIsUint8ClampedArray(ValuePtr ptr);
+int ValueIsInt8Array(ValuePtr ptr);
+int ValueIsUint16Array(ValuePtr ptr);
+int ValueIsInt16Array(ValuePtr ptr);
+int ValueIsUint32Array(ValuePtr ptr);
+int ValueIsInt32Array(ValuePtr ptr);
+int ValueIsFloat32Array(ValuePtr ptr);
+int ValueIsFloat64Array(ValuePtr ptr);
+int ValueIsBigInt64Array(ValuePtr ptr);
+int ValueIsBigUint64Array(ValuePtr ptr);
+int ValueIsDataView(ValuePtr ptr);
+int ValueIsSharedArrayBuffer(ValuePtr ptr);
+int ValueIsProxy(ValuePtr ptr);
+int ValueIsWasmModuleObject(ValuePtr ptr);
+int ValueIsModuleNamespaceObject(ValuePtr ptr);
+
+extern ValuePtr NewValueNull(IsolatePtr iso_ptr);
+extern ValuePtr NewValueUndefined(IsolatePtr iso_ptr);
+extern ValuePtr NewValueInteger(IsolatePtr iso_ptr, int32_t v);
+extern ValuePtr NewValueIntegerFromUnsigned(IsolatePtr iso_ptr, uint32_t v);
+extern RtnValue NewValueString(IsolatePtr iso_ptr, const char* v, int v_length);
+extern ValuePtr NewValueBoolean(IsolatePtr iso_ptr, int v);
+extern ValuePtr NewValueNumber(IsolatePtr iso_ptr, double v);
+extern ValuePtr NewValueBigInt(IsolatePtr iso_ptr, int64_t v);
+extern ValuePtr NewValueBigIntFromUnsigned(IsolatePtr iso_ptr, uint64_t v);
+extern RtnValue NewValueBigIntFromWords(IsolatePtr iso_ptr,
+                                        int sign_bit,
+                                        int word_count,
+                                        const uint64_t* words);
+extern ValuePtr NewValueError(IsolatePtr iso_ptr,
+                              ErrorTypeIndex idx,
+                              const char* message);
+
+const char* ExceptionGetMessageString(ValuePtr ptr);
+
+extern void ObjectSet(ValuePtr ptr, const char* key, ValuePtr val_ptr);
+extern void ObjectSetAnyKey(ValuePtr ptr, ValuePtr key, ValuePtr val_ptr);
+extern void ObjectSetIdx(ValuePtr ptr, uint32_t idx, ValuePtr val_ptr);
+extern int ObjectSetInternalField(ValuePtr ptr, int idx, ValuePtr val_ptr);
+extern int ObjectInternalFieldCount(ValuePtr ptr);
+extern RtnValue ObjectGet(ValuePtr ptr, const char* key);
+extern RtnValue ObjectGetAnyKey(ValuePtr ptr, ValuePtr key);
+extern RtnValue ObjectGetIdx(ValuePtr ptr, uint32_t idx);
+extern RtnValue ObjectGetInternalField(ValuePtr ptr, int idx);
+int ObjectHas(ValuePtr ptr, const char* key);
+int ObjectHasAnyKey(ValuePtr ptr, ValuePtr key);
+int ObjectHasIdx(ValuePtr ptr, uint32_t idx);
+int ObjectDelete(ValuePtr ptr, const char* key);
+int ObjectDeleteAnyKey(ValuePtr ptr, ValuePtr key);
+int ObjectDeleteIdx(ValuePtr ptr, uint32_t idx);
+extern RtnValue ObjectGetPrototype(ValuePtr ptr);
+extern void ObjectSetPrototype(ValuePtr ptr, ValuePtr proto_ptr);
+
+extern void BackingStoreRelease(BackingStorePtr ptr);
+extern void* BackingStoreData(BackingStorePtr ptr);
+extern size_t BackingStoreByteLength(BackingStorePtr ptr);
+extern BackingStorePtr SharedArrayBufferGetBackingStore(ValuePtr ptr);
+
+#ifdef __cplusplus
+}
+#endif
+#endif