diff --git a/Makefile.in b/Makefile.in
index 57cfcfd1605..cf51a468987 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -909,7 +909,7 @@ install-etc:
 	  done ; \
 	done
 
-### Install native compiled Lisp files.
+### Install native-compiled Lisp files.
 install-eln: lisp
 ifeq ($(HAVE_NATIVE_COMP),yes)
 	umask 022 ; \
diff --git a/configure.ac b/configure.ac
index 6b4d3ee914a..13e2d7e16ad 100644
--- a/configure.ac
+++ b/configure.ac
@@ -5179,7 +5179,7 @@ if test "${with_native_compilation}" != "no"; then
     LIBS=$SAVE_LIBS
 fi
 AC_DEFINE_UNQUOTED([NATIVE_ELISP_SUFFIX], [".eln"],
-  [System extension for native compiled elisp])
+  [System extension for native-compiled elisp])
 AC_SUBST([HAVE_NATIVE_COMP])
 AC_SUBST([LIBGCCJIT_CFLAGS])
 AC_SUBST([LIBGCCJIT_LIBS])
diff --git a/doc/emacs/building.texi b/doc/emacs/building.texi
index 1ee46d91a12..02ca71f069b 100644
--- a/doc/emacs/building.texi
+++ b/doc/emacs/building.texi
@@ -1580,7 +1580,7 @@ Emacs Lisp Reference Manual}.
 @cindex native compilation
   Emacs Lisp code can also be compiled into @dfn{native code}: machine
 code not unlike the one produced by a C or Fortran compiler.  Native
-code runs even faster than byte-code.  Natively-compiled Emacs Lisp
+code runs even faster than byte-code.  Natively compiled Emacs Lisp
 code is stored in files whose names end in @samp{.eln}.  @xref{Native
 Compilation,, Native Compilation, elisp, the Emacs Lisp Reference Manual}.
 
@@ -1660,7 +1660,7 @@ way, you don't need to modify the default value of @code{load-path}.
 
 @vindex native-comp-eln-load-path
   Similarly to @code{load-path}, the list of directories where Emacs
-looks for @file{*.eln} files with natively-compiled Lisp code is
+looks for @file{*.eln} files with native-compiled Lisp code is
 specified by the variable @code{native-comp-eln-load-path}.
 
 @cindex autoload
diff --git a/doc/lispref/compile.texi b/doc/lispref/compile.texi
index 060b5ccae4c..57e67001847 100644
--- a/doc/lispref/compile.texi
+++ b/doc/lispref/compile.texi
@@ -764,32 +764,32 @@ you to be able to native-compile Lisp code.
 
 @vindex native-compile@r{, a Lisp feature}
   To determine whether the current Emacs process can produce and load
-natively-compiled Lisp code, call
+natively compiled Lisp code, call
 @code{native-comp-available-p} (@pxref{Native-Compilation Functions}).
 
-  Unlike byte-compiled code, natively-compiled Lisp code is executed
+  Unlike byte-compiled code, native-compiled Lisp code is executed
 directly by the machine's hardware, and therefore runs at full speed
 that the host CPU can provide.  The resulting speedup generally
 depends on what the Lisp code does, but is usually 2.5 to 5 times
 faster than the corresponding byte-compiled code.
 
   Since native code is generally incompatible between different
-systems, the natively-compiled code is @emph{not} transportable from
+systems, the native-compiled code is @emph{not} transportable from
 one machine to another, it can only be used on the same machine where
 it was produced or on very similar ones (having the same CPU and
-run-time libraries).  The transportability of natively-compiled code
+run-time libraries).  The transportability of native-compiled code
 is the same as that of shared libraries (@file{.so} or @file{.dll}
 files).
 
-  Libraries of natively-compiled code include crucial dependencies on
+  Libraries of native-compiled code include crucial dependencies on
 Emacs Lisp primitives (@pxref{What Is a Function}) and their calling
-conventions, and thus Emacs usually won't load natively-compiled code
+conventions, and thus Emacs usually won't load native-compiled code
 produced by earlier or later Emacs versions; native compilation of the
 same Lisp code by a different Emacs version will usually produce a
-natively-compiled library under a unique file name that only that
+natively compiled library under a unique file name that only that
 version of Emacs will be able to load.  However, the use of unique
 file names enables several versions of the same Lisp library
-natively-compiled by several different versions of Emacs to be placed
+natively compiled by several different versions of Emacs to be placed
 within the same directory.
 
 @vindex no-native-compile
