diff --git a/bin/gegl-path-smooth.c b/bin/gegl-path-smooth.c
index a4663adf..dba228c9 100644
--- a/bin/gegl-path-smooth.c
+++ b/bin/gegl-path-smooth.c
@@ -115,7 +115,7 @@ static GeglPathList *gegl_path_smooth_flatten (GeglPathList *original)
   gboolean is_smooth_path = TRUE;
   gint count;
   gint i;
-  /* first we do a run through the path checking it's length
+  /* first we do a run through the path checking its length
    * and determining whether we can flatten the incoming path
    */
   for (count=0,iter = original; iter; iter=iter->next)
diff --git a/bin/gegl-path-spiro.c b/bin/gegl-path-spiro.c
index 561bcd1a..2d5b4637 100644
--- a/bin/gegl-path-spiro.c
+++ b/bin/gegl-path-spiro.c
@@ -72,7 +72,7 @@ static GeglPathList *gegl_path_spiro_flatten (GeglPathList *original)
   gboolean closed = FALSE;
   gint count;
   gint i;
-  /* first we do a run through the path checking it's length
+  /* first we do a run through the path checking its length
    * and determining whether we can flatten the incoming path
    */
   for (count=0,iter = original; iter; iter=iter->next)
diff --git a/docs/build.txt b/docs/build.txt
index 7515dc4c..4fae845d 100644
--- a/docs/build.txt
+++ b/docs/build.txt
@@ -1,6 +1,6 @@
 Building from source
 --------------------
-GEGL and it's dependencies are known to work on Linux based systems, windows
+GEGL and its dependencies are known to work on Linux based systems, windows
 with msys/mingw, and probably other platforms.
 
 Download
diff --git a/docs/operation-api.txt b/docs/operation-api.txt
index 98d6beb8..cceb06e7 100644
--- a/docs/operation-api.txt
+++ b/docs/operation-api.txt
@@ -40,7 +40,7 @@ link:gegl-operation-point-composer.h.html[GeglOperationPointComposer]::
 
 link:gegl-operation-source.h.html[GeglOperationSource]::
     Operations used as render sources or file loaders, the process method
-    receives a GeglBuffer to write it's output into
+    receives a GeglBuffer to write its output into
 
 link:gegl-operation-point-render.h.html[GeglOperationPointRender]::
     The point-render base class is a specialized source operation, where the
diff --git a/docs/source-overview.txt b/docs/source-overview.txt
index 0f27fd21..ad168285 100644
--- a/docs/source-overview.txt
+++ b/docs/source-overview.txt
@@ -15,11 +15,11 @@ Source overview
   │   │                  - read/write rectangular region as linear buffer for
   │   │                    any babl supported pixel format.
   │   ├──graph          graph storage and manipulation code.
-  │   ├──module         The code to load plug-ins located in a colon seperated
+  │   ├──module         The code to load plug-ins located in a colon separated
   │   │                 list of paths from the environment variable GEGL_PATH
   │   ├──opencl         The GEGL base class for OpenCL.
   │   ├──operation      The GeglOperation base class, and subclasses that act
-  │   │                 as baseclasses for implementeting different types of
+  │   │                 as baseclasses for implementing different types of
   │   │                 operation plug-ins.
   │   ├──process        The code controlling data processing.
   │   └──property-types specialized classes/paramspecs for GeglOperation
