diff --git a/base/accumulate.jl b/base/accumulate.jl
index 663bd850695a8..eeb9759e125c7 100644
--- a/base/accumulate.jl
+++ b/base/accumulate.jl
@@ -280,7 +280,7 @@ function accumulate(op, A; dims::Union{Nothing,Integer}=nothing, kw...)
     elseif keys(nt) === (:init,)
         out = similar(A, promote_op(op, typeof(nt.init), eltype(A)))
     else
-        throw(ArgumentError("acccumulate does not support the keyword arguments $(setdiff(keys(nt), (:init,)))"))
+        throw(ArgumentError("accumulate does not support the keyword arguments $(setdiff(keys(nt), (:init,)))"))
     end
     accumulate!(op, out, A; dims=dims, kw...)
 end
@@ -341,7 +341,7 @@ function accumulate!(op, B, A; dims::Union{Integer, Nothing} = nothing, kw...)
     elseif keys(kw) === (:init,)
         _accumulate!(op, B, A, dims, Some(nt.init))
     else
-        throw(ArgumentError("acccumulate! does not support the keyword arguments $(setdiff(keys(nt), (:init,)))"))
+        throw(ArgumentError("accumulate! does not support the keyword arguments $(setdiff(keys(nt), (:init,)))"))
     end
 end
 
diff --git a/base/binaryplatforms.jl b/base/binaryplatforms.jl
index f323ad4f2800e..cf08a961772da 100644
--- a/base/binaryplatforms.jl
+++ b/base/binaryplatforms.jl
@@ -259,14 +259,14 @@ end
 
 function set_compare_strategy!(p::Platform, key::String, f::Function)
     if !haskey(p.tags, key)
-        throw(ArgumentError("Cannot set comparison strategy for nonexistant tag $(key)!"))
+        throw(ArgumentError("Cannot set comparison strategy for nonexistent tag $(key)!"))
     end
     p.compare_strategies[key] = f
 end
 
 function get_compare_strategy(p::Platform, key::String, default = compare_default)
     if !haskey(p.tags, key)
-        throw(ArgumentError("Cannot get comparison strategy for nonexistant tag $(key)!"))
+        throw(ArgumentError("Cannot get comparison strategy for nonexistent tag $(key)!"))
     end
     return get(p.compare_strategies, key, default)
 end
diff --git a/base/c.jl b/base/c.jl
index 7d168f2293c9c..cfff070973f25 100644
--- a/base/c.jl
+++ b/base/c.jl
@@ -129,7 +129,7 @@ A C-style string composed of the native wide character type
 [`Cwchar_t`](@ref)s. `Cwstring`s are NUL-terminated. For
 C-style strings composed of the native character
 type, see [`Cstring`](@ref). For more information
-about string interopability with C, see the
+about string interoperability with C, see the
 [manual](@ref man-bits-types).
 
 """
@@ -142,7 +142,7 @@ A C-style string composed of the native character type
 [`Cchar`](@ref)s. `Cstring`s are NUL-terminated. For
 C-style strings composed of the native wide character
 type, see [`Cwstring`](@ref). For more information
-about string interopability with C, see the
+about string interoperability with C, see the
 [manual](@ref man-bits-types).
 """
 Cstring
diff --git a/base/checked.jl b/base/checked.jl
index c3c8a888dcd1c..d5b4112397e84 100644
--- a/base/checked.jl
+++ b/base/checked.jl
@@ -42,12 +42,12 @@ const UnsignedInt = Union{UInt8,UInt16,UInt32,UInt64,UInt128}
 
 # LLVM has several code generation bugs for checked integer arithmetic (see e.g.
 # #4905). We thus distinguish between operations that can be implemented via
-# intrinsics, and operations for which we have to provide work-arounds.
+# intrinsics, and operations for which we have to provide workarounds.
 
 # Note: As far as this code has been tested, most checked_* functions are
 # working fine in LLVM. (Note that division is still handled via `base/int.jl`,
 # which always checks for overflow, and which provides its own sets of
-# work-arounds for LLVM codegen bugs.) However, the comments in `base/int.jl`
+# workarounds for LLVM codegen bugs.) However, the comments in `base/int.jl`
 # and in issue #4905 are more pessimistic. For the time being, we thus retain
 # the ability to handle codegen bugs in LLVM, until the code here has been
 # tested on more systems and architectures. It also seems that things depend on
