diff --git a/shiny/driver/gldriver/window.go b/shiny/driver/gldriver/window.go
index 50d5f71..53408a4 100644
--- a/shiny/driver/gldriver/window.go
+++ b/shiny/driver/gldriver/window.go
@@ -121,7 +121,7 @@
 	}
 }
 
-func (w *windowImpl) Fill(dr image.Rectangle, src color.Color, op draw.Op) {
+func (w *windowImpl) fill(mvp f64.Aff3, src color.Color, op draw.Op) {
 	w.glctxMu.Lock()
 	defer w.glctxMu.Unlock()
 
@@ -143,15 +143,7 @@
 	}
 	w.glctx.UseProgram(w.s.fill.program)
 
-	dstL := float64(dr.Min.X)
-	dstT := float64(dr.Min.Y)
-	dstR := float64(dr.Max.X)
-	dstB := float64(dr.Max.Y)
-	writeAff3(w.glctx, w.s.fill.mvp, w.mvp(
-		dstL, dstT,
-		dstR, dstT,
-		dstL, dstB,
-	))
+	writeAff3(w.glctx, w.s.fill.mvp, mvp)
 
 	r, g, b, a := src.RGBA()
 	w.glctx.Uniform4f(
@@ -171,6 +163,33 @@
 	w.glctx.DisableVertexAttribArray(w.s.fill.pos)
 }
 
+func (w *windowImpl) Fill(dr image.Rectangle, src color.Color, op draw.Op) {
+	minX := float64(dr.Min.X)
+	minY := float64(dr.Min.Y)
+	maxX := float64(dr.Max.X)
+	maxY := float64(dr.Max.Y)
+	w.fill(w.mvp(
+		minX, minY,
+		maxX, minY,
+		minX, maxY,
+	), src, op)
+}
+
+func (w *windowImpl) DrawUniform(src2dst f64.Aff3, src color.Color, sr image.Rectangle, op draw.Op, opts *screen.DrawOptions) {
+	minX := float64(sr.Min.X)
+	minY := float64(sr.Min.Y)
+	maxX := float64(sr.Max.X)
+	maxY := float64(sr.Max.Y)
+	w.fill(w.mvp(
+		src2dst[0]*minX+src2dst[1]*minY+src2dst[2],
+		src2dst[3]*minX+src2dst[4]*minY+src2dst[5],
+		src2dst[0]*maxX+src2dst[1]*minY+src2dst[2],
+		src2dst[3]*maxX+src2dst[4]*minY+src2dst[5],
+		src2dst[0]*minX+src2dst[1]*maxY+src2dst[2],
+		src2dst[3]*minX+src2dst[4]*maxY+src2dst[5],
+	), src, op)
+}
+
 func (w *windowImpl) Draw(src2dst f64.Aff3, src screen.Texture, sr image.Rectangle, op draw.Op, opts *screen.DrawOptions) {
 	t := src.(*textureImpl)
 	sr = sr.Intersect(t.Bounds())
diff --git a/shiny/driver/windriver/window.go b/shiny/driver/windriver/window.go
index 3387bc7..9945974 100644
--- a/shiny/driver/windriver/window.go
+++ b/shiny/driver/windriver/window.go
@@ -77,6 +77,10 @@
 	})
 }
 
