diff --git a/CHANGELOG.md b/CHANGELOG.md
index 05384f15cd0..a3e4de0309d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -169,7 +169,7 @@
   - `boundingbox` overwrites must now include a secondary space argument to work `boundingbox(plot, space::Symbol = :data)` [#3723](https://github.com/MakieOrg/Makie.jl/pull/3723)
   - `boundingbox` now always consider `transform_func` and `model`
   - `data_limits(::Scatter)` and `boundingbox(::Scatter)` now consider marker transformations [#3716](https://github.com/MakieOrg/Makie.jl/pull/3716)
-- **Breaking** Improved Float64 compatability of Axis [#3681](https://github.com/MakieOrg/Makie.jl/pull/3681)
+- **Breaking** Improved Float64 compatibility of Axis [#3681](https://github.com/MakieOrg/Makie.jl/pull/3681)
   - This added an extra conversion step which only takes effect when Float32 precision becomes relevant. In those cases code using `project()` functions will be wrong as the transformation is not applied. Use `project(plot_or_scene, ...)` or apply the conversion yourself beforehand with `Makie.f32_convert(plot_or_scene, transformed_point)` and use `patched_model = Makie.patch_model(plot_or_scene, model)`.
   - `Makie.to_world(point, matrix, resolution)` has been deprecated in favor of `Makie.to_world(scene_or_plot, point)` to include float32 conversions.
 - **Breaking** Reworked line shaders in GLMakie and WGLMakie [#3558](https://github.com/MakieOrg/Makie.jl/pull/3558)
@@ -230,7 +230,7 @@
 ## [0.20.7] - 2024-02-04
 
 - Equalized alignment point of mirrored ticks to that of normal ticks [#3598](https://github.com/MakieOrg/Makie.jl/pull/3598).
-- Fixed stack overflow error on conversion of gridlike data with missings [#3597](https://github.com/MakieOrg/Makie.jl/pull/3597).
+- Fixed stack overflow error on conversion of gridlike data with `missing`s [#3597](https://github.com/MakieOrg/Makie.jl/pull/3597).
 - Fixed mutation of CairoMakie src dir when displaying png files [#3588](https://github.com/MakieOrg/Makie.jl/pull/3588).
 - Added better error messages for plotting into `FigureAxisPlot` and `AxisPlot` as Plots.jl users are likely to do [#3596](https://github.com/MakieOrg/Makie.jl/pull/3596).
 - Added compat bounds for IntervalArithmetic.jl due to bug with DelaunayTriangulation.jl [#3595](https://github.com/MakieOrg/Makie.jl/pull/3595).
@@ -246,7 +246,7 @@
 - Use plot plot instead of scene transform functions in CairoMakie, fixing missplaced h/vspan. [#3552](https://github.com/MakieOrg/Makie.jl/pull/3552)
 - Fix error printing on shader error [#3530](https://github.com/MakieOrg/Makie.jl/pull/3530).
 - Update pagefind to 1.0.4 for better headline search [#3534](https://github.com/MakieOrg/Makie.jl/pull/3534).
-- Remove unecessary deps, e.g. Setfield [3546](https://github.com/MakieOrg/Makie.jl/pull/3546).
+- Remove unnecessary deps, e.g. Setfield [3546](https://github.com/MakieOrg/Makie.jl/pull/3546).
 - Don't clear args, rely on delete deregister_callbacks [#3543](https://github.com/MakieOrg/Makie.jl/pull/3543).
 - Add interpolate keyword for Surface [#3541](https://github.com/MakieOrg/Makie.jl/pull/3541).
 - Fix a DataInspector bug if inspector_label is used with RGB images [#3468](https://github.com/MakieOrg/Makie.jl/pull/3468).
@@ -591,7 +591,7 @@ role as `datalimits` in `violin` [#2137](https://github.com/MakieOrg/Makie.jl/pu
 - **Breaking** Cleaned up `Scene` type [#1192](https://github.com/MakieOrg/Makie.jl/pull/1192), [#1393](https://github.com/MakieOrg/Makie.jl/pull/1393). The `Scene()` constructor doesn't create any axes or limits anymore. All keywords like `raw`, `show_axis` have been removed. A scene now always works like it did when using the deprecated `raw=true`. All the high level functionality like showing an axis and adding a 3d camera has been moved to `LScene`. See the new `Scene` tutorial for more info: https://docs.makie.org/dev/tutorials/scenes/.
 - **Breaking** Lights got moved to `Scene`, see the [lighting docs](https://docs.makie.org/stable/documentation/lighting) and [RPRMakie examples](https://docs.makie.org/stable/documentation/backends/rprmakie/).
 - Added ECDF plot [#1310](https://github.com/MakieOrg/Makie.jl/pull/1310).
-- Added Order Independent Transparency to GLMakie [#1418](https://github.com/MakieOrg/Makie.jl/pull/1418), [#1506](https://github.com/MakieOrg/Makie.jl/pull/1506). This type of transparency is now used with `transpareny = true`. The old transparency handling is available with `transparency = false`.
+- Added Order Independent Transparency to GLMakie [#1418](https://github.com/MakieOrg/Makie.jl/pull/1418), [#1506](https://github.com/MakieOrg/Makie.jl/pull/1506). This type of transparency is now used with `transparency = true`. The old transparency handling is available with `transparency = false`.
 - Fixed blurry text in GLMakie and WGLMakie [#1494](https://github.com/MakieOrg/Makie.jl/pull/1494).
 - Introduced a new experimental backend for ray tracing: [RPRMakie](https://docs.makie.org/stable/documentation/backends/rprmakie/).
 - Added the `Cycled` type, which can be used to select the i-th value from the current cycler for a specific attribute [#1248](https://github.com/MakieOrg/Makie.jl/pull/1248).
diff --git a/CairoMakie/src/infrastructure.jl b/CairoMakie/src/infrastructure.jl
index 0f70934682b..4dc5d4deba9 100644
--- a/CairoMakie/src/infrastructure.jl
+++ b/CairoMakie/src/infrastructure.jl
@@ -154,7 +154,7 @@ end
 function draw_plot_as_image(scene::Scene, screen::Screen{RT}, primitive::Plot, scale::Number = 1) where RT
     # you can provide `p.rasterize = scale::Int` or `p.rasterize = true`, both of which are numbers
 
-    # Extract scene width in device indepentent units
+    # Extract scene width in device independent units
     w, h = size(scene)
     # Create a new Screen which renders directly to an image surface,
     # specifically for the plot's parent scene.
diff --git a/CairoMakie/src/primitives.jl b/CairoMakie/src/primitives.jl
index 795359670ca..4cf37ea8b7c 100644
--- a/CairoMakie/src/primitives.jl
+++ b/CairoMakie/src/primitives.jl
@@ -928,7 +928,7 @@ end
 function draw_mesh2D(screen, per_face_cols, vs::Vector{<: Point2}, fs::Vector{GLTriangleFace})
 
     ctx = screen.context
-    # Priorize colors of the mesh if present
+    # Prioritize colors of the mesh if present
     # This is a hack, which needs cleaning up in the Mesh plot type!
 
     for (f, (c1, c2, c3)) in zip(fs, per_face_cols)
@@ -984,7 +984,7 @@ function draw_mesh3D(
         meshuvs = map(uv -> uv_transform * to_ndim(Vec3f, uv, 1), meshuvs)
     end
 
-    # Priorize colors of the mesh if present
+    # Prioritize colors of the mesh if present
     color = hasproperty(mesh, :color) ? mesh.color : to_value(attributes.calculated_colors)
     per_face_col = per_face_colors(color, matcap, meshfaces, meshnormals, meshuvs)
 
diff --git a/CairoMakie/test/svg_tests.jl b/CairoMakie/test/svg_tests.jl
index da30bba0948..8d7f4239437 100644
--- a/CairoMakie/test/svg_tests.jl
+++ b/CairoMakie/test/svg_tests.jl
@@ -61,7 +61,7 @@ end
     @test svg_isnt_rasterized(poly(MultiPolyWrapper([poly1, poly1]); color=[:red, :blue]))
 end
 
-@testset "reproducable svg ids" begin
+@testset "reproducible svg ids" begin
     # https://github.com/MakieOrg/Makie.jl/issues/2406
     f, ax, sc = scatter(1:10)
     save("test1.svg", f)
diff --git a/GLMakie/src/GLAbstraction/AbstractGPUArray.jl b/GLMakie/src/GLAbstraction/AbstractGPUArray.jl
index 2241931b7f4..edfba611746 100644
--- a/GLMakie/src/GLAbstraction/AbstractGPUArray.jl
+++ b/GLMakie/src/GLAbstraction/AbstractGPUArray.jl
@@ -192,7 +192,7 @@ max_dim(t)       = error("max_dim not implemented for: $(typeof(t)). This happen
 
 function (::Type{GPUArrayType})(data::Observable; kw...) where GPUArrayType <: GPUArray
     gpu_mem = GPUArrayType(data[]; kw...)
-    # TODO merge these and handle update tracking during contruction
+    # TODO merge these and handle update tracking during construction
     obs2 = on(new_data -> update!(gpu_mem, new_data), data)
     if GPUArrayType <: TextureBuffer
         push!(gpu_mem.buffer.observers, obs2)
diff --git a/GLMakie/src/GLAbstraction/GLAbstraction.jl b/GLMakie/src/GLAbstraction/GLAbstraction.jl
index e8c36de91c7..67c6843ed10 100644
--- a/GLMakie/src/GLAbstraction/GLAbstraction.jl
+++ b/GLMakie/src/GLAbstraction/GLAbstraction.jl
@@ -53,7 +53,7 @@ export update!                  # updates a gpu array with a Julia array
 export gpu_data                 # gets the data of a gpu array as a Julia Array
 
 export RenderObject             # An object which holds all GPU handles and datastructes to ready for rendering by calling render(obj)
-export prerender!               # adds a function to a RenderObject, which gets executed befor setting the OpenGL render state
+export prerender!               # adds a function to a RenderObject, which gets executed before setting the OpenGL render state
 export postrender!              # adds a function to a RenderObject, which gets executed after setting the OpenGL render states
 export extract_renderable
 export set_arg!
diff --git a/GLMakie/src/GLAbstraction/GLRender.jl b/GLMakie/src/GLAbstraction/GLRender.jl
index 146eeb6dd44..357ce23781b 100644
--- a/GLMakie/src/GLAbstraction/GLRender.jl
+++ b/GLMakie/src/GLAbstraction/GLRender.jl
@@ -160,7 +160,7 @@ function renderinstanced(vao::GLVertexArray{GLBuffer{T}}, amount::Integer, primi
 end
 
 """
-Renders `amount` instances of an not indexed geoemtry geometry
+Renders `amount` instances of an not indexed geometry geometry
 """
 function renderinstanced(vao::GLVertexArray, amount::Integer, primitive=GL_TRIANGLES)
     glDrawElementsInstanced(primitive, length(vao), GL_UNSIGNED_INT, C_NULL, amount)
diff --git a/GLMakie/src/GLAbstraction/GLRenderObject.jl b/GLMakie/src/GLAbstraction/GLRenderObject.jl
index fe644f5c586..c47b2479849 100644
--- a/GLMakie/src/GLAbstraction/GLRenderObject.jl
+++ b/GLMakie/src/GLAbstraction/GLRenderObject.jl
@@ -30,7 +30,7 @@ function (sp::StandardPrerender)()
         glDepthFunc(GL_LEQUAL)
     end
 
-    # Disable cullface for now, untill all rendering code is corrected!
+    # Disable cullface for now, until all rendering code is corrected!
     glDisable(GL_CULL_FACE)
     # glCullFace(GL_BACK)
 
diff --git a/GLMakie/src/GLAbstraction/GLTexture.jl b/GLMakie/src/GLAbstraction/GLTexture.jl
index 39d3cf3bb60..e0334e490f7 100644
--- a/GLMakie/src/GLAbstraction/GLTexture.jl
+++ b/GLMakie/src/GLAbstraction/GLTexture.jl
@@ -430,7 +430,7 @@ default_colorformat_sym(::Type{T}) where {T <: Colorant} = default_colorformat_s
 @generated function default_colorformat(::Type{T}) where T
     sym = default_colorformat_sym(T)
     if !isdefined(ModernGL, sym)
-        error("$T doesn't have a propper mapping to an OpenGL format")
+        error("$T doesn't have a proper mapping to an OpenGL format")
     end
     :($sym)
 end
@@ -462,7 +462,7 @@ end
 @generated function default_internalcolorformat(::Type{T}) where T
     sym = default_internalcolorformat_sym(T)
     if !isdefined(ModernGL, sym)
-        error("$T doesn't have a propper mapping to an OpenGL format")
+        error("$T doesn't have a proper mapping to an OpenGL format")
     end
     :($sym)
 end
diff --git a/GLMakie/src/GLAbstraction/GLTypes.jl b/GLMakie/src/GLAbstraction/GLTypes.jl
index b9ce99f0167..b580152fcb9 100644
--- a/GLMakie/src/GLAbstraction/GLTypes.jl
+++ b/GLMakie/src/GLAbstraction/GLTypes.jl
@@ -401,7 +401,7 @@ function RenderObject(
     program = gl_convert(to_value(program), data) # "compile" lazyshader
     vertexarray = GLVertexArray(Dict(buffers), program)
 
-    # remove all uniforms not occuring in shader
+    # remove all uniforms not occurring in shader
     # ssao, instances transparency are special for rendering passes. TODO do this more cleanly
     special = Set([:ssao, :transparency, :instances, :fxaa, :num_clip_planes])
     for k in setdiff(keys(data), keys(program.nametype))
diff --git a/GLMakie/src/GLAbstraction/GLUtils.jl b/GLMakie/src/GLAbstraction/GLUtils.jl
index 4176bdc97b9..5fe35eda5c7 100644
--- a/GLMakie/src/GLAbstraction/GLUtils.jl
+++ b/GLMakie/src/GLAbstraction/GLUtils.jl
@@ -28,7 +28,7 @@ gen_defaults! dict begin
     a = 55
     b = a * 2 # variables, like a, will get made visible in local scope
     c::JuliaType = X # `c` needs to be of type JuliaType. `c` will be made available with it's original type and then converted to JuliaType when inserted into `dict`
-    d = x => GLType # OpenGL convert target. Get's only applied if `x` is convertible to GLType. Will only be converted when passed to RenderObject
+    d = x => GLType # OpenGL convert target. Gets only applied if `x` is convertible to GLType. Will only be converted when passed to RenderObject
     d = x => \"doc string\"
     d = x => (GLType, \"doc string and gl target\")
 end
@@ -39,12 +39,12 @@ macro gen_defaults!(dict, args)
         a = 55
         b = a * 2 # variables, like a, will get made visible in local scope
         c::JuliaType = X # c needs to be of type JuliaType. c will be made available with it's original type and then converted to JuliaType when inserted into data
-        d = x => GLType # OpenGL convert target. Get's only applied if x is convertible to GLType. Will only be converted when passed to RenderObject
+        d = x => GLType # OpenGL convert target. Gets only applied if x is convertible to GLType. Will only be converted when passed to RenderObject
     end")
     tuple_list = args.args
     dictsym = gensym()
     return_expression = Expr(:block)
-    push!(return_expression.args, :($dictsym = $dict)) # dict could also be an expression, so we need to asign it to a variable at the beginning
+    push!(return_expression.args, :($dictsym = $dict)) # dict could also be an expression, so we need to assign it to a variable at the beginning
     push!(return_expression.args, :(gl_convert_targets = get!($dictsym, :gl_convert_targets, Dict{Symbol, Any}()))) # exceptions for glconvert.
     push!(return_expression.args, :(doc_strings = get!($dictsym, :doc_string, Dict{Symbol, Any}()))) # exceptions for glconvert.
     # @gen_defaults can be used multiple times, so we need to reuse gl_convert_targets if already in here
diff --git a/GLMakie/src/glshaders/lines.jl b/GLMakie/src/glshaders/lines.jl
index c4fa81d8cf8..9f29d47d8b7 100644
--- a/GLMakie/src/glshaders/lines.jl
+++ b/GLMakie/src/glshaders/lines.jl
@@ -1,5 +1,5 @@
 function sumlengths(points, resolution)
-    # normalize w component if availabke
+    # normalize w component if available
     f(p::VecTypes{4}) = p[Vec(1, 2)] / p[4]
     f(p::VecTypes) = p[Vec(1, 2)]
 
@@ -45,10 +45,10 @@ function generate_indices(positions)
         # if A != F (no loop):   0 A B C D E F 0
         # where 0 is NaN
         # It marks vertices as invalid (0) if they are NaN, valid (1) if they
-        # are part of a continous line section, or as ghost edges (2) used to
+        # are part of a continuous line section, or as ghost edges (2) used to
         # cleanly close a loop. The shader detects successive vertices with
         # 1-2-0 and 0-2-1 validity to avoid drawing ghost segments (E-A from
-        # 0-E-A-B and F-B from E-F-B-0 which would dublicate E-F and A-B)
+        # 0-E-A-B and F-B from E-F-B-0 which would duplicate E-F and A-B)
 
         last_start_pos = eltype(ps)(NaN)
         last_start_idx = -1
@@ -60,7 +60,7 @@ function generate_indices(positions)
             if not_nan
                 if last_start_idx == -1
                     # place nan before section of line vertices
-                    # (or dublicate ps[1])
+                    # (or duplicate ps[1])
                     push!(indices, i-1)
                     last_start_idx = length(indices) + 1
                     last_start_pos = p
diff --git a/GLMakie/src/screen.jl b/GLMakie/src/screen.jl
index 6188b400bd3..31bd584a089 100644
--- a/GLMakie/src/screen.jl
+++ b/GLMakie/src/screen.jl
@@ -571,7 +571,7 @@ function destroy!(rob::RenderObject)
             # but we do share the texture atlas, so we check v !== tex, since we can't just free shared resources
 
             # TODO, refcounting, or leaving freeing to GC...
-            # GC is a bit tricky with active contexts, so immediate free is prefered.
+            # GC is a bit tricky with active contexts, so immediate free is preferred.
             # I guess as long as we make it hard for users to share buffers directly, this should be fine!
             GLAbstraction.free(v)
         end
@@ -978,7 +978,7 @@ function renderloop(screen)
     end
     if screen.close_after_renderloop
         try
-            @debug("Closing screen after quiting renderloop!")
+            @debug("Closing screen after quitting renderloop!")
             close(screen)
         catch e
             @warn "error closing screen" exception=(e, Base.catch_backtrace())
diff --git a/GLMakie/test/glmakie_refimages.jl b/GLMakie/test/glmakie_refimages.jl
index d4e911474db..afc81dd8c17 100644
--- a/GLMakie/test/glmakie_refimages.jl
+++ b/GLMakie/test/glmakie_refimages.jl
@@ -10,7 +10,7 @@ using ReferenceTests.RNG
     # Directly access texture parameters:
     x = Sampler(fill(to_color(:yellow), 100, 100), minfilter=:nearest)
     scene = image(x)
-    # indexing will go straight to the GPU, while only transfering the changes
+    # indexing will go straight to the GPU, while only transferring the changes
     st = Stepper(scene)
     x[1:10, 1:50] .= to_color(:red)
     Makie.step!(st)
diff --git a/GLMakie/test/unit_tests.jl b/GLMakie/test/unit_tests.jl
index 6e08a85aba3..d62843af195 100644
--- a/GLMakie/test/unit_tests.jl
+++ b/GLMakie/test/unit_tests.jl
@@ -133,7 +133,7 @@ end
     end
 end
 
-@testset "emtpy!(fig)" begin
+@testset "empty!(fig)" begin
     GLMakie.closeall()
     fig = Figure()
     ax = Axis(fig[1,1])
diff --git a/MakieCore/src/conversion.jl b/MakieCore/src/conversion.jl
index 16c450ffc17..09d91fd9f9b 100644
--- a/MakieCore/src/conversion.jl
+++ b/MakieCore/src/conversion.jl
@@ -139,7 +139,7 @@ to be overloaded for DimConversions, e.g. for CategoricalConversion:
 `has_typed_convert(plot_or_trait)` and `should_dim_convert(get_element_type(args))`
  are true. The former is defined as true by `@convert_target`, i.e. when
 `convert_arguments_typed` is defined for the given plot type or conversion trait.
-The latter marks specific types as convertable.
+The latter marks specific types as convertible.
 
 If a recipe wants to use dim conversions, it should overload this function:
 ```julia
diff --git a/RPRMakie/src/meshes.jl b/RPRMakie/src/meshes.jl
index d635d58a8f7..b77138d10f2 100644
--- a/RPRMakie/src/meshes.jl
+++ b/RPRMakie/src/meshes.jl
@@ -167,7 +167,7 @@ function to_rpr_object(context, matsys, scene, plot::Makie.Surface)
     positions = lift(grid, x, y, z, Makie.transform_func_obs(plot))
     r = Tesselation(Rect2f((0, 0), (1, 1)), size(z[]))
     # decomposing a rectangle into uv and triangles is what we need to map the z coordinates on
-    # since the xyz data assumes the coordinates to have the same neighouring relations
+    # since the xyz data assumes the coordinates to have the same neighbouring relations
     # like a grid
     faces = decompose(GLTriangleFace, r)
     uv = decompose_uv(r)
diff --git a/ReferenceTests/src/tests/categorical.jl b/ReferenceTests/src/tests/categorical.jl
index bd2bd4865cb..4740ac2a4a4 100644
--- a/ReferenceTests/src/tests/categorical.jl
+++ b/ReferenceTests/src/tests/categorical.jl
@@ -11,7 +11,7 @@ using Makie: Categorical
 end
 
 @reference_test "different types without sorting function" begin
-    # If we set the ticks explicitely, with sortby defaulting to nothing,
+    # If we set the ticks explicitly, with sortby defaulting to nothing,
     # we can combine all objects:
     f = Figure()
     ax = Axis(f[1, 1];
@@ -42,7 +42,7 @@ end
     f
 end
 
-@reference_test "new categories, inbetween old values" begin
+@reference_test "new categories, in between old values" begin
     obs = Observable(Categorical(["a", "c", "e", "g"]))
     f, ax, p = scatter(1:4, obs, markersize=20, color=1:4, colormap=:viridis)
     obs[] = Categorical(["b", "d", "f", "h"])
diff --git a/ReferenceTests/src/tests/primitives.jl b/ReferenceTests/src/tests/primitives.jl
index f13448dd51d..919e74e903b 100644
--- a/ReferenceTests/src/tests/primitives.jl
+++ b/ReferenceTests/src/tests/primitives.jl
@@ -573,7 +573,7 @@ end
     campixel!(scene)
     # marker is in front, so it should not be smaller than the background rectangle
     plot_row!(scene, 0, false)
-    # marker is in the background, so one shouldnt see a single pixel of the marker
+    # marker is in the background, so one shouldn't see a single pixel of the marker
     plot_row!(scene, 300, true)
 
     center = Point2f(size(scene) ./ 2)
diff --git a/ReferenceUpdater/src/local_server.jl b/ReferenceUpdater/src/local_server.jl
index 4496911129d..668af3fd6d9 100644
--- a/ReferenceUpdater/src/local_server.jl
+++ b/ReferenceUpdater/src/local_server.jl
@@ -276,7 +276,7 @@ function group_files(path, input_filename, output_filename)
         end
     end
 
-    # generate new structed file
+    # generate new structured file
     open(joinpath(path, output_filename), "w") do file
         for (filename, valid) in data
             println(file,
diff --git a/ReferenceUpdater/src/reference_images.html b/ReferenceUpdater/src/reference_images.html
index 29f4f69e309..61af9f3e80f 100644
--- a/ReferenceUpdater/src/reference_images.html
+++ b/ReferenceUpdater/src/reference_images.html
@@ -57,7 +57,7 @@ <h2>Images with references</h2>
         This is the normal case where the selected CI run produced an image and the reference image exists.
         Each row shows one image per backend from the same reference image test, which can be compared with its reference image.
         Rows are sorted based on the maximum row score (bigger = more different).
-        Red cells fail CI (assuming the thresholds are up to date), yellow cells may but likely don't have signficant visual difference and gray cells are visually equivalent.
+        Red cells fail CI (assuming the thresholds are up to date), yellow cells may but likely don't have significant visual difference and gray cells are visually equivalent.
         <br><br>
         <div id="refimage-list" class="image-list"></div>
     </body>
diff --git a/WGLMakie/src/display.jl b/WGLMakie/src/display.jl
index a6070ebeb4b..16ebcb93588 100644
--- a/WGLMakie/src/display.jl
+++ b/WGLMakie/src/display.jl
@@ -87,13 +87,13 @@ function render_with_init(screen::Screen, session::Session, scene::Scene)
         if isready(screen.plot_initialized)
             # plot_initialized contains already an item
             # This should not happen, but lets check anyways, so it errors and doesn't hang forever
-            error("Plot inititalized multiple times?")
+            error("Plot initialized multiple times?")
         end
         if initialized == true
             put!(screen.plot_initialized, true)
             mark_as_displayed!(screen, scene)
         else
-            # Will be an eror from WGLMakie.js
+            # Will be an error from WGLMakie.js
             put!(screen.plot_initialized, initialized)
         end
         return
@@ -230,7 +230,7 @@ function get_screen_session(screen::Screen; timeout=100,
     success = Bonito.wait_for(() -> isready(screen.plot_initialized); timeout=timeout)
     # Throw error if error message specified
     if success !== :success
-        throw_error("Timed out waiting $(timeout)s for session to get initilize")
+        throw_error("Timed out waiting $(timeout)s for session to get initialize")
         return nothing
     end
     value = fetch(screen.plot_initialized)
@@ -316,7 +316,7 @@ function insert_scene!(session::Session, screen::Screen, scene::Scene)
         scene_ser = serialize_scene(scene)
         parent = scene.parent
         parent_uuid = js_uuid(parent)
-        err = "Cant find scene js_uuid(scene) == $(parent_uuid)"
+        err = "Cannot find scene js_uuid(scene) == $(parent_uuid)"
         evaljs_value(session, js"""
         $(WGL).then(WGL=> {
             const parent = WGL.find_scene($(parent_uuid));
diff --git a/WGLMakie/src/lines.jl b/WGLMakie/src/lines.jl
index 3a9864657c3..239b3cd2e37 100644
--- a/WGLMakie/src/lines.jl
+++ b/WGLMakie/src/lines.jl
@@ -41,7 +41,7 @@ function serialize_three(scene::Scene, plot::Union{Lines, LineSegments})
 
     # This is mostly NaN handling. The shader only draws a segment if each
     # involved point are not NaN, i.e. p1 -- p2 is only drawn if all of
-    # (p0, p1, p2, p3) are not NaN. So if p3 is NaN we need to dublicate p2 to
+    # (p0, p1, p2, p3) are not NaN. So if p3 is NaN we need to duplicate p2 to
     # make the p1 -- p2 segment draw, which is what indices does.
     indices = Observable(UInt32[])
     points_transformed = lift(
@@ -76,12 +76,12 @@ function serialize_three(scene::Scene, plot::Union{Lines, LineSegments})
                             # (nan, i-2, j, i+1) the segment (i-2, j) will not
                             # be drawn (which we want as that segment would overlap)
 
-                            # tweak dublicated vertices to be loop vertices
+                            # tweak duplicated vertices to be loop vertices
                             push!(indices[], indices[][loop_start_idx+1])
                             indices[][loop_start_idx-1] = i-2
                             # nan is inserted at bottom (and not necessary for start/end)
 
-                        else # no loop, dublicate end point
+                        else # no loop, duplicate end point
                             push!(indices[], i-1)
                         end
                     end
@@ -90,7 +90,7 @@ function serialize_three(scene::Scene, plot::Union{Lines, LineSegments})
                 else
 
                     if was_nan
-                        # line section start - dublicate point
+                        # line section start - duplicate point
                         push!(indices[], i)
                         # first point in a potential loop
                         loop_start_idx = length(indices[])+1
@@ -102,7 +102,7 @@ function serialize_three(scene::Scene, plot::Union{Lines, LineSegments})
                 push!(indices[], i)
             end
 
-            # Finish line (insert dublicate end point or close loop)
+            # Finish line (insert duplicate end point or close loop)
             if !was_nan
                 if loop_start_idx != -1 && (loop_start_idx + 2 < length(indices[])) &&
                     (transformed_points[indices[][loop_start_idx]] ≈ transformed_points[end])
@@ -145,9 +145,9 @@ function serialize_three(scene::Scene, plot::Union{Lines, LineSegments})
                 prev = scale .* Point2f(clip) ./ clip[4]
 
                 # calculate cumulative pixel scale length
-                output[1] = 0f0   # dublicated point
+                output[1] = 0f0   # duplicated point
                 output[2] = 0f0   # start of first line segment
-                output[end] = 0f0 # dublicated end point
+                output[end] = 0f0 # duplicated end point
                 i = 3           # end of first line segment, start of second
                 while i < length(ps)
                     if isfinite(ps[i])
@@ -187,7 +187,7 @@ function serialize_three(scene::Scene, plot::Union{Lines, LineSegments})
             uniforms[Symbol("$(name)_end")] = attr
         else
             # TODO: to js?
-            # dublicates per vertex attributes to match positional dublication
+            # duplicates per vertex attributes to match positional duplication
             # min(idxs, end) avoids update order issues here
             attributes[name] = lift(plot, indices, attr) do idxs, vals
                 serialize_buffer_attribute(vals[min.(idxs, end)])
diff --git a/WGLMakie/src/serialization.jl b/WGLMakie/src/serialization.jl
index a2942c681b3..64adb5bda0b 100644
--- a/WGLMakie/src/serialization.jl
+++ b/WGLMakie/src/serialization.jl
@@ -317,7 +317,7 @@ end
 
 function serialize_plots(scene::Scene, plots::Vector{Plot}, result=[])
     for plot in plots
-        # if no plots inserted, this truely is an atomic
+        # if no plots inserted, this truly is an atomic
         if isempty(plot.plots)
             plot_data = serialize_three(scene, plot)
             plot_data[:uuid] = js_uuid(plot)
diff --git a/WGLMakie/src/voxel.jl b/WGLMakie/src/voxel.jl
index a9d395565db..f8ba21e5242 100644
--- a/WGLMakie/src/voxel.jl
+++ b/WGLMakie/src/voxel.jl
@@ -89,7 +89,7 @@ function create_shader(scene::Scene, plot::Makie.Voxels)
     onany(plot, plot.gap, plot.converted[end]) do gap, chunk
         N = sum(size(chunk))
         N_instances = ifelse(gap > 0.01, 2 * N, N + 3)
-        if N_instances != length(dummy_data[]) # avoid updating unneccesarily
+        if N_instances != length(dummy_data[]) # avoid updating unnecessarily
             dummy_data[] = [0f0 for _ in 1:N_instances]
         end
         return
diff --git a/WGLMakie/test/runtests.jl b/WGLMakie/test/runtests.jl
index f625dbe893d..a54d8ebce69 100644
--- a/WGLMakie/test/runtests.jl
+++ b/WGLMakie/test/runtests.jl
@@ -10,7 +10,7 @@ import Electron
     @testset for mime in Makie.WEB_MIMES
         @test showable(mime(), f)
     end
-    # I guess we explicitely don't say we can show those since it's highly Inefficient compared to html
+    # I guess we explicitly don't say we can show those since it's highly Inefficient compared to html
     # See: https://github.com/MakieOrg/Makie.jl/blob/master/WGLMakie/src/display.jl#L66-L68=
     @test !showable("image/png", f)
     @test !showable("image/jpeg", f)
diff --git a/docs/src/explanations/backends/glmakie.md b/docs/src/explanations/backends/glmakie.md
index fd43d9bd2c6..358e0af89ff 100644
--- a/docs/src/explanations/backends/glmakie.md
+++ b/docs/src/explanations/backends/glmakie.md
@@ -62,7 +62,7 @@ GLMakie has experimental support for displaying multiple independent figures (or
 ## Embedding
 
 There's experimental support for embedding GLMakie by creating a custom 'window'
-type (analagous to the GLFW OS-level window) and grabbing GLMakie's framebuffers
+type (analogous to the GLFW OS-level window) and grabbing GLMakie's framebuffers
 to display in your own GUI. Here's a high-level overview of what you'd need to
 do:
 
@@ -91,7 +91,7 @@ do:
    calling `GLMakie.render_frame(screen)` whenever necessary (you can use
    `GLMakie.requires_update(screen)`).
 1. `display(screen, f)` will only draw the figure to a framebuffer. You can get
-   the color texture attachement of the framebuffer with
+   the color texture attachment of the framebuffer with
    `screen.framebuffer.buffers[:color]`, and display that color texture as an
    image in your chosen GUI framework.
 1. If interactivity is desired, you will need to pass input events from the
diff --git a/docs/src/explanations/backends/rprmakie.md b/docs/src/explanations/backends/rprmakie.md
index e697f59db95..fa3c7efd600 100644
--- a/docs/src/explanations/backends/rprmakie.md
+++ b/docs/src/explanations/backends/rprmakie.md
@@ -36,7 +36,7 @@ lights = [
 ]
 
 # Only LScene is supported right now,
-# since the other projections don't map to the pysical acurate Camera in RPR.
+# since the other projections don't map to the physical accurate Camera in RPR.
 ax = LScene(fig[1, 1]; show_axis = false, scenekw=(lights=lights,))
 # Note that since RPRMakie doesn't yet support text (this is being worked on!),
 # you can't show a 3d axis yet.
diff --git a/docs/src/explanations/backends/wglmakie.md b/docs/src/explanations/backends/wglmakie.md
index e2cf49153a5..27a919ea7f9 100644
--- a/docs/src/explanations/backends/wglmakie.md
+++ b/docs/src/explanations/backends/wglmakie.md
@@ -105,7 +105,7 @@ Bonito allows to record a statemap for all widgets, that satisfy the following i
 ```julia
 # must be true to be found inside the DOM
 is_widget(x) = true
-# Updating the widget isn't dependant on any other state (only thing supported right now)
+# Updating the widget isn't dependent on any other state (only thing supported right now)
 is_independant(x) = true
 # The values a widget can iterate
 function value_range end
diff --git a/docs/src/reference/blocks/colorbar.md b/docs/src/reference/blocks/colorbar.md
index a46f4df7e8f..dec42371b99 100644
--- a/docs/src/reference/blocks/colorbar.md
+++ b/docs/src/reference/blocks/colorbar.md
@@ -75,7 +75,7 @@ fig
 ```
 
 
-We can't use `cgrad(...; categorical=true)` for this, since it has an ambigious meaning for true categorical values.
+We can't use `cgrad(...; categorical=true)` for this, since it has an ambiguous meaning for true categorical values.
 
 ## Attributes
 
diff --git a/docs/src/reference/blocks/intervalslider.md b/docs/src/reference/blocks/intervalslider.md
index c6bcee7b8cb..aec38a7ae92 100644
--- a/docs/src/reference/blocks/intervalslider.md
+++ b/docs/src/reference/blocks/intervalslider.md
@@ -16,7 +16,7 @@ If the mouse hovers over the central area of the interval and both buttons are e
 You can double-click the slider to reset it to the values present in `startvalues`.
 If `startvalues === Makie.automatic`, the full interval will be selected (this is the default).
 
-If you set the attribute `snap = false`, the slider will move continously while dragging and only jump to the closest available values when releasing the mouse.
+If you set the attribute `snap = false`, the slider will move continuously while dragging and only jump to the closest available values when releasing the mouse.
 
 ```@example intervalslider
 using GLMakie
diff --git a/docs/src/reference/blocks/polaraxis.md b/docs/src/reference/blocks/polaraxis.md
index 35a08499b97..04f67285706 100644
--- a/docs/src/reference/blocks/polaraxis.md
+++ b/docs/src/reference/blocks/polaraxis.md
@@ -80,7 +80,7 @@ Note that by default translations in adjustments of rmin and thetalimits are blo
 These can be unblocked by calling `autolimits!(ax[, true])` which also tells the PolarAxis to derive r- and thetalimits freely from data, or by setting `ax.fixrmin[] = false` and `ax.thetazoomlock[] = false`.
 
 
-## Plot type compatability
+## Plot type compatibility
 
 Not every plot type is compatible with the polar transform.
 For example `image` is not as it expects to be drawn on a rectangle.
diff --git a/docs/src/reference/blocks/slider.md b/docs/src/reference/blocks/slider.md
index a05362e9927..99d4c5df7ec 100644
--- a/docs/src/reference/blocks/slider.md
+++ b/docs/src/reference/blocks/slider.md
@@ -11,7 +11,7 @@ This is necessary to ensure the value is actually present in the `range` attribu
 
 You can double-click the slider to reset it (approximately) to the value present in `startvalue`.
 
-If you set the attribute `snap = false`, the slider will move continously while dragging and only jump to the closest available value when releasing the mouse.
+If you set the attribute `snap = false`, the slider will move continuously while dragging and only jump to the closest available value when releasing the mouse.
 
 ```@figure backend=GLMakie
 
diff --git a/docs/src/reference/plots/datashader.md b/docs/src/reference/plots/datashader.md
index 45f0f3a45dc..f000f369a58 100644
--- a/docs/src/reference/plots/datashader.md
+++ b/docs/src/reference/plots/datashader.md
@@ -203,7 +203,7 @@ datashader(Dict(:category_a => all_points_a, :category_b => all_points_b))
 ```
 
 The type of the category doesn't matter, but will get converted to strings internally, to be displayed nicely in the legend.
-Categories are currently aggregated in one Canvas per category, and then overlayed with alpha blending.
+Categories are currently aggregated in one Canvas per category, and then overlaid with alpha blending.
 
 ```@figure backend=GLMakie
 normaldist = randn(Point2f, 1_000_000)
diff --git a/docs/src/reference/plots/heatmap.md b/docs/src/reference/plots/heatmap.md
index e2971df597a..ff21cd163b0 100644
--- a/docs/src/reference/plots/heatmap.md
+++ b/docs/src/reference/plots/heatmap.md
@@ -126,7 +126,7 @@ setting the colorrange explicitly, so that it is independent of the data shown b
 that particular heatmap.
 
 Since the heatmaps in the example below have the same colorrange and colormap, any of them
-can be passed to `Colorbar` to give the colorbar the same attributes. Alternativly,
+can be passed to `Colorbar` to give the colorbar the same attributes. Alternatively,
 the colorbar attributes can be set explicitly.
 
 ```@figure
diff --git a/docs/src/reference/plots/rainclouds.md b/docs/src/reference/plots/rainclouds.md
index de99693c2ed..06d571b2ce0 100644
--- a/docs/src/reference/plots/rainclouds.md
+++ b/docs/src/reference/plots/rainclouds.md
@@ -177,7 +177,7 @@ rainclouds!(
     plot_boxplots = false,
     color = colors[indexin(category_labels, unique(category_labels))])
 
-# Plots wiht more categories
+# Plots with more categories
 # dist_between_categories (0.6, 1.0)
 # with and without clouds
 
diff --git a/docs/src/tutorials/scenes.md b/docs/src/tutorials/scenes.md
index 91d98e929b4..cc62e243eae 100644
--- a/docs/src/tutorials/scenes.md
+++ b/docs/src/tutorials/scenes.md
@@ -8,7 +8,7 @@ scene = Scene(;
     clear = true,
     # the camera struct of the scene.
     visible = true,
-    # ssao and light are explained in more detail in `Documetation/Lighting`
+    # ssao and light are explained in more detail in `Documentation/Lighting`
     ssao = Makie.SSAO(),
     # Creates lights from theme, which right now defaults to `
     # set_theme!(lightposition=:eyeposition, ambient=RGBf(0.5, 0.5, 0.5))`
diff --git a/src/Makie.jl b/src/Makie.jl
index 6d6a6452068..1137e94148d 100644
--- a/src/Makie.jl
+++ b/src/Makie.jl
@@ -198,7 +198,7 @@ include("layouting/text_layouting.jl")
 include("layouting/boundingbox.jl")
 include("layouting/text_boundingbox.jl")
 
-# Declaritive SpecApi
+# Declarative SpecApi
 include("specapi.jl")
 
 # more default recipes
diff --git a/src/basic_recipes/barplot.jl b/src/basic_recipes/barplot.jl
index 4cf1d69f7e5..a93aa92d28a 100644
--- a/src/basic_recipes/barplot.jl
+++ b/src/basic_recipes/barplot.jl
@@ -21,7 +21,7 @@ function bar_default_fillto(tf, ys, offset, in_y_direction)
     return ys, offset
 end
 
-# `fillto` is related to `y-axis` transofrmation only, thus we expect `tf::Tuple`
+# `fillto` is related to `y-axis` transformation only, thus we expect `tf::Tuple`
 function bar_default_fillto(tf::Tuple, ys, offset, in_y_direction)
     _logT = Union{typeof(log), typeof(log2), typeof(log10), Base.Fix1{typeof(log), <: Real}}
     if in_y_direction && tf[2] isa _logT || (!in_y_direction && tf[1] isa _logT)
diff --git a/src/basic_recipes/datashader.jl b/src/basic_recipes/datashader.jl
index cffd2b098d6..321d1d75819 100644
--- a/src/basic_recipes/datashader.jl
+++ b/src/basic_recipes/datashader.jl
@@ -15,10 +15,10 @@ abstract type AggOp end
 using Makie
 canvas = Canvas(-1, 1, -1, 1; op=AggCount(), resolution=(800, 800))
 aggregate!(canvas, points; point_transform=reverse, method=AggThreads())
-aggregated_values = get_aggregation(canvas; operation=equalize_histogram, local_operation=identiy)
-# Recipes are defined for canvas as well and incorperate the `get_aggregation`, but `aggregate!` must be called manually.
-image!(canvas; operation=equalize_histogram, local_operation=identiy, colormap=:viridis, colorrange=(0, 20))
-surface!(canvas; operation=equalize_histogram, local_operation=identiy)
+aggregated_values = get_aggregation(canvas; operation=equalize_histogram, local_operation=identity)
+# Recipes are defined for canvas as well and incorporate the `get_aggregation`, but `aggregate!` must be called manually.
+image!(canvas; operation=equalize_histogram, local_operation=identity, colormap=:viridis, colorrange=(0, 20))
+surface!(canvas; operation=equalize_histogram, local_operation=identity)
 ```
 """
 mutable struct Canvas
@@ -291,7 +291,7 @@ For best performance, use `method=Makie.AggThreads()` and make sure to start jul
 @recipe DataShader (points,) begin
     """
     Can be `AggCount()`, `AggAny()` or `AggMean()`.
-    Be sure, to use the correct element type e.g. `AggCount{Float32}()`, which needs to accomodate the output of `local_operation`.
+    Be sure, to use the correct element type e.g. `AggCount{Float32}()`, which needs to accommodate the output of `local_operation`.
     User-extensible by overloading:
     ```julia
     struct MyAgg{T} <: Makie.AggOp end
@@ -500,7 +500,7 @@ function legendelements(plot::FakePlot, legend)
     return [PolyElement(; color=plot.attributes.color, strokecolor=legend.polystrokecolor, strokewidth=legend.polystrokewidth)]
 end
 
-# Sadly we must define the colorbar here and cant use the default fallback,
+# Sadly we must define the colorbar here and can't use the default fallback,
 # Since the Image plot will only see the scaled data, and since its hard to make Colorbar support the equalize_histogram
 # transform, we just create the colorbar form the raw data.
 # TODO, should we merge the local/global op with colorscale?
diff --git a/src/basic_recipes/raincloud.jl b/src/basic_recipes/raincloud.jl
index 767d6a32264..a450ae0c750 100644
--- a/src/basic_recipes/raincloud.jl
+++ b/src/basic_recipes/raincloud.jl
@@ -190,7 +190,7 @@ end
 
 function ungroup_labels(category_labels, data_array)
     if eltype(data_array) <: AbstractVector
-        @warn "Using a nested array for raincloud is deprected. Read raincloud's documentation and update your usage accordingly."
+        @warn "Using a nested array for raincloud is deprecated. Read raincloud's documentation and update your usage accordingly."
         data_array_ = reduce(vcat, data_array)
         category_labels_ = similar(category_labels, length(data_array_))
         ix = 0
diff --git a/src/basic_recipes/text.jl b/src/basic_recipes/text.jl
index 2c38861e438..a033fadeaef 100644
--- a/src/basic_recipes/text.jl
+++ b/src/basic_recipes/text.jl
@@ -189,7 +189,7 @@ function plot!(plot::Text{<:Tuple{<:AbstractArray{<:Tuple{<:Any, <:Point}}}})
         pos_unequal = positions.val != poss
         strings_unequal && (strings.val = strs)
         pos_unequal && (positions.val = poss)
-        # Check for equality very imortant, otherwise we get an infinite loop
+        # Check for equality very important, otherwise we get an infinite loop
         strings_unequal && notify(strings)
         pos_unequal && notify(positions)
 
diff --git a/src/basic_recipes/timeseries.jl b/src/basic_recipes/timeseries.jl
index cb7bd8ba3bb..7409047fac5 100644
--- a/src/basic_recipes/timeseries.jl
+++ b/src/basic_recipes/timeseries.jl
@@ -10,7 +10,7 @@ scene = timeseries(signal)
 display(scene)
 # @async is optional, but helps to continue evaluating more code
 @async while isopen(scene)
-    # aquire data from e.g. a sensor:
+    # acquire data from e.g. a sensor:
     data = rand()
     # update the signal
     signal[] = data
diff --git a/src/bezier.jl b/src/bezier.jl
index 20107e0bdbf..03d74c32e34 100644
--- a/src/bezier.jl
+++ b/src/bezier.jl
@@ -642,7 +642,7 @@ function render_path(path, bitmap_size_px = 256)
     # freetype has no ClosePath and EllipticalArc, so those need to be replaced
     path_replaced = replace_nonfreetype_commands(path)
 
-    # Minimal size that becomes integer when mutliplying by 64 (target size for
+    # Minimal size that becomes integer when multiplying by 64 (target size for
     # atlas). This adds padding to avoid blurring/scaling factors from rounding
     # during sdf generation
     path_size = widths(bbox(path)) / maximum(widths(bbox(path)))
diff --git a/src/configuration.yaml b/src/configuration.yaml
index 5a7f32fec1c..ef9fb5f065b 100644
--- a/src/configuration.yaml
+++ b/src/configuration.yaml
@@ -18,7 +18,7 @@ theme:
 
   SSAO:
     enable: false
-    bias: 0.025 # z threshhold for occlusion
+    bias: 0.025 # z threshold for occlusion
     radius: 0.5 # range of sample positions (in world space)
     blur: 2 # A (2blur+1) by (2blur+1) range is used for blurring
     N_samples: 64 # number of samples (requires shader reload)
diff --git a/src/conversions.jl b/src/conversions.jl
index 81fdad94dcc..cfdd000a1ae 100644
--- a/src/conversions.jl
+++ b/src/conversions.jl
@@ -36,7 +36,7 @@ end
 # if no specific conversion is defined, we don't convert
 convert_single_argument(@nospecialize(x)) = x
 
-# replace missings with NaNs
+# replace `missing`s with `NaN`s
 function convert_single_argument(a::AbstractArray{<:Union{Missing, <:Real}})
     return float_convert(a)
 end
@@ -195,7 +195,7 @@ end
 function convert_arguments(::Type{<: Lines}, rect::Rect3{T}) where {T}
     PT = Point3{float_type(T)}
     points = unique(decompose(PT, rect))
-    push!(points, PT(NaN)) # use to seperate linesegments
+    push!(points, PT(NaN)) # use to separate linesegments
     return (points[[1, 2, 3, 4, 1, 5, 6, 2, 9, 6, 8, 3, 9, 5, 7, 4, 9, 7, 8]],)
 end
 """
@@ -406,7 +406,7 @@ function convert_arguments(::CellGrid, x::EndPointsLike, y::EndPointsLike,
     Ty = typeof(ye[1])
     # heatmaps are centered on the edges, so we need to adjust the range
     # This is done in conversions, since it's also how we calculate the boundingbox (heatmapplot.x, heatmap.y)
-    # We need the endpoint type here, since convert_arguments((0, 1), (0, 1), z), whcih only substracts the step
+    # We need the endpoint type here, since convert_arguments((0, 1), (0, 1), z), which only subtracts the step
     # Will end in a stackoverflow, since convert_arguments gets called every time the `args_in != args_out`.
     # If we return a different type with no conversion overload, it stops that recursion
     return (EndPoints{Tx}(xe[1] - xstep, xe[2] + xstep), EndPoints{Ty}(ye[1] - ystep, ye[2] + ystep), el32convert(z))
@@ -1136,7 +1136,7 @@ function line_diff_pattern(ls::Symbol, gaps::GapType = :normal)
     else
         error(
             """
-            Unkown line style: $ls. Available linestyles are:
+            Unknown line style: $ls. Available linestyles are:
             :solid, :dash, :dot, :dashdot, :dashdotdot
             or a sequence of numbers enumerating the next transparent/opaque region.
             This sequence of numbers must be cumulative; 1 unit corresponds to 1 line width.
@@ -1463,7 +1463,7 @@ function available_gradients()
 end
 
 
-to_colormap(cm, categories::Integer) = error("`to_colormap(cm, categories)` is deprecated. Use `Makie.categorical_colors(cm, categories)` for categorical colors, and `resample_cmap(cmap, ncolors)` for continous resampling.")
+to_colormap(cm, categories::Integer) = error("`to_colormap(cm, categories)` is deprecated. Use `Makie.categorical_colors(cm, categories)` for categorical colors, and `resample_cmap(cmap, ncolors)` for continuous resampling.")
 
 """
     categorical_colors(colormaplike, categories::Integer)
diff --git a/src/dim-converts/categorical-integration.jl b/src/dim-converts/categorical-integration.jl
index 126aa859231..8d9d7936e74 100644
--- a/src/dim-converts/categorical-integration.jl
+++ b/src/dim-converts/categorical-integration.jl
@@ -14,7 +14,7 @@ scatter(1:4, Categorical(["a", "b", "c", "a"]))
 ```
 
 ```julia
-# Explicitely set them for other types:
+# Explicitly set them for other types:
 struct Named
     value
 end
diff --git a/src/dim-converts/dates-integration.jl b/src/dim-converts/dates-integration.jl
index f7b6ac54189..b8d51646481 100644
--- a/src/dim-converts/dates-integration.jl
+++ b/src/dim-converts/dates-integration.jl
@@ -36,7 +36,7 @@ date_time_range = range(date_time, step=Week(5), length=10)
 # Automatically chose xticks as DateTeimeTicks:
 scatter(date_time_range, 1:10)
 
-# explicitely chose DateTimeConversion and use it to plot unitful values into it and display in the `Time` format:
+# explicitly chose DateTimeConversion and use it to plot unitful values into it and display in the `Time` format:
 using Makie.Unitful
 conversion = Makie.DateTimeConversion(Time)
 scatter(1:4, (1:4) .* u"s", axis=(dim2_conversion=conversion,))
diff --git a/src/dim-converts/dim-converts.jl b/src/dim-converts/dim-converts.jl
index d4c32829311..bedb297883d 100644
--- a/src/dim-converts/dim-converts.jl
+++ b/src/dim-converts/dim-converts.jl
@@ -75,7 +75,7 @@ end
 
 
 # Recursively gets the dim convert from the plot
-# This needs to be recursive to allow recipes to use dim converst
+# This needs to be recursive to allow recipes to use dim convert
 # TODO, should a recipe always set the dim convert to it's parent?
 get_conversions(any) = nothing
 
diff --git a/src/display.jl b/src/display.jl
index b0d33f21979..c5ce72610de 100644
--- a/src/display.jl
+++ b/src/display.jl
@@ -22,7 +22,7 @@ end
 """
     push_screen!(scene::Scene, screen::MakieScreen)
 
-Adds a screen to the scene and registeres a clean up event when screen closes.
+Adds a screen to the scene and registered a clean up event when screen closes.
 Also, makes sure that always just one screen is active for on scene.
 """
 function push_screen!(scene::Scene, screen::T) where {T<:MakieScreen}
@@ -140,7 +140,7 @@ function Base.display(figlike::FigureLike; backend=current_backend(),
         """)
     end
 
-    # We show inline if explicitely requested or if automatic and we can actually show something inline!
+    # We show inline if explicitly requested or if automatic and we can actually show something inline!
     scene = get_scene(figlike)
     if (inline === true || inline === automatic) && can_show_inline(backend)
         # We can't forward the screenconfig to show, but show uses the current screen if there is any
@@ -187,7 +187,7 @@ end
 # Since VSCode doesn't call any display/show method for Figurelike if we return
 # `showable(mime, fig) == false`, we need to return `showable(mime, figlike) == true`
 # For some vscode displayable mime, even for `Makie.inline!(false)` when we want to display in our own window.
-# Only diagnostic can be used for this, since other mimes expect something to be shown afterall and
+# Only diagnostic can be used for this, since other mimes expect something to be shown after all and
 # therefore will look broken in the plotpane if we dont print anything to the IO.
 # I tried `throw(MethodError(...))` as well, but with plotpane enabled + showable == true,
 # VScode doesn't catch that method error.
diff --git a/src/documentation/documentation.jl b/src/documentation/documentation.jl
index 31001416569..f9879545d95 100644
--- a/src/documentation/documentation.jl
+++ b/src/documentation/documentation.jl
@@ -172,7 +172,7 @@ end
 """
     to_func(Typ)
 
-Maps the input of a Type name to its cooresponding function.
+Maps the input of a Type name to its corresponding function.
 """
 function to_func(Typ::Type{<: AbstractPlot{F}}) where F
     F
@@ -184,7 +184,7 @@ to_func(func::Function) = func
 """
     to_type(func)
 
-Maps the input of a function name to its cooresponding Type.
+Maps the input of a function name to its corresponding Type.
 """
 to_type(func::Function) = Plot{func}
 
diff --git a/src/ffmpeg-util.jl b/src/ffmpeg-util.jl
index 2bb14ffad61..9a9aea2d63f 100644
--- a/src/ffmpeg-util.jl
+++ b/src/ffmpeg-util.jl
@@ -50,7 +50,7 @@ struct VideoStreamOptions
             pixel_format, loop, loglevel::String, input::String, rawvideo::Bool=true)
 
         if !isa(framerate, Integer)
-            @warn "The given framefrate is not a subtype of `Integer`, and will be rounded to the nearest integer. To supress this warning, provide an integer as the framerate."
+            @warn "The given framefrate is not a subtype of `Integer`, and will be rounded to the nearest integer. To suppress this warning, provide an integer as the framerate."
             framerate = round(Int, framerate)
         end
 
diff --git a/src/float32-scaling.jl b/src/float32-scaling.jl
index deb4e5e0464..0b769fbe9b5 100644
--- a/src/float32-scaling.jl
+++ b/src/float32-scaling.jl
@@ -107,7 +107,7 @@ function patch_model(@nospecialize(plot), f32c::Float32Convert, model::Observabl
 
     onany(plot, f32c.scaling, model, update = true) do f32c, model
         # Neutral f32c can mean that data and model cancel each other and we 
-        # still have Float32 preicsion issues inbetween.
+        # still have Float32 preicsion issues in between.
 
         # works with rotation component as well, but drops signs on scale
         trans, scale = decompose_translation_scale_matrix(model)
@@ -122,7 +122,7 @@ function patch_model(@nospecialize(plot), f32c::Float32Convert, model::Observabl
         elseif is_float_safe(scale, trans) && is_rot_free
             # model can be applied on GPU and we can pull f32c through the 
             # model matrix. This can be merged with the option below, but 
-            # keeping them separate improves compatability with transform_marker
+            # keeping them separate improves compatibility with transform_marker
             scale = Vec3d(model[1, 1], model[2, 2], model[3, 3]) # existing scale is missing signs
             f32c_obs[] = Makie.LinearScaling(
                 f32c.scale, ((f32c.scale .- 1) .* trans .+ f32c.offset) ./ scale
@@ -195,7 +195,7 @@ conversion applied to the given limits results in a range not representable
 with Float32 to high enough precision, the conversion will update. After the
 update update the converted range will be -1 .. 1.
 
-The function returns true if an update has occured. If `Nothing` is passed, the
+The function returns true if an update has occurred. If `Nothing` is passed, the
 function always returns false.
 """
 function update_limits!(c::Float32Convert, mini::VecTypes{3, Float64}, maxi::VecTypes{3, Float64})
diff --git a/src/interaction/inspector.jl b/src/interaction/inspector.jl
index ba8a6901728..f5e166ef393 100644
--- a/src/interaction/inspector.jl
+++ b/src/interaction/inspector.jl
@@ -286,11 +286,11 @@ function DataInspector(scene::Scene; priority = 100, kwargs...)
             on_hover(inspector)
         end
     end
-    listners = onany(e.mouseposition, e.scroll) do _, _
+    listeners = onany(e.mouseposition, e.scroll) do _, _
         empty_channel!(channel) # remove queued up hover requests
         put!(channel, nothing)
     end
-    append!(inspector.obsfuncs, listners)
+    append!(inspector.obsfuncs, listeners)
     on(base_attrib.enable_indicators) do enabled
         if !enabled
             yield()
diff --git a/src/jl_rasterizer/bmp.jl b/src/jl_rasterizer/bmp.jl
index bf35407b4d3..e18a6d27f77 100644
--- a/src/jl_rasterizer/bmp.jl
+++ b/src/jl_rasterizer/bmp.jl
@@ -24,8 +24,8 @@ function writebmp(io, img)
     write(io, UInt32(0)) # image bits size
     write(io, Int32(0)) # horz resoluition in pixel / m
     write(io, Int32(0)) # vert resolutions (0x03C3 = 96 dpi, 0x0B13 = 72 dpi)
-    write(io, Int32(0)) #colors in pallete
-    write(io, Int32(0)) #important colors
+    write(io, Int32(0)) # colors in palette
+    write(io, Int32(0)) # important colors
 
     for i in h:-1:1
         for j in 1:w
diff --git a/src/makielayout/blocks/colorbar.jl b/src/makielayout/blocks/colorbar.jl
index 02075a67272..9dc1be7ab0c 100644
--- a/src/makielayout/blocks/colorbar.jl
+++ b/src/makielayout/blocks/colorbar.jl
@@ -82,7 +82,7 @@ function extract_colormap_recursive(@nospecialize(plot::T)) where {T <: Abstract
             # Prefer ColorMapping if in doubt!
             cmaps = filter(x-> x isa ColorMapping, colormaps)
             length(cmaps) == 1 && return cmaps[1]
-            error("Multiple colormaps found for plot $(plot), please specify which one to use manually. Please overload `Makie.extract_colormap(::$(T))` to allow for the automatical creation of a Colorbar.")
+            error("Multiple colormaps found for plot $(plot), please specify which one to use manually. Please overload `Makie.extract_colormap(::$(T))` to allow for the automatic creation of a Colorbar.")
         end
     end
 end
@@ -93,7 +93,7 @@ function Colorbar(fig_or_scene, plot::AbstractPlot; kwargs...)
     func = plotfunc(plot)
     if isnothing(cmap)
         error("Neither $(func) nor any of its children use a colormap. Cannot create a Colorbar from this plot, please create it manually.
-        If this is a recipe, one needs to overload `Makie.extract_colormap(::$(Plot{func}))` to allow for the automatical creation of a Colorbar.")
+        If this is a recipe, one needs to overload `Makie.extract_colormap(::$(Plot{func}))` to allow for the automatic creation of a Colorbar.")
     end
     if !(cmap isa ColorMapping)
         error("extract_colormap(::$(Plot{func})) returned an invalid value: $cmap. Needs to return either a `Makie.ColorMapping`.")
@@ -222,9 +222,9 @@ function initialize_block!(cb::Colorbar)
     update_xyrange(barbox[], cb.vertical[], colors[], cmap.scale[], cmap.color_mapping_type[])
     onany(update_xyrange, blockscene, barbox, cb.vertical, colors, cmap.scale, cmap.color_mapping_type)
 
-    # for continous colormaps we sample a 1d image
+    # for continuous colormaps we sample a 1d image
     # to avoid white lines when rendering vector graphics
-    continous_pixels = lift(blockscene, cb.vertical, colors,
+    continuous_pixels = lift(blockscene, cb.vertical, colors,
                             cmap.color_mapping_type) do v, colors, mapping_type
         if mapping_type !== Makie.categorical
             colors = (colors[1:end-1] .+ colors[2:end]) ./2
@@ -235,26 +235,26 @@ function initialize_block!(cb::Colorbar)
     # TODO, implement interpolate = true for irregular grics in CairoMakie
     # Then, we can just use heatmap! and don't need the image plot!
     show_cats = Observable(false; ignore_equal_values=true)
-    show_continous = Observable(false; ignore_equal_values=true)
+    show_continuous = Observable(false; ignore_equal_values=true)
     on(blockscene, cmap.color_mapping_type; update=true) do type
         if type === continuous
-            show_continous[] = true
+            show_continuous[] = true
             show_cats[] = false
         else
-            show_continous[] = false
+            show_continuous[] = false
             show_cats[] = true
         end
     end
     heatmap!(blockscene,
-        xrange, yrange, continous_pixels;
+        xrange, yrange, continuous_pixels;
         colormap=colormap,
         visible=show_cats,
         inspectable=false
     )
     image!(blockscene,
-        lift(extrema, xrange), lift(extrema, yrange), continous_pixels;
+        lift(extrema, xrange), lift(extrema, yrange), continuous_pixels;
         colormap = colormap,
-        visible = show_continous,
+        visible = show_continuous,
         inspectable = false
     )
 
diff --git a/src/makielayout/blocks/polaraxis.jl b/src/makielayout/blocks/polaraxis.jl
index 13ce889dec0..efc6c2d3dcc 100644
--- a/src/makielayout/blocks/polaraxis.jl
+++ b/src/makielayout/blocks/polaraxis.jl
@@ -1,5 +1,5 @@
 ################################################################################
-### Main Block Intialization
+### Main Block Initialization
 ################################################################################
 
 function initialize_block!(po::PolarAxis; palette=nothing)
diff --git a/src/specapi.jl b/src/specapi.jl
index 2f5e1a6e08d..8f4bf7dd11e 100644
--- a/src/specapi.jl
+++ b/src/specapi.jl
@@ -288,7 +288,7 @@ end
 
 function distance_score(a::BlockSpec, b::BlockSpec, scores_dict)
     a === b && return 0.0
-    (a.type !== b.type) && return 100.0 # Cant update when types dont match
+    (a.type !== b.type) && return 100.0 # Can't update when types dont match
     get!(scores_dict, (a, b)) do
         scores = Float64[
             distance_score(a.kwargs, b.kwargs, scores_dict),
@@ -448,7 +448,7 @@ function update_plot!(obs_to_notify, plot::AbstractPlot, oldspec::PlotSpec, spec
         end
     end
     # Cycling needs to be handled separately sadly,
-    # since they're implicitely mutating attributes, e.g. if I re-use a plot
+    # since they're implicitly mutating attributes, e.g. if I re-use a plot
     # that has been on cycling position 2, and now I re-use it for the first plot in the list
     # it will need to change to the color of cycling position 1
     if haskey(plot, :cycle)
diff --git a/src/stats/violin.jl b/src/stats/violin.jl
index 2e4f418223c..b42a61e7161 100644
--- a/src/stats/violin.jl
+++ b/src/stats/violin.jl
@@ -59,7 +59,7 @@ function plot!(plot::Violin)
                                dodge, n_dodge, gap, dodge_gap, orientation
         x̂, violinwidth = compute_x_and_width(x, width, gap, dodge, n_dodge, dodge_gap)
 
-        # for horizontal violin just flip all componentes
+        # for horizontal violin just flip all components
         point_func = Point2f
         if orientation === :horizontal
             point_func = flip_xy ∘ point_func
diff --git a/src/theming.jl b/src/theming.jl
index 00841657e68..a4aebd95c33 100644
--- a/src/theming.jl
+++ b/src/theming.jl
@@ -9,7 +9,7 @@ function wong_colors(alpha = 1.0)
         RGB(0/255, 158/255, 115/255), # green
         RGB(204/255, 121/255, 167/255), # reddish purple
         RGB(86/255, 180/255, 233/255), # sky blue
-        RGB(213/255, 94/255, 0/255), # vermillion
+        RGB(213/255, 94/255, 0/255), # vermilion
         RGB(240/255, 228/255, 66/255), # yellow
     ]
     return RGBAf.(colors, alpha)
@@ -64,7 +64,7 @@ const MAKIE_DEFAULT_THEME = Attributes(
     limits = automatic,
     SSAO = Attributes(
         # enable = false,
-        bias = 0.025f0,       # z threshhold for occlusion
+        bias = 0.025f0,       # z threshold for occlusion
         radius = 0.5f0,       # range of sample positions (in world space)
         blur = Int32(2),      # A (2blur+1) by (2blur+1) range is used for blurring
         # N_samples = 64,       # number of samples (requires shader reload)
@@ -72,7 +72,7 @@ const MAKIE_DEFAULT_THEME = Attributes(
     inspectable = true,
     clip_planes = Vector{Plane3f}(),
 
-    # Vec is equvalent to 36° right/east, 39° up/north from camera position
+    # Vec is equivalent to 36° right/east, 39° up/north from camera position
     # The order here is Vec3f(right of, up from, towards) viewer/camera
     light_direction = Vec3f(-0.45679495, -0.6293204, -0.6287243),
     camera_relative_light = true, # Only applies to default DirectionalLight
diff --git a/src/types.jl b/src/types.jl
index b99c5d56e60..7160cdc7b4e 100644
--- a/src/types.jl
+++ b/src/types.jl
@@ -21,7 +21,7 @@ include("interaction/iodevices.jl")
 
 Identifies the source of a tick:
 - `BackendTick`: A tick used for backend purposes which is not present in `event.tick`.
-- `UnknownTickState`: A tick from an uncategorized source (e.g. intialization of Events).
+- `UnknownTickState`: A tick from an uncategorized source (e.g. initialization of Events).
 - `PausedRenderTick`: A tick from a paused renderloop.
 - `SkippedRenderTick`: A tick from a running renderloop where the previous image was reused.
 - `RegularRenderTick`: A tick from a running renderloop where a new image was produced.
diff --git a/src/utilities/utilities.jl b/src/utilities/utilities.jl
index ee44ed34814..52e9cf7870a 100644
--- a/src/utilities/utilities.jl
+++ b/src/utilities/utilities.jl
@@ -298,7 +298,7 @@ function merged_get!(defaults::Function, key, scene::SceneLike, input::Attribute
     d = defaults()
     if haskey(theme(scene), key)
         # we need to merge theme(scene) with the defaults, because it might be an incomplete theme
-        # TODO have a mark that says "theme uncomplete" and only then get the defaults
+        # TODO have a mark that says "theme incomplete" and only then get the defaults
         d = merge!(to_value(theme(scene, key)), d)
     end
     return merge!(input, d)
@@ -427,7 +427,7 @@ function nan_aware_normals(vertices::AbstractVector{<:GeometryBasics.PointMeta{D
 end
 
 function surface2mesh(xs, ys, zs::AbstractMatrix, transform_func = identity, space = :data)
-    # crate a `Matrix{Point3}`
+    # create a `Matrix{Point3}`
     # ps = matrix_grid(identity, xs, ys, zs)
     ps = matrix_grid(p -> apply_transform(transform_func, p, space), xs, ys, zs)
     # create valid tessellations (triangulations) for the mesh
diff --git a/test/Plane.jl b/test/Plane.jl
index f3cac789700..3b528b5344f 100644
--- a/test/Plane.jl
+++ b/test/Plane.jl
@@ -86,7 +86,7 @@ using Makie: Plane, Plane3f, Point3d, Rect3d, Vec3d
         @test eachindex(ps) == Makie.unclipped_indices([plane], ps, :other)
     end
 
-    @testset "Tranformations" begin
+    @testset "Transformations" begin
         # Test apply_transform()
         plane = Plane(Point3f(1), Vec3f(0,0,1))
         v = normalize(2f0 .* rand(Vec3f) .- 1)
diff --git a/test/PolarAxis.jl b/test/PolarAxis.jl
index c05b24c0289..dcfc45535a3 100644
--- a/test/PolarAxis.jl
+++ b/test/PolarAxis.jl
@@ -13,7 +13,7 @@
         )
         rticklabelplot = po.overlay.plots[8].plots[1]
 
-        # Mostly for verfication that we got the right plot
+        # Mostly for verification that we got the right plot
         @test po.overlay.plots[8][1][] == [("0.0", Point2f(0.0, 0.0)), ("2.5", Point2f(0.25, 0.0)), ("5.0", Point2f(0.5, 0.0)), ("7.5", Point2f(0.75, 0.0)), ("10.0", Point2f(1.0, 0.0))]
 
         # automatic
diff --git a/test/convert_arguments.jl b/test/convert_arguments.jl
index 77e9e525815..a075c27b133 100644
--- a/test/convert_arguments.jl
+++ b/test/convert_arguments.jl
@@ -68,7 +68,7 @@ end
     @test_throws ArgumentError heatmap(1im)
 end
 
-# custom vector type to ensure that the conversion can be overriden for vectors
+# custom vector type to ensure that the conversion can be overridden for vectors
 struct MyConvVector <: AbstractVector{Float64} end
 Makie.convert_arguments(::PointBased, ::MyConvVector) = ([Point(10, 20)],)
 
diff --git a/test/events.jl b/test/events.jl
index 3e5ac1b2392..524d029e69e 100644
--- a/test/events.jl
+++ b/test/events.jl
@@ -230,7 +230,7 @@ Base.:(==)(l::Or, r::Or) = l.left == r.left && l.right == r.right
 
 
 
-        # Reset state so this is indepentent from the last checks
+        # Reset state so this is independent from the last checks
         scene = Scene(size=(800, 600));
         e = events(scene)
         cam3d!(scene, fixed_axis=true, cad=false, zoom_shift_lookat=false)
diff --git a/test/float32convert.jl b/test/float32convert.jl
index cd2408c8509..d01ace2079d 100644
--- a/test/float32convert.jl
+++ b/test/float32convert.jl
@@ -16,7 +16,7 @@ using Makie: Mat4f, Vec2d, Vec3d, Point2d, Point3d, Point4d
     f32min = Float64(floatmin(Float32)) * f32c.resolution
     f32eps = Float64(eps(Float32)) * f32c.resolution
 
-    @testset "Intialization" begin
+    @testset "Initialization" begin
         @test f32c.scaling[] == unit_scaling
         @test f32c.resolution == 1f4 # this may be subject to change
     end
diff --git a/test/ray_casting.jl b/test/ray_casting.jl
index 1d159fc0e75..2d9d39ae11f 100644
--- a/test/ray_casting.jl
+++ b/test/ray_casting.jl
@@ -276,7 +276,7 @@
         end
     end
 
-    # Optional - show selected positon
+    # Optional - show selected position
     # This may change the camera, so don't use it for test values
     # for apply_transform = false, add `transformation = transform`
     scatter!(scene, pos, color = :red, strokewidth = 1.0, strokecolor = :yellow, depth_shift = -1f-1)
diff --git a/test/scenes.jl b/test/scenes.jl
index a2c26e96b92..1a7876bcca7 100644
--- a/test/scenes.jl
+++ b/test/scenes.jl
@@ -4,8 +4,8 @@
     @testset "getproperty(scene, :$field)" for field in fieldnames(Scene)
         @test getproperty(scene, field) !== missing # well, just don't error
     end
-    @test theme(nothing, :nonexistant, default=1) == 1
-    @test theme(scene, :nonexistant, default=1) == 1
+    @test theme(nothing, :nonexistent, default=1) == 1
+    @test theme(scene, :nonexistent, default=1) == 1
 end
 
 @testset "Lighting" begin