@@ -40,7 +40,7 @@ Source overview
   │   ├──external      Operations with external dependencies.
   │   ├──common        Other operations.
   │   └──workshop      Works in progress, (you must pass --enable-workshop
-  │       │            when configurig to build these by default, you can enter
+  │       │            when configuring to build these by default, you can enter
   │       │            the directory manually and type make && sudo make install
   │       │            as well.
   │       │
diff --git a/gegl/buffer/gegl-buffer.h b/gegl/buffer/gegl-buffer.h
index 83c4f0d0..b026e3e3 100644
--- a/gegl/buffer/gegl-buffer.h
+++ b/gegl/buffer/gegl-buffer.h
@@ -127,7 +127,7 @@ GeglBuffer *     gegl_buffer_load             (const gchar         *path);
  * gegl_buffer_flush:
  * @buffer: a #GeglBuffer
  *
- * Flushes all unsaved data to disk, this is not neccesary for shared
+ * Flushes all unsaved data to disk, this is not necessary for shared
  * geglbuffers opened with gegl_buffer_open since they auto-sync on writes.
  */
 void            gegl_buffer_flush             (GeglBuffer          *buffer);
@@ -165,7 +165,7 @@ const GeglRectangle * gegl_buffer_get_extent  (GeglBuffer *buffer);
  * operation is valid on any buffer, reads on subbuffers outside the master
  * buffer's extent are at the moment undefined.
  *
- * Returns TRUE if the change of extent was succesful.
+ * Returns TRUE if the change of extent was successful.
  */
 gboolean          gegl_buffer_set_extent      (GeglBuffer          *buffer,
                                                const GeglRectangle *extent);
@@ -177,7 +177,7 @@ gboolean          gegl_buffer_set_extent      (GeglBuffer          *buffer,
  *
  * Changes the size and position of the abyss rectangle of a buffer.
  *
- * Returns TRUE if the change of abyss was succesful.
+ * Returns TRUE if the change of abyss was successful.
  */
 gboolean          gegl_buffer_set_abyss      (GeglBuffer          *buffer,
                                               const GeglRectangle *abyss);
diff --git a/gegl/gegl-instrument.h b/gegl/gegl-instrument.h
index 7dd6cb50..430363a2 100644
--- a/gegl/gegl-instrument.h
+++ b/gegl/gegl-instrument.h
@@ -37,7 +37,7 @@ void gegl_instrument_enable   (void);
   }
 
 /* store a timing instrumentation (parent is expected to exist,
- * and to keep it's own record of the time-slice reported) */
+ * and to keep its own record of the time-slice reported) */
 #define gegl_instrument(parent, scale, usecs) \
   { if (gegl_instrument_enabled) { \
 real_gegl_instrument (parent, scale, usecs); \
diff --git a/gegl/gegl-random.h b/gegl/gegl-random.h
index 72c2e69a..037bfa9e 100644
--- a/gegl/gegl-random.h
+++ b/gegl/gegl-random.h
@@ -86,7 +86,7 @@ void gegl_random_set_seed (GeglRandom *rand,
  * @n: number no (each x,y coordinate provides its own sequence of
  * numbers
  * @min: minimum value
- * @max: maxmimum value
+ * @max: maximum value
  *
  * Return a random floating point number in the range specified,
  * for the given x,y coordinates and GeglRandom provided, if multiple different
@@ -109,7 +109,7 @@ gfloat gegl_random_float_range (const GeglRandom *rand,
  * @n: number no (each x,y coordinate provides its own sequence of
  * numbers
  * @min: minimum value
- * @max: maxmimum value+1
+ * @max: maximum value+1
  *
  * Return a random integer point number in the range specified,
  * for the given x,y coordinates and GeglRandom provided, if multiple different
diff --git a/gegl/gegl-xml.c b/gegl/gegl-xml.c
index c0962ec8..e0eb05c0 100644
--- a/gegl/gegl-xml.c
+++ b/gegl/gegl-xml.c
@@ -252,7 +252,7 @@ set_clone_prop_as_well:
         }
       else
         {
-          g_warning ("operation desired unknown parapspec type for %s",
+          g_warning ("operation desired unknown paramspec type for %s",
                      param_name);
         }
     }
diff --git a/gegl/graph/gegl-node.c b/gegl/graph/gegl-node.c
index d8765fcd..bcb46a3a 100644
--- a/gegl/graph/gegl-node.c
+++ b/gegl/graph/gegl-node.c
@@ -589,7 +589,7 @@ gegl_node_connect_to (GeglNode    *source,
 }
 
 /* the implementation of gegl_node_invalidated() can use either GeglRegions
- * or GeglRectangles (bounding boxes) for calculating the invadilated areas
+ * or GeglRectangles (bounding boxes) for calculating the invalidated areas
  * of the nodes in the graph.  The GeglRegion version is more granular,
  * invalidating exact areas, but has higher overhead, while the GeglRectangle
  * version in more coarse, potentially over-invalidating (but never under-
diff --git a/gegl/graph/gegl-node.h b/gegl/graph/gegl-node.h
index 7b8a6604..16dda886 100644
--- a/gegl/graph/gegl-node.h
+++ b/gegl/graph/gegl-node.h
@@ -109,7 +109,7 @@ GeglNode    * gegl_node_new_child        (GeglNode      *parent,
  *
  * Makes a connection between the pads of two nodes.
  *
- * Returns TRUE if the connection was succesfully made.
+ * Returns TRUE if the connection was successfully made.
  */
 
 gboolean      gegl_node_connect_from     (GeglNode      *sink,
@@ -126,7 +126,7 @@ gboolean      gegl_node_connect_from     (GeglNode      *sink,
  *
  * Makes a connection between the pads of two nodes.
  *
- * Returns TRUE if the connection was succesfully made.
+ * Returns TRUE if the connection was successfully made.
  */
 gboolean      gegl_node_connect_to       (GeglNode      *source,
                                           const gchar   *output_pad_name,
@@ -308,7 +308,7 @@ void          gegl_node_blit_buffer      (GeglNode            *node,
  * @sink_node: a #GeglNode without outputs.
  *
  * Render a composition. This can be used for instance on a node with a "png-save"
- * operation to render all neccesary data, and make it be written to file. This
+ * operation to render all necessary data, and make it be written to file. This
  * function wraps the usage of a GeglProcessor in a single blocking function
  * call. If you need a non-blocking operation, then make a direct use of
  * #gegl_processor_work. See #GeglProcessor.
@@ -580,7 +580,7 @@ gchar      ** gegl_node_list_output_pads (GeglNode      *node);
  *
  * Creates a new processing node that performs the specified operation.
  * All properties of the operation will have their default values. This
- * is included as an addiiton to #gegl_node_new_child in the public API to have
+ * is included as an addition to #gegl_node_new_child in the public API to have
  * a non varargs entry point for bindings as well as sometimes simpler more
  * readable code.
  *
diff --git a/gegl/graph/gegl-pad.c b/gegl/graph/gegl-pad.c
index 02754bd6..33b38eb7 100644
--- a/gegl/graph/gegl-pad.c
+++ b/gegl/graph/gegl-pad.c
@@ -139,7 +139,7 @@ gegl_pad_disconnect (GeglPad        *sink,
 
   g_assert (sink == gegl_connection_get_sink_pad (connection));
   /*
-   *  this happends with ghostpads sometimes,. maybe check for that being
+   *  this happens with ghostpads sometimes,. maybe check for that being
    *  the case, and then do the assert, or bake it into the assert?
    *
      g_assert (source == gegl_connection_get_source_pad (connection));
diff --git a/gegl/opencl/gegl-cl-color.h b/gegl/opencl/gegl-cl-color.h
index 35d14d56..aebb2a39 100644
--- a/gegl/opencl/gegl-cl-color.h
+++ b/gegl/opencl/gegl-cl-color.h
@@ -38,12 +38,12 @@ gboolean      gegl_cl_color_compile_kernels (void);
 gboolean      gegl_cl_color_babl (const Babl *buffer_format,
                                   size_t     *bytes);
 
-/** Return TRUE if the convertion is OpenCL supported */
+/** Return TRUE if the conversion is OpenCL supported */
 GeglClColorOp gegl_cl_color_supported (const Babl *in_format,
                                        const Babl *out_format);
 
 /** Copy and convert size pixels from in_tex to aux_tex.
- *  Return TRUE if succesfull.
+ *  Return TRUE if successful.
  */
 gboolean      gegl_cl_color_conv (cl_mem        in_tex,
                                   cl_mem        aux_tex,
diff --git a/gegl/opencl/gegl-cl-introspection-support.h b/gegl/opencl/gegl-cl-introspection-support.h
index c0ee928d..a3afeeb4 100644
--- a/gegl/opencl/gegl-cl-introspection-support.h
+++ b/gegl/opencl/gegl-cl-introspection-support.h
@@ -1,7 +1,7 @@
 
  /**
  * gegl_cl_init:
- * @error: Any error that occured
+ * @error: Any error that occurred
  *
  * Initialize and enable OpenCL, calling this function again
  * will re-enable OpenCL if it has been disabled.
diff --git a/gegl/operation/gegl-operation-context-private.h b/gegl/operation/gegl-operation-context-private.h
index 35c80243..e468f7be 100644
--- a/gegl/operation/gegl-operation-context-private.h
+++ b/gegl/operation/gegl-operation-context-private.h
@@ -45,7 +45,7 @@ struct _GeglOperationContext
 
 
   gboolean       cached;       /* true if the cache can be used directly, and
-                                  recomputation of inputs is unneccesary) */
+                                  recomputation of inputs is unnecessary) */
 
   gint           refs;         /* set to number of nodes that depends on it
                                   before evaluation begins, each time data is
diff --git a/gegl/operation/gegl-operation-sink.h b/gegl/operation/gegl-operation-sink.h
index de10d331..9eb458cd 100644
--- a/gegl/operation/gegl-operation-sink.h
+++ b/gegl/operation/gegl-operation-sink.h
@@ -46,7 +46,7 @@ struct _GeglOperationSinkClass
 {
   GeglOperationClass parent_class;
 
-  /* Wether or not the sink operation needs full input data in one go
+  /* Whether or not the sink operation needs full input data in one go
    * in order to be able to do its processing
    */
   gboolean              needs_full;
diff --git a/gegl/operation/gegl-operation.c b/gegl/operation/gegl-operation.c
index 53efa4dc..2ce406f0 100644
--- a/gegl/operation/gegl-operation.c
+++ b/gegl/operation/gegl-operation.c
@@ -173,7 +173,7 @@ gegl_operation_process (GeglOperation        *operation,
 }
 
 /* Calls an extending class' get_bound_box method if defined otherwise
- * just returns a zero-initiliased bouding box
+ * just returns a zero-initialised bounding box
  */
 GeglRectangle
 gegl_operation_get_bounding_box (GeglOperation *self)
diff --git a/gegl/process/gegl-graph-traversal.c b/gegl/process/gegl-graph-traversal.c
index 22c4c5a7..36f0088e 100644
--- a/gegl/process/gegl-graph-traversal.c
+++ b/gegl/process/gegl-graph-traversal.c
@@ -464,7 +464,7 @@ gegl_graph_process (GeglGraphTraversal *path,
               context->level = level;
 
               /* note: this hard-coding of "output" makes some more custom
-               * graph topologies harder than neccesary.
+               * graph topologies harder than necessary.
                */
               gegl_operation_process (operation, context, "output", &context->need_rect, context->level);
               operation_result = GEGL_BUFFER (gegl_operation_context_get_object (context, "output"));
diff --git a/gegl/process/gegl-processor.c b/gegl/process/gegl-processor.c
index 477fe38b..dce16c26 100644
--- a/gegl/process/gegl-processor.c
+++ b/gegl/process/gegl-processor.c
@@ -432,7 +432,7 @@ render_rectangle (GeglProcessor *processor)
   const Babl *format   = NULL;
   gint        pxsize;
 
-  /* Retreive the cache if the processor's node is not buffered if it's
+  /* Retrieve the cache if the processor's node is not buffered if its
    * operation is a sink and it doesn't use the full area  */
   buffered = !(GEGL_IS_OPERATION_SINK(processor->real_node->operation) &&
                !gegl_operation_sink_needs_full (processor->real_node->operation));
@@ -512,7 +512,7 @@ render_rectangle (GeglProcessor *processor)
               buf = g_malloc (dr->width * dr->height * pxsize);
               g_assert (buf);
 
-              /* FIXME: Check if the node caches naturaly, if so the buffer_set call isn't needed */
+              /* FIXME: Check if the node caches naturally, if so the buffer_set call isn't needed */
 
               /* do the image calculations using the buffer */
               gegl_node_blit (processor->input, 1.0/(1<<processor->level),
diff --git a/gegl/property-types/gegl-color.c b/gegl/property-types/gegl-color.c
index 125cecee..5da23151 100644
--- a/gegl/property-types/gegl-color.c
+++ b/gegl/property-types/gegl-color.c
@@ -171,7 +171,7 @@ parse_float_argument_list (float rgba_color[4],
         }
     }
 
-  /* Make sure there is a traling ')' and that that is the last token. */
+  /* Make sure there is a trailing ')' and that that is the last token. */
   if (g_scanner_get_next_token (scanner) == G_TOKEN_RIGHT_PAREN &&
       g_scanner_get_next_token (scanner) == G_TOKEN_EOF)
     {
diff --git a/gegl/property-types/gegl-curve.c b/gegl/property-types/gegl-curve.c
index 0a58f075..9f818436 100644
--- a/gegl/property-types/gegl-curve.c
+++ b/gegl/property-types/gegl-curve.c
@@ -47,7 +47,7 @@ struct _GeglCurvePoint
 
 struct _GeglCurvePrivate
 {
-  gdouble          y_min;  /*< should definitly be construct properties */
+  gdouble          y_min;  /*< should definitely be construct properties */
   gdouble          y_max;
   GArray          *points;
   gboolean         need_recalc;
diff --git a/gegl/property-types/gegl-curve.h b/gegl/property-types/gegl-curve.h
index 3d1e6447..cc7ba2db 100644
--- a/gegl/property-types/gegl-curve.h
+++ b/gegl/property-types/gegl-curve.h
@@ -165,7 +165,7 @@ gdouble      gegl_curve_calc_value     (GeglCurve   *curve,
  * gegl_curve_calc_values: (skip)
  * @curve: a #GeglCurve.
  * @x_min: the minimum value to compute for
- * @x_max: the maxmimum value to compute for
+ * @x_max: the maximum value to compute for
  * @num_samples: number of samples to calculate
  * @xs: return location for the x coordinates
  * @ys: return location for the y coordinates
diff --git a/libs/poly2tri-c/poly2tri-c/p2t/common/shapes.c b/libs/poly2tri-c/poly2tri-c/p2t/common/shapes.c
index 463ac50e..65164338 100644
--- a/libs/poly2tri-c/poly2tri-c/p2t/common/shapes.c
+++ b/libs/poly2tri-c/poly2tri-c/p2t/common/shapes.c
@@ -265,7 +265,7 @@ p2t_triangle_legalize_pt (P2tTriangle* THIS, P2tPoint *point)
   THIS->points_[2] = point;
 }
 
-/* Legalize triagnle by rotating clockwise around oPoint */
+/* Legalize triangle by rotating clockwise around oPoint */
 
 void
 p2t_triangle_legalize_pt_pt (P2tTriangle* THIS, P2tPoint *opoint, P2tPoint *npoint)
@@ -602,7 +602,7 @@ p2t_triangle_debug_print (P2tTriangle* THIS)
   printf ("%f,%f\n", THIS->points_[2]->x, THIS->points_[2]->y);
 }
 
-/* WARNING! the function for sorting a g_ptr_array expects to recieve
+/* WARNING! the function for sorting a g_ptr_array expects to receive
  *          pointers to the pointers (double indirection)! */
 
 gint
diff --git a/libs/poly2tri-c/poly2tri-c/p2t/sweep/sweep.h b/libs/poly2tri-c/poly2tri-c/p2t/sweep/sweep.h
index 5e8444fa..5c0d41b1 100644
--- a/libs/poly2tri-c/poly2tri-c/p2t/sweep/sweep.h
+++ b/libs/poly2tri-c/poly2tri-c/p2t/sweep/sweep.h
@@ -237,7 +237,7 @@ void p2t_sweep_flip_edge_event (P2tSweep *THIS, P2tSweepContext *tcx, P2tPoint*
 
 /**
  * After a flip we have two triangles and know that only one will still be
- * intersecting the edge. So decide which to contiune with and legalize the other
+ * intersecting the edge. So decide which to continue with and legalize the other
  *
  * @param tcx
  * @param o - should be the result of an orient2d( eq, op, ep )
diff --git a/libs/poly2tri-c/poly2tri-c/p2t/sweep/sweep_context.c b/libs/poly2tri-c/poly2tri-c/p2t/sweep/sweep_context.c
index 9ed52d56..6cae0b4d 100644
--- a/libs/poly2tri-c/poly2tri-c/p2t/sweep/sweep_context.c
+++ b/libs/poly2tri-c/poly2tri-c/p2t/sweep/sweep_context.c
@@ -231,7 +231,7 @@ p2t_sweepcontext_create_advancingfront (P2tSweepContext *THIS, P2tNodePtrArray n
   THIS->af_tail_ = p2t_node_new_pt (p2t_triangle_get_point (triangle, 2));
   THIS->front_ = p2t_advancingfront_new (THIS->af_head_, THIS->af_tail_);
 
-  /* TODO: More intuitiv if head is middles next and not previous?
+  /* TODO: More intuitive if head is middles next and not previous?
    *       so swap head and tail */
   THIS->af_head_->next = THIS->af_middle_;
   THIS->af_middle_->next = THIS->af_tail_;
diff --git a/libs/poly2tri-c/poly2tri-c/p2t/sweep/sweep_context.h b/libs/poly2tri-c/poly2tri-c/p2t/sweep/sweep_context.h
index 2c9748f8..7c3d0dfb 100644
--- a/libs/poly2tri-c/poly2tri-c/p2t/sweep/sweep_context.h
+++ b/libs/poly2tri-c/poly2tri-c/p2t/sweep/sweep_context.h
@@ -40,7 +40,7 @@
 #include "../common/shapes.h"
 #include "advancing_front.h"
 
-/* Inital triangle factor, seed triangle will extend 30% of
+/* Initial triangle factor, seed triangle will extend 30% of
  * PointSet width to both left and right. */
 #define kAlpha 0.3
 
diff --git a/libs/poly2tri-c/poly2tri-c/refine/cdt-flipfix.c b/libs/poly2tri-c/poly2tri-c/refine/cdt-flipfix.c
index 3efeb098..d9d3481d 100644
--- a/libs/poly2tri-c/poly2tri-c/refine/cdt-flipfix.c
+++ b/libs/poly2tri-c/poly2tri-c/refine/cdt-flipfix.c
@@ -107,7 +107,7 @@ p2tr_cdt_flip_fix (P2trCDT     *self,
 }
 
 /**
- * Try to flip a given edge, If successfull, return the new edge (reffed!),
+ * Try to flip a given edge, If successful, return the new edge (reffed!),
  * otherwise return NULL
  */
 P2trEdge*
diff --git a/libs/poly2tri-c/poly2tri-c/refine/delaunay-terminator.c b/libs/poly2tri-c/poly2tri-c/refine/delaunay-terminator.c
index 1de1fea5..927d9a0d 100644
--- a/libs/poly2tri-c/poly2tri-c/refine/delaunay-terminator.c
+++ b/libs/poly2tri-c/poly2tri-c/refine/delaunay-terminator.c
@@ -164,8 +164,8 @@ vtriangle_quality_compare (P2trVTriangle *t1, P2trVTriangle *t2)
   r1 = p2tr_vtriangle_is_real (t1);
   r2 = p2tr_vtriangle_is_real (t2);
 
-  /* TODO: untill we make sure that removed triangles will get out
-   * of Qt, we will make the comparision treat removed triangles as
+  /* TODO: until we make sure that removed triangles will get out
+   * of Qt, we will make the comparison treat removed triangles as
    * triangles with "less" quality (meaning they are "smaller")
    */
   if (!r1 || !r2)
diff --git a/libs/poly2tri-c/poly2tri-c/refine/line.c b/libs/poly2tri-c/poly2tri-c/refine/line.c
index d2e0ccf3..f9fc264e 100644
--- a/libs/poly2tri-c/poly2tri-c/refine/line.c
+++ b/libs/poly2tri-c/poly2tri-c/refine/line.c
@@ -81,7 +81,7 @@ p2tr_line_intersection (const P2trLine    *l1,
    * never intersect */
   if (d == 0)
     {
-      /* We want to check if the offsets of boths the lines are the
+      /* We want to check if the offsets of both the lines are the
        * same, i.e. whether:  C1 / A1 = C2 / A2
        * This test can be done without zero division errors if we do
        * it in like this:     C1 * A2 = C2 * A1
diff --git a/libs/poly2tri-c/poly2tri-c/refine/mesh-action.h b/libs/poly2tri-c/poly2tri-c/refine/mesh-action.h
index cd3e840a..86799734 100644
--- a/libs/poly2tri-c/poly2tri-c/refine/mesh-action.h
+++ b/libs/poly2tri-c/poly2tri-c/refine/mesh-action.h
@@ -58,7 +58,7 @@ typedef enum
  * action may be the insertion/removal of a point/edge/triangle.
  *
  * Note that such an action only treats the direct geometric operation
- * related to the specific geometric primitve, without any of its
+ * related to the specific geometric primitive, without any of its
  * dependencies.
  *
  * For example, if removing a point requires the removal of several
diff --git a/libs/poly2tri-c/poly2tri-c/refine/point.c b/libs/poly2tri-c/poly2tri-c/refine/point.c
index 722cab64..3fee5f74 100644
--- a/libs/poly2tri-c/poly2tri-c/refine/point.c
+++ b/libs/poly2tri-c/poly2tri-c/refine/point.c
@@ -60,7 +60,7 @@ p2tr_point_remove (P2trPoint *self)
 {
   /* We can not iterate over the list of edges while removing the edges,
    * because the removal action will modify the list. Instead we will
-   * simply look at the first edge untill the list is emptied. */
+   * simply look at the first edge until the list is emptied. */
   while (self->outgoing_edges != NULL)
     p2tr_edge_remove ((P2trEdge*) self->outgoing_edges->data);
 
diff --git a/libs/poly2tri-c/poly2tri-c/refine/pslg.c b/libs/poly2tri-c/poly2tri-c/refine/pslg.c
index 59f4d0dd..755e6f3e 100644
--- a/libs/poly2tri-c/poly2tri-c/refine/pslg.c
+++ b/libs/poly2tri-c/poly2tri-c/refine/pslg.c
@@ -44,7 +44,7 @@ free_bounded_line_if_not_null (gpointer line)
  * a line, it means that this is a new line and therefore should be
  * freed. When it has an entry where the key is a line and the value is
  * NULL, it means this is a line that should not be freed.
- * This behaiour will be acheived by a NULL key free function and a
+ * This behaviour will be achieved by a NULL key free function and a
  * real free function for values */
 P2trPSLG*
 p2tr_pslg_new (void)
diff --git a/libs/poly2tri-c/poly2tri-c/refine/pslg.h b/libs/poly2tri-c/poly2tri-c/refine/pslg.h
index ef06bf34..117a4fe3 100644
--- a/libs/poly2tri-c/poly2tri-c/refine/pslg.h
+++ b/libs/poly2tri-c/poly2tri-c/refine/pslg.h
@@ -96,8 +96,8 @@ gboolean  p2tr_pslg_iter_next         (P2trPSLGIter           *iter,
                                        const P2trBoundedLine **line);
 
 /**
- * Test whether the PSLG contains this line. The line comparision is
- * done *by refrence* and not by value, so this function only test if
+ * Test whether the PSLG contains this line. The line comparison is
+ * done *by reference* and not by value, so this function only test if
  * the line at the given memory location is inside the PSLG.
  * @param[in] pslg The PSLG
  * @param[in] line The line to search for
diff --git a/libs/poly2tri-c/poly2tri-c/refine/triangle.c b/libs/poly2tri-c/poly2tri-c/refine/triangle.c
index ef47083a..cd608cde 100644
--- a/libs/poly2tri-c/poly2tri-c/refine/triangle.c
+++ b/libs/poly2tri-c/poly2tri-c/refine/triangle.c
@@ -169,7 +169,7 @@ p2tr_triangle_remove (P2trTriangle *self)
     p2tr_edge_unref (self->edges[i]);
     self->edges[i] = NULL;
     /* Although we lost reference to the triangle 3 rows above, we must
-     * not unref it untill here since we still use the struct until this
+     * not unref it until here since we still use the struct until this
      * line! */
     p2tr_triangle_unref (self);
   }
diff --git a/libs/poly2tri-c/poly2tri-c/refine/vedge.h b/libs/poly2tri-c/poly2tri-c/refine/vedge.h
index 1623dadb..86f6b9c9 100644
--- a/libs/poly2tri-c/poly2tri-c/refine/vedge.h
+++ b/libs/poly2tri-c/poly2tri-c/refine/vedge.h
@@ -129,7 +129,7 @@ gboolean     p2tr_vedge_set_pop  (P2trVEdgeSet  *self,
 guint        p2tr_vedge_set_size (P2trVEdgeSet  *self);
 
 /**
- * Free the flip set. IT IS THE REPONSIBILITY OF THE CALLER TO MAKE
+ * Free the flip set. IT IS THE RESPONSIBILITY OF THE CALLER TO MAKE
  * SURE NO VIRTUAL EDGES WERE LEFT IN THE SET!
  */
 void         p2tr_vedge_set_free (P2trVEdgeSet  *self);
diff --git a/libs/poly2tri-c/poly2tri-c/refine/visibility.c b/libs/poly2tri-c/poly2tri-c/refine/visibility.c
index b0645ca1..284efeec 100644
--- a/libs/poly2tri-c/poly2tri-c/refine/visibility.c
+++ b/libs/poly2tri-c/poly2tri-c/refine/visibility.c
@@ -36,7 +36,7 @@
  * the line does not intersect any of the lines of "PSLG".
  *
  * In this file is an algorithm for answering the above question, and
- * it's pseudo-code is hereby presented:
+ * its pseudo-code is hereby presented:
  *
  * IsVisible(G, Poly, P):
  * ----------------------
@@ -255,7 +255,7 @@ PointIsInsidePolygon (P2trVector2 *vec,
 }
 
 /* If the bounded line intersects the polygon in more than two places,
- * then the answer is simply NO - the line is not completly outside the
+ * then the answer is simply NO - the line is not completely outside the
  * polygon.
  * Else, if the bounded line intersects the polygon twice, we analyze
  * its end points and middle point:
diff --git a/libs/poly2tri-c/poly2tri-c/render/mesh-render.c b/libs/poly2tri-c/poly2tri-c/render/mesh-render.c
index f58bc3af..d1f3bf3d 100644
--- a/libs/poly2tri-c/poly2tri-c/render/mesh-render.c
+++ b/libs/poly2tri-c/poly2tri-c/render/mesh-render.c
@@ -164,7 +164,7 @@ G_STMT_START                                                           \
                                                                        \
             /* We are inside the mesh, so set as opaque */             \
             if (! alpha_last) *pixel++ = (cformat) 1;                  \
-            /* Interpolate the color using barycentric coodinates */   \
+            /* Interpolate the color using barycentric coordinates */  \
             for (i = 0; i < cpp; ++i)                                  \
               *pixel++ = (cformat) P2TR_USE_BARYCENTRIC (u, v,         \
                   colA[i], colB[i], colC[i]);                          \
diff --git a/libs/rgbe/rgbe.c b/libs/rgbe/rgbe.c
index 9b6628dd..10e45852 100644
--- a/libs/rgbe/rgbe.c
+++ b/libs/rgbe/rgbe.c
@@ -443,7 +443,7 @@ rgbe_header_read_orientation (rgbe_file *file,
           goto cleanup;
 
   /* The termination check is simplified to a space check, as each set of
-   * axis parameters are space seperated. We double check for a newline next
+   * axis parameters are space separated. We double check for a newline next
    * though.
    */
   } while (*data++ == ' ');
diff --git a/operations/common/distance-transform.c b/operations/common/distance-transform.c
index 9ccc6f38..5572d020 100644
--- a/operations/common/distance-transform.c
+++ b/operations/common/distance-transform.c
@@ -292,7 +292,7 @@ binary_dt_1st_pass (GeglOperation *operation,
  * @param output the output buffer.
  * @param result the region of interest.
  * @param level the level of detail
- * @return True, if the filter was successfull applied.
+ * @return True, if the filter was successfully applied.
  */
 static gboolean
 process (GeglOperation       *operation,
diff --git a/seamless-clone/sc-context.c b/seamless-clone/sc-context.c
index 08370259..985a2400 100644
--- a/seamless-clone/sc-context.c
+++ b/seamless-clone/sc-context.c
@@ -421,7 +421,7 @@ gegl_sc_context_sample_color_difference (GeglScRenderInfo *info,
   GeglScColor bg_c[GEGL_SC_COLORA_CHANNEL_COUNT];
 
   /* If the outline point is outside the background, then we can't
-   * compute a propper difference there. So, don't add it to the
+   * compute a proper difference there. So, don't add it to the
    * sampling.
    *
    * The outline point obviously must lie inside the foreground, so
diff --git a/seamless-clone/sc-context.h b/seamless-clone/sc-context.h
index 48a360e1..a57b0194 100644
--- a/seamless-clone/sc-context.h
+++ b/seamless-clone/sc-context.h
@@ -96,7 +96,7 @@ void            gegl_sc_context_set_uvt_cache  (GeglScContext       *context,
 
 /**
  * Call this function to render the specified area of the seamless
- * cloning composition. This call must be preceeded by a call to
+ * cloning composition. This call must be preceded by a call to
  * the prepare function.
  */
 gboolean        gegl_sc_context_render         (GeglScContext       *context,
diff --git a/seamless-clone/sc-outline.c b/seamless-clone/sc-outline.c
index 1b033b14..82d6a836 100644
--- a/seamless-clone/sc-outline.c
+++ b/seamless-clone/sc-outline.c
@@ -26,7 +26,7 @@
  *   Island  - An opaque pixel with 8 non-opaque neighbors
  *   Edge    - An opaque pixel with at least 1 (out of 8) non-opaque
  *             neighbors
- *   Area    - A continuos region (using 8 neighbor connectivity) of
+ *   Area    - A continuous region (using 8 neighbor connectivity) of
  *             pixels with the same opacity state
  *   Outline - A non-repeating sequence of edge pixels where each pixel
  *             is a neighbor of the previous, and the first pixel is a
@@ -35,7 +35,7 @@
  * Currently, the logic in this file implements an algorithm for
  * finding one outline. If more than one outline exists (may happen due
  * to non-opaque areas inside opaque areas ("holes") or due to the
- * existance of more than one opaque area in the image)
+ * existence of more than one opaque area in the image)
  * NOTE: Island pixels are ignored in the outline finding algorithm
  */
 
@@ -147,7 +147,7 @@ is_valid_edge (const GeglRectangle *search_area,
  *   the line to the next outline pixel must contain only non-opaque
  *   pixels!
  * - So, use this property to go clockwise inside this circular sector
- *   untill you find an opaque pixel. That pixel must then be the next
+ *   until you find an opaque pixel. That pixel must then be the next
  *   edge pixel (when going in clock-wise direction)!
  */
 static inline GeglScDirection
diff --git a/seamless-clone/sc-sample.c b/seamless-clone/sc-sample.c
index 5c23b8d7..228ebc4f 100644
--- a/seamless-clone/sc-sample.c
+++ b/seamless-clone/sc-sample.c
@@ -112,7 +112,7 @@ gegl_sc_compute_sample_list_weights (gdouble           Px,
       /* Did the point match one of the outline points? If so, convert
        * the sample list to be made only of that outline point.
        * This shouldn't happen since we give a direct sample list to
-       * boundry points, but this is a backup and also in case that due
+       * boundary points, but this is a backup and also in case that due
        * to small distances the norm came out zero
        */
       if (norm1 == 0)
diff --git a/tests/simple/test-misc.c b/tests/simple/test-misc.c
index 78a59bdc..93d1fcae 100644
--- a/tests/simple/test-misc.c
+++ b/tests/simple/test-misc.c
@@ -51,7 +51,7 @@ test_misc_case_insensitive_extension_handler (void)
 
   gegl_operation_handlers_register_loader (lowercase, handler);
 
-  /* Make sure comparisions are case insensitive */
+  /* Make sure comparisons are case insensitive */
   received_handler = gegl_operation_handlers_get_loader (uppercase);
   if (strcmp (received_handler, handler) != 0)
     result = FAILURE;
