diff --git a/swift.go b/swift.go
index 2407db7..a6f1a06 100644
--- a/swift.go
+++ b/swift.go
@@ -49,7 +49,6 @@
 		sutil.ThrowSwiftError(nil, err, unsafe.Pointer(errOut))
 		return
 	}
-
 	vlog.Log.Configure(vlog.OverridePriorConfiguration(true), dir, toStderr, level, vmodule)
 }
 
diff --git a/types.h b/types.h
index 622697d..e1b556e 100644
--- a/types.h
+++ b/types.h
@@ -19,6 +19,17 @@
 typedef _GoHandle GoContextHandle;
 typedef _GoHandle GoCancelableContextHandle;
 typedef _GoHandle GoClientCallHandle;
+typedef _GoHandle GoDiscoveryHandle;
+
+typedef struct {
+    _GoUint64 length;
+    char *data;
+} SwiftCString;
+
+typedef struct {
+    _GoUint64 length;
+    SwiftCString *data;
+} SwiftCStringArray;
 
 // Express byte arrays with lengths
 typedef struct {
@@ -44,7 +55,12 @@
 // Asynchronous callback function pointers, which use their own handle (AsyncCallbackIdentifier) to overcome
 // Swift limitations on context-free closures (function pointers)
 typedef int AsyncCallbackIdentifier;
-typedef void (*SwiftAsyncSuccessCallback)(AsyncCallbackIdentifier);
-typedef void (*SwiftAsyncSuccessHandleCallback)(AsyncCallbackIdentifier, _GoHandle);
-typedef void (*SwiftAsyncSuccessByteArrayArrayCallback)(AsyncCallbackIdentifier, SwiftByteArrayArray);
-typedef void (*SwiftAsyncFailureCallback)(AsyncCallbackIdentifier, SwiftVError);
+typedef void (*SwiftAsyncJsonCallback)(AsyncCallbackIdentifier asyncId, SwiftByteArray json);
+typedef void (*SwiftAsyncSuccessCallback)(AsyncCallbackIdentifier asyncId);
+typedef void (*SwiftAsyncSuccessHandleCallback)(AsyncCallbackIdentifier asyncId, _GoHandle handle);
+typedef void (*SwiftAsyncSuccessByteArrayArrayCallback)(AsyncCallbackIdentifier asyncId, SwiftByteArrayArray byteArrayArray);
+typedef void (*SwiftAsyncFailureCallback)(AsyncCallbackIdentifier asyncId, SwiftVError err);
+
+// Other callbacks
+typedef void (*SwiftAsyncVoidCallback)();
+
diff --git a/util/type.go b/util/type.go
index 63457c4..712ec35 100644
--- a/util/type.go
+++ b/util/type.go
@@ -16,6 +16,7 @@
 )
 
 /*
+#include <string.h> // memcpy
 #include <stdlib.h>
 #import "../types.h"
 */
@@ -61,6 +62,17 @@
 	return time.Duration(int64(d * 1e9))
 }
 
