diff --git a/examples/go/BUILD.gn b/examples/go/BUILD.gn
index 78412ab..59a9c74 100644
--- a/examples/go/BUILD.gn
+++ b/examples/go/BUILD.gn
@@ -9,6 +9,8 @@
     deps = [
       ":go_echo_client",
       ":go_echo_server",
+      ":go_http_handler",
+      ":go_http_server",
     ]
   }
 
@@ -37,4 +39,30 @@
       "//mojo/public/platform/native:system",
     ]
   }
+
+  go_mojo_application("go_http_handler") {
+    sources = [
+      "http_handler.go",
+    ]
+    deps = [
+      "//mojo/go:application",
+      "//mojo/go:platform_cgo",
+      "//mojo/public/c/system",
+      "//mojo/public/platform/native:system",
+      "//mojo/services/network/public/interfaces",
+    ]
+  }
+
+  go_mojo_application("go_http_server") {
+    sources = [
+      "http_server.go",
+    ]
+    deps = [
+      "//mojo/go:application",
+      "//mojo/go:platform_cgo",
+      "//mojo/public/c/system",
+      "//mojo/public/platform/native:system",
+      "//mojo/services/network/public/interfaces",
+    ]
+  }
 }
diff --git a/examples/go/README.txt b/examples/go/README.txt
index cdfc603..ac540ae 100644
--- a/examples/go/README.txt
+++ b/examples/go/README.txt
@@ -1,8 +1,21 @@
-Sample Go echo application.
+Sample Go applications.
 
-Instructions to run on android emulator:
+echo_client, echo_server - sample applications that talk to each other
+
+http_handler - application that implements HTTP server; uses the mojo HTTP
+Server service to handle the HTTP protocol details, and just contains the logic
+for handling its registered urls.
+
+http_server - application that implements HTTP server; uses go net stack on top
+of the mojo network service.
 
 1) Follow steps from //mojo/go/sample_app/README.txt
 
-To run client:
+To run echo client:
 $ mojo/tools/android_mojo_shell.py --enable-multiprocess mojo:go_echo_client
