diff --git a/app/core/gimpchannel.c b/app/core/gimpchannel.c
index 6a3b734ee3..3ae0ee55b5 100644
--- a/app/core/gimpchannel.c
+++ b/app/core/gimpchannel.c
@@ -411,19 +411,19 @@ gimp_channel_get_node (GimpFilter *filter)
   if (channel->show_masked)
     {
       gegl_node_link (source, channel->invert_node);
-      gegl_node_connect_to (channel->invert_node, "output",
-                            channel->mask_node,   "aux");
+      gegl_node_connect (channel->invert_node, "output",
+                         channel->mask_node,   "aux");
     }
   else
     {
-      gegl_node_connect_to (source,             "output",
-                            channel->mask_node, "aux");
+      gegl_node_connect (source,             "output",
+                         channel->mask_node, "aux");
     }
 
   mode_node = gimp_drawable_get_mode_node (drawable);
 
-  gegl_node_connect_to (channel->mask_node, "output",
-                        mode_node,          "aux");
+  gegl_node_connect (channel->mask_node, "output",
+                     mode_node,          "aux");
 
   return node;
 }
@@ -1753,15 +1753,15 @@ gimp_channel_set_show_masked (GimpChannel *channel,
           if (channel->show_masked)
             {
               gegl_node_link (source, channel->invert_node);
-              gegl_node_connect_to (channel->invert_node, "output",
-                                    channel->mask_node,   "aux");
+              gegl_node_connect (channel->invert_node, "output",
+                                 channel->mask_node,   "aux");
             }
           else
             {
               gegl_node_disconnect (channel->invert_node, "input");
 
-              gegl_node_connect_to (source,             "output",
-                                    channel->mask_node, "aux");
+              gegl_node_connect (source,             "output",
+                                 channel->mask_node, "aux");
             }
         }
 
diff --git a/app/core/gimpdrawable-floating-selection.c b/app/core/gimpdrawable-floating-selection.c
index 4c49208b29..ac1a1420ea 100644
--- a/app/core/gimpdrawable-floating-selection.c
+++ b/app/core/gimpdrawable-floating-selection.c
@@ -229,8 +229,8 @@ _gimp_drawable_add_floating_sel_filter (GimpDrawable *drawable)
                                                NULL);
 
   gegl_node_link (fs_source, private->fs_crop_node);
-  gegl_node_connect_to (private->fs_crop_node, "output",
-                        node,                  "aux");
+  gegl_node_connect (private->fs_crop_node, "output",
+                     node,                  "aux");
 
   gimp_drawable_add_filter (drawable, private->fs_filter);
 
diff --git a/app/core/gimpdrawable-foreground-extract.c b/app/core/gimpdrawable-foreground-extract.c
index 2a00efd652..b9b74e8c02 100644
--- a/app/core/gimpdrawable-foreground-extract.c
+++ b/app/core/gimpdrawable-foreground-extract.c
@@ -118,17 +118,14 @@ gimp_drawable_foreground_extract (GimpDrawable      *drawable,
                                   NULL);
 
       gegl_node_link (trimap_node, pre);
-      gegl_node_connect_to (pre,  "output", matting_node, "aux");
+      gegl_node_connect (pre,  "output", matting_node, "aux");
       gegl_node_link_many (input_node, matting_node, post, output_node, NULL);
     }
   else
     {
-      gegl_node_connect_to (input_node,   "output",
-                            matting_node, "input");
-      gegl_node_connect_to (trimap_node,  "output",
-                            matting_node, "aux");
-      gegl_node_connect_to (matting_node, "output",
-                            output_node,  "input");
+      gegl_node_connect (input_node,   "output", matting_node, "input");
+      gegl_node_connect (trimap_node,  "output", matting_node, "aux");
+      gegl_node_connect (matting_node, "output", output_node,  "input");
     }
 
   processor = gegl_node_new_processor (output_node, NULL);