+func (w *windowImpl) DrawUniform(src2dst f64.Aff3, src color.Color, sr image.Rectangle, op draw.Op, opts *screen.DrawOptions) {
+	panic("TODO: implement")
+}
+
 func drawWindow(dc syscall.Handle, src2dst f64.Aff3, src syscall.Handle, sr image.Rectangle, op draw.Op) (retErr error) {
 	var dr image.Rectangle
 	if src2dst[1] != 0 || src2dst[3] != 0 {
diff --git a/shiny/driver/x11driver/screen.go b/shiny/driver/x11driver/screen.go
index dcbfa89..2a55051 100644
--- a/shiny/driver/x11driver/screen.go
+++ b/shiny/driver/x11driver/screen.go
@@ -7,6 +7,8 @@
 import (
 	"fmt"
 	"image"
+	"image/color"
+	"image/draw"
 	"log"
 	"sync"
 
@@ -17,6 +19,7 @@
 
 	"golang.org/x/exp/shiny/driver/internal/x11key"
 	"golang.org/x/exp/shiny/screen"
+	"golang.org/x/image/math/f64"
 	"golang.org/x/mobile/event/key"
 	"golang.org/x/mobile/event/mouse"
 )
@@ -44,6 +47,13 @@
 	gcontext32 xproto.Gcontext
 	window32   xproto.Window
 
+	// opaqueP is a fully opaque, solid fill picture.
+	opaqueP render.Picture
+
+	uniformMu sync.Mutex
+	uniformC  render.Color
+	uniformP  render.Picture
+
 	mu              sync.Mutex
 	buffers         map[shm.Seg]*bufferImpl
 	uploads         map[uint16]chan struct{}
@@ -78,6 +88,24 @@
 	if err := s.initWindow32(); err != nil {
 		return nil, err
 	}
+
+	var err error
+	s.opaqueP, err = render.NewPictureId(xc)
+	if err != nil {
+		return nil, fmt.Errorf("x11driver: xproto.NewPictureId failed: %v", err)
+	}
+	s.uniformP, err = render.NewPictureId(xc)
+	if err != nil {
+		return nil, fmt.Errorf("x11driver: xproto.NewPictureId failed: %v", err)
+	}
+	render.CreateSolidFill(s.xc, s.opaqueP, render.Color{
+		Red:   0xffff,
+		Green: 0xffff,
+		Blue:  0xffff,
+		Alpha: 0xffff,
+	})
+	render.CreateSolidFill(s.xc, s.uniformP, render.Color{})
+
 	go s.run()
 	return s, nil
 }
@@ -313,14 +341,6 @@
 	if err != nil {
 		return nil, fmt.Errorf("x11driver: xproto.NewPictureId failed: %v", err)
 	}
-	opaqueM, err := xproto.NewPixmapId(s.xc)
-	if err != nil {
-		return nil, fmt.Errorf("x11driver: xproto.NewPixmapId failed: %v", err)
-	}
-	opaqueP, err := render.NewPictureId(s.xc)
-	if err != nil {
-		return nil, fmt.Errorf("x11driver: xproto.NewPictureId failed: %v", err)
-	}
 	xproto.CreatePixmap(s.xc, textureDepth, xm, xproto.Drawable(s.window32), uint16(w), uint16(h))
 	render.CreatePicture(s.xc, xp, xproto.Drawable(xm), s.pictformat32, render.CpRepeat, []uint32{render.RepeatPad})
 	render.SetPictureFilter(s.xc, xp, uint16(len("bilinear")), "bilinear", nil)
@@ -331,12 +351,10 @@
 	}})
 
 	return &textureImpl{
-		s:       s,
-		size:    size,
-		xm:      xm,
-		xp:      xp,
-		opaqueM: opaqueM,
-		opaqueP: opaqueP,
+		s:    s,
+		size: size,
+		xm:   xm,
+		xp:   xp,
 	}, nil
 }
 
@@ -552,3 +570,39 @@
 	}
 	xproto.ChangeProperty(s.xc, xproto.PropModeReplace, xw, prop, xproto.AtomAtom, 32, uint32(len(values)), b)
 }
+
+func (s *screenImpl) drawUniform(xp render.Picture, src2dst *f64.Aff3, src color.Color, sr image.Rectangle, op draw.Op, opts *screen.DrawOptions) {
+	if sr.Empty() {
+		return
+	}
+
+	if opts == nil && *src2dst == (f64.Aff3{1, 0, 0, 0, 1, 0}) {
+		fill(s.xc, xp, sr, src, op)
+		return
+	}
+
+	r, g, b, a := src.RGBA()
+	c := render.Color{
+		Red:   uint16(r),
+		Green: uint16(g),
+		Blue:  uint16(b),
+		Alpha: uint16(a),
+	}
+	points := trifanPoints(src2dst, sr)
+
+	s.uniformMu.Lock()
+	defer s.uniformMu.Unlock()
+
+	if s.uniformC != c {
+		s.uniformC = c
+		render.FreePicture(s.xc, s.uniformP)
+		render.CreateSolidFill(s.xc, s.uniformP, c)
+	}
+
+	if op == draw.Src {
+		// We implement draw.Src as render.PictOpOutReverse followed by
+		// render.PictOpOver, for the same reason as in textureImpl.draw.
+		render.TriFan(s.xc, render.PictOpOutReverse, s.opaqueP, xp, 0, 0, 0, points[:])
+	}
+	render.TriFan(s.xc, render.PictOpOver, s.uniformP, xp, 0, 0, 0, points[:])
+}
diff --git a/shiny/driver/x11driver/texture.go b/shiny/driver/x11driver/texture.go
index 3ee3a91..da6fc86 100644
--- a/shiny/driver/x11driver/texture.go
+++ b/shiny/driver/x11driver/texture.go
@@ -32,13 +32,7 @@
 	// multiple X11/Render calls. X11/Render is a stateful API, so interleaving
 	// X11/Render calls from separate higher-level operations causes
 	// inconsistencies.
