diff --git a/internal/gobj/gobj.go b/internal/gobj/gobj.go
new file mode 100644
index 00000000..fccaaa9a
--- /dev/null
+++ b/internal/gobj/gobj.go
@@ -0,0 +1,260 @@
+// Package gobj registers Go-backed GObject types. It is the only place
+// that touches type registration, class vfuncs, and the map from
+// instance pointers to Go values.
+package gobj
+
+import (
+	"cmp"
+	"fmt"
+	"reflect"
+	"sync"
+	"unsafe"
+
+	"codeberg.org/puregotk/puregotk/v4/glib"
+	"codeberg.org/puregotk/puregotk/v4/gobject"
+	"codeberg.org/puregotk/puregotk/v4/gobject/types"
+	"codeberg.org/puregotk/puregotk/v4/gtk"
+	"deedles.dev/trayscale/internal/gutil"
+)
+
+// Base is embedded in every Go-backed widget. gobj sets it before any
+// Go code sees the struct.
+type Base struct{ ptr uintptr }
+
+func (b *Base) base() *Base { return b }
+
+// GoPointer returns the instance pointer, so a *T can be passed where
+// puregotk wants a gobject.Ptr.
+func (b *Base) GoPointer() uintptr { return b.ptr }
+
+// SetGoPointer exists to satisfy gobject.Ptr. Changing the instance of
+// a Go-backed widget makes no sense, so it panics.
+func (b *Base) SetGoPointer(uintptr) { panic("gobj: SetGoPointer on a Go-backed widget") }
+
+// Widget returns the instance as a borrowed *gtk.Widget.
+func (b *Base) Widget() *gtk.Widget { return gtk.WidgetNewFromInternalPtr(b.ptr) }
+
+// Disposer is optional. Dispose runs once, from the class dispose,
+// while template children are still alive.
+type Disposer interface{ Dispose() }
+
+// WidgetSpec describes one widget subclass. Template is a full .ui
+// document whose <template class> must equal Name.
+type WidgetSpec struct {
+	Name     string
+	Parent   func() types.GType
+	Template string
+}
+
+type child struct {
+	field int
+	name  string
+	gtype string
+}
+
+type instance[T any] struct {
+	v        *T
+	disposed bool
+}
+
+// Class is a registered widget type whose instances carry a T.
+type Class[T any] struct {
+	spec     WidgetSpec
+	children []child
+	once     sync.Once
+	gtype    types.GType
+	parent   *gobject.ObjectClass
+	checked  bool
+
+	mu        sync.Mutex
+	instances map[uintptr]*instance[T]
+}
+
+var classes sync.Map // reflect.Type -> *Class[T]
+
+// Widget declares T as a widget subclass. The type is registered on
+// first use, so declaration order does not matter. T must embed Base
+// and must be declared once. T's exported pointer fields to puregotk
+// object types are filled with the template child named by their `gtk`
+// tag, or by the field name if untagged, borrowed from the widget. A
+// tag of "-" skips the field.
+func Widget[T any, P interface {
+	*T
+	base() *Base
+}](spec WidgetSpec) *Class[T] {
+	c := &Class[T]{spec: spec, instances: map[uintptr]*instance[T]{}}
+	rt := reflect.TypeFor[T]()
+	for i := range rt.NumField() {
+		f := rt.Field(i)
+		name := cmp.Or(f.Tag.Get("gtk"), f.Name)
+		if !f.IsExported() || name == "-" || f.Type.Kind() != reflect.Pointer {
+			continue
+		}
+		gtype, ok := typeName(f.Type.Elem())
+		if !ok {
+			continue
+		}
+		c.children = append(c.children, child{field: i, name: name, gtype: gtype})
+	}
+	if _, dup := classes.LoadOrStore(rt, c); dup {
+		panic(fmt.Sprintf("gobj: %v declared twice", rt))
+	}
+	return c
+}
+
+var prefixes = map[string]string{
+	"codeberg.org/puregotk/puregotk/v4/gtk":     "Gtk",
+	"codeberg.org/puregotk/puregotk/v4/adw":     "Adw",
+	"codeberg.org/puregotk/puregotk/v4/gio":     "G",
+	"codeberg.org/puregotk/puregotk/v4/gobject": "G",
+}
+
+// typeName maps a puregotk wrapper type to its GType name, which
+// puregotk derives the same way, so no hand-kept registry is needed.
+func typeName(t reflect.Type) (string, bool) {
+	p, ok := prefixes[t.PkgPath()]
+	return p + t.Name(), ok
+}
+
+// GType returns the registered type, registering it if needed.
+func (c *Class[T]) GType() types.GType {
+	c.once.Do(c.register)
+	return c.gtype
+}
+
+func (c *Class[T]) register() {
+	var classInit gobject.ClassInitFunc = func(tc *gobject.TypeClass, _ uintptr) {
+		c.parent = (*gobject.ObjectClass)(unsafe.Pointer(tc.PeekParent()))
+		wc := (*gtk.WidgetClass)(unsafe.Pointer(tc))
+		// SetTemplate doesn't take our reference: GTK keeps a precompiled
+		// copy, so the bytes must be dropped here.
+		tmpl := glib.NewBytes([]byte(c.spec.Template), uint(len(c.spec.Template)))
+		wc.SetTemplate(tmpl)
+		tmpl.Unref()
+		for _, ch := range c.children {
+			wc.BindTemplateChildFull(ch.name, false, 0)
+		}
+		oc := (*gobject.ObjectClass)(unsafe.Pointer(tc))
+		oc.OverrideDispose(c.dispose)
+		oc.OverrideFinalize(c.finalize)
+	}
+	var instInit gobject.InstanceInitFunc = func(ti *gobject.TypeInstance, _ *gobject.TypeClass) {
+		c.init(ti.GoPointer())
+	}
+	var q gobject.TypeQuery
+	gobject.NewTypeQuery(c.spec.Parent(), &q)
+	c.gtype = gobject.TypeRegisterStaticSimple(q.Type, c.spec.Name, q.ClassSize, &classInit, q.InstanceSize, &instInit, 0)
+	if c.gtype == 0 {
+		panic(fmt.Sprintf("gobj: registering %s on %s (class %d, instance %d) failed", c.spec.Name, gobject.TypeName(q.Type), q.ClassSize, q.InstanceSize))
+	}
+}
+
+func (c *Class[T]) init(p uintptr) {
+	w := gtk.WidgetNewFromInternalPtr(p)
+	w.InitTemplate()
+
+	v := new(T)
+	any(v).(interface{ base() *Base }).base().ptr = p
+	rv := reflect.ValueOf(v).Elem()
+	for _, ch := range c.children {
+		obj := w.GetTemplateChild(c.gtype, ch.name)
+		if obj == nil {
+			panic(fmt.Sprintf("gobj: %s template has no child %q", c.spec.Name, ch.name))
+		}
+		if !c.checked {
+			want := gobject.TypeFromName(ch.gtype)
+			if want == 0 || !gutil.IsA(obj, want) {
+				panic(fmt.Sprintf("gobj: %s child %q is a %s, want %s", c.spec.Name, ch.name, gutil.TypeName(obj), ch.gtype))
+			}
+		}
+		fv := rv.Field(ch.field)
+		nv := reflect.New(fv.Type().Elem())
+		nv.Interface().(gobject.Ptr).SetGoPointer(obj.GoPointer())
+		fv.Set(nv)
+		// puregotk refs the transfer-none result. The template keeps
+		// the child alive until dispose, so the field borrows it.
+		obj.Unref()
+	}
+	c.checked = true
+
+	c.mu.Lock()
+	c.instances[p] = &instance[T]{v: v}
+	c.mu.Unlock()
+}
+
+func (c *Class[T]) dispose(o *gobject.Object) {
+	p := o.GoPointer()
+	c.mu.Lock()
+	inst := c.instances[p]
+	first := inst != nil && !inst.disposed
+	if first {
+		inst.disposed = true
+	}
+	c.mu.Unlock()
+	if first {
+		if d, ok := any(inst.v).(Disposer); ok {
+			d.Dispose()
+		}
+	}
+	// No gtk_widget_dispose_template: it would unparent and free a
+	// child that a parent such as AdwBin still points to. GtkWidget's
+	// own dispose drops the template's references after the parent
+	// class has released its children.
+	c.parent.GetDispose()(o)
+}
+
+func (c *Class[T]) finalize(o *gobject.Object) {
+	c.mu.Lock()
+	delete(c.instances, o.GoPointer())
+	c.mu.Unlock()
+	c.parent.GetFinalize()(o)
+}
+
+// New returns a new instance. The caller owns one strong, non-floating
+// reference to it.
+func (c *Class[T]) New() *T {
+	o := gobject.NewObjectWithProperties(c.GType(), 0, nil, nil)
+	switch {
+	case o.IsFloating():
+		// puregotk's RefSink takes an extra reference on top of the
+		// sunk floating one.
+		o.RefSink().Unref()
+	case gobject.TypeIsA(c.gtype, gobject.InitiallyUnownedGLibType()):
+		// Already sunk by its own init, as GtkWindow is, so the only
+		// reference belongs to GTK.
+		o.Ref()
+	}
+	v, _ := c.lookup(o.GoPointer())
+	return v
+}
+
+func (c *Class[T]) lookup(p uintptr) (*T, bool) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	inst, ok := c.instances[p]
+	if !ok {
+		return nil, false
+	}
+	return inst.v, true
+}
+
+// Lookup returns the Go value for a borrowed instance of T, or false
+// if obj is nil or not a T.
+func Lookup[T any](obj gobject.Ptr) (*T, bool) {
+	if obj == nil || reflect.ValueOf(obj).IsNil() || obj.GoPointer() == 0 {
+		return nil, false
+	}
+	c, ok := classes.Load(reflect.TypeFor[T]())
+	if !ok {
+		return nil, false
+	}
+	return c.(*Class[T]).lookup(obj.GoPointer())
+}
+
+// live reports the number of instances whose Go value is still held.
+// For tests.
+func (c *Class[T]) live() int {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return len(c.instances)
+}
diff --git a/internal/gobj/gobj_test.go b/internal/gobj/gobj_test.go
new file mode 100644
index 00000000..5dde5406
--- /dev/null
+++ b/internal/gobj/gobj_test.go
@@ -0,0 +1,180 @@
+package gobj
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"strings"
+	"sync"
+	"testing"
+
+	"codeberg.org/puregotk/puregotk/v4/adw"
+	"codeberg.org/puregotk/puregotk/v4/gtk"
+	"deedles.dev/trayscale/internal/gutil"
+)
+
+var initGTK = sync.OnceValue(func() bool {
+	os.Setenv("GSK_RENDERER", "cairo")
+	if !gtk.InitCheck() {
+		return false
+	}
+	adw.Init()
+	return true
+})
+
+func requireGTK(t *testing.T) {
+	t.Helper()
+	if !initGTK() {
+		t.Skip("no display")
+	}
+}
+
+func TestMain(m *testing.M) {
+	code := m.Run()
+	runtime.GC()
+	os.Exit(code)
+}
+
+const testRowXML = `<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+  <template class="GobjTestRow" parent="AdwBin">
+    <property name="child">
+      <object class="GtkLabel" id="Label">
+        <property name="label">unset</property>
+      </object>
+    </property>
+  </template>
+</interface>`
+
+type testRow struct {
+	Base
+	Label *gtk.Label
+
+	disposed *int
+}
+
+func (r *testRow) Dispose() {
+	// Template children are still alive here.
+	r.Label.SetLabel("disposed")
+	if r.disposed != nil {
+		*r.disposed++
+	}
+}
+
+var testRowClass = Widget[testRow](WidgetSpec{
+	Name:     "GobjTestRow",
+	Parent:   adw.BinGLibType,
+	Template: testRowXML,
+})
+
+func TestNewBindsTemplate(t *testing.T) {
+	requireGTK(t)
+
+	r := testRowClass.New()
+	defer r.Widget().Unref()
+	if got := r.Label.GetLabel(); got != "unset" {
+		t.Fatalf("label = %q, want %q", got, "unset")
+	}
+	if r.Widget().IsFloating() {
+		t.Fatal("New returned a floating instance")
+	}
+	got, ok := Lookup[testRow](r)
+	if !ok || got != r {
+		t.Fatalf("Lookup = %p, %v; want %p", got, ok, r)
+	}
+	if _, ok := Lookup[testRow](gtk.NewLabel("x")); ok {
+		t.Fatal("Lookup found a testRow for a plain label")
+	}
+}
+
+func TestBuilderInstantiatesClass(t *testing.T) {
+	requireGTK(t)
+
+	testRowClass.GType()
+	b := gtk.NewBuilderFromString(`<interface><object class="GobjTestRow" id="row"/></interface>`, -1)
+	obj := b.GetObject("row")
+	b.Unref()
+	defer obj.Unref()
+	r, ok := Lookup[testRow](obj)
+	if !ok || r.Label.GetLabel() != "unset" {
+		t.Fatal("builder-made instance has no bound Go value")
+	}
+}
+
+func TestFinalizeFreesState(t *testing.T) {
+	requireGTK(t)
+
+	const n = 5000
+	// class_init's slots come once per class, and OnFinalize's once.
+	warm := testRowClass.New()
+	gutil.OnFinalize(warm.Label, func() {})
+	warm.Widget().Unref()
+	before := gutil.FreeCallbackSlots()
+	disposed, children := 0, 0
+	for range n {
+		r := testRowClass.New()
+		r.disposed = &disposed
+		gutil.OnFinalize(r.Label, func() { children++ })
+		r.Widget().Unref()
+	}
+	if after := gutil.FreeCallbackSlots(); after != before {
+		t.Errorf("free callback slots %d -> %d over %d instances", before, after, n)
+	}
+	if disposed != n {
+		t.Errorf("Dispose ran %d times, want %d", disposed, n)
+	}
+	if children != n {
+		t.Errorf("%d template children finalized, want %d", children, n)
+	}
+	if live := testRowClass.live(); live != 0 {
+		t.Errorf("%d instances still in the Go map after finalize", live)
+	}
+}
+
+type wrongRow struct {
+	Base
+	Label *gtk.Button
+}
+
+var wrongRowClass = Widget[wrongRow](WidgetSpec{
+	Name:     "GobjTestWrongRow",
+	Parent:   adw.BinGLibType,
+	Template: strings.ReplaceAll(testRowXML, "GobjTestRow", "GobjTestWrongRow"),
+})
+
+func TestWrongChildTypePanics(t *testing.T) {
+	requireGTK(t)
+
+	defer func() {
+		if r := recover(); r == nil || !strings.Contains(fmt.Sprint(r), "want GtkButton") {
+			t.Fatalf("recovered %v, want a child type panic", r)
+		}
+	}()
+	wrongRowClass.New()
+}
+
+type testWindow struct{ Base }
+
+var testWindowClass = Widget[testWindow](WidgetSpec{
+	Name:     "GobjTestWindow",
+	Parent:   gtk.WindowGLibType,
+	Template: `<interface><template class="GobjTestWindow" parent="GtkWindow"/></interface>`,
+})
+
+// TestNewOwnsWindow checks that New hands back an owned reference even
+// for a type whose init sinks itself, as GtkWindow does.
+func TestNewOwnsWindow(t *testing.T) {
+	requireGTK(t)
+
+	w := testWindowClass.New()
+	finalized := 0
+	gutil.OnFinalize(w, func() { finalized++ })
+	gtk.WindowNewFromInternalPtr(w.GoPointer()).Destroy()
+	if finalized != 0 {
+		t.Fatal("window finalized while the caller still owned it")
+	}
+	w.Widget().Unref()
+	if finalized != 1 {
+		t.Fatalf("window finalized %d times after the last unref, want 1", finalized)
+	}
+}
diff --git a/internal/gobj/list.go b/internal/gobj/list.go
new file mode 100644
index 00000000..dbed18d3
--- /dev/null
+++ b/internal/gobj/list.go
@@ -0,0 +1,167 @@
+package gobj
+
+import (
+	"iter"
+	"slices"
+	"sync"
+	"unsafe"
+
+	"codeberg.org/puregotk/puregotk/v4/gio"
+	"codeberg.org/puregotk/puregotk/v4/gobject"
+	"codeberg.org/puregotk/puregotk/v4/gobject/types"
+	"codeberg.org/puregotk/puregotk/v4/gtk"
+	"deedles.dev/trayscale/internal/gutil"
+)
+
+// Every List shares one item type. Each item's Go value lives in
+// items, keyed by the item's instance pointer, and is deleted when the
+// item is finalized, so no item costs a callback slot.
+var items = struct {
+	once   sync.Once
+	gtype  types.GType
+	parent *gobject.ObjectClass
+
+	sync.Mutex
+	values map[uintptr]any
+}{values: map[uintptr]any{}}
+
+func itemType() types.GType {
+	items.once.Do(func() {
+		var classInit gobject.ClassInitFunc = func(tc *gobject.TypeClass, _ uintptr) {
+			items.parent = (*gobject.ObjectClass)(unsafe.Pointer(tc.PeekParent()))
+			(*gobject.ObjectClass)(unsafe.Pointer(tc)).OverrideFinalize(func(o *gobject.Object) {
+				items.Lock()
+				delete(items.values, o.GoPointer())
+				items.Unlock()
+				items.parent.GetFinalize()(o)
+			})
+		}
+		var instInit gobject.InstanceInitFunc = func(*gobject.TypeInstance, *gobject.TypeClass) {}
+		var q gobject.TypeQuery
+		gobject.NewTypeQuery(gobject.ObjectGLibType(), &q)
+		items.gtype = gobject.TypeRegisterStaticSimple(q.Type, "TrayscaleListItem", q.ClassSize, &classInit, q.InstanceSize, &instInit, 0)
+	})
+	return items.gtype
+}
+
+func newItem(v any) *gobject.Object {
+	o := gobject.NewObjectWithProperties(itemType(), 0, nil, nil)
+	items.Lock()
+	items.values[o.GoPointer()] = v
+	items.Unlock()
+	return o
+}
+
+func setItem(p uintptr, v any) {
+	items.Lock()
+	items.values[p] = v
+	items.Unlock()
+}
+
+// Item returns the value carried by an item of a List's model, or of a
+// model wrapping it.
+func Item[T any](obj gobject.Ptr) T {
+	return itemAt[T](obj.GoPointer())
+}
+
+func itemAt[T any](p uintptr) T {
+	items.Lock()
+	defer items.Unlock()
+	return items.values[p].(T)
+}
+
+// List is a GListModel of Go values, kept sorted by cmp. Values that
+// compare equal are the same entry.
+//
+// The List owns its store; call Unref when done with it.
+type List[T comparable] struct {
+	store *gio.ListStore
+	cmp   func(T, T) int
+}
+
+// NewList returns an empty List ordered by cmp.
+func NewList[T comparable](cmp func(T, T) int) *List[T] {
+	return &List[T]{store: gio.NewListStore(itemType()), cmp: cmp}
+}
+
+// Unref drops the List's reference to its store.
+func (l *List[T]) Unref() { l.store.Unref() }
+
+// Model returns the underlying list model, borrowed from l.
+func (l *List[T]) Model() gio.ListModel { return l.store }
+
+// Len returns the number of entries.
+func (l *List[T]) Len() int { return int(l.store.GetNItems()) }
+
+func (l *List[T]) at(i uint32) (uintptr, T) {
+	p := l.store.GetItem(i)
+	v := itemAt[T](p)
+	gobject.ObjectNewFromInternalPtr(p).Unref()
+	return p, v
+}
+
+// All yields the values in order.
+func (l *List[T]) All() iter.Seq[T] {
+	return func(yield func(T) bool) {
+		for i := range l.store.GetNItems() {
+			if _, v := l.at(i); !yield(v) {
+				return
+			}
+		}
+	}
+}
+
+// Set makes values the contents of l. Entries that are unchanged keep
+// their items, so only rows for added, removed, or changed values are
+// rebuilt.
+func (l *List[T]) Set(values []T) {
+	want := slices.SortedStableFunc(slices.Values(values), l.cmp)
+	want = slices.CompactFunc(want, func(a, b T) bool { return l.cmp(a, b) == 0 })
+
+	var i uint32
+	for _, v := range want {
+		matched := false
+		for i < l.store.GetNItems() {
+			p, old := l.at(i)
+			c := l.cmp(old, v)
+			if c < 0 {
+				l.store.Remove(i)
+				continue
+			}
+			if c == 0 {
+				matched = true
+				if old != v {
+					setItem(p, v)
+					l.store.ItemsChanged(i, 1, 1)
+				}
+			}
+			break
+		}
+		if !matched {
+			o := newItem(v)
+			l.store.Insert(i, o)
+			o.Unref()
+		}
+		i++
+	}
+	if n := l.store.GetNItems(); i < n {
+		l.store.Splice(i, n-i, nil, 0)
+	}
+}
+
+// BindListBox binds lb to l, creating each row with row. row returns a
+// new widget that the list box takes over.
+func BindListBox[T comparable](lb *gtk.ListBox, l *List[T], row func(T) *gtk.Widget) {
+	create := func(item uintptr) uintptr {
+		w := row(itemAt[T](item))
+		// puregotk's constructors sink the floating reference. Hand
+		// ours back as floating, which the list box then sinks.
+		w.ForceFloating()
+		return w.GoPointer()
+	}
+	lb.BindModel(l.store, &listBoxCreate, gutil.Hold(create), &gutil.FreeData)
+}
+
+var listBoxCreate gtk.ListBoxCreateWidgetFunc = func(item, id uintptr) uintptr {
+	return gutil.Held[func(uintptr) uintptr](id)(item)
+}
diff --git a/internal/gobj/list_test.go b/internal/gobj/list_test.go
new file mode 100644
index 00000000..7643d2c7
--- /dev/null
+++ b/internal/gobj/list_test.go
@@ -0,0 +1,102 @@
+package gobj
+
+import (
+	"cmp"
+	"slices"
+	"strconv"
+	"testing"
+
+	"codeberg.org/puregotk/puregotk/v4/gtk"
+	"deedles.dev/trayscale/internal/gutil"
+)
+
+type entry struct {
+	key, val int
+}
+
+func byKey(a, b entry) int { return cmp.Compare(a.key, b.key) }
+
+func liveItems() int {
+	items.Lock()
+	defer items.Unlock()
+	return len(items.values)
+}
+
+func TestListSet(t *testing.T) {
+	requireGTK(t)
+
+	tests := []struct {
+		name        string
+		in, set     []entry
+		want        []entry
+		changedRows int
+	}{
+		{"empty", nil, []entry{{2, 0}, {1, 0}}, []entry{{1, 0}, {2, 0}}, 2},
+		{"remove", []entry{{1, 0}, {2, 0}, {3, 0}}, []entry{{2, 0}}, []entry{{2, 0}}, 0},
+		{"keep", []entry{{1, 0}, {2, 0}}, []entry{{2, 0}, {1, 0}}, []entry{{1, 0}, {2, 0}}, 0},
+		{"change", []entry{{1, 0}, {2, 0}}, []entry{{1, 0}, {2, 9}}, []entry{{1, 0}, {2, 9}}, 1},
+		{"mixed", []entry{{1, 0}, {3, 0}, {5, 0}}, []entry{{0, 0}, {3, 1}, {4, 0}, {6, 0}}, []entry{{0, 0}, {3, 1}, {4, 0}, {6, 0}}, 4},
+		{"duplicates", nil, []entry{{1, 0}, {1, 0}}, []entry{{1, 0}}, 1},
+		{"clear", []entry{{1, 0}, {2, 0}}, nil, nil, 0},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			l := NewList(byKey)
+			defer l.Unref()
+			l.Set(tt.in)
+
+			lb := gtk.NewListBox()
+			defer lb.Unref()
+			built := 0
+			BindListBox(lb, l, func(e entry) *gtk.Widget {
+				built++
+				return &gtk.NewLabel(strconv.Itoa(e.val)).Widget
+			})
+			built = 0
+
+			l.Set(tt.set)
+			if got := slices.Collect(l.All()); !slices.Equal(got, tt.want) {
+				t.Errorf("All() = %v, want %v", got, tt.want)
+			}
+			if built != tt.changedRows {
+				t.Errorf("rebuilt %d rows, want %d", built, tt.changedRows)
+			}
+			for i, e := range tt.want {
+				r := lb.GetRowAtIndex(int32(i))
+				l := gtk.LabelNewFromInternalPtr(r.GetChild().GoPointer())
+				if l.GetLabel() != strconv.Itoa(e.val) {
+					t.Errorf("row %d shows %q, want %d", i, l.GetLabel(), e.val)
+				}
+			}
+		})
+	}
+}
+
+func TestListFreesItems(t *testing.T) {
+	requireGTK(t)
+
+	const n = 2000
+	l := NewList(byKey)
+	lb := gtk.NewListBox()
+	BindListBox(lb, l, func(e entry) *gtk.Widget { return &gtk.NewLabel("").Widget })
+	before := gutil.FreeCallbackSlots()
+	base := liveItems()
+
+	es := make([]entry, n)
+	for i := range es {
+		es[i] = entry{i, 0}
+	}
+	l.Set(es)
+	if after := gutil.FreeCallbackSlots(); after != before {
+		t.Errorf("free callback slots %d -> %d over %d items", before, after, n)
+	}
+	l.Set(es[:n/2])
+	if got := liveItems() - base; got != n/2 {
+		t.Errorf("%d items live after removing half, want %d", got, n/2)
+	}
+	lb.Unref()
+	l.Unref()
+	if got := liveItems() - base; got != 0 {
+		t.Errorf("%d items live after dropping the list", got)
+	}
+}