diff --git a/impl/google/discovery/jni.go b/impl/google/discovery/jni.go
index 354593a..2eb2582 100644
--- a/impl/google/discovery/jni.go
+++ b/impl/google/discovery/jni.go
@@ -11,8 +11,12 @@
 	"encoding/binary"
 	"unsafe"
 
+	"v.io/v23/discovery"
+	"v.io/v23/security"
+	idiscovery "v.io/x/ref/lib/discovery"
+
 	jutil "v.io/x/jni/util"
-	"v.io/x/ref/lib/discovery"
+	jcontext "v.io/x/jni/v23/context"
 )
 
 // #include "jni.h"
@@ -20,9 +24,23 @@
 import "C"
 
 var (
-	classSign = jutil.ClassSign("java.lang.Class")
+	updateSign = jutil.ClassSign("io.v.v23.discovery.Update")
+
+
 	// Global reference for java.util.UUID class;
 	jUUIDClass jutil.Class
+
+	// Global reference io.v.impl.google.lib.discovery.ScanHandler
+	jScanHandlerClass jutil.Class
+
+	// Global reference io.v.v23.discovery.VDiscovery$DoneCallback
+	jServiceClass jutil.Class
+
+	// Global reference io.v.v23.security.BlessingPattern
+	jBlessingPatternClass jutil.Class
+
+	// Global reference io.v.v23.discovery.Update
+	jUpdateClass jutil.Class
 )
 
 // Init initializes the JNI code with the given Java environment. This method
@@ -33,11 +51,31 @@
 	// thread, so we aren't able to invoke FindClass in other threads.
 	var err error
 	jUUIDClass, err = jutil.JFindClass(env, "java/util/UUID")
+	if err != nil {
+		return err
+	}
 
+	jScanHandlerClass, err = jutil.JFindClass(env, "io/v/impl/google/lib/discovery/ScanHandler")
+	if err != nil {
+		return err
+	}
+
+	jServiceClass, err = jutil.JFindClass(env, "io/v/v23/discovery/Service")
+	if err != nil {
+		return err
+	}
+
+	jBlessingPatternClass, err = jutil.JFindClass(env, "io/v/v23/security/BlessingPattern")
+	if err != nil {
+		return err
+	}
+
+
+	jUpdateClass, err = jutil.JFindClass(env, "io/v/v23/discovery/Update")
 	return err
 }
 
-func convertStringtoUUID(jenv *C.JNIEnv, _ C.jclass, jName C.jstring, generator func(string) discovery.Uuid) C.jobject {
+func convertStringtoUUID(jenv *C.JNIEnv, _ C.jclass, jName C.jstring, generator func(string) idiscovery.Uuid) C.jobject {
 	env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
 	name := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jName))))
 	uuid := generator(name)
