diff --git a/app/api_topology.go b/app/api_topology.go
index ffa339e86..e0efd4e06 100644
--- a/app/api_topology.go
+++ b/app/api_topology.go
@@ -51,7 +51,7 @@ func handleNode(ctx context.Context, renderer render.Renderer, decorator render.
 	// To avoid repeating the work from step (1) in step (2), we
 	// replace the renderer in the latter with a constant renderer of
 	// the result obtained in step (1).
-	nodes := renderer.Render(rc.Report, nil)
+	nodes := renderer.Render(rc.Report)
 	node, ok := nodes.Nodes[nodeID]
 	if !ok {
 		http.NotFound(w, r)
diff --git a/render/benchmark_test.go b/render/benchmark_test.go
index 9be78cdd4..3ce56cb5d 100644
--- a/render/benchmark_test.go
+++ b/render/benchmark_test.go
@@ -52,7 +52,7 @@ func benchmarkRender(b *testing.B, r render.Renderer) {
 		b.StopTimer()
 		render.ResetCache()
 		b.StartTimer()
-		benchmarkRenderResult = r.Render(report, FilterNoop)
+		benchmarkRenderResult = r.Render(report)
 		if len(benchmarkRenderResult.Nodes) == 0 {
 			b.Errorf("Rendered topology contained no nodes")
 		}
diff --git a/render/container.go b/render/container.go
index 21fa42e0f..9c8c4424e 100644
--- a/render/container.go
+++ b/render/container.go
@@ -53,10 +53,10 @@ type connectionJoin struct {
 	r     Renderer
 }
 
-func (c connectionJoin) Render(rpt report.Report, dct Decorator) Nodes {
+func (c connectionJoin) Render(rpt report.Report) Nodes {
 	local := LocalNetworks(rpt)
-	inputNodes := c.r.Render(rpt, dct)
-	endpoints := SelectEndpoint.Render(rpt, dct)
+	inputNodes := c.r.Render(rpt)
+	endpoints := SelectEndpoint.Render(rpt)
 
 	// Collect all the IPs we are trying to map to, and which ID they map from
 	var ipNodes = map[string]string{}
@@ -131,9 +131,9 @@ type containerWithImageNameRenderer struct {
 
 // Render produces a container graph where the the latest metadata contains the
 // container image name, if found.
-func (r containerWithImageNameRenderer) Render(rpt report.Report, dct Decorator) Nodes {
-	containers := r.Renderer.Render(rpt, dct)
-	images := SelectContainerImage.Render(rpt, dct)
+func (r containerWithImageNameRenderer) Render(rpt report.Report) Nodes {
+	containers := r.Renderer.Render(rpt)
+	images := SelectContainerImage.Render(rpt)
 
 	outputs := report.Nodes{}
 	for id, c := range containers.Nodes {
diff --git a/render/container_test.go b/render/container_test.go
index 156a41ade..1001f17be 100644
--- a/render/container_test.go
+++ b/render/container_test.go
@@ -59,7 +59,7 @@ func testMap(t *testing.T, f render.MapFunc, input testcase) {
 }
 
 func TestContainerRenderer(t *testing.T) {
-	have := utils.Prune(render.ContainerWithImageNameRenderer.Render(fixture.Report, FilterNoop).Nodes)
+	have := utils.Prune(render.ContainerWithImageNameRenderer.Render(fixture.Report).Nodes)
 	want := utils.Prune(expected.RenderedContainers)
 	if !reflect.DeepEqual(want, have) {
 		t.Error(test.Diff(want, have))
diff --git a/render/detailed/node_test.go b/render/detailed/node_test.go
index 5d04cf2b9..719625241 100644
--- a/render/detailed/node_test.go
+++ b/render/detailed/node_test.go
@@ -18,7 +18,7 @@ import (
 )
 
 func child(t *testing.T, r render.Renderer, id string) detailed.NodeSummary {
-	s, ok := detailed.MakeNodeSummary(report.RenderContext{Report: fixture.Report}, r.Render(fixture.Report, nil).Nodes[id])
+	s, ok := detailed.MakeNodeSummary(report.RenderContext{Report: fixture.Report}, r.Render(fixture.Report).Nodes[id])
 	if !ok {
 		t.Fatalf("Expected node %s to be summarizable, but wasn't", id)
 	}
@@ -30,7 +30,7 @@ func connectionID(nodeID string, addr string) string {
 }
 
 func TestMakeDetailedHostNode(t *testing.T) {
-	renderableNodes := render.HostRenderer.Render(fixture.Report, nil).Nodes
+	renderableNodes := render.HostRenderer.Render(fixture.Report).Nodes
 	renderableNode := renderableNodes[fixture.ClientHostNodeID]
 	have := detailed.MakeNode("hosts", report.RenderContext{Report: fixture.Report}, renderableNodes, renderableNode)
 
@@ -178,7 +178,7 @@ func TestMakeDetailedHostNode(t *testing.T) {
 
 func TestMakeDetailedContainerNode(t *testing.T) {
 	id := fixture.ServerContainerNodeID
-	renderableNodes := render.ContainerWithImageNameRenderer.Render(fixture.Report, nil).Nodes
+	renderableNodes := render.ContainerWithImageNameRenderer.Render(fixture.Report).Nodes
 	renderableNode, ok := renderableNodes[id]
 	if !ok {
 		t.Fatalf("Node not found: %s", id)
@@ -308,7 +308,7 @@ func TestMakeDetailedContainerNode(t *testing.T) {
 
 func TestMakeDetailedPodNode(t *testing.T) {
 	id := fixture.ServerPodNodeID
-	renderableNodes := render.PodRenderer.Render(fixture.Report, nil).Nodes
+	renderableNodes := render.PodRenderer.Render(fixture.Report).Nodes
 	renderableNode, ok := renderableNodes[id]
 	if !ok {
 		t.Fatalf("Node not found: %s", id)
diff --git a/render/detailed/parents_test.go b/render/detailed/parents_test.go
index 28251d9c1..1a6cdf1d3 100644
--- a/render/detailed/parents_test.go
+++ b/render/detailed/parents_test.go
@@ -21,25 +21,25 @@ func TestParents(t *testing.T) {
 	}{
 		{
 			name: "Node accidentally tagged with itself",
-			node: render.HostRenderer.Render(fixture.Report, nil).Nodes[fixture.ClientHostNodeID].WithParents(
+			node: render.HostRenderer.Render(fixture.Report).Nodes[fixture.ClientHostNodeID].WithParents(
 				report.MakeSets().Add(report.Host, report.MakeStringSet(fixture.ClientHostNodeID)),
 			),
 			want: nil,
 		},
 		{
-			node: render.HostRenderer.Render(fixture.Report, nil).Nodes[fixture.ClientHostNodeID],
+			node: render.HostRenderer.Render(fixture.Report).Nodes[fixture.ClientHostNodeID],
 			want: nil,
 		},
 		{
 			name: "Container image",
-			node: render.ContainerImageRenderer.Render(fixture.Report, nil).Nodes[expected.ClientContainerImageNodeID],
+			node: render.ContainerImageRenderer.Render(fixture.Report).Nodes[expected.ClientContainerImageNodeID],
 			want: []detailed.Parent{
 				{ID: fixture.ClientHostNodeID, Label: fixture.ClientHostName, TopologyID: "hosts"},
 			},
 		},
 		{
 			name: "Container",
-			node: render.ContainerWithImageNameRenderer.Render(fixture.Report, nil).Nodes[fixture.ClientContainerNodeID],
+			node: render.ContainerWithImageNameRenderer.Render(fixture.Report).Nodes[fixture.ClientContainerNodeID],
 			want: []detailed.Parent{
 				{ID: expected.ClientContainerImageNodeID, Label: fixture.ClientContainerImageName, TopologyID: "containers-by-image"},
 				{ID: fixture.ClientHostNodeID, Label: fixture.ClientHostName, TopologyID: "hosts"},
@@ -47,7 +47,7 @@ func TestParents(t *testing.T) {
 			},
 		},
 		{
-			node: render.ProcessRenderer.Render(fixture.Report, nil).Nodes[fixture.ClientProcess1NodeID],
+			node: render.ProcessRenderer.Render(fixture.Report).Nodes[fixture.ClientProcess1NodeID],
 			want: []detailed.Parent{
 				{ID: fixture.ClientContainerNodeID, Label: fixture.ClientContainerName, TopologyID: "containers"},
 				{ID: fixture.ClientHostNodeID, Label: fixture.ClientHostName, TopologyID: "hosts"},
diff --git a/render/detailed/summary_test.go b/render/detailed/summary_test.go
index e04827f1a..9d142b4a2 100644
--- a/render/detailed/summary_test.go
+++ b/render/detailed/summary_test.go
@@ -21,7 +21,7 @@ import (
 func TestSummaries(t *testing.T) {
 	{
 		// Just a convenient source of some rendered nodes
-		have := detailed.Summaries(report.RenderContext{Report: fixture.Report}, render.ProcessRenderer.Render(fixture.Report, nil).Nodes)
+		have := detailed.Summaries(report.RenderContext{Report: fixture.Report}, render.ProcessRenderer.Render(fixture.Report).Nodes)
 		// The ids of the processes rendered above
 		expectedIDs := []string{
 			fixture.ClientProcess1NodeID,
@@ -51,7 +51,7 @@ func TestSummaries(t *testing.T) {
 		input := fixture.Report.Copy()
 
 		input.Process.Nodes[fixture.ClientProcess1NodeID].Metrics[process.CPUUsage] = metric
-		have := detailed.Summaries(report.RenderContext{Report: input}, render.ProcessRenderer.Render(input, nil).Nodes)
+		have := detailed.Summaries(report.RenderContext{Report: input}, render.ProcessRenderer.Render(input).Nodes)
 
 		node, ok := have[fixture.ClientProcess1NodeID]
 		if !ok {
diff --git a/render/filters.go b/render/filters.go
index 6bb888ec4..e09cdf2c5 100644
--- a/render/filters.go
+++ b/render/filters.go
@@ -23,8 +23,8 @@ type CustomRenderer struct {
 }
 
 // Render implements Renderer
-func (c CustomRenderer) Render(rpt report.Report, dct Decorator) Nodes {
-	return c.RenderFunc(c.Renderer.Render(rpt, dct))
+func (c CustomRenderer) Render(rpt report.Report) Nodes {
+	return c.RenderFunc(c.Renderer.Render(rpt))
 }
 
 // ColorConnected colors nodes with the IsConnected key if
@@ -123,15 +123,15 @@ func MakeFilterPseudoDecorator(f FilterFunc) Decorator {
 }
 
 // Render implements Renderer
-func (f Filter) Render(rpt report.Report, dct Decorator) Nodes {
-	return f.render(rpt, dct)
+func (f Filter) Render(rpt report.Report) Nodes {
+	return f.render(rpt)
 }
 
-func (f Filter) render(rpt report.Report, dct Decorator) Nodes {
+func (f Filter) render(rpt report.Report) Nodes {
 	output := report.Nodes{}
 	inDegrees := map[string]int{}
 	filtered := 0
-	for id, node := range f.Renderer.Render(rpt, dct).Nodes {
+	for id, node := range f.Renderer.Render(rpt).Nodes {
 		if f.FilterFunc(node) {
 			output[id] = node
 			inDegrees[id] = 0
diff --git a/render/filters_test.go b/render/filters_test.go
index 7e2f7434e..97a296287 100644
--- a/render/filters_test.go
+++ b/render/filters_test.go
@@ -16,7 +16,7 @@ func TestFilterRender(t *testing.T) {
 		"baz": report.MakeNode("baz"),
 	}}
 	have := report.MakeIDList()
-	for id := range renderer.Render(report.MakeReport(), render.FilterUnconnected).Nodes {
+	for id := range render.Decorate(report.MakeReport(), renderer, render.FilterUnconnected).Nodes {
 		have = have.Add(id)
 	}
 	want := report.MakeIDList("foo", "bar")
@@ -41,7 +41,7 @@ func TestFilterRender2(t *testing.T) {
 		"baz": report.MakeNode("baz"),
 	}}
 
-	have := renderer.Render(report.MakeReport(), filter).Nodes
+	have := render.Decorate(report.MakeReport(), renderer, filter).Nodes
 	if have["foo"].Adjacency.Contains("bar") {
 		t.Error("adjacencies for removed nodes should have been removed")
 	}
@@ -66,7 +66,7 @@ func TestFilterUnconnectedPseudoNodes(t *testing.T) {
 			}
 		}
 		want := nodes
-		have := renderer.Render(report.MakeReport(), filter).Nodes
+		have := render.Decorate(report.MakeReport(), renderer, filter).Nodes
 		if !reflect.DeepEqual(want, have) {
 			t.Error(test.Diff(want, have))
 		}
@@ -85,7 +85,7 @@ func TestFilterUnconnectedPseudoNodes(t *testing.T) {
 			"bar": report.MakeNode("bar").WithAdjacent("baz"),
 			"baz": report.MakeNode("baz").WithTopology(render.Pseudo),
 		}}
-		have := renderer.Render(report.MakeReport(), filter).Nodes
+		have := render.Decorate(report.MakeReport(), renderer, filter).Nodes
 		if _, ok := have["baz"]; ok {
 			t.Error("expected the unconnected pseudonode baz to have been removed")
 		}
@@ -104,7 +104,7 @@ func TestFilterUnconnectedPseudoNodes(t *testing.T) {
 			"bar": report.MakeNode("bar").WithAdjacent("foo"),
 			"baz": report.MakeNode("baz").WithTopology(render.Pseudo).WithAdjacent("bar"),
 		}}
-		have := renderer.Render(report.MakeReport(), filter).Nodes
+		have := render.Decorate(report.MakeReport(), renderer, filter).Nodes
 		if _, ok := have["baz"]; ok {
 			t.Error("expected the unconnected pseudonode baz to have been removed")
 		}
@@ -118,7 +118,7 @@ func TestFilterUnconnectedSelf(t *testing.T) {
 			"foo": report.MakeNode("foo").WithAdjacent("foo"),
 		}
 		renderer := mockRenderer{Nodes: nodes}
-		have := renderer.Render(report.MakeReport(), render.FilterUnconnected).Nodes
+		have := render.Decorate(report.MakeReport(), renderer, render.FilterUnconnected).Nodes
 		if len(have) > 0 {
 			t.Error("expected node only connected to self to be removed")
 		}
diff --git a/render/host.go b/render/host.go
index 44e19a36d..484142260 100644
--- a/render/host.go
+++ b/render/host.go
@@ -66,9 +66,9 @@ func MapX2Host(n report.Node, _ report.Networks) report.Nodes {
 type endpoints2Hosts struct {
 }
 
-func (e endpoints2Hosts) Render(rpt report.Report, dct Decorator) Nodes {
+func (e endpoints2Hosts) Render(rpt report.Report) Nodes {
 	local := LocalNetworks(rpt)
-	endpoints := SelectEndpoint.Render(rpt, dct)
+	endpoints := SelectEndpoint.Render(rpt)
 	ret := newJoinResults()
 
 	for _, n := range endpoints.Nodes {
diff --git a/render/host_test.go b/render/host_test.go
index 8596793b3..3f30188e6 100644
--- a/render/host_test.go
+++ b/render/host_test.go
@@ -12,7 +12,7 @@ import (
 )
 
 func TestHostRenderer(t *testing.T) {
-	have := utils.Prune(render.HostRenderer.Render(fixture.Report, FilterNoop).Nodes)
+	have := utils.Prune(render.HostRenderer.Render(fixture.Report).Nodes)
 	want := utils.Prune(expected.RenderedHosts)
 	if !reflect.DeepEqual(want, have) {
 		t.Error(test.Diff(want, have))
diff --git a/render/memoise.go b/render/memoise.go
index 55cfdab3e..e4121cea9 100644
--- a/render/memoise.go
+++ b/render/memoise.go
@@ -37,13 +37,7 @@ func Memoise(r Renderer) Renderer {
 // retrieves a promise from the cache and returns its value, otherwise
 // it stores a new promise and fulfils it by calling through to
 // m.Renderer.
-//
-// The cache is bypassed when rendering a report with a decorator.
-func (m *memoise) Render(rpt report.Report, dct Decorator) Nodes {
-	if dct != nil {
-		return m.Renderer.Render(rpt, dct)
-	}
-
+func (m *memoise) Render(rpt report.Report) Nodes {
 	key := fmt.Sprintf("%s-%s", rpt.ID, m.id)
 
 	m.Lock()
@@ -56,7 +50,7 @@ func (m *memoise) Render(rpt report.Report, dct Decorator) Nodes {
 	renderCache.Set(key, promise)
 	m.Unlock()
 
-	output := m.Renderer.Render(rpt, dct)
+	output := m.Renderer.Render(rpt)
 
 	promise.Set(output)
 
diff --git a/render/memoise_test.go b/render/memoise_test.go
index ea1acfd5f..9d7954ae9 100644
--- a/render/memoise_test.go
+++ b/render/memoise_test.go
@@ -11,7 +11,7 @@ import (
 
 type renderFunc func(r report.Report) render.Nodes
 
-func (f renderFunc) Render(r report.Report, _ render.Decorator) render.Nodes { return f(r) }
+func (f renderFunc) Render(r report.Report) render.Nodes { return f(r) }
 
 func TestMemoise(t *testing.T) {
 	calls := 0
@@ -22,7 +22,7 @@ func TestMemoise(t *testing.T) {
 	m := render.Memoise(r)
 	rpt1 := report.MakeReport()
 
-	result1 := m.Render(rpt1, nil)
+	result1 := m.Render(rpt1)
 	// it should have rendered it.
 	if _, ok := result1.Nodes[rpt1.ID]; !ok {
 		t.Errorf("Expected rendered report to contain a node, but got: %v", result1)
@@ -31,7 +31,7 @@ func TestMemoise(t *testing.T) {
 		t.Errorf("Expected renderer to have been called the first time")
 	}
 
-	result2 := m.Render(rpt1, nil)
+	result2 := m.Render(rpt1)
 	if !reflect.DeepEqual(result1, result2) {
 		t.Errorf("Expected memoised result to be returned: %s", test.Diff(result1, result2))
 	}
@@ -40,7 +40,7 @@ func TestMemoise(t *testing.T) {
 	}
 
 	rpt2 := report.MakeReport()
-	result3 := m.Render(rpt2, nil)
+	result3 := m.Render(rpt2)
 	if reflect.DeepEqual(result1, result3) {
 		t.Errorf("Expected different result for different report, but were the same")
 	}
@@ -49,7 +49,7 @@ func TestMemoise(t *testing.T) {
 	}
 
 	render.ResetCache()
-	result4 := m.Render(rpt1, nil)
+	result4 := m.Render(rpt1)
 	if !reflect.DeepEqual(result1, result4) {
 		t.Errorf("Expected original result to be returned: %s", test.Diff(result1, result4))
 	}
diff --git a/render/pod.go b/render/pod.go
index ccff7fbaa..a9ee1e73d 100644
--- a/render/pod.go
+++ b/render/pod.go
@@ -117,7 +117,7 @@ func renderParents(childTopology string, parentTopologies []string, noParentsPse
 // to deployments where applicable.
 type selectPodsWithDeployments struct{}
 
-func (s selectPodsWithDeployments) Render(rpt report.Report, dct Decorator) Nodes {
+func (s selectPodsWithDeployments) Render(rpt report.Report) Nodes {
 	result := report.Nodes{}
 	// For each pod, we check for any replica sets, and merge any deployments they point to
 	// into a replacement Parents value.
diff --git a/render/pod_test.go b/render/pod_test.go
index 92a7d3a9c..67264fe4b 100644
--- a/render/pod_test.go
+++ b/render/pod_test.go
@@ -13,7 +13,7 @@ import (
 )
 
 func TestPodRenderer(t *testing.T) {
-	have := utils.Prune(render.PodRenderer.Render(fixture.Report, nil).Nodes)
+	have := utils.Prune(render.PodRenderer.Render(fixture.Report).Nodes)
 	want := utils.Prune(expected.RenderedPods)
 	if !reflect.DeepEqual(want, have) {
 		t.Error(test.Diff(want, have))
@@ -41,7 +41,7 @@ func TestPodFilterRenderer(t *testing.T) {
 }
 
 func TestPodServiceRenderer(t *testing.T) {
-	have := utils.Prune(render.PodServiceRenderer.Render(fixture.Report, nil).Nodes)
+	have := utils.Prune(render.PodServiceRenderer.Render(fixture.Report).Nodes)
 	want := utils.Prune(expected.RenderedPodServices)
 	if !reflect.DeepEqual(want, have) {
 		t.Error(test.Diff(want, have))
diff --git a/render/process.go b/render/process.go
index c2415bbc7..ad174a9ad 100644
--- a/render/process.go
+++ b/render/process.go
@@ -40,9 +40,9 @@ type processWithContainerNameRenderer struct {
 	Renderer
 }
 
-func (r processWithContainerNameRenderer) Render(rpt report.Report, dct Decorator) Nodes {
-	processes := r.Renderer.Render(rpt, dct)
-	containers := SelectContainer.Render(rpt, dct)
+func (r processWithContainerNameRenderer) Render(rpt report.Report) Nodes {
+	processes := r.Renderer.Render(rpt)
+	containers := SelectContainer.Render(rpt)
 
 	outputs := report.Nodes{}
 	for id, p := range processes.Nodes {
@@ -86,13 +86,13 @@ var ProcessNameRenderer = ConditionalRenderer(renderProcesses,
 type endpoints2Processes struct {
 }
 
-func (e endpoints2Processes) Render(rpt report.Report, dct Decorator) Nodes {
+func (e endpoints2Processes) Render(rpt report.Report) Nodes {
 	if len(rpt.Process.Nodes) == 0 {
 		return Nodes{}
 	}
 	local := LocalNetworks(rpt)
-	processes := SelectProcess.Render(rpt, dct)
-	endpoints := SelectEndpoint.Render(rpt, dct)
+	processes := SelectProcess.Render(rpt)
+	endpoints := SelectEndpoint.Render(rpt)
 	ret := newJoinResults()
 
 	for _, n := range endpoints.Nodes {
diff --git a/render/process_test.go b/render/process_test.go
index 0cbbf0c4e..cdef54a15 100644
--- a/render/process_test.go
+++ b/render/process_test.go
@@ -12,7 +12,7 @@ import (
 )
 
 func TestEndpointRenderer(t *testing.T) {
-	have := utils.Prune(render.EndpointRenderer.Render(fixture.Report, FilterNoop).Nodes)
+	have := utils.Prune(render.EndpointRenderer.Render(fixture.Report).Nodes)
 	want := utils.Prune(expected.RenderedEndpoints)
 	if !reflect.DeepEqual(want, have) {
 		t.Error(test.Diff(want, have))
@@ -20,7 +20,7 @@ func TestEndpointRenderer(t *testing.T) {
 }
 
 func TestProcessRenderer(t *testing.T) {
-	have := utils.Prune(render.ProcessRenderer.Render(fixture.Report, FilterNoop).Nodes)
+	have := utils.Prune(render.ProcessRenderer.Render(fixture.Report).Nodes)
 	want := utils.Prune(expected.RenderedProcesses)
 	if !reflect.DeepEqual(want, have) {
 		t.Error(test.Diff(want, have))
@@ -28,7 +28,7 @@ func TestProcessRenderer(t *testing.T) {
 }
 
 func TestProcessNameRenderer(t *testing.T) {
-	have := utils.Prune(render.ProcessNameRenderer.Render(fixture.Report, FilterNoop).Nodes)
+	have := utils.Prune(render.ProcessNameRenderer.Render(fixture.Report).Nodes)
 	want := utils.Prune(expected.RenderedProcessNames)
 	if !reflect.DeepEqual(want, have) {
 		t.Error(test.Diff(want, have))
diff --git a/render/render.go b/render/render.go
index 317901d01..4379e829f 100644
--- a/render/render.go
+++ b/render/render.go
@@ -12,7 +12,7 @@ type MapFunc func(report.Node, report.Networks) report.Nodes
 
 // Renderer is something that can render a report to a set of Nodes.
 type Renderer interface {
-	Render(report.Report, Decorator) Nodes
+	Render(report.Report) Nodes
 }
 
 // Nodes is the result of Rendering
@@ -34,7 +34,7 @@ func Decorate(rpt report.Report, renderer Renderer, dct Decorator) Nodes {
 	if dct != nil {
 		renderer = dct(renderer)
 	}
-	return renderer.Render(rpt, nil)
+	return renderer.Render(rpt)
 }
 
 // Reduce renderer is a Renderer which merges together the output of several
@@ -47,7 +47,7 @@ func MakeReduce(renderers ...Renderer) Renderer {
 }
 
 // Render produces a set of Nodes given a Report.
-func (r Reduce) Render(rpt report.Report, dct Decorator) Nodes {
+func (r Reduce) Render(rpt report.Report) Nodes {
 	l := len(r)
 	switch l {
 	case 0:
@@ -57,7 +57,7 @@ func (r Reduce) Render(rpt report.Report, dct Decorator) Nodes {
 	for _, renderer := range r {
 		renderer := renderer // Pike!!
 		go func() {
-			c <- renderer.Render(rpt, dct)
+			c <- renderer.Render(rpt)
 		}()
 	}
 	for ; l > 1; l-- {
@@ -83,9 +83,9 @@ func MakeMap(f MapFunc, r Renderer) Renderer {
 
 // Render transforms a set of Nodes produces by another Renderer.
 // using a map function
-func (m Map) Render(rpt report.Report, dct Decorator) Nodes {
+func (m Map) Render(rpt report.Report) Nodes {
 	var (
-		input         = m.Renderer.Render(rpt, dct)
+		input         = m.Renderer.Render(rpt)
 		output        = report.Nodes{}
 		mapped        = map[string]report.IDList{} // input node ID -> output node IDs
 		adjacencies   = map[string]report.IDList{} // output node ID -> input node Adjacencies
@@ -153,9 +153,9 @@ func ConditionalRenderer(c Condition, r Renderer) Renderer {
 	return conditionalRenderer{c, r}
 }
 
-func (cr conditionalRenderer) Render(rpt report.Report, dct Decorator) Nodes {
+func (cr conditionalRenderer) Render(rpt report.Report) Nodes {
 	if cr.Condition(rpt) {
-		return cr.Renderer.Render(rpt, dct)
+		return cr.Renderer.Render(rpt)
 	}
 	return Nodes{}
 }
@@ -166,7 +166,7 @@ type ConstantRenderer struct {
 }
 
 // Render implements Renderer
-func (c ConstantRenderer) Render(_ report.Report, _ Decorator) Nodes {
+func (c ConstantRenderer) Render(_ report.Report) Nodes {
 	return c.Nodes
 }
 
diff --git a/render/render_test.go b/render/render_test.go
index b671effb2..74c1a25f1 100644
--- a/render/render_test.go
+++ b/render/render_test.go
@@ -13,10 +13,7 @@ type mockRenderer struct {
 	report.Nodes
 }
 
-func (m mockRenderer) Render(rpt report.Report, d render.Decorator) render.Nodes {
-	if d != nil {
-		return d(mockRenderer{m.Nodes}).Render(rpt, nil)
-	}
+func (m mockRenderer) Render(rpt report.Report) render.Nodes {
 	return render.Nodes{Nodes: m.Nodes}
 }
 
@@ -30,7 +27,7 @@ func TestReduceRender(t *testing.T) {
 		"foo": report.MakeNode("foo"),
 		"bar": report.MakeNode("bar"),
 	}
-	have := renderer.Render(report.MakeReport(), FilterNoop).Nodes
+	have := renderer.Render(report.MakeReport()).Nodes
 	if !reflect.DeepEqual(want, have) {
 		t.Errorf("want %+v, have %+v", want, have)
 	}
@@ -47,7 +44,7 @@ func TestMapRender1(t *testing.T) {
 		}},
 	}
 	want := report.Nodes{}
-	have := mapper.Render(report.MakeReport(), FilterNoop).Nodes
+	have := mapper.Render(report.MakeReport()).Nodes
 	if !reflect.DeepEqual(want, have) {
 		t.Errorf("want %+v, have %+v", want, have)
 	}
@@ -69,7 +66,7 @@ func TestMapRender2(t *testing.T) {
 	want := report.Nodes{
 		"bar": report.MakeNode("bar"),
 	}
-	have := mapper.Render(report.MakeReport(), FilterNoop).Nodes
+	have := mapper.Render(report.MakeReport()).Nodes
 	if !reflect.DeepEqual(want, have) {
 		t.Error(test.Diff(want, have))
 	}
@@ -91,7 +88,7 @@ func TestMapRender3(t *testing.T) {
 		"_foo": report.MakeNode("_foo").WithAdjacent("_baz"),
 		"_baz": report.MakeNode("_baz").WithAdjacent("_foo"),
 	}
-	have := mapper.Render(report.MakeReport(), FilterNoop).Nodes
+	have := mapper.Render(report.MakeReport()).Nodes
 	if !reflect.DeepEqual(want, have) {
 		t.Error(test.Diff(want, have))
 	}
diff --git a/render/selectors.go b/render/selectors.go
index e134aad5b..6b80e0ac4 100644
--- a/render/selectors.go
+++ b/render/selectors.go
@@ -9,7 +9,7 @@ import (
 type TopologySelector string
 
 // Render implements Renderer
-func (t TopologySelector) Render(r report.Report, _ Decorator) Nodes {
+func (t TopologySelector) Render(r report.Report) Nodes {
 	topology, _ := r.Topology(string(t))
 	return Nodes{Nodes: topology.Nodes}
 }
diff --git a/render/short_lived_connections_test.go b/render/short_lived_connections_test.go
index ebf2fd37a..214344f3f 100644
--- a/render/short_lived_connections_test.go
+++ b/render/short_lived_connections_test.go
@@ -109,7 +109,7 @@ var (
 )
 
 func TestShortLivedInternetNodeConnections(t *testing.T) {
-	have := utils.Prune(render.ContainerWithImageNameRenderer.Render(rpt, FilterNoop).Nodes)
+	have := utils.Prune(render.ContainerWithImageNameRenderer.Render(rpt).Nodes)
 
 	// Conntracked-only connections from the internet should be assigned to the internet pseudonode
 	internet, ok := have[render.IncomingInternetID]
@@ -123,7 +123,7 @@ func TestShortLivedInternetNodeConnections(t *testing.T) {
 }
 
 func TestPauseContainerDiscarded(t *testing.T) {
-	have := utils.Prune(render.ContainerWithImageNameRenderer.Render(rpt, FilterNoop).Nodes)
+	have := utils.Prune(render.ContainerWithImageNameRenderer.Render(rpt).Nodes)
 	// There should only be a connection from container1 and the destination should be container2
 	container1, ok := have[container1NodeID]
 	if !ok {