diff --git a/crates/renderer/src/lib.rs b/crates/renderer/src/lib.rs
index 846d7af..a0c27a6 100644
--- a/crates/renderer/src/lib.rs
+++ b/crates/renderer/src/lib.rs
@@ -2555,7 +2555,6 @@ impl<W> Renderer<W> {
                     output,
                     framebuffer,
                 )?;
-                render_graph::present_pass(&mut rg, framebuffer);
 
                 rg.mark_as_output(framebuffer, Access::present());
 
diff --git a/crates/renderer/src/render_graph.rs b/crates/renderer/src/render_graph.rs
index afd430a..1918197 100644
--- a/crates/renderer/src/render_graph.rs
+++ b/crates/renderer/src/render_graph.rs
@@ -676,8 +676,6 @@ mod graph_resolver {
                 }
             }
 
-            tracing::debug!("per-resource pass-count: {rid_passcount:?}");
-
             let mut total = 0;
             for num_passes in rid_passcount {
                 self.ref_ranges.push((total, total + num_passes, 0));
@@ -687,14 +685,6 @@ mod graph_resolver {
                     .extend((0..num_passes).map(|_| PassNode(0)));
                 total += num_passes;
             }
-
-            tracing::debug!(
-                "ref_ranges and ref_accesses:\n{:?}\n{:?}\n{:?}",
-                self.ref_ranges,
-                self.ref_accesses,
-                self.ref_access_passid
-            );
-            // for resourcedesc in resources: ref first pass
         }
 
         fn get_accesses_for_rid_pass_mut(
@@ -762,7 +752,7 @@ mod graph_resolver {
             let bit_idx = rid.0 as usize * (self.num_passes) + pass.index();
             let word_idx = bit_idx / 64;
             let word_offset = bit_idx % 64;
-            tracing::debug!(
+            tracing::trace!(
                 bit_idx,
                 word_idx,
                 word_offset,
@@ -795,13 +785,6 @@ mod graph_resolver {
                     self.reference_rid_pass(rid, PassNode::pass(i));
                 }
             }
-
-            tracing::debug!(
-                "ref_ranges and ref_accesses:\n{:?}\n{:?}\n{:?}",
-                self.ref_ranges,
-                self.ref_accesses,
-                self.ref_access_passid
-            );
         }
 
         pub fn build_dag(
@@ -839,12 +822,9 @@ mod graph_resolver {
                 crate::util::BitIter::new(&self.references, self.num_resources * (self.num_passes))
                     .chunks(self.num_passes);
 
-            tracing::debug!("building edges:");
-            tracing::debug!("chunks: {bits:#?}");
+            tracing::trace!("building edges.");
             for (i, bits) in bits.enumerate() {
                 let rid = GraphResourceId(i as u32);
-                tracing::debug!("rid: {rid:?}");
-                tracing::debug!("passes: {bits}");
 
                 let mut to_make_available = AccessMask::empty();
                 let mut made_available = AccessMask::empty();
@@ -854,8 +834,6 @@ mod graph_resolver {
 
                 for pass in bits {
                     let pass = PassNode::pass(pass);
-                    tracing::debug!("pass: {:?}", pass);
-                    tracing::debug!("accesses: {:?}", self.get_accesses_for_rid_pass(rid, pass));
 
                     if let Some(last_ref) = last_ref.as_ref() {
                         edges.push(Edge {
@@ -868,7 +846,7 @@ mod graph_resolver {
 
                     let read = self.get_reads_for_rid_pass(rid, pass);
                     if let Some(read) = read {
-                        tracing::debug!("read: {:?}", read);
+                        tracing::trace!("read: {:?}", read);
 
                         let make_visible = read.into_access_mask() & !made_available;
                         if let Some(last_write) = last_write.as_ref() {
@@ -939,7 +917,7 @@ mod graph_resolver {
 
                     let write = self.get_writes_for_rid_pass(rid, pass);
                     if let Some(write) = write {
-                        tracing::debug!("write: {:?}", write);
+                        tracing::trace!("write: {:?}", write);
                         match last_ref.as_ref() {
                             Some(Ref::Read(node, before)) => {
                                 // execution barrier to ward against write-after-read
@@ -1023,7 +1001,6 @@ mod graph_resolver {
                     }
                 }
 
-                tracing::debug!("removing {sink:?} from dag");
                 dag.remove_node(sink);
             }
 
@@ -1068,7 +1045,7 @@ mod graph_resolver {
             let mut next_sinks = BTreeSet::new();
 
             loop {
-                tracing::debug!("sinks: {sinks:?}, next_sinks: {next_sinks:?}");
+                tracing::trace!("sinks: {sinks:?}, next_sinks: {next_sinks:?}");
 
                 if sinks.is_empty() {
                     break;
@@ -1186,8 +1163,6 @@ mod graph_resolver {
                 core::mem::swap(&mut sinks, &mut next_sinks);
             }
 
-            tracing::debug!("topomap: {topomap:?}");
-
             topomap
         }
     }
@@ -1306,6 +1281,7 @@ pub fn clear_pass(rg: &mut RenderGraph, color: Rgba, target: GraphResourceId) {
     });
 }
 
+#[deprecated = "mark target as output with Access::present()."]
 pub fn present_pass(rg: &mut RenderGraph, target: GraphResourceId) {
     let reads = vec![(target, Access::present())];
     let writes = vec![(target, Access::present())];