diff --git a/app/core/gimpdrawable-histogram.c b/app/core/gimpdrawable-histogram.c
index 8fc8842e8f..9c74120334 100644
--- a/app/core/gimpdrawable-histogram.c
+++ b/app/core/gimpdrawable-histogram.c
@@ -106,8 +106,7 @@ gimp_drawable_calculate_histogram_internal (GimpDrawable  *drawable,
                                          gimp_drawable_get_buffer (GIMP_DRAWABLE (mask)),
                                          -off_x, -off_y);
 
-          gegl_node_connect_to (mask_source,    "output",
-                                histogram_sink, "aux");
+          gegl_node_connect (mask_source, "output", histogram_sink, "aux");
         }
 
       processor = gegl_node_new_processor (histogram_sink,
diff --git a/app/core/gimpdrawablefilter.c b/app/core/gimpdrawablefilter.c
index 8b0ab1ccff..3e58b054fd 100644
--- a/app/core/gimpdrawablefilter.c
+++ b/app/core/gimpdrawablefilter.c
@@ -276,8 +276,7 @@ gimp_drawable_filter_new (GimpDrawable *drawable,
                        filter->crop_after,
                        NULL);
 
-  gegl_node_connect_to (filter->crop_after, "output",
-                        node,               "aux");
+  gegl_node_connect (filter->crop_after, "output", node, "aux");
 
   return filter;
 }
diff --git a/app/core/gimplayer.c b/app/core/gimplayer.c
index e6af2ea70d..825b631ad8 100644
--- a/app/core/gimplayer.c
+++ b/app/core/gimplayer.c
@@ -826,8 +826,7 @@ gimp_layer_get_node (GimpFilter *filter)
   if (! source_node_hijacked)
     gegl_node_add_child (node, source);
 
-  gegl_node_connect_to (input,  "output",
-                        source, "input");
+  gegl_node_connect (input, "output", source, "input");
 
   g_warn_if_fail (layer->layer_offset_node == NULL);
   g_warn_if_fail (layer->mask_offset_node == NULL);
@@ -852,14 +851,14 @@ gimp_layer_get_node (GimpFilter *filter)
 
   if (! source_node_hijacked)
     {
-      gegl_node_connect_to (source,                   "output",
-                            layer->layer_offset_node, "input");
+      gegl_node_connect (source,                   "output",
+                         layer->layer_offset_node, "input");
     }
 
   if (! (layer->mask && gimp_layer_get_show_mask (layer)))
     {
-      gegl_node_connect_to (layer->layer_offset_node, "output",
-                            mode_node,                "aux");
+      gegl_node_connect (layer->layer_offset_node, "output",
+                         mode_node,                "aux");
     }
 
   if (layer->mask)
@@ -868,18 +867,18 @@ gimp_layer_get_node (GimpFilter *filter)
 
       mask = gimp_drawable_get_source_node (GIMP_DRAWABLE (layer->mask));
 
-      gegl_node_connect_to (mask,                    "output",
-                            layer->mask_offset_node, "input");
+      gegl_node_connect (mask,                    "output",
+                         layer->mask_offset_node, "input");
 
       if (gimp_layer_get_show_mask (layer))
         {
-          gegl_node_connect_to (layer->mask_offset_node, "output",
-                                mode_node,               "aux");
+          gegl_node_connect (layer->mask_offset_node, "output",
+                             mode_node,               "aux");
         }
       else if (gimp_layer_get_apply_mask (layer))
         {
-          gegl_node_connect_to (layer->mask_offset_node, "output",
-                                mode_node,               "aux2");
+          gegl_node_connect (layer->mask_offset_node, "output",
+                             mode_node,               "aux2");
         }
     }
 