@@ -882,7 +882,7 @@ non-@code{nil}, tells the function to place the resulting @file{.eln}
 files in the last directory mentioned in
 @code{native-comp-eln-load-path} (@pxref{Library Search}); this is
 meant to be used as part of building an Emacs source tarball for the
-first time, when the natively-compiled files, which are absent from
+first time, when the native-compiled files, which are absent from
 the source tarball, should be generated in the build tree instead of
 the user's cache directory.
 @end defun
@@ -891,7 +891,7 @@ Native compilation can be run entirely asynchronously, in a subprocess
 of the main Emacs process.  This leaves the main Emacs process free to
 use while the compilation runs in the background.  This is the method
 used by Emacs to natively-compile any Lisp file or byte-compiled Lisp
-file that is loaded into Emacs, when no natively-compiled file for it
+file that is loaded into Emacs, when no native-compiled file for it
 is available.  Note that because of this use of a subprocess, native
 compilation may produce warning and errors which byte-compilation does
 not, and Lisp code may thus need to be modified to work correctly.  See
@@ -938,7 +938,7 @@ in any of the directories mentioned in the
 @deffn Command emacs-lisp-native-compile
 This command compiles the file visited by the current buffer into
 native code, if the file was changed since the last time it was
-natively-compiled.
+natively compiled.
 @end deffn
 
 @deffn Command emacs-lisp-native-compile-and-load
@@ -1125,13 +1125,13 @@ control this, use a separate variable, described below.
 This variable controls generation of trampolines.  A trampoline is a
 small piece of native code required to allow calling Lisp primitives,
 which were advised or redefined, from Lisp code that was
-natively-compiled with @code{native-comp-speed} set to 2 or greater.
+natively compiled with @code{native-comp-speed} set to 2 or greater.
 Emacs stores the generated trampolines on separate @file{*.eln} files.
 By default, this variable's value is @code{t}, which enables the
 generation of trampoline files; setting it to @code{nil} disables the
 generation of trampolines.  Note that if a trampoline needed for
 advising or redefining a primitive is not available and cannot be
-generated, calls to that primitive from natively-compiled Lisp will
+generated, calls to that primitive from native-compiled Lisp will
 ignore redefinitions and advices, and will behave as if the primitive
 was called directly from C.  Therefore, we don't recommend disabling
 the trampoline generation, unless you know that all the trampolines
diff --git a/doc/lispref/functions.texi b/doc/lispref/functions.texi
index 8ed992d3e79..024ff2b7d5a 100644
--- a/doc/lispref/functions.texi
+++ b/doc/lispref/functions.texi
@@ -223,7 +223,7 @@ that is not in the form of ELisp source code but something like
 machine code or byte code instead.  More specifically it returns
 @code{t} if the function is built-in (a.k.a.@: ``primitive'',
 @pxref{What Is a Function}), or byte-compiled (@pxref{Byte
-Compilation}), or natively-compiled (@pxref{Native Compilation}), or
+Compilation}), or native-compiled (@pxref{Native Compilation}), or
 a function loaded from a dynamic module (@pxref{Dynamic Modules}).
 @end defun
 
@@ -2868,7 +2868,7 @@ For description of additional types, see @ref{Lisp Data Types}).
 
 Declaring a function with an incorrect type produces undefined behavior
 and could lead to unexpected results or might even crash Emacs when
-natively-compiled code is loaded, if it was compiled with
+native-compiled code is loaded, if it was compiled with
 @code{compilation-safety} level of zero (@pxref{compilation-safety}).
 Note also that when redefining (or advising) a type-declared function,
 the replacement should respect the original signature to avoid such
diff --git a/doc/lispref/loading.texi b/doc/lispref/loading.texi
index 15922cf1e89..87ebb787250 100644
--- a/doc/lispref/loading.texi
+++ b/doc/lispref/loading.texi
@@ -117,7 +117,7 @@ If the option @code{load-prefer-newer} is non-@code{nil}, then when
 searching suffixes, @code{load} selects whichever version of a file
 (@samp{.elc}, @samp{.el}, etc.)@: has been modified most recently.
 In this case, @code{load} doesn't load the @samp{.eln}
-natively-compiled file even if it exists.
+native-compiled file even if it exists.
 
 If @var{filename} is a relative file name, such as @file{foo} or
 @file{baz/foo.bar}, @code{load} searches for the file using the variable