@@ -55,13 +93,130 @@
 
 //export Java_io_v_impl_google_lib_discovery_UUIDUtil_UUIDForInterfaceName
 func Java_io_v_impl_google_lib_discovery_UUIDUtil_UUIDForInterfaceName(jenv *C.JNIEnv, jclass C.jclass, jName C.jstring) C.jobject {
-	return convertStringtoUUID(jenv, jclass, jName, discovery.NewServiceUUID)
+	return convertStringtoUUID(jenv, jclass, jName, idiscovery.NewServiceUUID)
 }
 
 //export Java_io_v_impl_google_lib_discovery_UUIDUtil_UUIDForAttributeKey
 func Java_io_v_impl_google_lib_discovery_UUIDUtil_UUIDForAttributeKey(jenv *C.JNIEnv, jclass C.jclass, jName C.jstring) C.jobject {
-	converter := func(s string) discovery.Uuid {
-		return discovery.Uuid(discovery.NewAttributeUUID(s))
+	converter := func(s string) idiscovery.Uuid {
+		return idiscovery.Uuid(idiscovery.NewAttributeUUID(s))
 	}
 	return convertStringtoUUID(jenv, jclass, jName, converter)
 }
+
+
+//export Java_io_v_impl_google_lib_discovery_VDiscoveryImpl_nativeDelete
+func Java_io_v_impl_google_lib_discovery_VDiscoveryImpl_nativeDelete(jenv *C.JNIEnv, _ C.jobject, discovery C.jlong, trigger C.jlong) {
+	jutil.GoUnref(jutil.NativePtr(discovery))
+	jutil.GoUnref(jutil.NativePtr(trigger))
+}
+
+//export Java_io_v_impl_google_lib_discovery_VDiscoveryImpl_advertise
+func Java_io_v_impl_google_lib_discovery_VDiscoveryImpl_advertise(jenv *C.JNIEnv, this C.jobject, jContext C.jobject, jService C.jobject, jPerms C.jobject, jCallback C.jobject) {
+	env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
+	ctx, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext))))
+	if err != nil {
+		return
+	}
+	servObject := jutil.Object(uintptr(unsafe.Pointer(jService)))
+	var service discovery.Service
+	if err := jutil.GoVomCopy(env, servObject, jServiceClass, &service); err != nil {
+		jutil.JThrowV(env, err)
+		return
+	}
+
+	permsArray, err := jutil.GoObjectList(env, jutil.Object(uintptr(unsafe.Pointer(jPerms))))
+	if err != nil {
+		jutil.JThrowV(env, err)
+		return
+	}
+	permsSlice := make([]security.BlessingPattern, len(permsArray))
+	for i, o := range permsArray {
+		if err := jutil.GoVomCopy(env, o, jBlessingPatternClass, &permsSlice[i]); err != nil {
+			jutil.JThrowV(env, err)
+			return
+		}
+	}
+	thisObject := jutil.Object(uintptr(unsafe.Pointer(this)))
+	discoveryPtr, err := jutil.JLongField(env, thisObject, "nativeDiscovery")
+	if err != nil {
+		jutil.JThrowV(env, err)
+		return
+	}
+
+	ds := *(*discovery.T)(jutil.NativePtr(jutil.Object(unsafe.Pointer(uintptr(discoveryPtr)))))
+
+	triggerPtr, err := jutil.JLongField(env, thisObject, "nativeTrigger")
+
+	if err != nil {
+		jutil.JThrowV(env, err)
+		return
+	}
+
+	trigger := (*idiscovery.Trigger)(jutil.NativePtr(jutil.Object(unsafe.Pointer(uintptr(triggerPtr)))))
+
+	done, err := ds.Advertise(ctx, service, permsSlice)
+
+	if err != nil {
+		jutil.JThrowV(env, err)
+		return
+	}
+	cb := jutil.Object(uintptr(unsafe.Pointer(jCallback)))
+	jutil.NewGlobalRef(env, cb)
+	trigger.Add(func() {
+		env, freeFunc := jutil.GetEnv()
+		defer freeFunc()
+		// TODO(bjornick): What should we do on errors?
+		if err := jutil.CallVoidMethod(env, cb, "done", []jutil.Sign{}); err != nil {
+			jutil.JThrowV(env, err)
+		}
+		jutil.DeleteGlobalRef(env, cb)
+	}, done)
+}
+
+//export Java_io_v_impl_google_lib_discovery_VDiscoveryImpl_scan
+func Java_io_v_impl_google_lib_discovery_VDiscoveryImpl_scan(jenv *C.JNIEnv, this C.jobject, jContext C.jobject, jQuery C.jstring, jCallback C.jobject) {
+	env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
+	ctx, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext))))
+	if err != nil {
+		return
+	}
+	query := jutil.GoString(env, jutil.Object(uintptr(unsafe.Pointer(jQuery))))
+
+	thisObject := jutil.Object(uintptr(unsafe.Pointer(this)))
+	discoveryPtr, err := jutil.JLongField(env, thisObject, "nativeDiscovery")
+	if err != nil {
+		jutil.JThrowV(env, err)
+		return
+	}
+	ds := *(*discovery.T)(jutil.NativePtr(jutil.Object(unsafe.Pointer(uintptr(discoveryPtr)))))
+
+	updates, err := ds.Scan(ctx, query)
+
+	jutil.NewGlobalRef(env, jutil.Object(uintptr(unsafe.Pointer(jCallback))))
+	if err != nil {
+		jutil.JThrowV(env, err)
+		return
+	}
+	cb := jutil.Object(uintptr(unsafe.Pointer(jCallback)))
+	jutil.NewGlobalRef(env, cb)
+	go func() {
+		env, freeFunc := jutil.GetEnv()
+		defer freeFunc()
+		for v := range updates {
+			jUpdate, err := jutil.JVomCopy(env, v, jUpdateClass)
+			if err != nil {
+				ctx.Errorf("Failed to convert update: %v", err)
+				continue
+			}
+			err = jutil.CallVoidMethod(env, cb, "handleUpdate", []jutil.Sign{updateSign}, jUpdate)
+			if err != nil {
+				ctx.Errorf("Failed to call handler: %v", err)
+				continue
+			}
+		}
+		jutil.DeleteGlobalRef(env, cb)
+	}()
+}
+
+
diff --git a/impl/google/rt/jni.go b/impl/google/rt/jni.go
index c5239ba..71f2369 100644
--- a/impl/google/rt/jni.go
+++ b/impl/google/rt/jni.go
@@ -11,7 +11,8 @@
 
 	"v.io/v23"
 	"v.io/v23/context"