+
+To run http handler:
+$ mojo/tools/android_mojo_shell.py --enable-multiprocess mojo:go_http_handler
+
+To run http server:
+$ mojo/tools/android_mojo_shell.py --enable-multiprocess mojo:go_http_server
diff --git a/examples/go/http_handler.go b/examples/go/http_handler.go
new file mode 100644
index 0000000..3794c9f
--- /dev/null
+++ b/examples/go/http_handler.go
@@ -0,0 +1,108 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"golang.org/x/mobile/app"
+
+	"mojo/public/go/application"
+	"mojo/public/go/bindings"
+	"mojo/public/go/system"
+
+	"mojo/services/http_server/public/interfaces/http_request"
+	"mojo/services/http_server/public/interfaces/http_response"
+	"mojo/services/http_server/public/interfaces/http_server"
+	"mojo/services/http_server/public/interfaces/http_server_factory"
+	"mojo/services/network/public/interfaces/net_address"
+)
+
+//#include "mojo/public/c/system/types.h"
+import "C"
+
+type HttpHandler struct{}
+
+func (h *HttpHandler) HandleRequest(request http_request.HttpRequest) (http_response.HttpResponse, error) {
+	resp := "Hello, Go http handler!"
+	r, producer, consumer := system.GetCore().CreateDataPipe(&system.DataPipeOptions{
+		system.MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,
+		1,
+		uint32(len(resp)),
+	})
+	if r != system.MOJO_RESULT_OK {
+		panic(fmt.Sprintf("can't create data pipe: %v", r))
+	}
+
+	producer.WriteData([]byte(resp), system.MOJO_WRITE_DATA_FLAG_ALL_OR_NONE)
+	producer.Close()
+	return http_response.HttpResponse{
+		200,
+		&consumer,
+		int64(len(resp)),
+		"text/html; charset=utf-8",
+		nil,
+	}, nil
+}
+
+type HttpHandlerDelegate struct {
+	server      *http_server.HttpServerProxy
+	handlerStub *bindings.Stub
+}
+
+func (d *HttpHandlerDelegate) Initialize(ctx application.Context) {
+	request, pointer := http_server_factory.CreateMessagePipeForHttpServerFactory()
+	ctx.ConnectToApplication("mojo:http_server").ConnectToService(&request)
+	factory := http_server_factory.NewHttpServerFactoryProxy(pointer, bindings.GetAsyncWaiter())
+
+	addr := &net_address.NetAddress{
+		net_address.NetAddressFamily_IpV4,
+		&net_address.NetAddressIPv4{
+			8080,
+			[4]uint8{127, 0, 0, 1},
+		},
+		nil,
+	}
+	serverRequest, serverPointer := http_server.CreateMessagePipeForHttpServer()
+	factory.CreateHttpServer(serverRequest, addr)
+	d.server = http_server.NewHttpServerProxy(serverPointer, bindings.GetAsyncWaiter())
+	handlerRequest, handlerPointer := http_server.CreateMessagePipeForHttpHandler()
+	ok, err := d.server.SetHandler("/go", handlerPointer)
+	if !ok {
+		log.Println("can't set handler:", err)
+		return
+	}
+
+	d.handlerStub = http_server.NewHttpHandlerStub(handlerRequest, &HttpHandler{}, bindings.GetAsyncWaiter())
+	go func() {
+		for {
+			if err := d.handlerStub.ServeRequest(); err != nil {
+				log.Println("can't handle http request:", err)
+				return
+			}
+		}
+	}()
+	factory.Close_proxy()
+}
+
+func (d *HttpHandlerDelegate) AcceptConnection(c *application.Connection) {
+	c.Close()
+}
+
+func (d *HttpHandlerDelegate) Quit() {
+	d.server.Close_proxy()
+	d.handlerStub.Close()
+}
+
+//export MojoMain
+func MojoMain(handle C.MojoHandle) C.MojoResult {
+	application.Run(&HttpHandlerDelegate{}, system.MojoHandle(handle))
+	return C.MOJO_RESULT_OK
+}
+
+func main() {
+	app.Run(app.Callbacks{})
+}
diff --git a/examples/go/http_server.go b/examples/go/http_server.go
new file mode 100644
index 0000000..0d5eab8
--- /dev/null
+++ b/examples/go/http_server.go
@@ -0,0 +1,247 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package main
+
+import (
+	"fmt"
+	"log"
+	"net"
+	"net/http"
+	"time"
+
+	"golang.org/x/mobile/app"
+
+	"mojo/public/go/application"
+	"mojo/public/go/bindings"
+	"mojo/public/go/system"
+
+	"mojo/services/network/public/interfaces/net_address"
+	"mojo/services/network/public/interfaces/network_service"
+	"mojo/services/network/public/interfaces/tcp_bound_socket"
+	"mojo/services/network/public/interfaces/tcp_connected_socket"
+	"mojo/services/network/public/interfaces/tcp_server_socket"
+)
+
+//#include "mojo/public/c/system/types.h"
+import "C"
+
+type MojoConnection struct {
+	sendStream    system.ProducerHandle
+	receiveStream system.ConsumerHandle
+	socket        system.MessagePipeHandle
+	localAddr     net.Addr
+	remoteAddr    net.Addr
+}
+
+// Implements net.Conn.
+func (c *MojoConnection) Read(b []byte) (int, error) {
+	l := len(b)
+	r, read := c.receiveStream.BeginReadData(l, system.MOJO_READ_DATA_FLAG_NONE)
+	if r != system.MOJO_RESULT_OK {
+		return 0, fmt.Errorf("can't read %v bytes: %v", l, r)
+	}
+	if l > len(read) {
+		l = len(read)
+	}
+	copy(b, read[:l])
+	if r := c.receiveStream.EndReadData(l); r != system.MOJO_RESULT_OK {
+		return 0, fmt.Errorf("can't read %v bytes: %v", l, r)
+	}
+	return l, nil
+}
+
+// Implements net.Conn.
+func (c *MojoConnection) Write(b []byte) (int, error) {
+	l := len(b)
+	r, buf := c.sendStream.BeginWriteData(l, system.MOJO_WRITE_DATA_FLAG_ALL_OR_NONE)
+	if r != system.MOJO_RESULT_OK {
+		return 0, fmt.Errorf("can't write %v bytes: %v", l, r)
+	}
+	copy(buf, b)
+	if r := c.sendStream.EndWriteData(l); r != system.MOJO_RESULT_OK {
+		return 0, fmt.Errorf("can't write %v bytes: %v", l, r)
+	}
+	return l, nil
+}
+
+// Implements net.Conn.
+func (c *MojoConnection) Close() error {
+	c.sendStream.Close()
+	c.receiveStream.Close()
+	c.socket.Close()
+	return nil
+}
+
+// Implements net.Conn.
+func (c *MojoConnection) LocalAddr() net.Addr {
+	return c.localAddr
+}
+
+// Implements net.Conn.
+func (c *MojoConnection) RemoteAddr() net.Addr {
+	return c.remoteAddr
+}
+
+// Implements net.Conn.
+func (c *MojoConnection) SetDeadline(t time.Time) error {
+	if err := c.SetReadDeadline(t); err != nil {
+		return err
+	}
+	return c.SetWriteDeadline(t)
+}
+
+// Implements net.Conn.
+func (c *MojoConnection) SetReadDeadline(t time.Time) error {
+	// Do nothing.
+	return nil
+}
+
+// Implements net.Conn.
+func (c *MojoConnection) SetWriteDeadline(t time.Time) error {
+	// Do nothing.
+	return nil
+}
+
+type MojoListener struct {
+	serverSocket *tcp_server_socket.TcpServerSocketProxy
+}
+
+// Implements net.Listener.
+func (l *MojoListener) Accept() (net.Conn, error) {
+	r, sendProducer, sendConsumer := system.GetCore().CreateDataPipe(nil)
+	if r != system.MOJO_RESULT_OK {
+		panic(fmt.Sprintf("can't create data pipe: %v", r))
+	}
+	r, receiveProducer, receiveConsumer := system.GetCore().CreateDataPipe(nil)
+	if r != system.MOJO_RESULT_OK {
+		panic(fmt.Sprintf("can't create data pipe: %v", r))
+	}
+	request, pointer := tcp_connected_socket.CreateMessagePipeForTcpConnectedSocket()
+	networkError, remoteAddress, err := l.serverSocket.Accept(sendConsumer, receiveProducer, request)
+	if err != nil {
+		return nil, err
+	}
+	if networkError.Code != 0 {
+		return nil, fmt.Errorf("%s", *networkError.Description)
+	}
+
+	var addr net.Addr
+	if remoteAddress.Ipv4 != nil {
+		addr = &net.TCPAddr{
+			IP:   remoteAddress.Ipv4.Addr[:4],
+			Port: int(remoteAddress.Ipv4.Port),
+		}
+	} else {
+		addr = &net.TCPAddr{
+			IP:   remoteAddress.Ipv6.Addr[:16],
+			Port: int(remoteAddress.Ipv6.Port),
+		}
+	}
+	return &MojoConnection{
+		sendProducer,
+		receiveConsumer,
+		pointer.PassMessagePipe(),
+		l.Addr(),
+		addr,
+	}, nil
+}
+
+// Implements net.Listener.
+func (l *MojoListener) Close() error {
+	l.serverSocket.Close_proxy()
+	return nil
+}
+
+// Implements net.Listener.
+func (l *MojoListener) Addr() net.Addr {
+	return &net.TCPAddr{
+		IP:   []byte{127, 0, 0, 1},
+		Port: 8080,
+	}
+}
+
+type HttpServerDelegate struct {
+	networkService *network_service.NetworkServiceProxy
+	tcpBoundSocket *tcp_bound_socket.TcpBoundSocketProxy
+	serverSocket   *tcp_server_socket.TcpServerSocketProxy
+}
+
+func (d *HttpServerDelegate) InitTCPBoundSocket() error {
+	addr := &net_address.NetAddress{
+		net_address.NetAddressFamily_IpV4,
+		&net_address.NetAddressIPv4{
+			8080,
+			[4]uint8{127, 0, 0, 1},
+		},
+		nil,
+	}
+	request, pointer := tcp_bound_socket.CreateMessagePipeForTcpBoundSocket()
+	networkError, _, err := d.networkService.CreateTcpBoundSocket(addr, request)
+	if err != nil {
+		return err
+	}
+	if networkError.Code != 0 {
+		return fmt.Errorf("%s", *networkError.Description)
+	}
+	d.tcpBoundSocket = tcp_bound_socket.NewTcpBoundSocketProxy(pointer, bindings.GetAsyncWaiter())
+	return nil
+}
+
+func (d *HttpServerDelegate) InitServerSocket() error {
+	request, pointer := tcp_server_socket.CreateMessagePipeForTcpServerSocket()
+	networkError, err := d.tcpBoundSocket.StartListening(request)
+	if err != nil {
+		return err
+	}
+	if networkError.Code != 0 {
+		return fmt.Errorf("%s", *networkError.Description)
+	}
+	d.serverSocket = tcp_server_socket.NewTcpServerSocketProxy(pointer, bindings.GetAsyncWaiter())
+	return nil
+}
+
+func (d *HttpServerDelegate) Initialize(ctx application.Context) {
+	request, pointer := network_service.CreateMessagePipeForNetworkService()
+	ctx.ConnectToApplication("mojo:network_service").ConnectToService(&request)
+	d.networkService = network_service.NewNetworkServiceProxy(pointer, bindings.GetAsyncWaiter())
+
+	if err := d.InitTCPBoundSocket(); err != nil {
+		log.Printf("can't create TCP socket: %v\n", err)
+		return
+	}
+	if err := d.InitServerSocket(); err != nil {
+		log.Printf("can't create server socket: %v\n", err)
+		return
+	}
+
+	http.HandleFunc("/go", func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintf(w, "Hello, Go http server!")
+	})
+	l := &MojoListener{d.serverSocket}
+	if err := http.Serve(l, nil); err != nil {
+		log.Printf("can't serve request: %v\n", err)
+		return
+	}
+}
+
+func (d *HttpServerDelegate) AcceptConnection(c *application.Connection) {
+	c.Close()
+}
+
+func (d *HttpServerDelegate) Quit() {
+	d.networkService.Close_proxy()
+	d.tcpBoundSocket.Close_proxy()
+	d.serverSocket.Close_proxy()
+}
+
+//export MojoMain
+func MojoMain(handle C.MojoHandle) C.MojoResult {
+	application.Run(&HttpServerDelegate{}, system.MojoHandle(handle))
+	return C.MOJO_RESULT_OK
+}
+
+func main() {
+	app.Run(app.Callbacks{})
+}