@@ -161,7 +161,7 @@ during compilation.  @xref{Compiling Macros}.
 
 Messages like @samp{Loading foo...} and @samp{Loading foo...done} appear
 in the echo area during loading unless @var{nomessage} is
-non-@code{nil}.  If a natively-compiled @samp{.eln} file is loaded,
+non-@code{nil}.  If a native-compiled @samp{.eln} file is loaded,
 the message says so.
 
 @cindex load errors
@@ -462,13 +462,13 @@ the shadowed files as a string.
 (@pxref{Native Compilation}), then when a @samp{.elc} byte-compiled
 file is found by searching @code{load-path}, Emacs will try to look
 for a corresponding @samp{.eln} file holding the corresponding
-natively-compiled code.  The natively-compiled files are looked up in
+native-compiled code.  The native-compiled files are looked up in
 the directories listed by the @code{native-comp-eln-load-path}.
 
 @vindex comp-native-version-dir
 @defvar native-comp-eln-load-path
 This variable holds a list of directories where Emacs looks for
-natively-compiled @samp{.eln} files.  File names in the list that are
+native-compiled @samp{.eln} files.  File names in the list that are
 not absolute are interpreted as relative to @code{invocation-directory}
 (@pxref{System Environment}).  The last directory in the list is the
 system directory, i.e.@: the directory with @samp{.eln} files
diff --git a/etc/NEWS b/etc/NEWS
index 76c8290fe32..0867822a7d8 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -1470,8 +1470,8 @@ strings in a variety of formats, for example "6 months 3 weeks" or "5m
 ** The function 'purecopy' is now an obsolete alias for 'identity'.
 
 ** New function 'native-compile-directory'.
-This function natively-compiles all Lisp files in a directory and in its
-sub-directories, recursively, which were not already natively-compiled.
+This function natively compiles all Lisp files in a directory and in its
+sub-directories, recursively, which were not already natively compiled.
 
 ---
 ** New function 'color-blend'.
diff --git a/etc/NEWS.28 b/etc/NEWS.28
index 2c0009e1902..f8f8664f00b 100644
--- a/etc/NEWS.28
+++ b/etc/NEWS.28
@@ -32,7 +32,7 @@ It is no longer enough to specify 'bindir=DIRECTORY' on the command
 line of the "make install" command.
 
 The reason for this new requirement is that Emacs needs to locate at
-startup the directory with its "*.eln" natively-compiled files for the
+startup the directory with its "*.eln" natively compiled files for the
 preloaded Lisp packages, and the relative name of that directory needs
 therefore to be recorded in the executable as part of the build.
 
diff --git a/etc/NEWS.29 b/etc/NEWS.29
index f99a6fbe7c4..00641ef1e16 100644
--- a/etc/NEWS.29
+++ b/etc/NEWS.29
@@ -3487,7 +3487,7 @@ These are like 'line-end-position' and 'line-beginning-position'
 
 ** New function 'compiled-function-p'.
 This returns non-nil if its argument is either a built-in, or a
-byte-compiled, or a natively-compiled function object, or a function
+byte-compiled, or a native-compiled function object, or a function
 loaded from a dynamic module.
 
 ** 'deactivate-mark' can have new value 'dont-save'.
@@ -3580,7 +3580,7 @@ things to be saved.
 ** New function 'string-equal-ignore-case'.
 This compares strings ignoring case differences.
 
-** 'symbol-file' can now report natively-compiled ".eln" files.
+** 'symbol-file' can now report native-compiled ".eln" files.
 If Emacs was built with native-compilation enabled, Lisp programs can
 now call 'symbol-file' with the new optional 3rd argument non-nil to
 request the name of the ".eln" file which defined a given symbol.
diff --git a/etc/NEWS.30 b/etc/NEWS.30
index ec14e447859..8369aa05423 100644
--- a/etc/NEWS.30
+++ b/etc/NEWS.30
@@ -425,7 +425,7 @@ This user option controls outline visibility in the output buffer of
 'describe-bindings' when 'describe-bindings-outline' is non-nil.
 
 *** 'describe-function' shows the function's inferred type when available.
-For native compiled Lisp functions, 'describe-function' prints (after
+For native-compiled Lisp functions, 'describe-function' prints (after
 the signature) the automatically inferred function type as well.  If the
 function's type was explicitly declared (via the 'declare' form's
 'ftype' property), 'describe-function' shows the declared type.  This is