-	_ "v.io/x/ref/runtime/factories/roaming"
+
+	idiscovery "v.io/x/ref/lib/discovery"
 
 	jns "v.io/x/jni/impl/google/namespace"
 	jrpc "v.io/x/jni/impl/google/rpc"
@@ -28,6 +29,8 @@
 	serverSign  = jutil.ClassSign("io.v.v23.rpc.Server")
 
 	jVRuntimeImplClass jutil.Class
+
+	jVDiscoveryImplClass jutil.Class
 )
 
 // Init initializes the JNI code with the given Java environment.  This method
@@ -39,6 +42,12 @@
 	if err != nil {
 		return err
 	}
+
+	jVDiscoveryImplClass, err = jutil.JFindClass(env, "io/v/impl/google/lib/discovery/VDiscoveryImpl")
+	if err != nil {
+		return err
+	}
+
 	return nil
 }
 
@@ -272,3 +281,25 @@
 	}
 	return C.jobject(unsafe.Pointer(jSpec))
 }
+
+//export Java_io_v_impl_google_rt_VRuntimeImpl_nativeGetDiscovery
+func Java_io_v_impl_google_rt_VRuntimeImpl_nativeGetDiscovery(jenv *C.JNIEnv, jclass C.jclass, jContext C.jobject) C.jobject {
+	env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
+	ctx, err := jcontext.GoContext(env, jutil.Object(uintptr(unsafe.Pointer(jContext))))
+	if err != nil {
+		jutil.JThrowV(env, err);
+		return C.jobject(unsafe.Pointer(jutil.NullObject))
+	}
+	d := v23.GetDiscovery(ctx)
+	ptrD := &d
+	jutil.GoRef(ptrD)
+	trigger := idiscovery.NewTrigger()
+	jutil.GoRef(trigger)
+
+	jDiscovery, err := jutil.NewObject(env, jVDiscoveryImplClass, []jutil.Sign{jutil.LongSign, jutil.LongSign}, int64(jutil.PtrValue(ptrD)), int64(jutil.PtrValue(trigger)))
+	if err != nil {
+		jutil.JThrowV(env, err);
+		return C.jobject(unsafe.Pointer(jutil.NullObject))
+	}
+	return C.jobject(unsafe.Pointer(jDiscovery))
+}
diff --git a/jni.go b/jni.go
index fc311e0..9168811 100644
--- a/jni.go
+++ b/jni.go
@@ -2,19 +2,16 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build java android
+// +build java
 
 package jni
 
 import (
-	"os"
 	"unsafe"
 
-	"v.io/x/lib/vlog"
-
-	jgoogle "v.io/x/jni/impl/google"
 	jutil "v.io/x/jni/util"
-	jv23 "v.io/x/jni/v23"
+
+	_ "v.io/x/ref/runtime/factories/roaming"
 )
 
 // #include "jni.h"
