diff --git a/go.mod b/go.mod
index cb9f99c..06739c5 100644
--- a/go.mod
+++ b/go.mod
@@ -3,7 +3,9 @@
 go 1.12
 
 require (
+	dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9
 	github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802
+	github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1
 	golang.org/x/image v0.0.0-20190802002840-cff245a6509b
 	golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028
 	golang.org/x/mod v0.1.0
diff --git a/go.sum b/go.sum
index 7f7395b..2a7c68a 100644
--- a/go.sum
+++ b/go.sum
@@ -1,5 +1,9 @@
+dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9 h1:VpgP7xuJadIUuKccphEpTJnWhS2jkQyMt6Y7pJCD7fY=
+dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802 h1:1BDTz0u9nC3//pOCMdNH+CiXJVYJh5UQNCOBG7jbELc=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
+github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1 h1:QbL/5oDUmRBzO9/Z7Seo6zf912W/a6Sr4Eu0G/3Jho0=
+github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
diff --git a/shiny/driver/driver_darwin.go b/shiny/driver/driver_darwin.go
index 2af9550..ee59ac6 100644
--- a/shiny/driver/driver_darwin.go
+++ b/shiny/driver/driver_darwin.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build darwin
+// +build darwin,!metal
 
 package driver
 
diff --git a/shiny/driver/mtldriver/buffer.go b/shiny/driver/mtldriver/buffer.go
new file mode 100644
index 0000000..c9a10ed
--- /dev/null
+++ b/shiny/driver/mtldriver/buffer.go
@@ -0,0 +1,19 @@
+// Copyright 2019 The Go 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 mtldriver
+
+import "image"
+
+// bufferImpl implements screen.Buffer.
+type bufferImpl struct {
+	rgba *image.RGBA
+}
+
+func (*bufferImpl) Release()                  {}
+func (b *bufferImpl) Size() image.Point       { return b.rgba.Rect.Max }
+func (b *bufferImpl) Bounds() image.Rectangle { return b.rgba.Rect }
+func (b *bufferImpl) RGBA() *image.RGBA       { return b.rgba }
diff --git a/shiny/driver/mtldriver/internal/appkit/appkit.go b/shiny/driver/mtldriver/internal/appkit/appkit.go
new file mode 100644
index 0000000..f6f6d5d
--- /dev/null
+++ b/shiny/driver/mtldriver/internal/appkit/appkit.go
@@ -0,0 +1,74 @@
+// Copyright 2019 The Go 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 appkit provides access to Apple's AppKit API
+// (https://developer.apple.com/documentation/appkit).
+//
+// This package is in very early stages of development.
+// It's a minimal implementation with scope limited to
+// supporting mtldriver.
+//
+// It was copied from dmitri.shuralyov.com/gpu/mtl/example/movingtriangle/internal/ns.
+package appkit
+
+import (
+	"unsafe"
+
+	"golang.org/x/exp/shiny/driver/mtldriver/internal/coreanim"
+)
+
+/*
+#include "appkit.h"
+*/
+import "C"
+
+// Window is a window that an app displays on the screen.
+//
+// Reference: https://developer.apple.com/documentation/appkit/nswindow.
+type Window struct {
+	window unsafe.Pointer
+}
+
+// NewWindow returns a Window that wraps an existing NSWindow * pointer.
+func NewWindow(window unsafe.Pointer) Window {
+	return Window{window}
+}
+
+// ContentView returns the window's content view, the highest accessible View
+// in the window's view hierarchy.
+//
+// Reference: https://developer.apple.com/documentation/appkit/nswindow/1419160-contentview.
+func (w Window) ContentView() View {
+	return View{C.Window_ContentView(w.window)}
+}
+
+// View is the infrastructure for drawing, printing, and handling events in an app.
+//
+// Reference: https://developer.apple.com/documentation/appkit/nsview.
+type View struct {
+	view unsafe.Pointer
+}
+
+// SetLayer sets v.layer to l.
+//
+// Reference: https://developer.apple.com/documentation/appkit/nsview/1483298-layer.
+func (v View) SetLayer(l coreanim.Layer) {
+	C.View_SetLayer(v.view, l.Layer())
+}
+
+// SetWantsLayer sets v.wantsLayer to wantsLayer.
+//
+// Reference: https://developer.apple.com/documentation/appkit/nsview/1483695-wantslayer.
+func (v View) SetWantsLayer(wantsLayer bool) {
+	C.View_SetWantsLayer(v.view, toCBool(wantsLayer))
+}
+
+func toCBool(b bool) C.BOOL {
+	if b {
+		return 1
+	}
+	return 0
+}
diff --git a/shiny/driver/mtldriver/internal/appkit/appkit.h b/shiny/driver/mtldriver/internal/appkit/appkit.h
new file mode 100644
index 0000000..eb3a92c
--- /dev/null
+++ b/shiny/driver/mtldriver/internal/appkit/appkit.h
@@ -0,0 +1,12 @@
+// Copyright 2019 The Go 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
+
+typedef signed char BOOL;
+
+void * Window_ContentView(void * window);
+
+void View_SetLayer(void * view, void * layer);
+void View_SetWantsLayer(void * view, BOOL wantsLayer);
diff --git a/shiny/driver/mtldriver/internal/appkit/appkit.m b/shiny/driver/mtldriver/internal/appkit/appkit.m
new file mode 100644
index 0000000..8bb74e3
--- /dev/null
+++ b/shiny/driver/mtldriver/internal/appkit/appkit.m
@@ -0,0 +1,20 @@
+// Copyright 2019 The Go 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
+
+#import <Cocoa/Cocoa.h>
+#include "appkit.h"
+
+void * Window_ContentView(void * window) {
+	return ((NSWindow *)window).contentView;
+}
+
+void View_SetLayer(void * view, void * layer) {
+	((NSView *)view).layer = (CALayer *)layer;
+}
+
+void View_SetWantsLayer(void * view, BOOL wantsLayer) {
+	((NSView *)view).wantsLayer = wantsLayer;
+}
diff --git a/shiny/driver/mtldriver/internal/coreanim/coreanim.go b/shiny/driver/mtldriver/internal/coreanim/coreanim.go
new file mode 100644
index 0000000..857c5e1
--- /dev/null
+++ b/shiny/driver/mtldriver/internal/coreanim/coreanim.go
@@ -0,0 +1,146 @@
+// Copyright 2019 The Go 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 coreanim provides access to Apple's Core Animation API
+// (https://developer.apple.com/documentation/quartzcore).
+//
+// This package is in very early stages of development.
+// It's a minimal implementation with scope limited to
+// supporting mtldriver.
+//
+// It was copied from dmitri.shuralyov.com/gpu/mtl/example/movingtriangle/internal/ca.
+package coreanim
+
+import (
+	"errors"
+	"unsafe"
+
+	"dmitri.shuralyov.com/gpu/mtl"
+)
+
+/*
+#cgo LDFLAGS: -framework QuartzCore -framework Foundation
+#include "coreanim.h"
+*/
+import "C"
+
+// Layer is an object that manages image-based content and
+// allows you to perform animations on that content.
+//
+// Reference: https://developer.apple.com/documentation/quartzcore/calayer.
+type Layer interface {
+	// Layer returns the underlying CALayer * pointer.
+	Layer() unsafe.Pointer
+}
+
+// MetalLayer is a Core Animation Metal layer, a layer that manages a pool of Metal drawables.
+//
+// Reference: https://developer.apple.com/documentation/quartzcore/cametallayer.
+type MetalLayer struct {
+	metalLayer unsafe.Pointer
+}
+
+// MakeMetalLayer creates a new Core Animation Metal layer.
+//
+// Reference: https://developer.apple.com/documentation/quartzcore/cametallayer.
+func MakeMetalLayer() MetalLayer {
+	return MetalLayer{C.MakeMetalLayer()}
+}
+
+// Layer implements the Layer interface.
+func (ml MetalLayer) Layer() unsafe.Pointer { return ml.metalLayer }
+
+// PixelFormat returns the pixel format of textures for rendering layer content.
+//
+// Reference: https://developer.apple.com/documentation/quartzcore/cametallayer/1478155-pixelformat.
+func (ml MetalLayer) PixelFormat() mtl.PixelFormat {
+	return mtl.PixelFormat(C.MetalLayer_PixelFormat(ml.metalLayer))
+}
+
+// SetDevice sets the Metal device responsible for the layer's drawable resources.
+//
+// Reference: https://developer.apple.com/documentation/quartzcore/cametallayer/1478163-device.
+func (ml MetalLayer) SetDevice(device mtl.Device) {
+	C.MetalLayer_SetDevice(ml.metalLayer, device.Device())
+}
+
+// SetPixelFormat controls the pixel format of textures for rendering layer content.
+//
+// The pixel format for a Metal layer must be PixelFormatBGRA8UNorm, PixelFormatBGRA8UNormSRGB,
+// PixelFormatRGBA16Float, PixelFormatBGRA10XR, or PixelFormatBGRA10XRSRGB.
+// SetPixelFormat panics for other values.
+//
+// Reference: https://developer.apple.com/documentation/quartzcore/cametallayer/1478155-pixelformat.
+func (ml MetalLayer) SetPixelFormat(pf mtl.PixelFormat) {
+	e := C.MetalLayer_SetPixelFormat(ml.metalLayer, C.uint16_t(pf))
+	if e != nil {
+		panic(errors.New(C.GoString(e)))
+	}
+}
+
+// SetMaximumDrawableCount controls the number of Metal drawables in the resource pool
+// managed by Core Animation.
+//
+// It can set to 2 or 3 only. SetMaximumDrawableCount panics for other values.
+//
+// Reference: https://developer.apple.com/documentation/quartzcore/cametallayer/2938720-maximumdrawablecount.
+func (ml MetalLayer) SetMaximumDrawableCount(count int) {
+	e := C.MetalLayer_SetMaximumDrawableCount(ml.metalLayer, C.uint_t(count))
+	if e != nil {
+		panic(errors.New(C.GoString(e)))
+	}
+}
+
+// SetDisplaySyncEnabled controls whether the Metal layer and its drawables
+// are synchronized with the display's refresh rate.
+//
+// Reference: https://developer.apple.com/documentation/quartzcore/cametallayer/2887087-displaysyncenabled.
+func (ml MetalLayer) SetDisplaySyncEnabled(enabled bool) {
+	C.MetalLayer_SetDisplaySyncEnabled(ml.metalLayer, toCBool(enabled))
+}
+
+// SetDrawableSize sets the size, in pixels, of textures for rendering layer content.
+//
+// Reference: https://developer.apple.com/documentation/quartzcore/cametallayer/1478174-drawablesize.
+func (ml MetalLayer) SetDrawableSize(width, height int) {
+	C.MetalLayer_SetDrawableSize(ml.metalLayer, C.double(width), C.double(height))
+}
+
+// NextDrawable returns a Metal drawable.
+//
+// Reference: https://developer.apple.com/documentation/quartzcore/cametallayer/1478172-nextdrawable.
+func (ml MetalLayer) NextDrawable() (MetalDrawable, error) {
+	md := C.MetalLayer_NextDrawable(ml.metalLayer)
+	if md == nil {
+		return MetalDrawable{}, errors.New("nextDrawable returned nil")
+	}
+
+	return MetalDrawable{md}, nil
+}
+
+// MetalDrawable is a displayable resource that can be rendered or written to by Metal.
+//
+// Reference: https://developer.apple.com/documentation/quartzcore/cametaldrawable.
+type MetalDrawable struct {
+	metalDrawable unsafe.Pointer
+}
+
+// Drawable implements the mtl.Drawable interface.
+func (md MetalDrawable) Drawable() unsafe.Pointer { return md.metalDrawable }
+
+// Texture returns a Metal texture object representing the drawable object's content.
+//
+// Reference: https://developer.apple.com/documentation/quartzcore/cametaldrawable/1478159-texture.
+func (md MetalDrawable) Texture() mtl.Texture {
+	return mtl.NewTexture(C.MetalDrawable_Texture(md.metalDrawable))
+}
+
+func toCBool(b bool) C.BOOL {
+	if b {
+		return 1
+	}
+	return 0
+}
diff --git a/shiny/driver/mtldriver/internal/coreanim/coreanim.h b/shiny/driver/mtldriver/internal/coreanim/coreanim.h
new file mode 100644
index 0000000..36cd06c
--- /dev/null
+++ b/shiny/driver/mtldriver/internal/coreanim/coreanim.h
@@ -0,0 +1,21 @@
+// Copyright 2019 The Go 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
+
+typedef signed char BOOL;
+typedef unsigned long uint_t;
+typedef unsigned short uint16_t;
+
+void * MakeMetalLayer();
+
+uint16_t     MetalLayer_PixelFormat(void * metalLayer);
+void         MetalLayer_SetDevice(void * metalLayer, void * device);
+const char * MetalLayer_SetPixelFormat(void * metalLayer, uint16_t pixelFormat);
+const char * MetalLayer_SetMaximumDrawableCount(void * metalLayer, uint_t maximumDrawableCount);
+void         MetalLayer_SetDisplaySyncEnabled(void * metalLayer, BOOL displaySyncEnabled);
+void         MetalLayer_SetDrawableSize(void * metalLayer, double width, double height);
+void *       MetalLayer_NextDrawable(void * metalLayer);
+
+void * MetalDrawable_Texture(void * drawable);
diff --git a/shiny/driver/mtldriver/internal/coreanim/coreanim.m b/shiny/driver/mtldriver/internal/coreanim/coreanim.m
new file mode 100644
index 0000000..7aecf83
--- /dev/null
+++ b/shiny/driver/mtldriver/internal/coreanim/coreanim.m
@@ -0,0 +1,58 @@
+// Copyright 2019 The Go 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
+
+#import <QuartzCore/QuartzCore.h>
+#include "coreanim.h"
+
+void * MakeMetalLayer() {
+	return [[CAMetalLayer alloc] init];
+}
+
+uint16_t MetalLayer_PixelFormat(void * metalLayer) {
+	return ((CAMetalLayer *)metalLayer).pixelFormat;
+}
+
+void MetalLayer_SetDevice(void * metalLayer, void * device) {
+	((CAMetalLayer *)metalLayer).device = (id<MTLDevice>)device;
+}
+
+const char * MetalLayer_SetPixelFormat(void * metalLayer, uint16_t pixelFormat) {
+	@try {
+		((CAMetalLayer *)metalLayer).pixelFormat = (MTLPixelFormat)pixelFormat;
+	}
+	@catch (NSException * exception) {
+		return exception.reason.UTF8String;
+	}
+	return NULL;
+}
+
+const char * MetalLayer_SetMaximumDrawableCount(void * metalLayer, uint_t maximumDrawableCount) {
+	if (@available(macOS 10.13.2, *)) {
+		@try {
+			((CAMetalLayer *)metalLayer).maximumDrawableCount = (NSUInteger)maximumDrawableCount;
+		}
+		@catch (NSException * exception) {
+			return exception.reason.UTF8String;
+		}
+	}
+	return NULL;
+}
+
+void MetalLayer_SetDisplaySyncEnabled(void * metalLayer, BOOL displaySyncEnabled) {
+	((CAMetalLayer *)metalLayer).displaySyncEnabled = displaySyncEnabled;
+}
+
+void MetalLayer_SetDrawableSize(void * metalLayer, double width, double height) {
+	((CAMetalLayer *)metalLayer).drawableSize = (CGSize){width, height};
+}
+
+void * MetalLayer_NextDrawable(void * metalLayer) {
+	return [(CAMetalLayer *)metalLayer nextDrawable];
+}
+
+void * MetalDrawable_Texture(void * metalDrawable) {
+	return ((id<CAMetalDrawable>)metalDrawable).texture;
+}
diff --git a/shiny/driver/mtldriver/mtldriver.go b/shiny/driver/mtldriver/mtldriver.go
new file mode 100644
index 0000000..505bffb
--- /dev/null
+++ b/shiny/driver/mtldriver/mtldriver.go
@@ -0,0 +1,246 @@
+// Copyright 2019 The Go 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 mtldriver provides a Metal driver for accessing a screen.
+//
+// At this time, the Metal API is used only to present the final pixels
+// to the screen. All rendering is performed on the CPU via the image/draw
+// algorithms. Future work is to use mtl.Buffer, mtl.Texture, etc., and
+// do more of the rendering work on the GPU.
+package mtldriver
+
+import (
+	"runtime"
+	"unsafe"
+
+	"dmitri.shuralyov.com/gpu/mtl"
+	"github.com/go-gl/glfw/v3.2/glfw"
+	"golang.org/x/exp/shiny/driver/internal/errscreen"
+	"golang.org/x/exp/shiny/driver/mtldriver/internal/appkit"
+	"golang.org/x/exp/shiny/driver/mtldriver/internal/coreanim"
+	"golang.org/x/exp/shiny/screen"
+	"golang.org/x/mobile/event/key"
+	"golang.org/x/mobile/event/mouse"
+	"golang.org/x/mobile/event/paint"
+	"golang.org/x/mobile/event/size"
+)
+
+func init() {
+	runtime.LockOSThread()
+}
+
+// Main is called by the program's main function to run the graphical
+// application.
+//
+// It calls f on the Screen, possibly in a separate goroutine, as some OS-
+// specific libraries require being on 'the main thread'. It returns when f
+// returns.
+func Main(f func(screen.Screen)) {
+	if err := main(f); err != nil {
+		f(errscreen.Stub(err))
+	}
+}
+
+func main(f func(screen.Screen)) error {
+	device, err := mtl.CreateSystemDefaultDevice()
+	if err != nil {
+		return err
+	}
+	err = glfw.Init()
+	if err != nil {
+		return err
+	}
+	defer glfw.Terminate()
+	glfw.WindowHint(glfw.ClientAPI, glfw.NoAPI)
+	var (
+		done            = make(chan struct{})
+		newWindowCh     = make(chan newWindowReq, 1)
+		releaseWindowCh = make(chan releaseWindowReq, 1)
+	)
+	go func() {
+		f(&screenImpl{
+			newWindowCh: newWindowCh,
+		})
+		close(done)
+		glfw.PostEmptyEvent() // Break main loop out of glfw.WaitEvents so it can receive on done.
+	}()
+	for {
+		select {
+		case <-done:
+			return nil
+		case req := <-newWindowCh:
+			w, err := newWindow(device, releaseWindowCh, req.opts)
+			req.respCh <- newWindowResp{w, err}
+		case req := <-releaseWindowCh:
+			req.window.Destroy()
+			req.respCh <- struct{}{}
+		default:
+			glfw.WaitEvents()
+		}
+	}
+}
+
+type newWindowReq struct {
+	opts   *screen.NewWindowOptions
+	respCh chan newWindowResp
+}
+
+type newWindowResp struct {
+	w   screen.Window
+	err error
+}
+
+type releaseWindowReq struct {
+	window *glfw.Window
+	respCh chan struct{}
+}
+
+// newWindow creates a new GLFW window.
+// It must be called on the main thread.
+func newWindow(device mtl.Device, releaseWindowCh chan releaseWindowReq, opts *screen.NewWindowOptions) (screen.Window, error) {
+	width, height := optsSize(opts)
+	window, err := glfw.CreateWindow(width, height, opts.GetTitle(), nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	ml := coreanim.MakeMetalLayer()
+	ml.SetDevice(device)
+	ml.SetPixelFormat(mtl.PixelFormatBGRA8UNorm)
+	ml.SetMaximumDrawableCount(3)
+	ml.SetDisplaySyncEnabled(true)
+	cv := appkit.NewWindow(unsafe.Pointer(window.GetCocoaWindow())).ContentView()
+	cv.SetLayer(ml)
+	cv.SetWantsLayer(true)
+
+	w := &windowImpl{
+		device:          device,
+		window:          window,
+		releaseWindowCh: releaseWindowCh,
+		ml:              ml,
+		cq:              device.MakeCommandQueue(),
+	}
+
+	// Set callbacks.
+	framebufferSizeCallback := func(_ *glfw.Window, width, height int) {
+		w.Send(size.Event{
+			WidthPx:  width,
+			HeightPx: height,
+			// TODO(dmitshur): ppp,
+		})
+		w.Send(paint.Event{External: true})
+	}
+	window.SetFramebufferSizeCallback(framebufferSizeCallback)
+	window.SetCursorPosCallback(func(_ *glfw.Window, x, y float64) {
+		const scale = 2 // TODO(dmitshur): compute dynamically
+		w.Send(mouse.Event{X: float32(x * scale), Y: float32(y * scale)})
+	})
+	window.SetMouseButtonCallback(func(_ *glfw.Window, b glfw.MouseButton, a glfw.Action, mods glfw.ModifierKey) {
+		btn := glfwMouseButton(b)
+		if btn == mouse.ButtonNone {
+			return
+		}
+		const scale = 2 // TODO(dmitshur): compute dynamically
+		x, y := window.GetCursorPos()
+		w.Send(mouse.Event{
+			X: float32(x * scale), Y: float32(y * scale),
+			Button:    btn,
+			Direction: glfwMouseDirection(a),
+			// TODO(dmitshur): set Modifiers
+		})
+	})
+	window.SetKeyCallback(func(_ *glfw.Window, k glfw.Key, _ int, a glfw.Action, mods glfw.ModifierKey) {
+		code := glfwKeyCode(k)
+		if code == key.CodeUnknown {
+			return
+		}
+		w.Send(key.Event{
+			Code:      code,
+			Direction: glfwKeyDirection(a),
+			// TODO(dmitshur): set Modifiers
+		})
+	})
+	// TODO(dmitshur): set CharModsCallback to catch text (runes) that are typed,
+	//                 and perhaps try to unify key pressed + character typed into single event
+	window.SetCloseCallback(func(*glfw.Window) {
+		w.lifecycler.SetDead(true)
+		w.lifecycler.SendEvent(w, nil)
+	})
+
+	// TODO(dmitshur): more fine-grained tracking of whether window is visible and/or focused
+	w.lifecycler.SetDead(false)
+	w.lifecycler.SetVisible(true)
+	w.lifecycler.SetFocused(true)
+	w.lifecycler.SendEvent(w, nil)
+
+	// Send the initial size and paint events.
+	width, height = window.GetFramebufferSize()
+	framebufferSizeCallback(window, width, height)
+
+	return w, nil
+}
+
+func optsSize(opts *screen.NewWindowOptions) (width, height int) {
+	width, height = 1024/2, 768/2
+	if opts != nil {
+		if opts.Width > 0 {
+			width = opts.Width
+		}
+		if opts.Height > 0 {
+			height = opts.Height
+		}
+	}
+	return width, height
+}
+
+func glfwMouseButton(button glfw.MouseButton) mouse.Button {
+	switch button {
+	case glfw.MouseButtonLeft:
+		return mouse.ButtonLeft
+	case glfw.MouseButtonRight:
+		return mouse.ButtonRight
+	case glfw.MouseButtonMiddle:
+		return mouse.ButtonMiddle
+	default:
+		return mouse.ButtonNone
+	}
+}
+
+func glfwMouseDirection(action glfw.Action) mouse.Direction {
+	switch action {
+	case glfw.Press:
+		return mouse.DirPress
+	case glfw.Release:
+		return mouse.DirRelease
+	default:
+		panic("unreachable")
+	}
+}
+
+func glfwKeyCode(k glfw.Key) key.Code {
+	// TODO(dmitshur): support more keys
+	switch k {
+	case glfw.KeyEnter:
+		return key.CodeReturnEnter
+	case glfw.KeyEscape:
+		return key.CodeEscape
+	default:
+		return key.CodeUnknown
+	}
+}
+
+func glfwKeyDirection(action glfw.Action) key.Direction {
+	switch action {
+	case glfw.Press:
+		return key.DirPress
+	case glfw.Release:
+		return key.DirRelease
+	case glfw.Repeat:
+		return key.DirNone
+	default:
+		panic("unreachable")
+	}
+}
diff --git a/shiny/driver/mtldriver/screen.go b/shiny/driver/mtldriver/screen.go
new file mode 100644
index 0000000..7abba42
--- /dev/null
+++ b/shiny/driver/mtldriver/screen.go
@@ -0,0 +1,42 @@
+// Copyright 2019 The Go 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 mtldriver
+
+import (
+	"image"
+
+	"github.com/go-gl/glfw/v3.2/glfw"
+	"golang.org/x/exp/shiny/screen"
+)
+
+// screenImpl implements screen.Screen.
+type screenImpl struct {
+	newWindowCh chan newWindowReq
+}
+
+func (*screenImpl) NewBuffer(size image.Point) (screen.Buffer, error) {
+	return &bufferImpl{
+		rgba: image.NewRGBA(image.Rectangle{Max: size}),
+	}, nil
+}
+
+func (*screenImpl) NewTexture(size image.Point) (screen.Texture, error) {
+	return &textureImpl{
+		rgba: image.NewRGBA(image.Rectangle{Max: size}),
+	}, nil
+}
+
+func (s *screenImpl) NewWindow(opts *screen.NewWindowOptions) (screen.Window, error) {
+	respCh := make(chan newWindowResp)
+	s.newWindowCh <- newWindowReq{
+		opts:   opts,
+		respCh: respCh,
+	}
+	glfw.PostEmptyEvent() // Break main loop out of glfw.WaitEvents so it can receive on newWindowCh.
+	resp := <-respCh
+	return resp.w, resp.err
+}
diff --git a/shiny/driver/mtldriver/texture.go b/shiny/driver/mtldriver/texture.go
new file mode 100644
index 0000000..6a60dfd
--- /dev/null
+++ b/shiny/driver/mtldriver/texture.go
@@ -0,0 +1,32 @@
+// Copyright 2019 The Go 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 mtldriver
+
+import (
+	"image"
+	"image/color"
+
+	"golang.org/x/exp/shiny/screen"
+	"golang.org/x/image/draw"
+)
+
+// textureImpl implements screen.Texture.
+type textureImpl struct {
+	rgba *image.RGBA
+}
+
+func (*textureImpl) Release()                  {}
+func (t *textureImpl) Size() image.Point       { return t.rgba.Rect.Max }
+func (t *textureImpl) Bounds() image.Rectangle { return t.rgba.Rect }
+
+func (t *textureImpl) Upload(dp image.Point, src screen.Buffer, sr image.Rectangle) {
+	draw.Draw(t.rgba, sr.Sub(sr.Min).Add(dp), src.RGBA(), sr.Min, draw.Src)
+}
+
+func (t *textureImpl) Fill(dr image.Rectangle, src color.Color, op draw.Op) {
+	draw.Draw(t.rgba, dr, &image.Uniform{src}, image.Point{}, op)
+}
diff --git a/shiny/driver/mtldriver/window.go b/shiny/driver/mtldriver/window.go
new file mode 100644
index 0000000..7ba0d73
--- /dev/null
+++ b/shiny/driver/mtldriver/window.go
@@ -0,0 +1,119 @@
+// Copyright 2019 The Go 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 mtldriver
+
+import (
+	"image"
+	"image/color"
+	"log"
+
+	"dmitri.shuralyov.com/gpu/mtl"
+	"github.com/go-gl/glfw/v3.2/glfw"
+	"golang.org/x/exp/shiny/driver/internal/drawer"
+	"golang.org/x/exp/shiny/driver/internal/event"
+	"golang.org/x/exp/shiny/driver/internal/lifecycler"
+	"golang.org/x/exp/shiny/driver/mtldriver/internal/coreanim"
+	"golang.org/x/exp/shiny/screen"
+	"golang.org/x/image/draw"
+	"golang.org/x/image/math/f64"
+	"golang.org/x/mobile/event/size"
+)
+
+// windowImpl implements screen.Window.
+type windowImpl struct {
+	device          mtl.Device
+	window          *glfw.Window
+	releaseWindowCh chan releaseWindowReq
+	ml              coreanim.MetalLayer
+	cq              mtl.CommandQueue
+
+	event.Deque
+	lifecycler lifecycler.State
+
+	rgba    *image.RGBA
+	texture mtl.Texture // Used in Publish.
+}
+
+func (w *windowImpl) Release() {
+	respCh := make(chan struct{})
+	w.releaseWindowCh <- releaseWindowReq{
+		window: w.window,
+		respCh: respCh,
+	}
+	glfw.PostEmptyEvent() // Break main loop out of glfw.WaitEvents so it can receive on releaseWindowCh.
+	<-respCh
+}
+
+func (w *windowImpl) NextEvent() interface{} {
+	e := w.Deque.NextEvent()
+	if sz, ok := e.(size.Event); ok {
+		// TODO(dmitshur): this is the best place/time/frequency to do this
+		//                 I've found so far, but see if it can be even better
+
+		// Set drawable size, create backing image and texture.
+		w.ml.SetDrawableSize(sz.WidthPx, sz.HeightPx)
+		w.rgba = image.NewRGBA(image.Rectangle{Max: image.Point{X: sz.WidthPx, Y: sz.HeightPx}})
+		w.texture = w.device.MakeTexture(mtl.TextureDescriptor{
+			PixelFormat: mtl.PixelFormatRGBA8UNorm,
+			Width:       sz.WidthPx,
+			Height:      sz.HeightPx,
+			StorageMode: mtl.StorageModeManaged,
+		})
+	}
+	return e
+}
+
+func (w *windowImpl) Publish() screen.PublishResult {
+	// Copy w.rgba pixels into a texture.
+	region := mtl.RegionMake2D(0, 0, w.texture.Width, w.texture.Height)
+	bytesPerRow := 4 * w.texture.Width
+	w.texture.ReplaceRegion(region, 0, &w.rgba.Pix[0], uintptr(bytesPerRow))
+
+	drawable, err := w.ml.NextDrawable()
+	if err != nil {
+		log.Println("Window.Publish: couldn't get the next drawable:", err)
+		return screen.PublishResult{}
+	}
+
+	cb := w.cq.MakeCommandBuffer()
+
+	// Copy the texture into the drawable.
+	bce := cb.MakeBlitCommandEncoder()
+	bce.CopyFromTexture(
+		w.texture, 0, 0, mtl.Origin{}, mtl.Size{w.texture.Width, w.texture.Height, 1},
+		drawable.Texture(), 0, 0, mtl.Origin{})
+	bce.EndEncoding()
+
+	cb.PresentDrawable(drawable)
+	cb.Commit()
+
+	return screen.PublishResult{}
+}
+
+func (w *windowImpl) Upload(dp image.Point, src screen.Buffer, sr image.Rectangle) {
+	draw.Draw(w.rgba, sr.Sub(sr.Min).Add(dp), src.RGBA(), sr.Min, draw.Src)
+}
+
+func (w *windowImpl) Fill(dr image.Rectangle, src color.Color, op draw.Op) {
+	draw.Draw(w.rgba, dr, &image.Uniform{src}, image.Point{}, op)
+}
+
+func (w *windowImpl) Draw(src2dst f64.Aff3, src screen.Texture, sr image.Rectangle, op draw.Op, _ *screen.DrawOptions) {
+	draw.NearestNeighbor.Transform(w.rgba, src2dst, src.(*textureImpl).rgba, sr, op, nil)
+}
+
+func (w *windowImpl) DrawUniform(src2dst f64.Aff3, src color.Color, sr image.Rectangle, op draw.Op, _ *screen.DrawOptions) {
+	draw.NearestNeighbor.Transform(w.rgba, src2dst, &image.Uniform{src}, sr, op, nil)
+}
+
+func (w *windowImpl) Copy(dp image.Point, src screen.Texture, sr image.Rectangle, op draw.Op, opts *screen.DrawOptions) {
+	drawer.Copy(w, dp, src, sr, op, opts)
+}
+
+func (w *windowImpl) Scale(dr image.Rectangle, src screen.Texture, sr image.Rectangle, op draw.Op, opts *screen.DrawOptions) {
+	drawer.Scale(w, dr, src, sr, op, opts)
+}
diff --git a/shiny/driver/mtldriver_darwin.go b/shiny/driver/mtldriver_darwin.go
new file mode 100644
index 0000000..d94e633
--- /dev/null
+++ b/shiny/driver/mtldriver_darwin.go
@@ -0,0 +1,16 @@
+// Copyright 2019 The Go 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,metal
+
+package driver
+
+import (
+	"golang.org/x/exp/shiny/driver/mtldriver"
+	"golang.org/x/exp/shiny/screen"
+)
+
+func main(f func(screen.Screen)) {
+	mtldriver.Main(f)
+}