diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8ee01b2c..b8730320 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,12 +10,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Support for the BigInt value to the big.Int Go type
 - Create Object Templates with primitive values, including other Object Templates
 - Configure Object Template as the global object of any new Context
+- Function Templates with callbacks to Go
 
 ### Changed
 - NewContext() API has been improved to handle optional global object, as well as optional Isolate
 - Package error messages are now prefixed with `v8go` rather than the struct name
-
-### Changed
+- Deprecated `iso.Close()` in favor of `iso.Dispose()` to keep consistancy with the C++ API
 - Upgraded V8 to 8.8.278.14
 
 ## [v0.4.0] - 2021-01-14
diff --git a/context.go b/context.go
index 94b4afaf..fb8f4336 100644
--- a/context.go
+++ b/context.go
@@ -6,12 +6,28 @@ import "C"
 import (
 	"fmt"
 	"runtime"
+	"sync"
 	"unsafe"
 )
 
+// Due to the limitations of passing pointers to C from Go we need to create
+// a registry so that we can lookup the Context from any given callback from V8.
+// This is similar to what is described here: https://github.com/golang/go/wiki/cgo#function-variables
+// To make sure we can still GC *Context we register the context only when we are
+// running a script inside the context and then deregister.
+type ctxRef struct {
+	ctx      *Context
+	refCount int
+}
+
+var ctxMutex sync.RWMutex
+var ctxRegistry = make(map[int]*ctxRef)
+var ctxSeq = 0
+
 // Context is a global root execution environment that allows separate,
 // unrelated, JavaScript applications to run in a single instance of V8.
 type Context struct {
+	ref int
 	ptr C.ContextPtr
 	iso *Isolate
 }
@@ -45,12 +61,18 @@ func NewContext(opt ...ContextOption) (*Context, error) {
 	}
 
 	if opts.gTmpl == nil {
-		opts.gTmpl = &ObjectTemplate{}
+		opts.gTmpl = &ObjectTemplate{&template{}}
 	}
 
+	ctxMutex.Lock()
+	ctxSeq++
+	ref := ctxSeq
+	ctxMutex.Unlock()
+
 	ctx := &Context{
+		ref: ref,
+		ptr: C.NewContext(opts.iso.ptr, opts.gTmpl.ptr, C.int(ref)),
 		iso: opts.iso,
-		ptr: C.NewContext(opts.iso.ptr, opts.gTmpl.ptr),
 	}
 	runtime.SetFinalizer(ctx, (*Context).finalizer)
 	// TODO: [RC] catch any C++ exceptions and return as error
@@ -73,7 +95,10 @@ func (c *Context) RunScript(source string, origin string) (*Value, error) {
 	defer C.free(unsafe.Pointer(cSource))
 	defer C.free(unsafe.Pointer(cOrigin))
 
+	c.register()
 	rtn := C.RunScript(c.ptr, cSource, cOrigin)
+	c.deregister()
+
 	return getValue(c, rtn), getError(rtn)
 }
 
@@ -83,11 +108,45 @@ func (c *Context) Close() {
 }
 
 func (c *Context) finalizer() {
-	C.ContextDispose(c.ptr)
+	C.ContextFree(c.ptr)
 	c.ptr = nil
 	runtime.SetFinalizer(c, nil)
 }
 