diff --git a/base/compiler/abstractinterpretation.jl b/base/compiler/abstractinterpretation.jl
index 5b3bbdd433760..0c1fe25ff96a5 100644
--- a/base/compiler/abstractinterpretation.jl
+++ b/base/compiler/abstractinterpretation.jl
@@ -559,7 +559,7 @@ function abstract_call_method(interp::AbstractInterpreter, method::Method, @nosp
         end
 
         if isdefined(method, :recursion_relation)
-            # We don't recquire the recursion_relation to be transitive, so
+            # We don't require the recursion_relation to be transitive, so
             # apply a hard limit
             hardlimit = true
         end
@@ -855,7 +855,7 @@ function concrete_eval_call(interp::AbstractInterpreter,
         value = try
             Core._call_in_world_total(world, f, args...)
         catch
-            # The evaulation threw. By :consistent-cy, we're guaranteed this would have happened at runtime
+            # The evaluation threw. By :consistent-cy, we're guaranteed this would have happened at runtime
             return ConstCallResults(Union{}, ConcreteResult(result.edge::MethodInstance, result.effects), result.effects)
         end
         if is_inlineable_constant(value) || call_result_unused(sv)
@@ -1449,7 +1449,7 @@ function abstract_apply(interp::AbstractInterpreter, argtypes::Vector{Any}, sv::
             for j = 1:length(ctypes)
                 ct = ctypes[j]::Vector{Any}
                 if isvarargtype(ct[end])
-                    # This is vararg, we're not gonna be able to do any inling,
+                    # This is vararg, we're not gonna be able to do any inlining,
                     # drop the info
                     info = nothing
                     tail = tuple_tail_elem(unwrapva(ct[end]), cti)
diff --git a/base/compiler/abstractlattice.jl b/base/compiler/abstractlattice.jl
index 80b16615e87b0..83e64cd4a042f 100644
--- a/base/compiler/abstractlattice.jl
+++ b/base/compiler/abstractlattice.jl
@@ -60,7 +60,7 @@ const IPOResultLattice = typeof(InterConditionalsLattice(PartialsLattice(ConstsL
 """
     struct InferenceLattice{L}
 
-The full lattice used for abstract interpration during inference. Takes
+The full lattice used for abstract interpretation during inference. Takes
 a base lattice and adjoins `LimitedAccuracy`.
 """
 struct InferenceLattice{L} <: AbstractLattice
@@ -85,7 +85,7 @@ is_valid_lattice(lattice::OptimizerLattice, @nospecialize(elem)) =
     tmeet(lattice, a, b::Type)
 
 Compute the lattice meet of lattice elements `a` and `b` over the lattice
-`lattice`. If `lattice` is `JLTypeLattice`, this is equiavalent to type
+`lattice`. If `lattice` is `JLTypeLattice`, this is equivalent to type
 intersection. Note that currently `b` is restricted to being a type (interpreted
 as a lattice element in the JLTypeLattice sub-lattice of `lattice`).
 """
@@ -113,7 +113,7 @@ function tmerge end
 
 Compute the lattice ordering (i.e. less-than-or-equal) relationship between
 lattice elements `a` and `b` over the lattice `lattice`. If `lattice` is
-`JLTypeLattice`, this is equiavalent to subtyping.
+`JLTypeLattice`, this is equivalent to subtyping.
 """
 function ⊑ end
 
diff --git a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
index 7785e61f31e09..e49d650bcf17b 100644
--- a/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
+++ b/base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl
@@ -773,7 +773,7 @@ A preparatory linear scan before the escape analysis on `ir` to find:
     This array dimension analysis to compute `arrayinfo` is very local and doesn't account
     for flow-sensitivity nor complex aliasing.
     Ideally this dimension analysis should be done as a part of type inference that
-    propagates array dimenstions in a flow sensitive way.
+    propagates array dimensions in a flow sensitive way.
 """
 function compute_frameinfo(ir::IRCode, call_resolved::Bool)
     nstmts, nnewnodes = length(ir.stmts), length(ir.new_nodes.stmts)
@@ -1876,13 +1876,13 @@ end
 # # COMBAK do we want to enable this (and also backport this to Base for array allocations?)
 # import Core.Compiler: Cint, svec
 # function validate_foreigncall_args(args::Vector{Any},
-#     name::Symbol, @nospecialize(rt), argtypes::SimpleVector, nreq::Int, convension::Symbol)
+#     name::Symbol, @nospecialize(rt), argtypes::SimpleVector, nreq::Int, convention::Symbol)
 #     length(args) ≥ 5 || return false
 #     normalize(args[1]) === name || return false
 #     args[2] === rt || return false
 #     args[3] === argtypes || return false
 #     args[4] === vararg || return false
-#     normalize(args[5]) === convension || return false
+#     normalize(args[5]) === convention || return false
 #     return true
 # end
 
diff --git a/base/compiler/ssair/inlining.jl b/base/compiler/ssair/inlining.jl
index 94a008b3830e3..5e6872c213399 100644
--- a/base/compiler/ssair/inlining.jl
+++ b/base/compiler/ssair/inlining.jl
@@ -81,7 +81,7 @@ end
 @specialize
 
 function ssa_inlining_pass!(ir::IRCode, linetable::Vector{LineInfoNode}, state::InliningState, propagate_inbounds::Bool)
-    # Go through the function, performing simple ininlingin (e.g. replacing call by constants
+    # Go through the function, performing simple inlining (e.g. replacing call by constants
     # and analyzing legality of inlining).
     @timeit "analysis" todo = assemble_inline_todo!(ir, state)
     isempty(todo) && return ir
@@ -1174,7 +1174,7 @@ function narrow_opaque_closure!(ir::IRCode, stmt::Expr, @nospecialize(info), sta
         # Narrow opaque closure type
         newT = widenconst(tmeet(OptimizerLattice(), tmerge(OptimizerLattice(), lb, info.unspec.rt), ub))
         if newT != ub
-            # N.B.: Narrowing the ub requires a backdge on the mi whose type
+            # N.B.: Narrowing the ub requires a backedge on the mi whose type
             # information we're using, since a change in that function may
             # invalidate ub result.
             stmt.args[3] = newT
@@ -1329,7 +1329,7 @@ function compute_inlining_cases(infos::Vector{MethodMatchInfo},
         handled_all_cases &= handle_match!(match, argtypes, flag, state, cases, #=allow_abstract=#true, #=allow_typevars=#true)
     elseif length(cases) == 0 && only_method isa Method
         # if the signature is fully covered and there is only one applicable method,
-        # we can try to inline it even in the prescence of unmatched sparams
+        # we can try to inline it even in the presence of unmatched sparams
         # -- But don't try it if we already tried to handle the match in the revisit_idx
         # case, because that'll (necessarily) be the same method.
         if length(infos) > 1
@@ -1676,7 +1676,7 @@ function early_inline_special_case(
         setting = setting.val
         isa(setting, Symbol) || return nothing
         setting === :const || setting === :conditional || setting === :type || return nothing
-        # barrierred successfully already, eliminate it
+        # barriered successfully already, eliminate it
         return SomeCase(stmt.args[3])
     end
     return nothing
diff --git a/base/compiler/ssair/passes.jl b/base/compiler/ssair/passes.jl
index ddc72963854ae..b718bb072485b 100644
--- a/base/compiler/ssair/passes.jl
+++ b/base/compiler/ssair/passes.jl
@@ -140,7 +140,7 @@ function has_safe_def(
         # if this block has already been examined, bail out to avoid infinite cycles
         pred in seen && return false
         idx = last(ir.cfg.blocks[pred].stmts)
-        # NOTE `idx` isn't a load, thus we can use inclusive coondition within the `find_def_for_use`
+        # NOTE `idx` isn't a load, thus we can use inclusive condition within the `find_def_for_use`
         def, _, _ = find_def_for_use(ir, domtree, allblocks, du, idx, true)
         # will throw since we already checked this `:new` site doesn't define this field
         def == newidx && return false
diff --git a/base/compiler/typeinfer.jl b/base/compiler/typeinfer.jl
index e30e2fc9f7e2d..08d9c4bbd244c 100644
--- a/base/compiler/typeinfer.jl
+++ b/base/compiler/typeinfer.jl
@@ -680,7 +680,7 @@ end
 # returns `nothing` otherwise
 function find_dominating_assignment(id::Int, idx::Int, sv::InferenceState)
     block = block_for_inst(sv.cfg, idx)
-    for pc in reverse(sv.cfg.blocks[block].stmts) # N.B. reverse since the last assignement is dominating this block
+    for pc in reverse(sv.cfg.blocks[block].stmts) # N.B. reverse since the last assignment is dominating this block
         pc < idx || continue # N.B. needs pc ≠ idx as `id` can be assigned at `idx`
         stmt = sv.src.code[pc]
         isexpr(stmt, :(=)) || continue
diff --git a/base/compiler/typelattice.jl b/base/compiler/typelattice.jl
index d389b4cd399c4..75ca2f45a02c6 100644
--- a/base/compiler/typelattice.jl
+++ b/base/compiler/typelattice.jl
@@ -78,7 +78,7 @@ InterConditional(var::SlotNumber, @nospecialize(thentype), @nospecialize(elsetyp
     InterConditional(slot_id(var), thentype, elsetype)
 
 const AnyConditional = Union{Conditional,InterConditional}
-Conditional(cnd::InterConditional) = Conditinal(cnd.slot, cnd.thentype, cnd.elsetype)
+Conditional(cnd::InterConditional) = Conditional(cnd.slot, cnd.thentype, cnd.elsetype)
 InterConditional(cnd::Conditional) = InterConditional(cnd.slot, cnd.thentype, cnd.elsetype)
 
 struct PartialTypeVar
@@ -106,7 +106,7 @@ struct StateUpdate
 end
 
 # Represent that the type estimate has been approximated, due to "causes"
-# (only used in abstract interpretion, doesn't appear in optimization)
+# (only used in abstract interpretation, doesn't appear in optimization)
 # N.B. in the lattice, this is epsilon smaller than `typ` (except Union{})
 struct LimitedAccuracy
     typ
diff --git a/base/deprecated.jl b/base/deprecated.jl
index 8d07abc687bd7..87fc670cd594a 100644
--- a/base/deprecated.jl
+++ b/base/deprecated.jl
@@ -290,7 +290,7 @@ cat_shape(dims, shape::Tuple{}) = () # make sure `cat_shape(dims, ())` do not re
 @deprecate unsafe_indices(A) axes(A) false
 @deprecate unsafe_length(r) length(r) false
 
-# these were internal type aliases, but some pacakges seem to be relying on them
+# these were internal type aliases, but some packages seem to be relying on them
 const Any16{N} = Tuple{Any,Any,Any,Any,Any,Any,Any,Any,
                         Any,Any,Any,Any,Any,Any,Any,Any,Vararg{Any,N}}
 const All16{T,N} = Tuple{T,T,T,T,T,T,T,T,
diff --git a/base/dict.jl b/base/dict.jl
index 750b98ea070f2..5f725f82ac57b 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -205,7 +205,7 @@ end
         end
     end
 
-    @assert h.age == age0 "Muliple concurent writes to Dict detected!"
+    @assert h.age == age0 "Muliple concurrent writes to Dict detected!"
     h.age += 1
     h.slots = slots
     h.keys = keys
diff --git a/base/docs/basedocs.jl b/base/docs/basedocs.jl
index 454d4b394e503..2b2fadf8a779e 100644
--- a/base/docs/basedocs.jl
+++ b/base/docs/basedocs.jl
@@ -795,7 +795,7 @@ julia> f(2)
 7
 ```
 
-Anonymous functions can also be defined for multiple argumets.
+Anonymous functions can also be defined for multiple arguments.
 ```jldoctest
 julia> g = (x,y) -> x^2 + y^2
 #2 (generic function with 1 method)
@@ -3088,7 +3088,7 @@ unused and delete the entire benchmark code).
 ```julia
 function loop()
     for i = 1:1000
-        # The complier must guarantee that there are 1000 program points (in the correct
+        # The compiler must guarantee that there are 1000 program points (in the correct
         # order) at which the value of `i` is in a register, but has otherwise
         # total control over the program.
         donotdelete(i)
diff --git a/base/file.jl b/base/file.jl
index eaff9efae43d3..b449a68bfa5da 100644
--- a/base/file.jl
+++ b/base/file.jl
@@ -1062,7 +1062,7 @@ See also: [`hardlink`](@ref).
 
 !!! compat "Julia 1.6"
     The `dir_target` keyword argument was added in Julia 1.6.  Prior to this,
-    symlinks to nonexistant paths on windows would always be file symlinks, and
+    symlinks to nonexistent paths on windows would always be file symlinks, and
     relative symlinks to directories were not supported.
 """
 function symlink(target::AbstractString, link::AbstractString;
diff --git a/base/loading.jl b/base/loading.jl
index 72d4b5c237895..43ff380fd62ca 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -347,7 +347,7 @@ There `where` argument provides the context from where to search for the
 package: in this case it first checks if the name matches the context itself,
 otherwise it searches all recursive dependencies (from the resolved manifest of
 each environment) until it locates the context `where`, and from there
-identifies the depdencency with with the corresponding name.
+identifies the dependency with with the corresponding name.
 
 ```julia-repl
 julia> Base.identify_package("Pkg") # Pkg is a dependency of the default environment
@@ -502,7 +502,7 @@ function locate_project_file(env::String)
 end
 
 # classify the LOAD_PATH entry to be one of:
-#  - `false`: nonexistant / nothing to see here
+#  - `false`: nonexistent / nothing to see here
 #  - `true`: `env` is an implicit environment
 #  - `path`: the path of an explicit project file
 function env_project_file(env::String)::Union{Bool,String}
diff --git a/base/math.jl b/base/math.jl
index 7f812f82a419e..09ded65bcddb8 100644
--- a/base/math.jl
+++ b/base/math.jl
@@ -1162,7 +1162,7 @@ end
     n == 3 && return x*x*x # keep compatibility with literal_pow
     if n < 0
         rx = inv(x)
-        n==-2 && return rx*rx #keep compatability with literal_pow
+        n==-2 && return rx*rx #keep compatibility with literal_pow
         isfinite(x) && (xnlo = -fma(x, rx, -1.) * rx)
         x = rx
         n = -n
diff --git a/base/multidimensional.jl b/base/multidimensional.jl
index 487be1d9b42a0..285a8992b8c3e 100644
--- a/base/multidimensional.jl
+++ b/base/multidimensional.jl
@@ -1348,7 +1348,7 @@ end
 
 # Note: the next two functions rely on the following definition of the conversion to Bool:
 #   convert(::Type{Bool}, x::Real) = x==0 ? false : x==1 ? true : throw(InexactError(...))
-# they're used to pre-emptively check in bulk when possible, which is much faster.
+# they're used to preemptively check in bulk when possible, which is much faster.
 # Also, the functions can be overloaded for custom types T<:Real :
 #  a) in the unlikely eventuality that they use a different logic for Bool conversion
 #  b) to skip the check if not necessary
diff --git a/base/rational.jl b/base/rational.jl
index 782b05e587e1b..26746ad0b4bc2 100644
--- a/base/rational.jl
+++ b/base/rational.jl
@@ -551,7 +551,7 @@ function hash(x::Rational{<:BitInteger64}, h::UInt)
 end
 
 # These methods are only needed for performance. Since `first(r)` and `last(r)` have the
-# same denominator (because their difference is an integer), `length(r)` can be calulated
+# same denominator (because their difference is an integer), `length(r)` can be calculated
 # without calling `gcd`.
 function length(r::AbstractUnitRange{T}) where T<:Rational
     @inline
diff --git a/base/show.jl b/base/show.jl
index 5ac50ec3526e9..1ca2e2c3282d4 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -615,7 +615,7 @@ function make_typealias(@nospecialize(x::Type))
                         env = env::SimpleVector
                         # TODO: In some cases (such as the following), the `env` is over-approximated.
                         #       We'd like to disable `fix_inferred_var_bound` since we'll already do that fix-up here.
-                        #       (or detect and reverse the compution of it here).
+                        #       (or detect and reverse the computation of it here).
                         #   T = Array{Array{T,1}, 1} where T
                         #   (ti, env) = ccall(:jl_type_intersection_with_env, Any, (Any, Any), T, Vector)
                         #   env[1].ub.var == T.var
diff --git a/base/special/log.jl b/base/special/log.jl
index d868071818a18..5e20cdbaa06a6 100644
--- a/base/special/log.jl
+++ b/base/special/log.jl
@@ -556,7 +556,7 @@ const t_log_table_compact = (
 end
 
 # Log implementation that returns 2 numbers which sum to give true value with about 68 bits of precision
-# Since `log` only makes sense for positive exponents, we speed up the implimentation by stealing the sign bit
+# Since `log` only makes sense for positive exponents, we speed up the implementation by stealing the sign bit
 # of the input for an extra bit of the exponent which is used to normalize subnormal inputs.
 # Does not normalize results.
 # Adapted and modified from https://github.com/ARM-software/optimized-routines/blob/master/math/pow.c
@@ -575,7 +575,7 @@ function _log_ext(xu)
     t, logctail = getfield(t_log_table_compact, Int(i+1))
     invc, logc = log_tab_unpack(t)
     # Note: invc is j/N or j/N/2 where j is an integer in [N,2N) and
-    # |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.
+    # |z/c - 1| < 1/N, so r = z/c - 1 is exactly representable.
     r = fma(z, invc, -1.0)
     # k*Ln2 + log(c) + r.
     t1 = muladd(k, 0.6931471805598903, logc) #ln(2) hi part
diff --git a/base/special/trig.jl b/base/special/trig.jl
index e3033aab6c272..817d073d0cc48 100644
--- a/base/special/trig.jl
+++ b/base/special/trig.jl
@@ -255,7 +255,7 @@ end
     #
     #       Note: tan(y+z) = tan(y) + tan'(y)*z
     #                  ~ tan(y) + (1+y*y)*z
-    #       Therefore, for better accuracz in computing tan(y+z), let
+    #       Therefore, for better accuracy in computing tan(y+z), let
     #             3      2      2       2       2
     #        r = y *(T2+y *(T3+y *(...+y *(T12+y *T13))))
     #       then
diff --git a/base/stream.jl b/base/stream.jl
index 6c81f5f44ea6a..0d8676885fa0c 100644
--- a/base/stream.jl
+++ b/base/stream.jl
@@ -1361,7 +1361,7 @@ julia> io1 = open("same/path", "w")
 
 julia> io2 = open("same/path", "w")
 
-julia> redirect_stdio(f, stdout=io1, stderr=io2) # not suppored
+julia> redirect_stdio(f, stdout=io1, stderr=io2) # not supported
 ```
 Also the `stdin` argument may not be the same descriptor as `stdout` or `stderr`.
 ```julia-repl
diff --git a/base/threadingconstructs.jl b/base/threadingconstructs.jl
index 0852fafe192ec..6c8ea35cfa373 100644
--- a/base/threadingconstructs.jl
+++ b/base/threadingconstructs.jl
@@ -199,7 +199,7 @@ microseconds).
 
 `:static` scheduler creates one task per thread and divides the iterations equally among
 them, assigning each task specifically to each thread. In particular, the value of
-[`threadid()`](@ref Threads.threadid) is guranteed to be constant within one iteration.
+[`threadid()`](@ref Threads.threadid) is guaranteed to be constant within one iteration.
 Specifying `:static` is an error if used from inside another `@threads` loop or from a
 thread other than 1.
 
diff --git a/base/util.jl b/base/util.jl
index e1fef49d20f01..f26ed0717a1fd 100644
--- a/base/util.jl
+++ b/base/util.jl
@@ -119,7 +119,7 @@ or an integer between 0 and 255 inclusive. Note that not all terminals support 2
 
 Keywords `bold=true`, `underline=true`, `blink=true` are self-explanatory.
 Keyword `reverse=true` prints with foreground and background colors exchanged,
-and `hidden=true` should be invisibe in the terminal but can still be copied.
+and `hidden=true` should be invisible in the terminal but can still be copied.
 These properties can be used in any combination.
 
 See also [`print`](@ref), [`println`](@ref), [`show`](@ref).
diff --git a/doc/src/manual/distributed-computing.md b/doc/src/manual/distributed-computing.md
index 2c1af8ecb9c26..544dace1a99ec 100644
--- a/doc/src/manual/distributed-computing.md
+++ b/doc/src/manual/distributed-computing.md
@@ -251,7 +251,7 @@ The base Julia installation has in-built support for two types of clusters:
     should use to connect to this worker.
 
 !!! note
-    While Julia generally strives for backward compatability, distribution of code to worker processes relies on
+    While Julia generally strives for backward compatibility, distribution of code to worker processes relies on
     [`Serialization.serialize`](@ref). As pointed out in the corresponding documentation, this can not be guaranteed to work across
     different Julia versions, so it is advised that all workers on all machines use the same version.
 
diff --git a/stdlib/Artifacts/src/Artifacts.jl b/stdlib/Artifacts/src/Artifacts.jl
index b446fdb12dd68..1a3214acc3c87 100644
--- a/stdlib/Artifacts/src/Artifacts.jl
+++ b/stdlib/Artifacts/src/Artifacts.jl
@@ -88,7 +88,7 @@ function load_overrides(;force::Bool = false)::Dict{Symbol, Any}
     #
     # Overrides per UUID/bound name are intercepted upon Artifacts.toml load, and new
     # entries within the "hash" overrides are generated on-the-fly.  Thus, all redirects
-    # mechanisticly happen through the "hash" overrides.
+    # mechanistically happen through the "hash" overrides.
     overrides = Dict{Symbol,Any}(
         # Overrides by UUID
         :UUID => Dict{Base.UUID,Dict{String,Union{String,SHA1}}}(),
@@ -267,7 +267,7 @@ function unpack_platform(entry::Dict{String,Any}, name::String,
     end
 
     if !haskey(entry, "arch")
-        @error("Invalid artifacts file at '$(artifacts_toml)': platform-specific artifact entrty '$name' missing 'arch' key")
+        @error("Invalid artifacts file at '$(artifacts_toml)': platform-specific artifact entry '$name' missing 'arch' key")
         return nothing
     end
 
@@ -570,7 +570,7 @@ end
 raw"""
     split_artifact_slash(name::String)
 
-Splits an artifact indexing string by path deliminters, isolates the first path element,
+Splits an artifact indexing string by path delimiters, isolates the first path element,
 returning that and the `joinpath()` of the remaining arguments.  This normalizes all path
 separators to the native path separator for the current platform.  Examples:
 
diff --git a/stdlib/Dates/src/types.jl b/stdlib/Dates/src/types.jl
index d3a9203ed0cde..1d9769a05bd3d 100644
--- a/stdlib/Dates/src/types.jl
+++ b/stdlib/Dates/src/types.jl
@@ -103,7 +103,7 @@ end
 UTM(x) = UTInstant(Millisecond(x))
 UTD(x) = UTInstant(Day(x))
 
-# Calendar types provide rules for interpretating instant
+# Calendar types provide rules for interpreting instant
 # timelines in human-readable form.
 abstract type Calendar <: AbstractTime end
 
@@ -199,7 +199,7 @@ daysinmonth(y,m) = DAYSINMONTH[m] + (m == 2 && isleapyear(y))
 """
     validargs(::Type{<:TimeType}, args...) -> Union{ArgumentError, Nothing}
 
-Determine whether the given arguments consitute valid inputs for the given type.
+Determine whether the given arguments constitute valid inputs for the given type.
 Returns either an `ArgumentError`, or [`nothing`](@ref) in case of success.
 """
 function validargs end
diff --git a/stdlib/Dates/test/accessors.jl b/stdlib/Dates/test/accessors.jl
index 819fa8c40ddbc..b690a81d70e49 100644
--- a/stdlib/Dates/test/accessors.jl
+++ b/stdlib/Dates/test/accessors.jl
@@ -29,7 +29,7 @@ using Test
     @test Dates.yearmonthday(730120) == (2000, 1, 1)
 end
 @testset "year/month/day" begin
-    # year, month, and day return the indivial components
+    # year, month, and day return the individual components
     # of yearmonthday, avoiding additional calculations when possible
     @test Dates.year(-1) == 0
     @test Dates.month(-1) == 12
diff --git a/stdlib/Distributed/src/cluster.jl b/stdlib/Distributed/src/cluster.jl
index 37f1660e19478..4845640a1a913 100644
--- a/stdlib/Distributed/src/cluster.jl
+++ b/stdlib/Distributed/src/cluster.jl
@@ -22,7 +22,7 @@ Some are used by the cluster manager to add workers to an already-initialized ho
   * `count` -- the number of workers to be launched on the host
   * `exename` -- the path to the Julia executable on the host, defaults to `"\$(Sys.BINDIR)/julia"` or
     `"\$(Sys.BINDIR)/julia-debug"`
-  * `exeflags` -- flags to use when lauching Julia remotely
+  * `exeflags` -- flags to use when launching Julia remotely
 
 The `userdata` field is used to store information for each worker by external managers.
 
diff --git a/stdlib/Distributed/src/remotecall.jl b/stdlib/Distributed/src/remotecall.jl
index d4bf767537c1d..0554f47670eb3 100644
--- a/stdlib/Distributed/src/remotecall.jl
+++ b/stdlib/Distributed/src/remotecall.jl
@@ -321,7 +321,7 @@ function process_worker(rr)
     w = worker_from_id(rr.where)::Worker
     msg = (remoteref_id(rr), myid())
 
-    # Needs to aquire a lock on the del_msg queue
+    # Needs to acquire a lock on the del_msg queue
     T = Threads.@spawn begin
         publish_del_msg!($w, $msg)
     end
diff --git a/stdlib/Distributed/src/workerpool.jl b/stdlib/Distributed/src/workerpool.jl
index 0cada2db103de..89e52667c82c9 100644
--- a/stdlib/Distributed/src/workerpool.jl
+++ b/stdlib/Distributed/src/workerpool.jl
@@ -73,7 +73,7 @@ wp_local_length(pool::AbstractWorkerPool) = length(pool.workers)
 wp_local_isready(pool::AbstractWorkerPool) = isready(pool.channel)
 
 function wp_local_put!(pool::AbstractWorkerPool, w::Int)
-    # In case of default_worker_pool, the master is implictly considered a worker, i.e.,
+    # In case of default_worker_pool, the master is implicitly considered a worker, i.e.,
     # it is not present in pool.workers.
     # Confirm the that the worker is part of a pool before making it available.
     w in pool.workers && put!(pool.channel, w)
diff --git a/stdlib/Distributed/test/distributed_exec.jl b/stdlib/Distributed/test/distributed_exec.jl
index 8ed55550e61b9..9dffbe0e41994 100644
--- a/stdlib/Distributed/test/distributed_exec.jl
+++ b/stdlib/Distributed/test/distributed_exec.jl
@@ -993,7 +993,7 @@ end
 let
     @test_throws RemoteException remotecall_fetch(()->LocalFoo.foo, 2)
 
-    bad_thunk = ()->NonexistantModule.f()
+    bad_thunk = ()->NonexistentModule.f()
     @test_throws RemoteException remotecall_fetch(bad_thunk, 2)
 
     # Test that the stream is still usable
diff --git a/stdlib/InteractiveUtils/src/codeview.jl b/stdlib/InteractiveUtils/src/codeview.jl
index 3937eeb4ba2e8..344144843c55b 100644
--- a/stdlib/InteractiveUtils/src/codeview.jl
+++ b/stdlib/InteractiveUtils/src/codeview.jl
@@ -66,7 +66,7 @@ Not all non-leaf types are particularly problematic for performance, and the per
 characteristics of a particular type is an implementation detail of the compiler.
 `code_warntype` will err on the side of coloring types red if they might be a performance
 concern, so some types may be colored red even if they do not impact performance.
-Small unions of concrete types are usually not a concern, so these are highlighed in yellow.
+Small unions of concrete types are usually not a concern, so these are highlighted in yellow.
 
 Keyword argument `debuginfo` may be one of `:source` or `:none` (default), to specify the verbosity of code comments.
 
diff --git a/stdlib/LibGit2/src/oid.jl b/stdlib/LibGit2/src/oid.jl
index 1074f003ebd2f..937684439419f 100644
--- a/stdlib/LibGit2/src/oid.jl
+++ b/stdlib/LibGit2/src/oid.jl
@@ -154,7 +154,7 @@ end
 
 Get a shortened identifier (`GitShortHash`) of `obj`. The minimum length (in characters)
 is determined by the `core.abbrev` config option, and will be of sufficient length to
-unambiuously identify the object in the repository.
+unambiguously identify the object in the repository.
 """
 function GitShortHash(obj::GitObject)
     ensure_initialized()
diff --git a/stdlib/LibGit2/test/libgit2-tests.jl b/stdlib/LibGit2/test/libgit2-tests.jl
index 4dbd1837045e9..4a86294dc87cd 100644
--- a/stdlib/LibGit2/test/libgit2-tests.jl
+++ b/stdlib/LibGit2/test/libgit2-tests.jl
@@ -1011,7 +1011,7 @@ mktempdir() do dir
                     LibGit2.Signature(repo)
                 catch ex
                     # these test configure repo with new signature
-                    # in case when global one does not exsist
+                    # in case when global one does not exist
                     @test isa(ex, LibGit2.Error.GitError) == true
 
                     cfg = LibGit2.GitConfig(repo)
diff --git a/stdlib/LinearAlgebra/src/LinearAlgebra.jl b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
index c9609449580ab..cb58155aff140 100644
--- a/stdlib/LinearAlgebra/src/LinearAlgebra.jl
+++ b/stdlib/LinearAlgebra/src/LinearAlgebra.jl
@@ -460,7 +460,7 @@ _cut_B(x::AbstractVector, r::UnitRange) = length(x)  > length(r) ? x[r]   : x
 _cut_B(X::AbstractMatrix, r::UnitRange) = size(X, 1) > length(r) ? X[r,:] : X
 
 # SymTridiagonal ev can be the same length as dv, but the last element is
-# ignored. However, some methods can fail if they read the entired ev
+# ignored. However, some methods can fail if they read the entire ev
 # rather than just the meaningful elements. This is a helper function
 # for getting only the meaningful elements of ev. See #41089
 _evview(S::SymTridiagonal) = @view S.ev[begin:begin + length(S.dv) - 2]
diff --git a/stdlib/LinearAlgebra/src/blas.jl b/stdlib/LinearAlgebra/src/blas.jl
index 4a83fcecbc8d9..7547a60f390d4 100644
--- a/stdlib/LinearAlgebra/src/blas.jl
+++ b/stdlib/LinearAlgebra/src/blas.jl
@@ -167,7 +167,7 @@ end
 # Level 1
 # A help function to pick the pointer and inc for 1d like inputs.
 @inline function vec_pointer_stride(x::AbstractArray, stride0check = nothing)
-    Base._checkcontiguous(Bool, x) && return pointer(x), 1 # simpify runtime check when possibe
+    Base._checkcontiguous(Bool, x) && return pointer(x), 1 # simplify runtime check when possibe
     st, ptr = checkedstride(x), pointer(x)
     isnothing(stride0check) || (st == 0 && throw(stride0check))
     ptr += min(st, 0) * sizeof(eltype(x)) * (length(x) - 1)
diff --git a/stdlib/LinearAlgebra/src/dense.jl b/stdlib/LinearAlgebra/src/dense.jl
index 23f63f71f3e52..bcf9443f7632c 100644
--- a/stdlib/LinearAlgebra/src/dense.jl
+++ b/stdlib/LinearAlgebra/src/dense.jl
@@ -722,7 +722,7 @@ function exp!(A::StridedMatrix{T}) where T<:BlasFloat
         V = mul!(tmp2, A6, tmp1, true, true)
 
         tmp1 .= V .+ U
-        tmp2 .= V .- U # tmp2 aleady contained V but this seems more readable
+        tmp2 .= V .- U # tmp2 already contained V but this seems more readable
         X = LAPACK.gesv!(tmp2, tmp1)[1] # X now contains r_13 in Higham 2008
 
         if s > 0
diff --git a/stdlib/LinearAlgebra/src/exceptions.jl b/stdlib/LinearAlgebra/src/exceptions.jl
index ae29b8bc2f7b9..a8d81aad3e067 100644
--- a/stdlib/LinearAlgebra/src/exceptions.jl
+++ b/stdlib/LinearAlgebra/src/exceptions.jl
@@ -50,7 +50,7 @@ end
 
 Exception thrown when a matrix factorization/solve encounters a zero in a pivot (diagonal)
 position and cannot proceed.  This may *not* mean that the matrix is singular:
-it may be fruitful to switch to a diffent factorization such as pivoted LU
+it may be fruitful to switch to a different factorization such as pivoted LU
 that can re-order variables to eliminate spurious zero pivots.
 The `info` field indicates the location of (one of) the zero pivot(s).
 """
diff --git a/stdlib/LinearAlgebra/src/matmul.jl b/stdlib/LinearAlgebra/src/matmul.jl
index 81eb9e3d3012a..2216d1858d46f 100644
--- a/stdlib/LinearAlgebra/src/matmul.jl
+++ b/stdlib/LinearAlgebra/src/matmul.jl
@@ -66,7 +66,7 @@ end
     gemv!(y, 'N', A, x, alpha, beta)
 
 # Complex matrix times real vector.
-# Reinterpret the matrix as a real matrix and do real matvec compuation.
+# Reinterpret the matrix as a real matrix and do real matvec computation.
 @inline mul!(y::StridedVector{Complex{T}}, A::StridedVecOrMat{Complex{T}}, x::StridedVector{T},
         alpha::Number, beta::Number) where {T<:BlasReal} =
     gemv!(y, 'N', A, x, alpha, beta)
@@ -469,7 +469,7 @@ end
 
 # Supporting functions for matrix multiplication
 
-# copy transposed(adjoint) of upper(lower) side-digonals. Optionally include diagonal.
+# copy transposed(adjoint) of upper(lower) side-diagonals. Optionally include diagonal.
 @inline function copytri!(A::AbstractMatrix, uplo::AbstractChar, conjugate::Bool=false, diag::Bool=false)
     n = checksquare(A)
     off = diag ? 0 : 1
diff --git a/stdlib/LinearAlgebra/src/triangular.jl b/stdlib/LinearAlgebra/src/triangular.jl
index d939a5df0da01..a0edfdcd3c40a 100644
--- a/stdlib/LinearAlgebra/src/triangular.jl
+++ b/stdlib/LinearAlgebra/src/triangular.jl
@@ -674,7 +674,7 @@ mul!(C::AbstractMatrix, A::AbstractTriangular, adjB::Adjoint{<:Any,<:AbstractVec
 mul!(C::AbstractVecOrMat, A::AbstractTriangular, adjB::Adjoint{<:Any,<:AbstractVecOrMat}) =
     (B = adjB.parent; lmul!(A, adjoint!(C, B)))
 
-# The three methods are neceesary to avoid ambiguities with definitions in matmul.jl
+# The three methods are necessary to avoid ambiguities with definitions in matmul.jl
 mul!(C::AbstractVector  , A::AbstractTriangular, B::AbstractVector)   = lmul!(A, copyto!(C, B))
 mul!(C::AbstractMatrix  , A::AbstractTriangular, B::AbstractVecOrMat) = lmul!(A, copyto!(C, B))
 mul!(C::AbstractVecOrMat, A::AbstractTriangular, B::AbstractVecOrMat) = lmul!(A, copyto!(C, B))
diff --git a/stdlib/LinearAlgebra/test/structuredbroadcast.jl b/stdlib/LinearAlgebra/test/structuredbroadcast.jl
index 4aeca31a79a03..4855446bc194b 100644
--- a/stdlib/LinearAlgebra/test/structuredbroadcast.jl
+++ b/stdlib/LinearAlgebra/test/structuredbroadcast.jl
@@ -200,7 +200,7 @@ end
     Bu2 = 2 .* Bl
     @test typeof(Bl2) <: Bidiagonal && Bl2.uplo == 'L'
 
-    # Example of Nested Brodacasts
+    # Example of Nested Broadcasts
     tmp = (1 .* 2) .* (Bidiagonal(1:3, 1:2, 'U') .* (3 .* 4)) .* (5 .* Bidiagonal(1:3, 1:2, 'L'))
     @test typeof(tmp) <: Tridiagonal
 
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index 5d6232e4b7626..79821ba8de6e8 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -524,7 +524,7 @@ let s = "CompletionFoo.test4(CompletionFoo.test_y_array[1]()[1], CompletionFoo.t
     @test c[1] == string(first(methods(Main.CompletionFoo.test4, Tuple{String, String})))
 end
 
-# Test that string escaption is handled correct
+# Test that string escaping is handled correct
 let s = """CompletionFoo.test4("\\"","""
     c, r, res = test_complete(s)
     @test !res
diff --git a/stdlib/Random/src/RNGs.jl b/stdlib/Random/src/RNGs.jl
index f79f113bc95eb..02ea1477961ac 100644
--- a/stdlib/Random/src/RNGs.jl
+++ b/stdlib/Random/src/RNGs.jl
@@ -466,7 +466,7 @@ end
 
 ##### Array : internal functions
 
-# internal array-like type to circumevent the lack of flexibility with reinterpret
+# internal array-like type to circumvent the lack of flexibility with reinterpret
 struct UnsafeView{T} <: DenseArray{T,1}
     ptr::Ptr{T}
     len::Int
diff --git a/stdlib/Random/src/Random.jl b/stdlib/Random/src/Random.jl
index 02bc609e55679..b9adb5ae39f54 100644
--- a/stdlib/Random/src/Random.jl
+++ b/stdlib/Random/src/Random.jl
@@ -215,7 +215,7 @@ end
 # TODO: make constraining constructors to enforce that those
 # types are <: Sampler{T}
 
-##### Adapter to generate a randome value in [0, n]
+##### Adapter to generate a random value in [0, n]
 
 struct LessThan{T<:Integer,S} <: Sampler{T}
     sup::T
diff --git a/stdlib/Random/src/generation.jl b/stdlib/Random/src/generation.jl
index ddbf6dce98bec..61e722a7719db 100644
--- a/stdlib/Random/src/generation.jl
+++ b/stdlib/Random/src/generation.jl
@@ -132,7 +132,7 @@ rand(r::AbstractRNG, sp::SamplerTrivial{<:UniformBits{T}}) where {T} =
 
 # rand_generic methods are intended to help RNG implementors with common operations
 # we don't call them simply `rand` as this can easily contribute to create
-# amibuities with user-side methods (forcing the user to resort to @eval)
+# ambiguities with user-side methods (forcing the user to resort to @eval)
 
 rand_generic(r::AbstractRNG, T::Union{Bool,Int8,UInt8,Int16,UInt16,Int32,UInt32}) =
     rand(r, UInt52Raw()) % T[]
diff --git a/stdlib/TOML/test/testfiles/valid/arrays-hetergeneous.jl b/stdlib/TOML/test/testfiles/valid/arrays-heterogeneous.jl
similarity index 100%
rename from stdlib/TOML/test/testfiles/valid/arrays-hetergeneous.jl
rename to stdlib/TOML/test/testfiles/valid/arrays-heterogeneous.jl
diff --git a/stdlib/TOML/test/testfiles/valid/arrays-hetergeneous.json b/stdlib/TOML/test/testfiles/valid/arrays-heterogeneous.json
similarity index 100%
rename from stdlib/TOML/test/testfiles/valid/arrays-hetergeneous.json
rename to stdlib/TOML/test/testfiles/valid/arrays-heterogeneous.json
diff --git a/stdlib/TOML/test/testfiles/valid/arrays-hetergeneous.toml b/stdlib/TOML/test/testfiles/valid/arrays-heterogeneous.toml
similarity index 100%
rename from stdlib/TOML/test/testfiles/valid/arrays-hetergeneous.toml
rename to stdlib/TOML/test/testfiles/valid/arrays-heterogeneous.toml
diff --git a/stdlib/TOML/test/toml_test.jl b/stdlib/TOML/test/toml_test.jl
index 45fbd20dbcdab..7ad28a2b7af7b 100644
--- a/stdlib/TOML/test/toml_test.jl
+++ b/stdlib/TOML/test/toml_test.jl
@@ -46,7 +46,7 @@ end
 @test check_valid("array-string-quote-comma")
 @test check_valid("array-string-with-comma")
 @test check_valid("array-table-array-string-backslash")
-@test check_valid("arrays-hetergeneous")
+@test check_valid("arrays-heterogeneous")
 @test check_valid("arrays-nested")
 @test check_valid("arrays")
 @test check_valid("bool")
diff --git a/stdlib/Test/src/Test.jl b/stdlib/Test/src/Test.jl
index 69714de01de50..863a75885ba0e 100644
--- a/stdlib/Test/src/Test.jl
+++ b/stdlib/Test/src/Test.jl
@@ -1314,7 +1314,7 @@ end
 # With begin/end or function call
 
 When @testset is used, with begin/end or a single function call, the macro
-starts a new test set in which to evaulate the given expression.
+starts a new test set in which to evaluate the given expression.
 
 If no custom testset type is given it defaults to creating a `DefaultTestSet`.
 `DefaultTestSet` records all the results and, if there are any `Fail`s or
@@ -1518,7 +1518,7 @@ end
 
 function failfast_print()
     printstyled("\nFail-fast enabled:"; color = Base.error_color(), bold=true)
-    printstyled(" Fail or Error occured\n\n"; color = Base.error_color())
+    printstyled(" Fail or Error occurred\n\n"; color = Base.error_color())
 end
 
 """
diff --git a/test/ccall.jl b/test/ccall.jl
index 3a1b6ff3db733..d302d5e3d75d0 100644
--- a/test/ccall.jl
+++ b/test/ccall.jl
@@ -1125,12 +1125,12 @@ struct Struct_AA64_2
     v2::Float64
 end
 
-# This is a homogenious short vector aggregate
+# This is a homogeneous short vector aggregate
 struct Struct_AA64_3
     v1::VecReg{8,Int8}
     v2::VecReg{2,Float32}
 end
-# This is NOT a homogenious short vector aggregate
+# This is NOT a homogeneous short vector aggregate
 struct Struct_AA64_4
     v2::VecReg{2,Float32}
     v1::VecReg{8,Int16}
@@ -1791,7 +1791,7 @@ end
     str_identity = @cfunction(identity, Cstring, (Cstring,))
     foo = @ccall $str_identity("foo"::Cstring)::Cstring
     @test unsafe_string(foo) == "foo"
-    # test interpolation of an expresison that returns a pointer.
+    # test interpolation of an expression that returns a pointer.
     foo = @ccall $(@cfunction(identity, Cstring, (Cstring,)))("foo"::Cstring)::Cstring
     @test unsafe_string(foo) == "foo"
 
diff --git a/test/compiler/EscapeAnalysis/EAUtils.jl b/test/compiler/EscapeAnalysis/EAUtils.jl
index 17a70faeb91b5..c16271d049932 100644
--- a/test/compiler/EscapeAnalysis/EAUtils.jl
+++ b/test/compiler/EscapeAnalysis/EAUtils.jl
@@ -204,7 +204,7 @@ function run_passes_with_ea(interp::EscapeAnalyzer, ci::CodeInfo, sv::Optimizati
                 cache_escapes!(interp, caller, state, cccopy(ir))
             end
         catch err
-            @error "error happened within [IPO EA], insepct `Main.ir` and `Main.nargs`"
+            @error "error happened within [IPO EA], inspect `Main.ir` and `Main.nargs`"
             @eval Main (ir = $ir; nargs = $nargs)
             rethrow(err)
         end
@@ -222,7 +222,7 @@ function run_passes_with_ea(interp::EscapeAnalyzer, ci::CodeInfo, sv::Optimizati
         try
             @timeit "[Local EA]" state = analyze_escapes(ir, nargs, true, get_escape_cache(interp))
         catch err
-            @error "error happened within [Local EA], insepct `Main.ir` and `Main.nargs`"
+            @error "error happened within [Local EA], inspect `Main.ir` and `Main.nargs`"
             @eval Main (ir = $ir; nargs = $nargs)
             rethrow(err)
         end
diff --git a/test/compiler/effects.jl b/test/compiler/effects.jl
index d0ca45d98bcae..556cb147b914e 100644
--- a/test/compiler/effects.jl
+++ b/test/compiler/effects.jl
@@ -28,7 +28,7 @@ end
     return nothing
 end
 
-# Test that ambigous calls don't accidentally get nothrow effect
+# Test that ambiguous calls don't accidentally get nothrow effect
 ambig_effects_test(a::Int, b) = 1
 ambig_effects_test(a, b::Int) = 1
 ambig_effects_test(a, b) = 1
@@ -367,7 +367,7 @@ end
 
 # we should taint `nothrow` if the binding doesn't exist and isn't fixed yet,
 # as the cached effects can be easily wrong otherwise
-# since the inference curently doesn't track "world-age" of global variables
+# since the inference currently doesn't track "world-age" of global variables
 @eval global_assignment_undefinedyet() = $(GlobalRef(@__MODULE__, :UNDEFINEDYET)) = 42
 setglobal!_nothrow_undefinedyet() = setglobal!(@__MODULE__, :UNDEFINEDYET, 42)
 let effects = Base.infer_effects() do
diff --git a/test/compiler/inference.jl b/test/compiler/inference.jl
index 514766f48b9a8..294546932ff65 100644
--- a/test/compiler/inference.jl
+++ b/test/compiler/inference.jl
@@ -379,7 +379,7 @@ struct A15259
     x
     y
 end
-# check that allocation was ellided
+# check that allocation was elided
 @eval f15259(x,y) = (a = $(Expr(:new, :A15259, :x, :y)); (a.x, a.y, getfield(a,1), getfield(a, 2)))
 @test isempty(filter(x -> isa(x,Expr) && x.head === :(=) &&
                           isa(x.args[2], Expr) && x.args[2].head === :new,
diff --git a/test/compiler/inline.jl b/test/compiler/inline.jl
index 13f9a1145c10a..02c4a6c24aaaa 100644
--- a/test/compiler/inline.jl
+++ b/test/compiler/inline.jl
@@ -601,7 +601,7 @@ g41299(f::Tf, args::Vararg{Any,N}) where {Tf,N} = f(args...)
 @test_throws TypeError g41299(>:, 1, 2)
 
 # https://github.com/JuliaLang/julia/issues/42078
-# idempotency of callsite inling
+# idempotency of callsite inlining
 function getcache(mi::Core.MethodInstance)
     cache = Core.Compiler.code_cache(Core.Compiler.NativeInterpreter())
     codeinf = Core.Compiler.get(cache, mi, nothing)
@@ -638,7 +638,7 @@ let
 end
 
 begin
-    # more idempotency of callsite inling
+    # more idempotency of callsite inlining
     # -----------------------------------
     # this test case requires forced constant propagation for callsite inlined function call,
     # particularly, in the following example, the inlinear will look up `+ₚ(::Point, ::Const(Point(2.25, 4.75)))`
@@ -927,7 +927,7 @@ let # aggressive inlining of single, abstract method match (with constant-prop'e
     # both callsite should be inlined with constant-prop'ed result
     @test count(isinvoke(:isType), src.code) == 2
     @test count(isinvoke(:has_free_typevars), src.code) == 0
-    # `isGoodType(y::Any)` isn't fully convered, thus a runtime type check and fallback dynamic dispatch should be inserted
+    # `isGoodType(y::Any)` isn't fully covered, thus a runtime type check and fallback dynamic dispatch should be inserted
     @test count(iscall((src,isGoodType2)), src.code) == 1
 end
 
diff --git a/test/compiler/irpasses.jl b/test/compiler/irpasses.jl
index f39137a391b08..1e5948182adb1 100644
--- a/test/compiler/irpasses.jl
+++ b/test/compiler/irpasses.jl
@@ -960,7 +960,7 @@ let # effect-freeness computation for array allocation
         end
     end
 
-    # shouldn't eliminate errorneous dead allocations
+    # shouldn't eliminate erroneous dead allocations
     bad_dims = [-1, typemax(Int)]
     for dim in bad_dims, N in 1:10
         dims = ntuple(i->dim, N)
diff --git a/test/core.jl b/test/core.jl
index e409eef85233d..69e5ff3049bab 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -6914,9 +6914,9 @@ g27209(x) = f27209(x ? nothing : 1.0)
 # Issue 27240
 @inline function foo27240()
     if rand(Bool)
-        return foo_nonexistant_27240
+        return foo_nonexistent_27240
     else
-        return bar_nonexistant_27240
+        return bar_nonexistent_27240
     end
 end
 bar27240() = foo27240()
diff --git a/test/deprecation_exec.jl b/test/deprecation_exec.jl
index 2f6cd34ec8b8d..4f19f9415ba29 100644
--- a/test/deprecation_exec.jl
+++ b/test/deprecation_exec.jl
@@ -181,7 +181,7 @@ begin #@deprecated error message
     # `Old{T}(args...) where {...} = new(args...)` or
     # `(Old{T} where {...})(args...) = new(args...)`.
     # Since nobody has requested this feature yet, make sure that it throws, until we
-    # conciously define
+    # consciously define
     @test_throws(
         "invalid usage of @deprecate",
         @eval @deprecate Foo{T} where {T <: Int} g true
diff --git a/test/file.jl b/test/file.jl
index e29b3099d3ed9..9f834d77799ff 100644
--- a/test/file.jl
+++ b/test/file.jl
@@ -42,7 +42,7 @@ if !Sys.iswindows() || Sys.windows_version() >= Sys.WINDOWS_VISTA_VER
     # creation of symlink to directory that does not yet exist
     new_dir = joinpath(subdir, "new_dir")
     foo_file = joinpath(subdir, "new_dir", "foo")
-    nedlink = joinpath(subdir, "non_existant_dirlink")
+    nedlink = joinpath(subdir, "nonexistent_dirlink")
     symlink("new_dir", nedlink; dir_target=true)
     try
         readdir(nedlink)
@@ -1453,7 +1453,7 @@ rm(dir)
 ####################
 mktempdir() do dir
     name1 = joinpath(dir, "apples")
-    name2 = joinpath(dir, "bannanas")
+    name2 = joinpath(dir, "bananas")
     @test !ispath(name1)
     @test touch(name1) == name1
     @test isfile(name1)
@@ -1651,7 +1651,7 @@ end
 
 if Sys.iswindows()
 @testset "mkdir/rm permissions" begin
-    # test delete permission in system folders (i.e. impliclty test chmod permissions)
+    # test delete permission in system folders (i.e. implicitly test chmod permissions)
     # issue #38433
     @test withenv("TMP" => "C:\\") do
         mktempdir() do dir end
diff --git a/test/math.jl b/test/math.jl
index b7870dc72b08d..055f143cea39d 100644
--- a/test/math.jl
+++ b/test/math.jl
@@ -1280,7 +1280,7 @@ struct BadFloatWrapper <: AbstractFloat
     x::Float64
 end
 
-@testset "not impelemented errors" begin
+@testset "not implemented errors" begin
     x = BadFloatWrapper(1.9)
     for f in (sin, cos, tan, sinh, cosh, tanh, atan, acos, asin, asinh, acosh, atanh, exp, log1p, expm1, log) #exp2, exp10 broken for now
         @test_throws MethodError f(x)
diff --git a/test/missing.jl b/test/missing.jl
index 13ed684f1fc05..474e10620732f 100644
--- a/test/missing.jl
+++ b/test/missing.jl
@@ -529,7 +529,7 @@ end
             @test mapreduce(cos, *, collect(skipmissing(A))) ≈ mapreduce(cos, *, skipmissing(A))
         end
 
-        # Patterns that exercize code paths for inputs with 1 or 2 non-missing values
+        # Patterns that exercise code paths for inputs with 1 or 2 non-missing values
         @test sum(skipmissing([1, missing, missing, missing])) === 1
         @test sum(skipmissing([missing, missing, missing, 1])) === 1
         @test sum(skipmissing([1, missing, missing, missing, 2])) === 3
diff --git a/test/numbers.jl b/test/numbers.jl
index 1fa940c65b93a..ce8095bc4cfe4 100644
--- a/test/numbers.jl
+++ b/test/numbers.jl
@@ -103,7 +103,7 @@ end
         min = Top(T,Base.min)
         max = Top(T,Base.max)
         (==) = Top(T,_compare)
-        (===) = Top(T,Base.isequal) # we only use === to compare -0.0/0.0, `isequal` should be equalvient
+        (===) = Top(T,Base.isequal) # we only use === to compare -0.0/0.0, `isequal` should be equivalent
         @test minmax(3., 5.) == (3., 5.)
         @test minmax(5., 3.) == (3., 5.)
         @test minmax(3., NaN) ≣ (NaN, NaN)
diff --git a/test/reinterpretarray.jl b/test/reinterpretarray.jl
index f3f28993c313a..e9803b9bd9ceb 100644
--- a/test/reinterpretarray.jl
+++ b/test/reinterpretarray.jl
@@ -180,7 +180,7 @@ end
         else
             @test_throws "Parent's strides" strides(reinterpret(Int64, view(A, 1:8, viewax2)))
         end
-        # non-integer-multipled classified
+        # non-integer-multiplied classified
         if mod(step(viewax2), 3) == 0
             @test check_strides(reinterpret(NTuple{3,Int16}, view(A, 2:7, viewax2)))
         else
diff --git a/test/show.jl b/test/show.jl
index b44ba0f84d51c..96631a4727eb2 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -1438,7 +1438,7 @@ struct var"#X#" end
 var"#f#"() = 2
 struct var"%X%" end  # Invalid name without '#'
 
-# (Just to make this test more sustainable,) we don't necesssarily need to test the exact
+# (Just to make this test more sustainable,) we don't necessarily need to test the exact
 # output format, just ensure that it prints at least the parts we expect:
 @test occursin(".var\"#X#\"", static_shown(var"#X#"))  # Leading `.` tests it printed a module name.
 @test occursin(r"Set{var\"[^\"]+\"} where var\"[^\"]+\"", static_shown(Set{<:Any}))