+func GoString(swiftStringPtr unsafe.Pointer, freeWhenDone bool) string {
+	str := *(*C.SwiftCString)(swiftStringPtr)
+	if freeWhenDone && str.data != nil {
+		defer C.free(unsafe.Pointer(str.data))
+	}
+	if str.data == nil || str.length == 0 {
+		return ""
+	}
+	return C.GoStringN(str.data, C.int(str.length))
+}
+
 //export swift_io_v_swift_impl_util_type_nativeBase64UrlDecode
 func swift_io_v_swift_impl_util_type_nativeBase64UrlDecode(base64UrlEncoded *C.char) C.SwiftByteArray {
 	// Decode the base64 url encoded string to bytes in a way that prevents extra copies along the CGO boundary.
diff --git a/v23/discovery/swift.go b/v23/discovery/swift.go
new file mode 100644
index 0000000..0a6f65a
--- /dev/null
+++ b/v23/discovery/swift.go
@@ -0,0 +1,106 @@
+// 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 darwin
+
+package discovery
+
+import (
+	"encoding/json"
+	"unsafe"
+
+	"v.io/v23"
+	"v.io/v23/discovery"
+	"v.io/v23/security"
+	sutil "v.io/x/swift/util"
+	scontext "v.io/x/swift/v23/context"
+)
+
+/*
+#include <stdlib.h>
+#import "../../types.h"
+
+static void CallAdvertisingCallback(SwiftAsyncSuccessCallback callback, AsyncCallbackIdentifier asyncId) {
+  callback(asyncId);
+}
+static void CallScanCallback(SwiftAsyncJsonCallback callback, AsyncCallbackIdentifier asyncId, SwiftByteArray data) {
+  callback(asyncId, data);
+}
+*/
+import "C"
+
+//export swift_io_v_v23_discovery_new
+func swift_io_v_v23_discovery_new(ctxHandle C.GoContextHandle, errOut *C.SwiftVError) C.GoDiscoveryHandle {
+	ctx := scontext.GoContext(uint64(ctxHandle))
+	d, err := v23.NewDiscovery(ctx)
+	if err != nil {
+		sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(errOut))
+		return C.GoDiscoveryHandle(0)
+	}
+	return C.GoDiscoveryHandle(sutil.GoNewRef(&d))
+}
+
+//export swift_io_v_v23_discovery_finalize
+func swift_io_v_v23_discovery_finalize(discoveryHandle C.GoDiscoveryHandle) {
+	sutil.GoUnref(uint64(discoveryHandle))
+}
+
+// Exports the discovery advertise API to CGO using JSON to marshal ads
+//export swift_io_v_v23_discovery_advertise
+func swift_io_v_v23_discovery_advertise(ctxHandle C.GoContextHandle, discoveryHandle C.GoDiscoveryHandle, adJson C.SwiftByteArray, visibilityArray C.SwiftCStringArray, asyncId C.AsyncCallbackIdentifier, doneCallback C.SwiftAsyncSuccessCallback, errOut *C.SwiftVError) bool {
+	ctx := scontext.GoContext(uint64(ctxHandle))
+	d := GoDiscoveryT(uint64(discoveryHandle))
+	ad := discovery.Advertisement{}
+	if err := json.Unmarshal(sutil.GoBytesNoCopy(unsafe.Pointer(&adJson)), &ad); err != nil {
+		sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(errOut))
+		return false
+	}
+	var visibility []security.BlessingPattern
+	for _, v := range visibilityArray.toStrings() {
+		visibility = append(visibility, security.BlessingPattern(v))
+	}
+	doneChan, err := d.Advertise(ctx, &ad, visibility)
+	if err != nil {
+		sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(errOut))
+		return false
+	}
+	go func() {
+		<-doneChan
+		C.CallAdvertisingCallback(doneCallback, asyncId)
+	}()
+	return true
+}
+
+// Exports the discovery scan API to CGO using JSON to marshal ads
+//export swift_io_v_v23_discovery_scan
+func swift_io_v_v23_discovery_scan(ctxHandle C.GoContextHandle, discoveryHandle C.GoDiscoveryHandle, query C.SwiftCString, asyncId C.AsyncCallbackIdentifier, callbackBlock C.SwiftAsyncJsonCallback, errOut *C.SwiftVError) bool {
+	ctx := scontext.GoContext(uint64(ctxHandle))
+	d := GoDiscoveryT(uint64(discoveryHandle))
+	goQuery := sutil.GoString(unsafe.Pointer(&query), false)
+	ch, err := d.Scan(ctx, goQuery)
+	if err != nil {
+		sutil.ThrowSwiftError(ctx, err, unsafe.Pointer(errOut))
+		return false
+	}
+	go func() {
+		for update := range ch {
+			data := struct {
+				IsLost        bool
+				Ad            discovery.Advertisement
+			}{
+				IsLost:        update.IsLost(),
+				Ad:            update.Advertisement(),
+			}
+			b, err := json.Marshal(data)
+			if err != nil {
+				ctx.Fatal("Unable to JSON serialize discovery update: ", err)
+			}
+			ba := swiftBytesCopy(b)
+			C.CallScanCallback(callbackBlock, asyncId, ba)
+			C.free(ba.data)
+		}
+		C.CallScanCallback(callbackBlock, asyncId, emptySwiftByteArray())
+	}()
+	return true
+}
diff --git a/v23/discovery/util.go b/v23/discovery/util.go
new file mode 100644
index 0000000..ce7470e
--- /dev/null
+++ b/v23/discovery/util.go
@@ -0,0 +1,57 @@
+package discovery
+
+import (
+	"fmt"
+	"unsafe"
+
+	"v.io/v23/discovery"
+	"v.io/x/swift/util"
+)
+
+/*
+#include <string.h> // memcpy
+#include <stdlib.h>
+#import "../../types.h"
+*/
+import "C"
+
+// Converts a native pointer from Swift to a Go Discovery.T. Panics if it can't.
+func GoDiscoveryT(discoveryHandle uint64) discovery.T {
+	valptr := util.GoGetRef(discoveryHandle)
+	if d, ok := valptr.(*discovery.T); ok {
+		return *d
+	} else {
+		panic(fmt.Sprintf("Couldn't get discovery.T from handle with id %d", discoveryHandle))
+	}
+}
+
+func swiftBytesCopy(data []byte) C.SwiftByteArray {
+	var a C.SwiftByteArray
+	a.length = C._GoUint64(len(data))
+	a.data = C.malloc(C.size_t(len(data)))
+	if a.data == nil {
+		panic(fmt.Errorf("Unable to allocate %d bytes", a.length))
+	}
+	C.memmove(a.data, unsafe.Pointer(&data[0]), C.size_t(len(data)))
+	return a
+}
+
+func emptySwiftByteArray() C.SwiftByteArray {
+	var empty C.SwiftByteArray
+	empty.length = 0
+	empty.data = nil
+	return empty
+}
+
+func (s *C.SwiftCString) toString() string {
+	return C.GoStringN(s.data, C.int(s.length))
+}
+
+func (a *C.SwiftCStringArray) toStrings() []string {
+	var cstrs = (*[1 << 30]C.SwiftCString)(unsafe.Pointer(a.data))[:int(a.length):int(a.length)]
+	var ret []string
+	for _, cstr := range cstrs {
+		ret = append(ret, cstr.toString())
+	}
+	return ret
+}
\ No newline at end of file
diff --git a/v23/swift.go b/v23/swift.go
index 201603f..60cbc76 100644
--- a/v23/swift.go
+++ b/v23/swift.go
@@ -8,6 +8,7 @@
 
 import (
 	_ "v.io/x/swift/v23/context"
+	_ "v.io/x/swift/v23/discovery"
 	_ "v.io/x/swift/v23/security"
 )