diff --git a/lisp/emacs-lisp/comp-common.el b/lisp/emacs-lisp/comp-common.el
index bffadd9bd09..faf368bb858 100644
--- a/lisp/emacs-lisp/comp-common.el
+++ b/lisp/emacs-lisp/comp-common.el
@@ -56,7 +56,7 @@ This is intended for debugging the compiler itself.
   "Primitive functions to exclude from trampoline optimization.
 
 Primitive functions included in this list will not be called
-directly by the natively-compiled code, which makes trampolines for
+directly by the native-compiled code, which makes trampolines for
 those primitives unnecessary in case of function redefinition/advice."
   :type '(repeat symbol)
   :version "30.1")
@@ -520,7 +520,7 @@ itself."
             ;; Declared Lisp function
             (setf type-spec delc-type)
           (when (native-comp-function-p f)
-            ;; Native compiled inferred
+            ;; Natively compiled inferred
             (setf kind 'inferred
                   type-spec (subr-type f))))))
     (when type-spec
diff --git a/lisp/emacs-lisp/comp-cstr.el b/lisp/emacs-lisp/comp-cstr.el
index dfbef785ee6..67c72c8ce2b 100644
--- a/lisp/emacs-lisp/comp-cstr.el
+++ b/lisp/emacs-lisp/comp-cstr.el
@@ -216,7 +216,7 @@ Return them as multiple value."
      collect cstr into positives
    finally return (cl-values positives negatives)))
 
-;; So we can load comp-cstr.el and comp.el in non native compiled
+;; So we can load comp-cstr.el and comp.el in non natively compiled
 ;; builds.
 (defvar comp-ctxt nil)
 
diff --git a/lisp/subr.el b/lisp/subr.el
index f52264d3158..c7be73224cf 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -3112,7 +3112,7 @@ This is to `put' what `defalias' is to `fset'."
 (declare-function comp-el-to-eln-rel-filename "comp.c")
 
 (defun locate-eln-file (eln-file)
-  "Locate a natively-compiled ELN-FILE by searching its load path.
+  "Locate a native-compiled ELN-FILE by searching its load path.
 This function looks in directories named by `native-comp-eln-load-path'."
   (declare (important-return-value t))
   (or (locate-file-internal (concat comp-native-version-dir "/" eln-file)
diff --git a/src/comp.c b/src/comp.c
index 692b28e00cb..219a482931e 100644
--- a/src/comp.c
+++ b/src/comp.c
@@ -518,7 +518,7 @@ load_gccjit_if_necessary (bool mandatory)
 #endif
 #define SETJMP_NAME SETJMP
 
-/* Max number function importable by native compiled code.  */
+/* Max number function importable by native-compiled code.  */
 #define F_RELOC_MAX_SIZE 1600
 
 typedef struct {
@@ -5556,7 +5556,7 @@ syms_of_comp (void)
     doc: /* If non-nil, compile loaded .elc files asynchronously.
 
 After compilation, each function definition is updated to use the
-natively-compiled one.  */);
+natively compiled one.  */);
   native_comp_jit_compilation = true;
 
   DEFSYM (Qnative_comp_speed, "native-comp-speed");
@@ -5726,7 +5726,7 @@ For internal use.  */);
   Vcomp_eln_to_el_h = CALLN (Fmake_hash_table, QCtest, Qequal);
 
   DEFVAR_LISP ("native-comp-eln-load-path", Vnative_comp_eln_load_path,
-    doc: /* List of directories to look for natively-compiled *.eln files.
+    doc: /* List of directories to look for native-compiled *.eln files.
 
 The *.eln files are actually looked for in a version-specific
 subdirectory of each directory in this list.  That subdirectory
@@ -5746,11 +5746,11 @@ Emacs.  */);
 	       Vnative_comp_enable_subr_trampolines,
     doc: /* If non-nil, enable generation of trampolines for calling primitives.
 Trampolines are needed so that Emacs respects redefinition or advice of
-primitive functions when they are called from Lisp code natively-compiled
+primitive functions when they are called from native-compiled Lisp code
 at `native-comp-speed' of 2.
 
 By default, the value is t, and when Emacs sees a redefined or advised
-primitive called from natively-compiled Lisp, it generates a trampoline
+primitive called from native-compiled Lisp, it generates a trampoline
 for it on-the-fly.
 
 If the value is a file name (a string), it specifies the directory in
@@ -5762,8 +5762,8 @@ When this variable is nil, generation of trampolines is disabled.
 Disabling the generation of trampolines, when a trampoline for a redefined
 or advised primitive is not already available from previous compilations,
 means that such redefinition or advice will not have effect when calling
-primitives from natively-compiled Lisp code.  That is, calls to primitives
-without existing trampolines from natively-compiled Lisp will behave as if
+primitives from native-compiled Lisp code.  That is, calls to primitives
+without existing trampolines from native-compiled Lisp will behave as if
 the primitive was called directly from C, and will ignore its redefinition
 and advice.  */);
 