+func (c *Context) register() {
+	ctxMutex.Lock()
+	r := ctxRegistry[c.ref]
+	if r == nil {
+		r = &ctxRef{ctx: c}
+		ctxRegistry[c.ref] = r
+	}
+	r.refCount++
+	ctxMutex.Unlock()
+}
+
+func (c *Context) deregister() {
+	ctxMutex.Lock()
+	defer ctxMutex.Unlock()
+	r := ctxRegistry[c.ref]
+	if r == nil {
+		return
+	}
+	r.refCount--
+	if r.refCount <= 0 {
+		delete(ctxRegistry, c.ref)
+	}
+}
+
+func getContext(ref int) *Context {
+	ctxMutex.RLock()
+	defer ctxMutex.RUnlock()
+	r := ctxRegistry[ref]
+	if r == nil {
+		return nil
+	}
+	return r.ctx
+}
+
 func getValue(ctx *Context, rtn C.RtnValue) *Value {
 	if rtn.value == nil {
 		return nil
diff --git a/context_test.go b/context_test.go
index 07efe26c..d3d8649e 100644
--- a/context_test.go
+++ b/context_test.go
@@ -61,6 +61,33 @@ func TestJSExceptions(t *testing.T) {
 	}
 }
 
+func TestContextRegistry(t *testing.T) {
+	t.Parallel()
+
+	ctx, _ := v8go.NewContext()
+	ctxref := ctx.Ref()
+
+	c1 := v8go.GetContext(ctxref)
+	if c1 != nil {
+		t.Error("expected context to be <nil>")
+	}
+
+	ctx.Register()
+	c2 := v8go.GetContext(ctxref)
+	if c2 == nil {
+		t.Error("expected context, but got <nil>")
+	}
+	if c2 != ctx {
+		t.Errorf("contexts should match %p != %p", c2, ctx)
+	}
+	ctx.Deregister()
+
+	c3 := v8go.GetContext(ctxref)
+	if c3 != nil {
+		t.Error("expected context to be <nil>")
+	}
+}
+
 func BenchmarkContext(b *testing.B) {
 	b.ReportAllocs()
 	vm, _ := v8go.NewIsolate()
diff --git a/export_test.go b/export_test.go
new file mode 100644
index 00000000..2f0cb324
--- /dev/null
+++ b/export_test.go
@@ -0,0 +1,29 @@
+package v8go
+
+// RegisterCallback is exported for testing only.
+func (i *Isolate) RegisterCallback(cb FunctionCallback) int {
+	return i.registerCallback(cb)
+}
+
+// GetCallback is exported for testing only.
+func (i *Isolate) GetCallback(ref int) FunctionCallback {
+	return i.getCallback(ref)
+}
+
+// Register is exported for testing only.
+func (c *Context) Register() {
+	c.register()
+}
+
+// Deregister is exported for testing only.
+func (c *Context) Deregister() {
+	c.deregister()
+}
+
+// GetContext is exported for testing only.
+var GetContext = getContext
+
+// Ref is exported for testing only.
+func (c *Context) Ref() int {
+	return c.ref
+}
diff --git a/function_template.go b/function_template.go
new file mode 100644
index 00000000..443bd3f1
--- /dev/null
+++ b/function_template.go
@@ -0,0 +1,78 @@
+package v8go
+
+// #include <stdlib.h>
+// #include "v8go.h"
+import "C"
+import (
+	"errors"
+	"runtime"
+	"unsafe"
+)
+
+// FunctionCallback is a callback that is executed in Go when a function is executed in JS.
+type FunctionCallback func(info *FunctionCallbackInfo) *Value
+
+// FunctionCallbackInfo is the argument that is passed to a FunctionCallback.
+type FunctionCallbackInfo struct {
+	ctx  *Context
+	args []*Value
+}
+
+// Context is the current context that the callback is being executed in.
+func (i *FunctionCallbackInfo) Context() *Context {
+	return i.ctx
+}
+
+// Args returns a slice of the value arguments that are passed to the JS function.
+func (i *FunctionCallbackInfo) Args() []*Value {
+	return i.args
+}
+
+// FunctionTemplate is used to create functions at runtime.
+// There can only be one function created from a FunctionTemplate in a context.
+// The lifetime of the created function is equal to the lifetime of the context.
+type FunctionTemplate struct {
+	*template
+}
+
+// NewFunctionTemplate creates a FunctionTemplate for a given callback.
+func NewFunctionTemplate(iso *Isolate, callback FunctionCallback) (*FunctionTemplate, error) {
+	if iso == nil {
+		return nil, errors.New("v8go: failed to create new FunctionTemplate: Isolate cannot be <nil>")
+	}
+	if callback == nil {
+		return nil, errors.New("v8go: failed to create new FunctionTemplate: FunctionCallback cannot be <nil>")
+	}
+
+	cbref := iso.registerCallback(callback)
+
+	tmpl := &template{
+		ptr: C.NewFunctionTemplate(iso.ptr, C.int(cbref)),
+		iso: iso,
+	}
+	runtime.SetFinalizer(tmpl, (*template).finalizer)
+	return &FunctionTemplate{tmpl}, nil
+}
+
+//export goFunctionCallback
+func goFunctionCallback(ctxref int, cbref int, args *C.ValuePtr, argsCount int) C.ValuePtr {
+	ctx := getContext(ctxref)
+
+	info := &FunctionCallbackInfo{
+		ctx:  ctx,
+		args: make([]*Value, argsCount),
+	}
+
+	argv := (*[1 << 30]C.ValuePtr)(unsafe.Pointer(args))[:argsCount:argsCount]
+	for i, v := range argv {
+		val := &Value{ptr: v}
+		runtime.SetFinalizer(val, (*Value).finalizer)
+		info.args[i] = val
+	}
+
+	callbackFunc := ctx.iso.getCallback(cbref)
+	if val := callbackFunc(info); val != nil {
+		return val.ptr
+	}
+	return nil
+}
diff --git a/function_template_test.go b/function_template_test.go
new file mode 100644
index 00000000..a061a37c
--- /dev/null
+++ b/function_template_test.go
@@ -0,0 +1,65 @@
+package v8go_test
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"strings"
+	"testing"
+
+	"rogchap.com/v8go"
+)
+
+func TestFunctionTemplate(t *testing.T) {
+	t.Parallel()
+
+	if _, err := v8go.NewFunctionTemplate(nil, func(*v8go.FunctionCallbackInfo) *v8go.Value { return nil }); err == nil {
+		t.Error("expected error but got <nil>")
+	}
+
+	iso, _ := v8go.NewIsolate()
+	if _, err := v8go.NewFunctionTemplate(iso, nil); err == nil {
+		t.Error("expected error but got <nil>")
+	}
+
+	fn, err := v8go.NewFunctionTemplate(iso, func(*v8go.FunctionCallbackInfo) *v8go.Value { return nil })
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if fn == nil {
+		t.Error("expected FunctionTemplate, but got <nil>")
+	}
+}
+
+func ExampleFunctionTemplate() {
+	iso, _ := v8go.NewIsolate()
+	global, _ := v8go.NewObjectTemplate(iso)
+	printfn, _ := v8go.NewFunctionTemplate(iso, func(info *v8go.FunctionCallbackInfo) *v8go.Value {
+		fmt.Printf("%+v\n", info.Args())
+		return nil
+	})
+	global.Set("print", printfn, v8go.ReadOnly)
+	ctx, _ := v8go.NewContext(iso, global)
+	ctx.RunScript("print('foo', 'bar', 0, 1)", "")
+	// Output:
+	// [foo bar 0 1]
+}
+
+func ExampleFunctionTemplate_fetch() {
+	iso, _ := v8go.NewIsolate()
+	global, _ := v8go.NewObjectTemplate(iso)
+	fetchfn, _ := v8go.NewFunctionTemplate(iso, func(info *v8go.FunctionCallbackInfo) *v8go.Value {
+		args := info.Args()
+		url := args[0].String()
+		res, _ := http.Get(url)
+		body, _ := ioutil.ReadAll(res.Body)
+		val, _ := v8go.NewValue(iso, string(body))
+		return val
+	})
+	global.Set("fetch", fetchfn, v8go.ReadOnly)
+	ctx, _ := v8go.NewContext(iso, global)
+	val, _ := ctx.RunScript("fetch('https://rogchap.com/v8go')", "")
+	fmt.Printf("%s\n", strings.Split(val.String(), "\n")[0])
+	// Output:
+	// <!DOCTYPE html>
+}
diff --git a/isolate.go b/isolate.go
index acc13ac0..c5cf1416 100644
--- a/isolate.go
+++ b/isolate.go
@@ -15,6 +15,10 @@ var v8once sync.Once
 // with many V8 contexts for execution.
 type Isolate struct {
 	ptr C.IsolatePtr
+
+	cbMutex sync.RWMutex
+	cbSeq   int
+	cbs     map[int]FunctionCallback
 }
 
 // HeapStatistics represents V8 isolate heap statistics
@@ -35,13 +39,18 @@ type HeapStatistics struct {
 // NewIsolate creates a new V8 isolate. Only one thread may access
 // a given isolate at a time, but different threads may access
 // different isolates simultaneously.
+// When an isolate is no longer used its resources should be freed
+// by calling iso.Dispose().
 // An *Isolate can be used as a v8go.ContextOption to create a new
 // Context, rather than creating a new default Isolate.
 func NewIsolate() (*Isolate, error) {
 	v8once.Do(func() {
 		C.Init()
 	})
-	iso := &Isolate{C.NewIsolate()}
+	iso := &Isolate{
+		ptr: C.NewIsolate(),
+		cbs: make(map[int]FunctionCallback),
+	}
 	runtime.SetFinalizer(iso, (*Isolate).finalizer)
 	// TODO: [RC] catch any C++ exceptions and return as error
 	return iso, nil
@@ -72,17 +81,40 @@ func (i *Isolate) GetHeapStatistics() HeapStatistics {
 	}
 }
 
-func (i *Isolate) finalizer() {
-	C.IsolateDispose(i.ptr)
-	i.ptr = nil
-	runtime.SetFinalizer(i, nil)
+// Dispose will dispose the Isolate VM; subsequent calls will panic.
+func (i *Isolate) Dispose() {
+	i.finalizer()
 }
 
-// Close will dispose the Isolate VM; subsequent calls will panic
+// Deprecated: use `iso.Dispose()`.
 func (i *Isolate) Close() {
-	i.finalizer()
+	i.Dispose()
+}
+
+func (i *Isolate) finalizer() {
+	defer runtime.SetFinalizer(i, nil)
+	if i.ptr == nil {
+		return
+	}
+	C.IsolateDispose(i.ptr)
+	i.ptr = nil
 }
 
 func (i *Isolate) apply(opts *contextOptions) {
 	opts.iso = i
 }
+
+func (i *Isolate) registerCallback(cb FunctionCallback) int {
+	i.cbMutex.Lock()
+	i.cbSeq++
+	ref := i.cbSeq
+	i.cbs[ref] = cb
+	i.cbMutex.Unlock()
+	return ref
+}
+
+func (i *Isolate) getCallback(ref int) FunctionCallback {
+	i.cbMutex.RLock()
+	defer i.cbMutex.RUnlock()
+	return i.cbs[ref]
+}
diff --git a/isolate_test.go b/isolate_test.go
index e85ce9ae..af16783a 100644
--- a/isolate_test.go
+++ b/isolate_test.go
@@ -43,8 +43,8 @@ func TestGetHeapStatistics(t *testing.T) {
 
 	hs := iso.GetHeapStatistics()
 
-	if hs.NumberOfNativeContexts != 2 {
-		t.Error("expect NumberOfNativeContexts return 2, got", hs.NumberOfNativeContexts)
+	if hs.NumberOfNativeContexts != 3 {
+		t.Error("expect NumberOfNativeContexts return 3, got", hs.NumberOfNativeContexts)
 	}
 
 	if hs.NumberOfDetachedContexts != 0 {
@@ -52,6 +52,26 @@ func TestGetHeapStatistics(t *testing.T) {
 	}
 }
 
+func TestCallbackRegistry(t *testing.T) {
+	t.Parallel()
+
+	iso, _ := v8go.NewIsolate()
+	cb := func(*v8go.FunctionCallbackInfo) *v8go.Value { return nil }
+
+	cb0 := iso.GetCallback(0)
+	if cb0 != nil {
+		t.Error("expected callback function to be <nil>")
+	}
+	ref1 := iso.RegisterCallback(cb)
+	if ref1 != 1 {
+		t.Errorf("expected callback ref == 1, got %d", ref1)
+	}
+	cb1 := iso.GetCallback(1)
+	if fmt.Sprintf("%p", cb1) != fmt.Sprintf("%p", cb) {
+		t.Errorf("unexpected callback function; want %p, got %p", cb, cb1)
+	}
+}
+
 func BenchmarkIsolateInitialization(b *testing.B) {
 	b.ReportAllocs()
 	for n := 0; n < b.N; n++ {
diff --git a/object_template.go b/object_template.go
index 3006ae9e..314bf742 100644
--- a/object_template.go
+++ b/object_template.go
@@ -5,10 +5,7 @@ package v8go
 import "C"
 import (
 	"errors"
-	"fmt"
-	"math/big"
 	"runtime"
-	"unsafe"
 )
 
 // PropertyAttribute are the attribute flags for a property on an Object.
@@ -30,8 +27,7 @@ const (
 // ObjectTemplate is used to create objects at runtime.
 // Properties added to an ObjectTemplate are added to each object created from the ObjectTemplate.
 type ObjectTemplate struct {
-	ptr C.ObjectTemplatePtr
-	iso *Isolate
+	*template
 }
 
 // NewObjectTemplate creates a new ObjectTemplate.
@@ -40,54 +36,15 @@ func NewObjectTemplate(iso *Isolate) (*ObjectTemplate, error) {
 	if iso == nil {
 		return nil, errors.New("v8go: failed to create new ObjectTemplate: Isolate cannot be <nil>")
 	}
-	ob := &ObjectTemplate{
+
+	tmpl := &template{
 		ptr: C.NewObjectTemplate(iso.ptr),
 		iso: iso,
 	}
-	runtime.SetFinalizer(ob, (*ObjectTemplate).finalizer)
-	return ob, nil
-}
-
-// Set adds a property to each instance created by this template.
-// The property must be defined either as a primitive value, or a template.
-// If the value passed is a Go supported primitive (string, int32, uint32, int64, uint64, float64, big.Int)
-// then a value will be created and set as the value property.
-func (o *ObjectTemplate) Set(name string, val interface{}, attributes ...PropertyAttribute) error {
-	cname := C.CString(name)
-	defer C.free(unsafe.Pointer(cname))
-
-	var attrs PropertyAttribute
-	for _, a := range attributes {
-		attrs |= a
-	}
-
-	switch v := val.(type) {
-	case string, int32, uint32, int64, uint64, float64, bool, *big.Int:
-		newVal, err := NewValue(o.iso, v)
-		if err != nil {
-			return fmt.Errorf("v8go: unable to create new value: %v", err)
-		}
-		C.ObjectTemplateSetValue(o.ptr, cname, newVal.ptr, C.int(attrs))
-	case *ObjectTemplate:
-		C.ObjectTemplateSetObjectTemplate(o.ptr, cname, v.ptr, C.int(attrs))
-	case *Value:
-		if v.IsObject() || v.IsExternal() {
-			return errors.New("v8go: unsupported property: value type must be a primitive or use a template")
-		}
-		C.ObjectTemplateSetValue(o.ptr, cname, v.ptr, C.int(attrs))
-	default:
-		return fmt.Errorf("v8go: unsupported property type `%T`, must be one of string, int32, uint32, int64, uint64, float64, *big.Int, *v8go.Value or *v8go.ObjectTemplate", v)
-	}
-
-	return nil
+	runtime.SetFinalizer(tmpl, (*template).finalizer)
+	return &ObjectTemplate{tmpl}, nil
 }
 
 func (o *ObjectTemplate) apply(opts *contextOptions) {
 	opts.gTmpl = o
 }
-
-func (o *ObjectTemplate) finalizer() {
-	C.ObjectTemplateDispose(o.ptr)
-	o.ptr = nil
-	runtime.SetFinalizer(o, nil)
-}
diff --git a/template.go b/template.go
new file mode 100644
index 00000000..c1cdd8f3
--- /dev/null
+++ b/template.go
@@ -0,0 +1,59 @@
+package v8go
+
+// #include <stdlib.h>
+// #include "v8go.h"
+import "C"
+import (
+	"errors"
+	"fmt"
+	"math/big"
+	"runtime"
+	"unsafe"
+)
+
+type template struct {
+	ptr C.TemplatePtr
+	iso *Isolate
+}
+
+// Set adds a property to each instance created by this template.
+// The property must be defined either as a primitive value, or a template.
+// If the value passed is a Go supported primitive (string, int32, uint32, int64, uint64, float64, big.Int)
+// then a value will be created and set as the value property.
+func (t *template) Set(name string, val interface{}, attributes ...PropertyAttribute) error {
+	cname := C.CString(name)
+	defer C.free(unsafe.Pointer(cname))
+
+	var attrs PropertyAttribute
+	for _, a := range attributes {
+		attrs |= a
+	}
+
+	switch v := val.(type) {
+	case string, int32, uint32, int64, uint64, float64, bool, *big.Int:
+		newVal, err := NewValue(t.iso, v)
+		if err != nil {
+			return fmt.Errorf("v8go: unable to create new value: %v", err)
+		}
+		C.TemplateSetValue(t.ptr, cname, newVal.ptr, C.int(attrs))
+	case *ObjectTemplate:
+		C.TemplateSetTemplate(t.ptr, cname, v.ptr, C.int(attrs))
+	case *FunctionTemplate:
+		C.TemplateSetTemplate(t.ptr, cname, v.ptr, C.int(attrs))
+	case *Value:
+		if v.IsObject() || v.IsExternal() {
+			return errors.New("v8go: unsupported property: value type must be a primitive or use a template")
+		}
+		C.TemplateSetValue(t.ptr, cname, v.ptr, C.int(attrs))
+	default:
+		return fmt.Errorf("v8go: unsupported property type `%T`, must be one of string, int32, uint32, int64, uint64, float64, *big.Int, *v8go.Value, *v8go.ObjectTemplate or *v8go.FunctionTemplate", v)
+	}
+
+	return nil
+}
+
+func (t *template) finalizer() {
+	C.TemplateFree(t.ptr)
+	t.ptr = nil
+	runtime.SetFinalizer(t, nil)
+}
diff --git a/v8go.cc b/v8go.cc
index eef49001..5e3c16cd 100644
--- a/v8go.cc
+++ b/v8go.cc
@@ -23,14 +23,14 @@ typedef struct {
 
 typedef struct {
   Persistent<Value> ptr;
+  Persistent<Context> ctx;
   Isolate* iso;
-  m_ctx* ctx_ptr;
 } m_value;
 
 typedef struct {
-  Persistent<ObjectTemplate> ptr;
+  Persistent<Template> ptr;
   Isolate* iso;
-} m_object_template;
+} m_template;
 
 const char* CopyString(std::string str) {
   int len = str.length();
@@ -93,11 +93,11 @@ extern "C" {
 
 /********** Isolate **********/
 
-#define ISOLATE_SCOPE(iso_ptr) \
+#define ISOLATE_SCOPE(iso_ptr)                   \
   Isolate* iso = static_cast<Isolate*>(iso_ptr); \
-  Locker locker(iso); \
-  Isolate::Scope isolate_scope(iso); \
-  HandleScope handle_scope(iso); \
+  Locker locker(iso);                            \
+  Isolate::Scope isolate_scope(iso);             \
+  HandleScope handle_scope(iso);
 
 void Init() {
 #ifdef _WIN32
@@ -111,7 +111,20 @@ void Init() {
 IsolatePtr NewIsolate() {
   Isolate::CreateParams params;
   params.array_buffer_allocator = default_allocator;
-  return static_cast<IsolatePtr>(Isolate::New(params));
+  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 static_cast<IsolatePtr>(iso);
 }
 
 void IsolateDispose(IsolatePtr ptr) {
@@ -119,6 +132,10 @@ void IsolateDispose(IsolatePtr ptr) {
     return;
   }
   Isolate* iso = static_cast<Isolate*>(ptr);
+  m_ctx* ctx = static_cast<m_ctx*>(iso->GetData(0));
+  ctx->ptr.Reset();
+  delete ctx;
+
   iso->Dispose();
 }
 
@@ -148,57 +165,117 @@ IsolateHStatistics IsolationGetHeapStatistics(IsolatePtr ptr) {
                             hs.number_of_detached_contexts()};
 }
 
-/********** ObjectTemplate **********/
+/********** Template **********/
 
-#define LOCAL_OBJECT_TEMPLATE(ptr)                              \
-  m_object_template* ot = static_cast<m_object_template*>(ptr); \
-  Isolate* iso = ot->iso;                                       \
-  Locker locker(iso);                                           \
-  Isolate::Scope isolate_scope(iso);                            \
-  HandleScope handle_scope(iso);                                \
-  Local<ObjectTemplate> object_template = ot->ptr.Get(iso);
+#define LOCAL_TEMPLATE(ptr)                       \
+  m_template* ot = static_cast<m_template*>(ptr); \
+  Isolate* iso = ot->iso;                         \
+  Locker locker(iso);                             \
+  Isolate::Scope isolate_scope(iso);              \
+  HandleScope handle_scope(iso);                  \
+  Local<Template> tmpl = ot->ptr.Get(iso);
 
-ObjectTemplatePtr NewObjectTemplate(IsolatePtr iso_ptr) {
+void TemplateFree(TemplatePtr ptr) {
+  delete static_cast<m_template*>(ptr);
+}
+
+void TemplateSetValue(TemplatePtr ptr,
+                      const char* name,
+                      ValuePtr val_ptr,
+                      int attributes) {
+  LOCAL_TEMPLATE(ptr);
+
+  Local<String> prop_name =
+      String::NewFromUtf8(iso, name, NewStringType::kNormal).ToLocalChecked();
+  m_value* val = static_cast<m_value*>(val_ptr);
+  tmpl->Set(prop_name, val->ptr.Get(iso), (PropertyAttribute)attributes);
+}
+
+void TemplateSetTemplate(TemplatePtr ptr,
+                         const char* name,
+                         TemplatePtr obj_ptr,
+                         int attributes) {
+  LOCAL_TEMPLATE(ptr);
+
+  Local<String> prop_name =
+      String::NewFromUtf8(iso, name, NewStringType::kNormal).ToLocalChecked();
+  m_template* obj = static_cast<m_template*>(obj_ptr);
+  tmpl->Set(prop_name, obj->ptr.Get(iso), (PropertyAttribute)attributes);
+}
+
+/********** ObjectTemplate **********/
+
+TemplatePtr NewObjectTemplate(IsolatePtr iso_ptr) {
   Isolate* iso = static_cast<Isolate*>(iso_ptr);
   Locker locker(iso);
   Isolate::Scope isolate_scope(iso);
   HandleScope handle_scope(iso);
 
-  m_object_template* ot = new m_object_template;
+  m_template* ot = new m_template;
   ot->iso = iso;
   ot->ptr.Reset(iso, ObjectTemplate::New(iso));
-  return static_cast<ObjectTemplatePtr>(ot);
+  return static_cast<TemplatePtr>(ot);
 }
+/********** FunctionTemplate **********/
 
-void ObjectTemplateDispose(ObjectTemplatePtr ptr) {
-  delete static_cast<m_object_template*>(ptr);
-}
+static void FunctionTemplateCallback(const FunctionCallbackInfo<Value>& info) {
+  Isolate* iso_ptr = info.GetIsolate();
+  ISOLATE_SCOPE(iso_ptr);
 
-void ObjectTemplateSetValue(ObjectTemplatePtr ptr,
-                       const char* name,
-                       ValuePtr val_ptr,
-                       int attributes) {
-  LOCAL_OBJECT_TEMPLATE(ptr);
+  // This callback function can be called from any Context, which we only know
+  // at runtime. We extract the Context reference from the embedder data so that
+  // we can use the context registry to match the Context on the Go side
+  Local<Context> local_ctx = iso->GetCurrentContext();
+  int ctx_ref = local_ctx->GetEmbedderData(1).As<Integer>()->Value();
+
+  int callback_ref = info.Data().As<Integer>()->Value();
+
+  int args_count = info.Length();
+  ValuePtr args[args_count];
+  for (int i = 0; i < args_count; i++) {
+    m_value* val = new m_value;
+    val->iso = iso;
+    val->ctx.Reset(iso, local_ctx);
+    val->ptr.Reset(iso, Persistent<Value>(iso, info[i]));
+    args[i] = static_cast<ValuePtr>(val);
+  }
 
-  Local<String> prop_name =
-      String::NewFromUtf8(iso, name, NewStringType::kNormal).ToLocalChecked();
-  m_value* val = static_cast<m_value*>(val_ptr);
-  object_template->Set(prop_name, val->ptr.Get(iso), (PropertyAttribute)attributes);
+  ValuePtr goFunctionCallback(int ctxref, int cbref, const ValuePtr* args,
+                              int args_count);
+  ValuePtr val_ptr =
+      goFunctionCallback(ctx_ref, callback_ref, args, args_count);
+  if (val_ptr != nullptr) {
+    m_value* val = static_cast<m_value*>(val_ptr);
+    info.GetReturnValue().Set(val->ptr.Get(iso));
+  } else {
+    info.GetReturnValue().SetUndefined();
+  }
 }
 
-void ObjectTemplateSetObjectTemplate(ObjectTemplatePtr ptr, const char* name, ObjectTemplatePtr obj_ptr, int attributes) {
-  LOCAL_OBJECT_TEMPLATE(ptr);
+TemplatePtr NewFunctionTemplate(IsolatePtr iso_ptr, int callback_ref) {
+  Isolate* iso = static_cast<Isolate*>(iso_ptr);
+  Locker locker(iso);
+  Isolate::Scope isolate_scope(iso);
+  HandleScope handle_scope(iso);
 
-  Local<String> prop_name =
-      String::NewFromUtf8(iso, name, NewStringType::kNormal).ToLocalChecked();
-  m_object_template* obj = static_cast<m_object_template*>(obj_ptr);
-  object_template->Set(prop_name, obj->ptr.Get(iso), (PropertyAttribute)attributes);
+  // (rogchap) We only need to store one value, callback_ref, into the
+  // C++ callback function data, but if we needed to store more items we could
+  // use an V8::Array; this would require the internal context from
+  // iso->GetData(0)
+  Local<Integer> cbData = Integer::New(iso, callback_ref);
+
+  m_template* ot = new m_template;
+  ot->iso = iso;
+  ot->ptr.Reset(iso,
+                FunctionTemplate::New(iso, FunctionTemplateCallback, cbData));
+  return static_cast<TemplatePtr>(ot);
 }
 
 /********** Context **********/
 
 ContextPtr NewContext(IsolatePtr iso_ptr,
-                      ObjectTemplatePtr global_template_ptr) {
+                      TemplatePtr global_template_ptr,
+                      int ref) {
   Isolate* iso = static_cast<Isolate*>(iso_ptr);
   Locker locker(iso);
   Isolate::Scope isolate_scope(iso);
@@ -206,21 +283,38 @@ ContextPtr NewContext(IsolatePtr iso_ptr,
 
   Local<ObjectTemplate> global_template;
   if (global_template_ptr != nullptr) {
-    m_object_template* ob =
-        static_cast<m_object_template*>(global_template_ptr);
-    global_template = ob->ptr.Get(iso);
+    m_template* ob = static_cast<m_template*>(global_template_ptr);
+    global_template = ob->ptr.Get(iso).As<ObjectTemplate>();
   } else {
     global_template = ObjectTemplate::New(iso);
   }
 
-  iso->SetCaptureStackTraceForUncaughtExceptions(true);
+  // 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, Context::New(iso, nullptr, global_template));
+  ctx->ptr.Reset(iso, local_ctx);
   ctx->iso = iso;
   return static_cast<ContextPtr>(ctx);
 }
 
+void ContextFree(ContextPtr ptr) {
+  if (ptr == nullptr) {
+    return;
+  }
+  m_ctx* ctx = static_cast<m_ctx*>(ptr);
+  if (ctx == nullptr) {
+    return;
+  }
+  ctx->ptr.Reset();
+  delete ctx;
+}
+
 RtnValue RunScript(ContextPtr ctx_ptr, const char* source, const char* origin) {
   m_ctx* ctx = static_cast<m_ctx*>(ctx_ptr);
   Isolate* iso = ctx->iso;
@@ -252,35 +346,27 @@ RtnValue RunScript(ContextPtr ctx_ptr, const char* source, const char* origin) {
   }
   m_value* val = new m_value;
   val->iso = iso;
-  val->ctx_ptr = ctx;
+  val->ctx.Reset(iso, local_ctx);
   val->ptr.Reset(iso, Persistent<Value>(iso, result.ToLocalChecked()));
 
   rtn.value = static_cast<ValuePtr>(val);
   return rtn;
 }
 
-void ContextDispose(ContextPtr ptr) {
-  if (ptr == nullptr) {
-    return;
-  }
-  m_ctx* ctx = static_cast<m_ctx*>(ptr);
-  if (ctx == nullptr) {
-    return;
-  }
-  ctx->ptr.Reset();
-  delete ctx;
-}
-
 /********** Value **********/
 
-#define LOCAL_VALUE(ptr)                           \
-  m_value* val = static_cast<m_value*>(ptr);       \
-  m_ctx* ctx = val->ctx_ptr;                       \
-  Isolate* iso = val->iso;                         \
-  Locker locker(iso);                              \
-  Isolate::Scope isolate_scope(iso);               \
-  HandleScope handle_scope(iso);                   \
-  Context::Scope context_scope(ctx->ptr.Get(iso)); \
+#define LOCAL_VALUE(ptr)                               \
+  m_value* val = static_cast<m_value*>(ptr);           \
+  Isolate* iso = val->iso;                             \
+  Locker locker(iso);                                  \
+  Isolate::Scope isolate_scope(iso);                   \
+  HandleScope handle_scope(iso);                       \
+  Local<Context> local_ctx = val->ctx.Get(iso);        \
+  if (local_ctx.IsEmpty()) {                           \
+    m_ctx* ctx = static_cast<m_ctx*>(iso->GetData(0)); \
+    local_ctx = ctx->ptr.Get(iso);                     \
+  }                                                    \
+  Context::Scope context_scope(local_ctx);             \
   Local<Value> value = val->ptr.Get(iso);
 
 ValuePtr NewValueInteger(IsolatePtr iso_ptr, int32_t v) {
@@ -303,7 +389,8 @@ ValuePtr NewValueString(IsolatePtr iso_ptr, const char* v) {
   ISOLATE_SCOPE(iso_ptr);
   m_value* val = new m_value;
   val->iso = iso;
-  val->ptr.Reset(iso, Persistent<Value>(iso, String::NewFromUtf8(iso, v).ToLocalChecked()));
+  val->ptr.Reset(iso, Persistent<Value>(
+                          iso, String::NewFromUtf8(iso, v).ToLocalChecked()));
   return static_cast<ValuePtr>(val);
 }
 
@@ -339,29 +426,32 @@ ValuePtr NewValueBigIntFromUnsigned(IsolatePtr iso_ptr, uint64_t v) {
   return static_cast<ValuePtr>(val);
 }
 
-ValuePtr NewValueBigIntFromWords(IsolatePtr iso_ptr, int sign_bit, int word_count, const uint64_t* words) {
+ValuePtr NewValueBigIntFromWords(IsolatePtr iso_ptr,
+                                 int sign_bit,
+                                 int word_count,
+                                 const uint64_t* words) {
   ISOLATE_SCOPE(iso_ptr);
+  m_ctx* ctx = static_cast<m_ctx*>(iso->GetData(0));
+
   m_value* val = new m_value;
   val->iso = iso;
-
-  // V8::BigInt::NewFromWords requires a context, which is different from all the other V8::Primitive types
-  // It seems that the implementation just gets the Isolate from the Context and nothing else, so this function
-  // should really only need the Isolate.
-  // We'll have to create a temp context to hold the Isolate to create the BigInt.
-  Local<Context> ctx = Context::New(iso);
-
-  MaybeLocal<BigInt> bigint = BigInt::NewFromWords(ctx, sign_bit, word_count, words);
+  MaybeLocal<BigInt> bigint =
+      BigInt::NewFromWords(ctx->ptr.Get(iso), sign_bit, word_count, words);
   val->ptr.Reset(iso, Persistent<Value>(iso, bigint.ToLocalChecked()));
   return static_cast<ValuePtr>(val);
 }
 
-void ValueDispose(ValuePtr ptr) {
-  delete static_cast<m_value*>(ptr);
+void ValueFree(ValuePtr ptr) {
+  if (ptr == nullptr) {
+    return;
+  }
+  m_value* val = static_cast<m_value*>(ptr);
+  delete val;
 }
 
 const uint32_t* ValueToArrayIndex(ValuePtr ptr) {
   LOCAL_VALUE(ptr);
-  MaybeLocal<Uint32> array_index = value->ToArrayIndex(ctx->ptr.Get(iso));
+  MaybeLocal<Uint32> array_index = value->ToArrayIndex(local_ctx);
   if (array_index.IsEmpty()) {
     return nullptr;
   }
@@ -378,23 +468,22 @@ int ValueToBoolean(ValuePtr ptr) {
 
 int32_t ValueToInt32(ValuePtr ptr) {
   LOCAL_VALUE(ptr);
-  return value->Int32Value(ctx->ptr.Get(iso)).ToChecked();
+  return value->Int32Value(local_ctx).ToChecked();
 }
 
 int64_t ValueToInteger(ValuePtr ptr) {
   LOCAL_VALUE(ptr);
-  return value->IntegerValue(ctx->ptr.Get(iso)).ToChecked();
+  return value->IntegerValue(local_ctx).ToChecked();
 }
 
 double ValueToNumber(ValuePtr ptr) {
   LOCAL_VALUE(ptr);
-  return value->NumberValue(ctx->ptr.Get(iso)).ToChecked();
+  return value->NumberValue(local_ctx).ToChecked();
 }
 
 const char* ValueToDetailString(ValuePtr ptr) {
   LOCAL_VALUE(ptr);
-  String::Utf8Value ds(
-      iso, value->ToDetailString(ctx->ptr.Get(iso)).ToLocalChecked());
+  String::Utf8Value ds(iso, value->ToDetailString(local_ctx).ToLocalChecked());
   return CopyString(ds);
 }
 
@@ -406,12 +495,12 @@ const char* ValueToString(ValuePtr ptr) {
 
 uint32_t ValueToUint32(ValuePtr ptr) {
   LOCAL_VALUE(ptr);
-  return value->Uint32Value(ctx->ptr.Get(iso)).ToChecked();
+  return value->Uint32Value(local_ctx).ToChecked();
 }
 
 ValueBigInt ValueToBigInt(ValuePtr ptr) {
   LOCAL_VALUE(ptr);
-  MaybeLocal<BigInt> bint = value->ToBigInt(ctx->ptr.Get(iso));
+  MaybeLocal<BigInt> bint = value->ToBigInt(local_ctx);
   if (bint.IsEmpty()) {
     return {nullptr, 0};
   }
diff --git a/v8go.h b/v8go.h
index 575b4e55..77fe4033 100644
--- a/v8go.h
+++ b/v8go.h
@@ -10,7 +10,7 @@ extern "C" {
 typedef void* IsolatePtr;
 typedef void* ContextPtr;
 typedef void* ValuePtr;
-typedef void* ObjectTemplatePtr;
+typedef void* TemplatePtr;
 
 typedef struct {
   const char* msg;
@@ -50,19 +50,25 @@ extern void IsolateTerminateExecution(IsolatePtr ptr);
 extern IsolateHStatistics IsolationGetHeapStatistics(IsolatePtr ptr);
 
 extern ContextPtr NewContext(IsolatePtr iso_ptr,
-                             ObjectTemplatePtr global_template_ptr);
-extern void ContextDispose(ContextPtr ptr);
+                             TemplatePtr global_template_ptr,
+                             int ref);
+extern void ContextFree(ContextPtr ptr);
 extern RtnValue RunScript(ContextPtr ctx_ptr,
                           const char* source,
                           const char* origin);
 
-extern ObjectTemplatePtr NewObjectTemplate(IsolatePtr iso_ptr);
-extern void ObjectTemplateDispose(ObjectTemplatePtr ptr);
-extern void ObjectTemplateSetValue(ObjectTemplatePtr ptr,
-                              const char* name,
-                              ValuePtr val_ptr,
-                              int attributes);
-extern void ObjectTemplateSetObjectTemplate(ObjectTemplatePtr ptr, const char* name, ObjectTemplatePtr obj_ptr, int attributes);
+extern void TemplateFree(TemplatePtr ptr);
+extern void TemplateSetValue(TemplatePtr ptr,
+                             const char* name,
+                             ValuePtr val_ptr,
+                             int attributes);
+extern void TemplateSetTemplate(TemplatePtr ptr,
+                                const char* name,
+                                TemplatePtr obj_ptr,
+                                int attributes);
+
+extern TemplatePtr NewObjectTemplate(IsolatePtr iso_ptr);
+extern TemplatePtr NewFunctionTemplate(IsolatePtr iso_ptr, int callback_ref);
 
 extern ValuePtr NewValueInteger(IsolatePtr iso_ptr, int32_t v);
 extern ValuePtr NewValueIntegerFromUnsigned(IsolatePtr iso_ptr, uint32_t v);
@@ -71,8 +77,11 @@ 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 ValuePtr NewValueBigIntFromWords(IsolatePtr iso_ptr, int sign_bit, int word_count, const uint64_t* words);
-extern void ValueDispose(ValuePtr ptr);
+extern ValuePtr NewValueBigIntFromWords(IsolatePtr iso_ptr,
+                                        int sign_bit,
+                                        int word_count,
+                                        const uint64_t* words);
+extern void ValueFree(ValuePtr ptr);
 const char* ValueToString(ValuePtr ptr);
 const uint32_t* ValueToArrayIndex(ValuePtr ptr);
 int ValueToBoolean(ValuePtr ptr);
diff --git a/value.go b/value.go
index cfa24449..b76018f7 100644
--- a/value.go
+++ b/value.go
@@ -74,12 +74,14 @@ func NewValue(iso *Isolate, val interface{}) (*Value, error) {
 			rtnVal = &Value{
 				ptr: C.NewValueBigInt(iso.ptr, C.int64_t(v.Int64())),
 			}
+			break
 		}
 
 		if v.IsUint64() {
 			rtnVal = &Value{
 				ptr: C.NewValueBigIntFromUnsigned(iso.ptr, C.uint64_t(v.Uint64())),
 			}
+			break
 		}
 
 		var sign, count int
@@ -496,7 +498,7 @@ func (v *Value) IsModuleNamespaceObject() bool {
 }
 
 func (v *Value) finalizer() {
-	C.ValueDispose(v.ptr)
+	C.ValueFree(v.ptr)
 	v.ptr = nil
 	runtime.SetFinalizer(v, nil)
 }
diff --git a/value_test.go b/value_test.go
index 02e78d70..784975ed 100644
--- a/value_test.go
+++ b/value_test.go
@@ -333,8 +333,6 @@ func TestValueBigInt(t *testing.T) {
 			ctx, _ := v8go.NewContext(iso)
 			val, _ := ctx.RunScript(tt.source, "test.js")
 			b := val.BigInt()
-			fmt.Printf("b = %+v\n", b)
-			fmt.Printf("tt = %+v\n", tt)
 			if b == nil && tt.expected != nil {
 				t.Errorf("uexpected <nil> value")
 				return