-	//
-	// It also protects the opaqueXxx fields, which hold a lazily created,
-	// fully opaque mask picture.
-	renderMu      sync.Mutex
-	opaqueM       xproto.Pixmap
-	opaqueP       render.Picture
-	opaqueCreated bool
+	renderMu sync.Mutex
 
 	releasedMu sync.Mutex
 	released   bool
@@ -57,10 +51,6 @@
 	if released || t.degenerate() {
 		return
 	}
-	if t.opaqueCreated {
-		render.FreePicture(t.s.xc, t.opaqueP)
-		xproto.FreePixmap(t.s.xc, t.opaqueM)
-	}
 	render.FreePicture(t.s.xc, t.xp)
 	xproto.FreePixmap(t.s.xc, t.xm)
 }
@@ -151,41 +141,8 @@
 		0, 0, 1 << 16,
 	})
 
-	minX := float64(sr.Min.X)
-	maxX := float64(sr.Max.X)
-	minY := float64(sr.Min.Y)
-	maxY := float64(sr.Max.Y)
-	points := [4]render.Pointfix{{
-		f64ToFixed(src2dst[0]*minX + src2dst[1]*minY + src2dst[2]),
-		f64ToFixed(src2dst[3]*minX + src2dst[4]*minY + src2dst[5]),
-	}, {
-		f64ToFixed(src2dst[0]*maxX + src2dst[1]*minY + src2dst[2]),
-		f64ToFixed(src2dst[3]*maxX + src2dst[4]*minY + src2dst[5]),
-	}, {
-		f64ToFixed(src2dst[0]*maxX + src2dst[1]*maxY + src2dst[2]),
-		f64ToFixed(src2dst[3]*maxX + src2dst[4]*maxY + src2dst[5]),
-	}, {
-		f64ToFixed(src2dst[0]*minX + src2dst[1]*maxY + src2dst[2]),
-		f64ToFixed(src2dst[3]*minX + src2dst[4]*maxY + src2dst[5]),
-	}}
-
+	points := trifanPoints(src2dst, sr)
 	if op == draw.Src {
-		// Lazily create the opaque mask picture.
-		if !t.opaqueCreated {
-			t.opaqueCreated = true
-			xproto.CreatePixmap(t.s.xc, textureDepth, t.opaqueM, xproto.Drawable(t.s.window32), 1, 1)
-			render.CreatePicture(t.s.xc, t.opaqueP, xproto.Drawable(t.opaqueM), t.s.pictformat32, 0, nil)
-			render.FillRectangles(t.s.xc, render.PictOpSrc, t.opaqueP, render.Color{
-				Red:   0xffff,
-				Green: 0xffff,
-				Blue:  0xffff,
-				Alpha: 0xffff,
-			}, []xproto.Rectangle{{
-				Width:  1,
-				Height: 1,
-			}})
-		}
-
 		// render.TriFan visits every dst-space pixel in the axis-aligned
 		// bounding box (AABB) containing the transformation of the sr
 		// rectangle in src-space to a quad in dst-space.
@@ -210,18 +167,31 @@
 		// What X11/Render calls PictOpOutReverse is also known as dst-out. See
 		// http://www.w3.org/TR/SVGCompositing/examples/compop-porterduff-examples.png
 		// for a visualization.
-		invW := 1 / float64(sr.Dx())
-		invH := 1 / float64(sr.Dy())
-		render.SetPictureTransform(t.s.xc, t.opaqueP, render.Transform{
-			f64ToFixed(invW * dst2src[0]), f64ToFixed(invW * dst2src[1]), 0,
-			f64ToFixed(invH * dst2src[3]), f64ToFixed(invH * dst2src[4]), 0,
-			0, 0, 1 << 16,
-		})
-		render.TriFan(t.s.xc, render.PictOpOutReverse, t.opaqueP, xp, 0, 0, 0, points[:])
+		render.TriFan(t.s.xc, render.PictOpOutReverse, t.s.opaqueP, xp, 0, 0, 0, points[:])
 	}
 	render.TriFan(t.s.xc, render.PictOpOver, t.xp, xp, 0, 0, 0, points[:])
 }
 