@@ -1972,18 +1971,18 @@ gimp_layer_add_mask (GimpLayer      *layer,
 
       mask = gimp_drawable_get_source_node (GIMP_DRAWABLE (layer->mask));
 
-      gegl_node_connect_to (mask,                    "output",
-                            layer->mask_offset_node, "input");
+      gegl_node_connect (mask,                    "output",
+                         layer->mask_offset_node, "input");
 
       if (layer->show_mask)
         {
-          gegl_node_connect_to (layer->mask_offset_node, "output",
-                                mode_node,               "aux");
+          gegl_node_connect (layer->mask_offset_node, "output",
+                             mode_node,               "aux");
         }
       else
         {
-          gegl_node_connect_to (layer->mask_offset_node, "output",
-                                mode_node,               "aux2");
+          gegl_node_connect (layer->mask_offset_node, "output",
+                             mode_node,               "aux2");
         }
 
       gimp_layer_update_mode_node (layer);
@@ -2301,8 +2300,8 @@ gimp_layer_apply_mask (GimpLayer         *layer,
 
       if (layer->show_mask)
         {
-          gegl_node_connect_to (layer->layer_offset_node, "output",
-                                mode_node,                "aux");
+          gegl_node_connect (layer->layer_offset_node, "output",
+                             mode_node,                "aux");
         }
       else
         {
@@ -2362,8 +2361,8 @@ gimp_layer_set_apply_mask (GimpLayer *layer,
 
           if (layer->apply_mask)
             {
-              gegl_node_connect_to (layer->mask_offset_node, "output",
-                                    mode_node,               "aux2");
+              gegl_node_connect (layer->mask_offset_node, "output",
+                                 mode_node,               "aux2");
             }
           else
             {
@@ -2444,18 +2443,18 @@ gimp_layer_set_show_mask (GimpLayer *layer,
             {
               gegl_node_disconnect (mode_node, "aux2");
 
-              gegl_node_connect_to (layer->mask_offset_node, "output",
-                                    mode_node,               "aux");
+              gegl_node_connect (layer->mask_offset_node, "output",
+                                 mode_node,               "aux");
             }
           else
             {
-              gegl_node_connect_to (layer->layer_offset_node, "output",
-                                    mode_node,                "aux");
+              gegl_node_connect (layer->layer_offset_node, "output",
+                                 mode_node,                "aux");
 
               if (gimp_layer_get_apply_mask (layer))
                 {
-                  gegl_node_connect_to (layer->mask_offset_node, "output",
-                                        mode_node,               "aux2");
+                  gegl_node_connect (layer->mask_offset_node, "output",
+                                     mode_node,               "aux2");
                 }
             }
 
diff --git a/app/core/gimplineart.c b/app/core/gimplineart.c
index beac888b1b..9f5c30dd5b 100644
--- a/app/core/gimplineart.c
+++ b/app/core/gimplineart.c
@@ -1341,8 +1341,7 @@ gimp_line_art_close (GeglBuffer  *buffer,
                                  "metric",    GEGL_DISTANCE_METRIC_EUCLIDEAN,
                                  "normalize", FALSE,
                                  NULL);
-      gegl_node_connect_to (input, "output",
-                            op, "input");
+      gegl_node_link (input, op);
       gegl_node_blit (op, 1.0, gegl_buffer_get_extent (closed),
                       NULL, *closed_distmap,
                       GEGL_AUTO_ROWSTRIDE, GEGL_BLIT_DEFAULT);
@@ -2343,7 +2342,7 @@ gimp_lineart_estimate_strokes_radii (GeglBuffer *mask,
                              "metric",    GEGL_DISTANCE_METRIC_EUCLIDEAN,
                              "normalize", FALSE,
                              NULL);
-  gegl_node_connect_to (input, "output", op, "input");
+  gegl_node_link (input, op);
   gegl_node_blit (op, 1.0, gegl_buffer_get_extent (mask),
                   NULL, dist, GEGL_AUTO_ROWSTRIDE, GEGL_BLIT_DEFAULT);
   g_object_unref (graph);
diff --git a/app/display/gimpcanvastransformpreview.c b/app/display/gimpcanvastransformpreview.c
index 8c8d9505e2..f1f9a7ca48 100644
--- a/app/display/gimpcanvastransformpreview.c
+++ b/app/display/gimpcanvastransformpreview.c
@@ -559,8 +559,8 @@ gimp_canvas_transform_preview_sync_node (GimpCanvasTransformPreview *transform_p
                            private->transform_node,
                            NULL);
 
-      gegl_node_connect_to (private->layer_mask_source_node,  "output",
-                            private->layer_mask_opacity_node, "aux");
+      gegl_node_connect (private->layer_mask_source_node,  "output",
+                         private->layer_mask_opacity_node, "aux");
 
       gegl_node_link_many (private->mask_source_node,
                            private->mask_translate_node,
@@ -680,8 +680,8 @@ gimp_canvas_transform_preview_sync_node (GimpCanvasTransformPreview *transform_p
 
       if (! private->node_mask)
         {
-          gegl_node_connect_to (private->mask_crop_node, "output",
-                                private->opacity_node,   "aux");
+          gegl_node_connect (private->mask_crop_node, "output",
+                             private->opacity_node,   "aux");
         }
     }
   else if (private->node_mask)
diff --git a/app/gegl/gimp-gegl-apply-operation.c b/app/gegl/gimp-gegl-apply-operation.c
index 752cf93f40..4f93844ceb 100644
--- a/app/gegl/gimp-gegl-apply-operation.c
+++ b/app/gegl/gimp-gegl-apply-operation.c
@@ -267,8 +267,7 @@ gimp_gegl_apply_cached_operation (GeglBuffer          *src_buffer,
                                         "operation", "gimp:normal",
                                         NULL);
 
-          gegl_node_connect_to (operation, "output",
-                                effect,    "aux");
+          gegl_node_connect (operation, "output", effect,    "aux");
         }
 
       gegl_node_link (src_node, effect);
@@ -534,7 +533,7 @@ gimp_gegl_apply_border (GeglBuffer             *src_buffer,
 
         gegl_node_link_many (input, grow, subtract, output, NULL);
         gegl_node_link (input, shrink);
-        gegl_node_connect_to (shrink, "output", subtract, "aux");
+        gegl_node_connect (shrink, "output", subtract, "aux");
       }
       break;
 
diff --git a/app/gegl/gimp-gegl-nodes.c b/app/gegl/gimp-gegl-nodes.c
index 143f9aed8a..de8747e509 100644
--- a/app/gegl/gimp-gegl-nodes.c
+++ b/app/gegl/gimp-gegl-nodes.c
@@ -76,8 +76,8 @@ gimp_gegl_create_flatten_node (const GimpRGB       *background,
                                 composite_space,
                                 GIMP_LAYER_COMPOSITE_AUTO);
 
-  gegl_node_connect_to (input,  "output",
-                        mode,   "aux");
+  gegl_node_connect (input,  "output",
+                     mode,   "aux");
   gegl_node_link_many (color, mode, output, NULL);
 
   return node;
@@ -114,8 +114,8 @@ gimp_gegl_create_apply_opacity_node (GeglBuffer *mask,
                                              mask_offset_y);
 
   gegl_node_link_many (input, opacity_node, output, NULL);
-  gegl_node_connect_to (mask_source,  "output",
-                        opacity_node, "aux");
+  gegl_node_connect (mask_source,  "output",
+                     opacity_node, "aux");
 
   return node;
 }
diff --git a/app/gegl/gimpapplicator.c b/app/gegl/gimpapplicator.c
index ce6d17be4e..43b7f19d11 100644
--- a/app/gegl/gimpapplicator.c
+++ b/app/gegl/gimpapplicator.c
@@ -150,8 +150,8 @@ gimp_applicator_new (GeglNode *parent)
                        applicator->apply_offset_node,
                        NULL);
 
-  gegl_node_connect_to (applicator->apply_offset_node, "output",
-                        applicator->mode_node,         "aux");
+  gegl_node_connect (applicator->apply_offset_node, "output",
+                     applicator->mode_node,         "aux");
 
   applicator->mask_node =
     gegl_node_new_child (applicator->node,
@@ -195,8 +195,8 @@ gimp_applicator_new (GeglNode *parent)
                        applicator->output_node,
                        NULL);
 
-  gegl_node_connect_to (applicator->mode_node,   "output",
-                        applicator->affect_node, "aux");
+  gegl_node_connect (applicator->mode_node,   "output",
+                     applicator->affect_node, "aux");
 
   return applicator;
 }
@@ -318,8 +318,8 @@ gimp_applicator_set_mask_buffer (GimpApplicator *applicator,
 
   if (mask_buffer)
     {
-      gegl_node_connect_to (applicator->mask_offset_node, "output",
-                            applicator->mode_node,        "aux2");
+      gegl_node_connect (applicator->mask_offset_node, "output",
+                         applicator->mode_node,        "aux2");
     }
   else
     {
@@ -378,8 +378,8 @@ gimp_applicator_set_apply_buffer (GimpApplicator *applicator,
 
       if (! applicator->apply_buffer)
         {
-          gegl_node_connect_to (applicator->apply_src_node,    "output",
-                                applicator->apply_offset_node, "input");
+          gegl_node_connect (applicator->apply_src_node,    "output",
+                             applicator->apply_offset_node, "input");
         }
     }
   else if (applicator->apply_buffer)
@@ -599,8 +599,8 @@ gimp_applicator_set_crop (GimpApplicator      *applicator,
                              "height",    rect->height,
                              NULL);
 
-              gegl_node_connect_to (applicator->input_node, "output",
-                                    applicator->crop_node,  "aux");
+              gegl_node_connect (applicator->input_node, "output",
+                                 applicator->crop_node,  "aux");
             }
           else
             {
diff --git a/app/operations/tests/test-operations.c b/app/operations/tests/test-operations.c
index 3ef6444e43..085ca89537 100644
--- a/app/operations/tests/test-operations.c
+++ b/app/operations/tests/test-operations.c
@@ -345,7 +345,7 @@ process_operations (GType type)
                                             "operation", "gegl:save",
                                             "path", output_path,
                                             NULL);
-              gegl_node_connect_to (composition, "output", output, "input");
+              gegl_node_connect (composition, "output", output, "input");
               gegl_node_process (output);
 
               if (image_compare (output_path, image_path))
diff --git a/app/pdb/plug-in-compat-cmds.c b/app/pdb/plug-in-compat-cmds.c
index e2bbbf1f25..d5eea2b86c 100644
--- a/app/pdb/plug-in-compat-cmds.c
+++ b/app/pdb/plug-in-compat-cmds.c
@@ -266,7 +266,7 @@ bump_map (GimpDrawable *drawable,
 
       src_node = create_buffer_source_node (graph, bump_map);
 
-      gegl_node_connect_to (src_node, "output", node, "aux");
+      gegl_node_connect (src_node, "output", node, "aux");
 
       gimp_drawable_apply_operation (drawable, progress,
                                      C_("undo-type", "Bump Map"),
@@ -330,14 +330,14 @@ displace (GimpDrawable  *drawable,
             {
               GeglNode *src_node;
               src_node = create_buffer_source_node (graph, displace_map_x);
-              gegl_node_connect_to (src_node, "output", node, "aux");
+              gegl_node_connect (src_node, "output", node, "aux");
             }
 
           if (do_y)
             {
               GeglNode *src_node;
               src_node = create_buffer_source_node (graph, displace_map_y);
-              gegl_node_connect_to (src_node, "output", node, "aux2");
+              gegl_node_connect (src_node, "output", node, "aux2");
             }
 
           gimp_drawable_apply_operation (drawable, progress,
@@ -3079,14 +3079,14 @@ plug_in_oilify_enhanced_invoker (GimpProcedure         *procedure,
             {
               GeglNode *src_node;
               src_node = create_buffer_source_node (graph, mask_size_map);
-              gegl_node_connect_to (src_node, "output", node, "aux");
+              gegl_node_connect (src_node, "output", node, "aux");
             }
 
           if (exponent_map)
             {
               GeglNode *src_node;
               src_node = create_buffer_source_node (graph, exponent_map);
-              gegl_node_connect_to (src_node, "output", node, "aux2");
+              gegl_node_connect (src_node, "output", node, "aux2");
             }
 
           gimp_drawable_apply_operation (drawable, progress,
diff --git a/app/tools/gimpcagetool.c b/app/tools/gimpcagetool.c
index 83727ec013..053fccae75 100644
--- a/app/tools/gimpcagetool.c
+++ b/app/tools/gimpcagetool.c
@@ -1241,13 +1241,13 @@ gimp_cage_tool_create_render_node (GimpCageTool *ct)
 
   gegl_node_link (input, ct->cage_node);
 
-  gegl_node_connect_to (ct->coef_node, "output",
-                        ct->cage_node, "aux");
+  gegl_node_connect (ct->coef_node, "output",
+                     ct->cage_node, "aux");
 
   gegl_node_link (input, render);
 
-  gegl_node_connect_to (ct->cage_node, "output",
-                        render,        "aux");
+  gegl_node_connect (ct->cage_node, "output",
+                     render,        "aux");
 
   gegl_node_link (render, output);
 
diff --git a/app/tools/gimpoperationtool.c b/app/tools/gimpoperationtool.c
index ba7fd7c49b..fdd2b8eaea 100644
--- a/app/tools/gimpoperationtool.c
+++ b/app/tools/gimpoperationtool.c
@@ -673,8 +673,8 @@ gimp_operation_tool_aux_input_new (GimpOperationTool *op_tool,
                                      "operation", "gegl:buffer-source",
                                      NULL);
 
-  gegl_node_connect_to (input->node, "output",
-                        operation,   input_pad);
+  gegl_node_connect (input->node, "output",
+                     operation,   input_pad);
 
   context = GIMP_CONTEXT (GIMP_TOOL_GET_OPTIONS (op_tool));
 
diff --git a/app/tools/gimppaintselecttool.c b/app/tools/gimppaintselecttool.c
index 353cc39426..749cc55f0c 100644
--- a/app/tools/gimppaintselecttool.c
+++ b/app/tools/gimppaintselecttool.c
@@ -866,8 +866,8 @@ gimp_paint_select_tool_create_graph (GimpPaintSelectTool  *ps_tool)
   else
     gegl_node_link_many (crop, ps_tool->ps_node, ps_tool->render_node, NULL);
 
-  gegl_node_connect_to (d, "output", ps_tool->ps_node, "aux");
-  gegl_node_connect_to (t, "output", ps_tool->ps_node, "aux2");
+  gegl_node_connect (d, "output", ps_tool->ps_node, "aux");
+  gegl_node_connect (t, "output", ps_tool->ps_node, "aux2");
 }
 
 static void
diff --git a/app/tools/gimpseamlessclonetool.c b/app/tools/gimpseamlessclonetool.c
index 612c0a8fad..a3dc6099ad 100644
--- a/app/tools/gimpseamlessclonetool.c
+++ b/app/tools/gimpseamlessclonetool.c
@@ -694,11 +694,11 @@ gimp_seamless_clone_tool_create_render_node (GimpSeamlessCloneTool *sc)
 
   gegl_node_link_many (input, op, overlay, output, NULL);
 
-  gegl_node_connect_to (paste,   "output",
-                        op,      "aux");
+  gegl_node_connect (paste,   "output",
+                     op,      "aux");
 
-  gegl_node_connect_to (input,   "output",
-                        overlay, "aux");
+  gegl_node_connect (input,   "output",
+                     overlay, "aux");
 
 
   sc->render_node = node;
diff --git a/app/tools/gimpwarptool.c b/app/tools/gimpwarptool.c
index 1495bcf52b..ffe0b8b24f 100644
--- a/app/tools/gimpwarptool.c
+++ b/app/tools/gimpwarptool.c
@@ -634,8 +634,8 @@ gimp_warp_tool_undo (GimpTool    *tool,
    */
   prev_node = gegl_node_get_producer (to_delete, "input", NULL);
 
-  gegl_node_connect_to (prev_node,       "output",
-                        wt->render_node, "aux");
+  gegl_node_connect (prev_node,       "output",
+                     wt->render_node, "aux");
 
   gimp_warp_tool_update_bounds (wt);
   gimp_warp_tool_update_stroke (wt, to_delete);
@@ -652,8 +652,8 @@ gimp_warp_tool_redo (GimpTool    *tool,
 
   to_add = wt->redo_stack->data;
 
-  gegl_node_connect_to (to_add,          "output",
-                        wt->render_node, "aux");
+  gegl_node_connect (to_add,          "output",
+                     wt->render_node, "aux");
 
   wt->redo_stack = g_list_remove_link (wt->redo_stack, wt->redo_stack);
 
@@ -1066,8 +1066,8 @@ gimp_warp_tool_create_graph (GimpWarpTool *wt)
                                 NULL);
 
   gegl_node_link_many (input, render, output, NULL);
-  gegl_node_connect_to (coords, "output",
-                        render, "aux");
+  gegl_node_connect (coords, "output",
+                     render, "aux");
 
 
   wt->graph       = graph;
@@ -1370,8 +1370,8 @@ gimp_warp_tool_add_op (GimpWarpTool *wt,
 
   gegl_node_disconnect (wt->render_node, "aux");
   gegl_node_link (last_op, op);
-  gegl_node_connect_to (op,              "output",
-                        wt->render_node, "aux");
+  gegl_node_connect (op,              "output",
+                     wt->render_node, "aux");
 }
 
 static void
@@ -1385,8 +1385,8 @@ gimp_warp_tool_remove_op (GimpWarpTool *wt,
   previous = gegl_node_get_producer (op, "input", NULL);
 
   gegl_node_disconnect (op,              "input");
-  gegl_node_connect_to (previous,        "output",
-                        wt->render_node, "aux");
+  gegl_node_connect (previous,        "output",
+                     wt->render_node, "aux");
 
   gegl_node_remove_child (wt->graph, op);
 }
diff --git a/pdb/groups/plug_in_compat.pdb b/pdb/groups/plug_in_compat.pdb
index 7573f278cc..e4ca564f83 100644
--- a/pdb/groups/plug_in_compat.pdb
+++ b/pdb/groups/plug_in_compat.pdb
@@ -3051,14 +3051,14 @@ HELP
         {
           GeglNode *src_node;
           src_node = create_buffer_source_node (graph, mask_size_map);
-          gegl_node_connect_to (src_node, "output", node, "aux");
+          gegl_node_connect (src_node, "output", node, "aux");
         }
 
       if (exponent_map)
         {
           GeglNode *src_node;
           src_node = create_buffer_source_node (graph, exponent_map);
-          gegl_node_connect_to (src_node, "output", node, "aux2");
+          gegl_node_connect (src_node, "output", node, "aux2");
         }
 
       gimp_drawable_apply_operation (drawable, progress,
@@ -5332,7 +5332,7 @@ bump_map (GimpDrawable *drawable,
 
       src_node = create_buffer_source_node (graph, bump_map);
 
-      gegl_node_connect_to (src_node, "output", node, "aux");
+      gegl_node_connect (src_node, "output", node, "aux");
 
       gimp_drawable_apply_operation (drawable, progress,
                                      C_("undo-type", "Bump Map"),
@@ -5396,14 +5396,14 @@ displace (GimpDrawable  *drawable,
             {
               GeglNode *src_node;
               src_node = create_buffer_source_node (graph, displace_map_x);
-              gegl_node_connect_to (src_node, "output", node, "aux");
+              gegl_node_connect (src_node, "output", node, "aux");
             }
 
           if (do_y)
             {
               GeglNode *src_node;
               src_node = create_buffer_source_node (graph, displace_map_y);
-              gegl_node_connect_to (src_node, "output", node, "aux2");
+              gegl_node_connect (src_node, "output", node, "aux2");
             }
 
           gimp_drawable_apply_operation (drawable, progress,
diff --git a/plug-ins/file-webp/file-webp-save.c b/plug-ins/file-webp/file-webp-save.c
index e3dded72d4..cfe5076522 100644
--- a/plug-ins/file-webp/file-webp-save.c
+++ b/plug-ins/file-webp/file-webp-save.c
@@ -494,8 +494,7 @@ combine_buffers (GeglBuffer *layer_buffer,
                                 "buffer", buffer,
                                 NULL);
   gegl_node_link_many (backdrop, over, target, NULL);
-  gegl_node_connect_to (source, "output",
-                        over, "aux");
+  gegl_node_connect (source, "output", over, "aux");
   gegl_node_process (target);
   g_object_unref (graph);