diff --git a/src/data.c b/src/data.c
index 5fcdda1b6e8..b2e5ffe4eed 100644
--- a/src/data.c
+++ b/src/data.c
@@ -499,7 +499,7 @@ DEFUN ("user-ptrp", Fuser_ptrp, Suser_ptrp, 1, 1, 0,
 #endif
 
 DEFUN ("subrp", Fsubrp, Ssubrp, 1, 1, 0,
-       doc: /* Return t if OBJECT is a built-in or native compiled Lisp function.
+       doc: /* Return t if OBJECT is a built-in or native-compiled Lisp function.
 
 See also `primitive-function-p' and `native-comp-function-p'.  */)
   (Lisp_Object object)
@@ -1046,7 +1046,7 @@ SUBR must be a built-in function.  */)
 }
 
 DEFUN ("native-comp-function-p", Fnative_comp_function_p, Snative_comp_function_p, 1, 1,
-       0, doc: /* Return t if the object is native compiled Lisp function, nil otherwise.  */)
+       0, doc: /* Return t if the object is native-compiled Lisp function, nil otherwise.  */)
   (Lisp_Object object)
 {
   return NATIVE_COMP_FUNCTIONP (object) ? Qt : Qnil;
@@ -1054,7 +1054,7 @@ DEFUN ("native-comp-function-p", Fnative_comp_function_p, Snative_comp_function_
 
 DEFUN ("subr-native-lambda-list", Fsubr_native_lambda_list,
        Ssubr_native_lambda_list, 1, 1, 0,
-       doc: /* Return the lambda list for a native compiled lisp/d
+       doc: /* Return the lambda list for a native-compiled lisp/d
 function or t otherwise.  */)
   (Lisp_Object subr)
 {
diff --git a/src/lread.c b/src/lread.c
index df1caaf5732..d45860fd470 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -1680,7 +1680,7 @@ Return t if the file exists and loads successfully.  */)
       if (is_module)
         message_with_string ("Loading %s (module)...", file, 1);
       else if (is_native_elisp)
-        message_with_string ("Loading %s (native compiled elisp)...", file, 1);
+        message_with_string ("Loading %s (native-compiled elisp)...", file, 1);
       else if (!compiled)
 	message_with_string ("Loading %s (source)...", file, 1);
       else if (newer)
@@ -1759,7 +1759,7 @@ Return t if the file exists and loads successfully.  */)
       if (is_module)
         message_with_string ("Loading %s (module)...done", file, 1);
       else if (is_native_elisp)
-	message_with_string ("Loading %s (native compiled elisp)...done", file, 1);
+	message_with_string ("Loading %s (native-compiled elisp)...done", file, 1);
       else if (!compiled)
 	message_with_string ("Loading %s (source)...done", file, 1);
       else if (newer)
diff --git a/src/pdumper.c b/src/pdumper.c
index b954421e225..7a8c5bba9ad 100644
--- a/src/pdumper.c
+++ b/src/pdumper.c
@@ -5503,7 +5503,7 @@ dump_do_dump_relocation (const uintptr_t dump_base,
     case RELOC_NATIVE_SUBR:
       {
 	/* When resurrecting from a dump given non all the original
-	   native compiled subrs may be still around we can't rely on
+	   native-compiled subrs may be still around we can't rely on
 	   a 'top_level_run' mechanism, we revive them one-by-one
 	   here.  */
 	struct Lisp_Subr *subr = dump_ptr (dump_base, reloc_offset);
diff --git a/test/src/comp-tests.el b/test/src/comp-tests.el
index e8ea2fde9e2..2991a05d771 100644
--- a/test/src/comp-tests.el
+++ b/test/src/comp-tests.el
@@ -329,7 +329,7 @@ Check that the resulting binaries do not differ."
     (should (= (funcall f 3) 4))))
 
 (comp-deftest lambda-return2 ()
-  "Check a nested lambda function gets native compiled."
+  "Check a nested lambda function gets natively compiled."
   (let ((f (comp-tests-lambda-return-f2)))
     (should (native-comp-function-p f))
     (let ((f2 (funcall f)))