@@ -23,29 +20,8 @@
 //export Java_io_v_v23_V_nativeInit
 func Java_io_v_v23_V_nativeInit(jenv *C.JNIEnv, jVRuntimeClass C.jclass) {
 	env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
-	// Ignore all args except for the first one.
-	// NOTE(spetrovic): in the future, we could accept all arguments that are
-	// actually defined in Go.  We'd have to manually check.
-	if len(os.Args) > 1 {
-		os.Args = os.Args[:1]
-	}
-	// Send all logging to stderr, so that the output is visible in android.
-	// Note that if this flag is removed, the process will likely crash on
-	// android as android requires that all logs are written into the app's
-	// local directory.
-	vlog.Log.Configure(vlog.LogToStderr(true))
-	if err := jutil.Init(env); err != nil {
-		jutil.JThrowV(env, err)
-		return
-	}
-	if err := jv23.Init(env); err != nil {
-		jutil.JThrowV(env, err)
-		return
-	}
-	if err := jgoogle.Init(env); err != nil {
-		jutil.JThrowV(env, err)
-		return
-	}
+	setupUtil(env)
+	setupV23(env)
 }
 
 func main() {
diff --git a/jni_android.go b/jni_android.go
new file mode 100644
index 0000000..a6e269d
--- /dev/null
+++ b/jni_android.go
@@ -0,0 +1,43 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build android
+
+package jni
+import (
+	jutil "v.io/x/jni/util"
+	"v.io/x/jni/libs/discovery"
+
+	_ "v.io/x/ref/runtime/factories/android"
+	"v.io/x/ref/lib/discovery/factory"
+)
+
+// #include "jni.h"
+import "C"
+
+var (
+	// Global reference for io.v.android.libs.discovery.ble.BlePlugin
+	jBlePlugin jutil.Class
+	// Global reference for io.v.v23.context.CancelableVContext class.
+	jCancelableVContextClass jutil.Class
+	// Global reference for java.jutil.concurrent.CountDownLatch class.
+	jCountDownLatchClass jutil.Class
+)
+
+//export Java_io_v_v23_V_nativeInit
+func Java_io_v_v23_V_nativeInit(jenv *C.JNIEnv, jVRuntimeClass C.jclass, androidCtx C.jobject) {
+	env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
+	setupUtil(env)
+	err := discovery.Init(env)
+	if err != nil {
+		return
+	}
+
+	factory.SetAndroidBleCreator(discovery.NewBleCreator(env, androidCtx))
+
+	setupV23(env)
+}
+
+func main() {
+}
diff --git a/libs/discovery/jni.go b/libs/discovery/jni.go
new file mode 100644
index 0000000..e25e2d6
--- /dev/null
+++ b/libs/discovery/jni.go
@@ -0,0 +1,71 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build android
+
+package discovery
+
+import (
+	"fmt"
+	"unsafe"
+
+	jutil "v.io/x/jni/util"
+	"v.io/x/ref/lib/discovery"
+)
+// #include "jni.h"
+import "C"
+var (
+// Global reference for io.v.android.libs.discovery.ble.BlePlugin
+	jBlePluginClass jutil.Class
+	// Global reference for io.v.x.ref.lib.discovery.Advertisement
+	jAdvertisementClass jutil.Class
+	// Global reference for java.util.UUID
+	jUUIdClass jutil.Class
+	// Global reference for io.v.android.libs.discovery.ble.NativeScanHandler
+	jNativeScanHandlerClass jutil.Class
+)
+
+func Init(env jutil.Env) error {
+	var err error
+	jUUIDClass, err = jutil.JFindClass(env, "java/util/UUID")
+	if err != nil {
+		return err
+	}
+
+	jNativeScanHandlerClass, err = jutil.JFindClass(env, "io/v/android/libs/discovery/ble/NativeScanHandler")
+	if err != nil {
+		return err
+	}
+
+	jBlePluginClass, err = jutil.JFindClass(env, "io/v/android/libs/discovery/ble/BlePlugin")
+	if err != nil {
+		return err
+	}
+
+	jAdvertisementClass, err = jutil.JFindClass(env, "io/v/x/ref/lib/discovery/Advertisement")
+	return err
+}
+
+//export Java_io_android_libs_discovery_ble_NativeScanHandler_nativeHandleUpdate
+func Java_io_android_libs_discovery_ble_NativeScanHandler_nativeHandleUpdate(jenv *C.JNIEnv, _ C.jobject, jAdv C.jobject, goPtr C.jlong)  {
+	env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
+	c, ok := (*(*chan <- discovery.Advertisement)(jutil.NativePtr(goPtr)))
+
+	if !ok {
+		jutil.JThrow(env, fmt.Errorf("Internal error"))
+		return
+	}
+	advObject := jutil.Object(uintptr(unsafe.Pointer(jAdv)))
+	var adv discovery.Advertisement
+	if err := jutil.GoVomCopy(env, advObject, jAdvertisementClass, &adv); err != nil {
+		jutil.JThrow(env, err)
+		return
+	}
+	ch <-advObject
+}
+
+//export Java_io_android_libs_discovery_ble_NativeScanHandler_nativeCleanup
+func Java_io_android_libs_discovery_ble_NativeScanHandler_nativeCleanup(jenv *C.JNIEnv, _ C.jobject, goPtr c.jlong) {
+	jutil.GoUnref(jutil.NativePtr(goPtr))
+}
diff --git a/libs/discovery/plugin.go b/libs/discovery/plugin.go
new file mode 100644
index 0000000..e7e2df7
--- /dev/null
+++ b/libs/discovery/plugin.go
@@ -0,0 +1,143 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build android
+
+package discovery
+import (
+	"bytes"
+	"runtime"
+	"unsafe"
+
+	"v.io/v23/context"
+
+	"v.io/x/ref/lib/discovery"
+	"v.io/x/ref/runtime/factories/android"
+
+	jcontext "v.io/x/jni/v23/context"
+	jutil "v.io/x/jni/util"
+
+)
+
+// #include "jni.h"
+import "C"
+
+var (
+	androidContextSign = jutil.ClassSign("android.content.Context")
+	contextSign = jutil.ClassSign("io.v.v23.Context")
+	advertisementSign = jutil.ClassSign("io.v.x.ref.lib.discovery.Advertisement")
+	uuidSign = jutil.ClassSign("java.util.UUID")
+	scanHandlerSign = jutil.ClassSign("io.v.impl.google.lib.discovery.ScanHandler")
+)
+
+
+func NewPluginCreator(env jutil.Env, context C.jobject) func(string) (discovery.Plugin, error) {
+	// Reference Java VPrincipal; it will be de-referenced when the Go Principal
+	// created below is garbage-collected (through the finalizer callback we
+	// setup just below).
+	jContext = jutil.NewGlobalRef(env, context)
+	return func(host string) (discovery.Plugin, error) {
+		env, freeFunc := jutil.GetEnv()
+		defer freeFunc()
+		jPlugin, err := jutil.NewObject(env, jBlePluginClass, []jutil.Sign{androidContextSign}, context)
+
+		jutil.DeleteGlobalRef(env, jContext)
+		if err != nil {
+			return nil, err
+		}
+		jplugin = jutil.NewGlobalRef(env, jPlugin)
+		p := &plugin{
+			trigger: discovery.NewTrigger(),
+			jPlugin: jPlugin,
+		}
+		runtime.SetFinalizer(p, func(p *plugin) {
+			env, freeFunc := jutil.GetEnv()
+			defer freeFunc()
+			jutil.DeleteGlobalRef(env, p.jPlugin)
+		})
+		return p, nil
+	}
+
+}
+
+type plugin struct {
+	trigger *discovery.Trigger
+	jPlugin C.jobject
+}
+
+// Plugin is the basic interface for a plugin to discovery service.
+// All implementation should be goroutine-safe.
+type Plugin interface {
+	// Advertise advertises the advertisement. Advertising will continue until
+	// the context is canceled or exceeds its deadline. done should be called
+	// once when advertising is done or canceled.
+	Advertise(ctx *context.T, ad Advertisement, done func()) error
+
+	// Scan scans services that match the service uuid and returns scanned
+	// advertisements to the channel. A zero-value service uuid means any service.
+	// Scanning will continue until the context is canceled or exceeds its
+	// deadline. done should be called once when scanning is done or canceled.
+	//
+	// TODO(jhahn): Pass a filter on service attributes.
+	Scan(ctx *context.T, serviceUuid Uuid, ch chan<- Advertisement, done func()) error
+}
+func (p *plugin) Advertise(ctx *context.T, ad discovery.Advertisement, done func()) error {
+	env, freeFunc := jutil.GetEnv()
+	defer freeFunc()
+	jContext, err := jcontext.NewJavaContext(env, ctx)
+	if err != nil {
+		return err
+	}
+	jAdv, err := jutil.JVomCopy(env, ad, jAdvertisementClass)
+	if err != nil {
+		return err
+	}
+
+	err := jutil.CallVoidMethod(env, p.jPlugin, "addAdvertisesment", []jutil.Sign{contextSign, advertisementSign}, jContext, jAdv)
+
+	p.trigger.Add(done, ctx.Done())
+
+	return err
+}
+
+func (p *plugin) Scan(ctx *context.T, serviceUuid discovery.Uuid, ch chan<- discovery.Advertisement, done func()) error {
+	env, freeFunc := jutil.GetEnv()
+	defer freeFunc()
+	jContext, err := jcontext.NewJavaContext(env, ctx)
+	if err != nil {
+		return err
+	}
+
+	jUuid, err := convertToJavaUUID(env, serviceUuid)
+
+	if err != nil {
+		return err
+	}
+
+
+	chPtr := &ch
+	jutil.GoRef(chPtr)
+	jNativeScanHandler, err := jutil.NewObject(env, jNativeScanHandlerClass, []jutil.Sign{jutil.LongSign}, int64(jutil.PtrValue(chPtr)))
+	if err != nil {
+		return err
+	}
+
+	err = jutil.CallVoidMethod(env, p.jPlugin, "addScanner", []jutil.Sign{contextSign, uuidSign, scanHandlerSign},
+		jContext, jUuid, jNativeScanHandler)
+
+	if err != nil {
+		return err
+	}
+	p.trigger.Add(done, ctx.Done())
+	return nil
+}
+
+
+func convertToJavaUUID(env jutil.Env, uuid discovery.Uuid) (C.jobject, error) {
+	buf := bytes.NewBuffer(uuid)
+	var high, low int64
+	binary.Read(buf, binary.BigEndian, &high)
+	binary.Read(buf, binary.BigEndian, &low)
+	jUUID, err := jutil.NewObject(env, jUUIDClass, []jutil.Sign{jutil.LongSign, jutil.LongSign}, high, low)
+}
diff --git a/shared.go b/shared.go
new file mode 100644
index 0000000..7832b4a
--- /dev/null
+++ b/shared.go
@@ -0,0 +1,49 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build java android
+
+package jni
+
+import (
+	"os"
+
+	"v.io/x/lib/vlog"
+
+	jgoogle "v.io/x/jni/impl/google"
+	jutil "v.io/x/jni/util"
+	jv23 "v.io/x/jni/v23"
+)
+
+// #include "jni.h"
+import "C"
+
+func setupUtil(env jutil.Env) {
+	// Ignore all args except for the first one.
+	// NOTE(spetrovic): in the future, we could accept all arguments that are
+	// actually defined in Go.  We'd have to manually check.
+	if len(os.Args) > 1 {
+		os.Args = os.Args[:1]
+	}
+	// Send all logging to stderr, so that the output is visible in android.
+	// Note that if this flag is removed, the process will likely crash on
+	// android as android requires that all logs are written into the app's
+	// local directory.
+	vlog.Log.Configure(vlog.LogToStderr(true))
+	if err := jutil.Init(env); err != nil {
+		jutil.JThrowV(env, err)
+	}
+}
+
+func setupV23(env jutil.Env) {
+	if err := jv23.Init(env); err != nil {
+		jutil.JThrowV(env, err)
+		return
+	}
+	if err := jgoogle.Init(env); err != nil {
+		jutil.JThrowV(env, err)
+		return
+	}
+}
+