+func trifanPoints(src2dst *f64.Aff3, sr image.Rectangle) [4]render.Pointfix {
+	minX := float64(sr.Min.X)
+	maxX := float64(sr.Max.X)
+	minY := float64(sr.Min.Y)
+	maxY := float64(sr.Max.Y)
+	return [4]render.Pointfix{{
+		f64ToFixed(src2dst[0]*minX + src2dst[1]*minY + src2dst[2]),
+		f64ToFixed(src2dst[3]*minX + src2dst[4]*minY + src2dst[5]),
+	}, {
+		f64ToFixed(src2dst[0]*maxX + src2dst[1]*minY + src2dst[2]),
+		f64ToFixed(src2dst[3]*maxX + src2dst[4]*minY + src2dst[5]),
+	}, {
+		f64ToFixed(src2dst[0]*maxX + src2dst[1]*maxY + src2dst[2]),
+		f64ToFixed(src2dst[3]*maxX + src2dst[4]*maxY + src2dst[5]),
+	}, {
+		f64ToFixed(src2dst[0]*minX + src2dst[1]*maxY + src2dst[2]),
+		f64ToFixed(src2dst[3]*minX + src2dst[4]*maxY + src2dst[5]),
+	}}
+}
+
 func renderOp(op draw.Op) byte {
 	if op == draw.Src {
 		return render.PictOpSrc
diff --git a/shiny/driver/x11driver/window.go b/shiny/driver/x11driver/window.go
index 3f5ca90..9234d0f 100644
--- a/shiny/driver/x11driver/window.go
+++ b/shiny/driver/x11driver/window.go
@@ -74,6 +74,10 @@
 	fill(w.s.xc, w.xp, dr, src, op)
 }
 
+func (w *windowImpl) DrawUniform(src2dst f64.Aff3, src color.Color, sr image.Rectangle, op draw.Op, opts *screen.DrawOptions) {
+	w.s.drawUniform(w.xp, &src2dst, src, sr, op, opts)
+}
+
 func (w *windowImpl) Draw(src2dst f64.Aff3, src screen.Texture, sr image.Rectangle, op draw.Op, opts *screen.DrawOptions) {
 	src.(*textureImpl).draw(w.xp, &src2dst, sr, op, opts)
 }
diff --git a/shiny/example/basic/main.go b/shiny/example/basic/main.go
index fe789fa..c3d7ee4 100644
--- a/shiny/example/basic/main.go
+++ b/shiny/example/basic/main.go
@@ -33,6 +33,7 @@
 	blue1    = color.RGBA{0x00, 0x00, 0x3f, 0xff}
 	darkGray = color.RGBA{0x3f, 0x3f, 0x3f, 0xff}
 	red      = color.RGBA{0x7f, 0x00, 0x00, 0x7f}
+	yellow   = color.RGBA{0x3f, 0x3f, 0x00, 0x3f}
 
 	cos30 = math.Cos(math.Pi / 6)
 	sin30 = math.Sin(math.Pi / 6)
@@ -110,6 +111,7 @@
 					+0.5 * sin30, +1.0 * cos30, 200,
 				}
 				w.Draw(src2dst, t, tRect, op, nil)
+				w.DrawUniform(src2dst, yellow, tRect.Inset(30), screen.Over, nil)
 
 				// Draw crosses at the transformed corners of tRect.
 				for _, sx := range []int{tRect.Min.X, tRect.Max.X} {
diff --git a/shiny/screen/screen.go b/shiny/screen/screen.go
index c0dd9a5..cbc1cb4 100644
--- a/shiny/screen/screen.go
+++ b/shiny/screen/screen.go
@@ -290,6 +290,10 @@
 	// (m00*sx + m01*sy + m02, m10*sx + m11*sy + m12).
 	Draw(src2dst f64.Aff3, src Texture, sr image.Rectangle, op draw.Op, opts *DrawOptions)
 
+	// DrawUniform is like Draw except that the src is a uniform color instead
+	// of a Texture.
+	DrawUniform(src2dst f64.Aff3, src color.Color, sr image.Rectangle, op draw.Op, opts *DrawOptions)
+
 	// Copy copies the sub-Texture defined by src and sr to the destination
 	// (the method receiver), such that sr.Min in src-space aligns with dp in
 	// dst-space.