diff --git a/AUTHORS b/AUTHORS
index 4165b09..d9f5670 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -2,7 +2,7 @@
 Julian Seward, jseward@acm.org, is the main author.
 
 Nicholas Nethercote, njn25@cam.ac.uk, did the core/tool
-generalisation, and wrote Cachegrind and some of the other skins.
+generalisation, and wrote Cachegrind and some of the other tools.
 
 Jeremy Fitzhardinge, jeremy@goop.org, wrote much of Helgrind, and lots
 of low-level syscall/signal stuff.
diff --git a/cachegrind/cg_main.c b/cachegrind/cg_main.c
index 4726c90..54850a9 100644
--- a/cachegrind/cg_main.c
+++ b/cachegrind/cg_main.c
@@ -69,7 +69,7 @@
       VgpCacheSimulate,
       VgpCacheResults
    } 
-   VgpSkinCC;
+   VgpToolCC;
 
 /*------------------------------------------------------------*/
 /*--- Output file related stuff                            ---*/
diff --git a/coregrind/vg_errcontext.c b/coregrind/vg_errcontext.c
index 892502f..dffe4f3 100644
--- a/coregrind/vg_errcontext.c
+++ b/coregrind/vg_errcontext.c
@@ -420,7 +420,7 @@
 }
 
 /* Second top-level entry point to the error management subsystem, for
-   errors that the skin want to report immediately, eg. because they're
+   errors that the tool wants to report immediately, eg. because they're
    guaranteed to only happen once.  This avoids all the recording and
    comparing stuff.  But they can be suppressed;  returns True if it is
    suppressed.  Bool `print_error' dictates whether to print the error. 
@@ -627,9 +627,9 @@
 }
 
 
-/* Look for "skin" in a string like "skin1,skin2,skin3" */
+/* Look for "tool" in a string like "tool1,tool2,tool3" */
 static __inline__
-Bool skin_name_present(Char *name, Char *names)
+Bool tool_name_present(Char *name, Char *names)
 {
    Bool  found;
    Char *s = NULL;   /* Shut gcc up */
@@ -653,7 +653,7 @@
    Int   fd, i;
    Bool  eof;
    Char  buf[N_BUF+1];
-   Char* skin_names;
+   Char* tool_names;
    Char* supp_name;
 
    fd = VG_(open)( filename, VKI_O_RDONLY, 0 );
@@ -664,7 +664,7 @@
    }
 
    while (True) {
-      /* Assign and initialise the two suppression halves (core and skin) */
+      /* Assign and initialise the two suppression halves (core and tool) */
       Supp* supp;
       supp        = VG_(arena_malloc)(VG_AR_CORE, sizeof(Supp));
       supp->count = 0;
@@ -693,11 +693,11 @@
       }
       buf[i]    = '\0';    /* Replace ':', splitting into two strings */
 
-      skin_names = & buf[0];
+      tool_names = & buf[0];
       supp_name  = & buf[i+1];
 
       /* Is it a core suppression? */
-      if (VG_(needs).core_errors && skin_name_present("core", skin_names))
+      if (VG_(needs).core_errors && tool_name_present("core", tool_names))
       {
          if (VG_STREQ(supp_name, "PThread"))
             supp->skind = PThreadSupp;
@@ -705,9 +705,9 @@
             goto syntax_error;
       }
 
-      /* Is it a skin suppression? */
+      /* Is it a tool suppression? */
       else if (VG_(needs).skin_errors && 
-               skin_name_present(VG_(details).name, skin_names))
+               tool_name_present(VG_(details).name, tool_names))
       {
          if (SK_(recognised_suppression)(supp_name, supp)) 
          {
diff --git a/coregrind/vg_malloc2.c b/coregrind/vg_malloc2.c
index 6aa035c..f171480 100644
--- a/coregrind/vg_malloc2.c
+++ b/coregrind/vg_malloc2.c
@@ -254,14 +254,14 @@
 
    /* Use a checked red zone size of 1 word for our internal stuff,
       and an unchecked zone of arbitrary size for the client.  Of
-      course the client's red zone can be checked by the skin, eg. 
+      course the client's red zone can be checked by the tool, eg. 
       by using addressibility maps, but not by the mechanism implemented
       here, which merely checks at the time of freeing that the red 
       zone words are unchanged. */
 
    arena_init ( &vg_arena[VG_AR_CORE],      "core",     1, True, 262144, False );
 
-   arena_init ( &vg_arena[VG_AR_SKIN],      "skin",     1, True, 262144, False );
+   arena_init ( &vg_arena[VG_AR_SKIN],      "tool",     1, True, 262144, False );
 
    arena_init ( &vg_arena[VG_AR_SYMTAB],    "symtab",   1, True, 262144, False );
 
@@ -1358,7 +1358,7 @@
 /*--- Skin-visible functions.                              ---*/
 /*------------------------------------------------------------*/
 
-/* All just wrappers to avoid exposing arenas to skins */
+/* All just wrappers to avoid exposing arenas to tools */
 
 void* VG_(malloc) ( Int nbytes )
 {
diff --git a/coregrind/vg_mylibc.c b/coregrind/vg_mylibc.c
index 99200aa..41cd3ee 100644
--- a/coregrind/vg_mylibc.c
+++ b/coregrind/vg_mylibc.c
@@ -1034,7 +1034,7 @@
    return res;
 }
 
-/* Wrapper to avoid exposing skins to ArenaId's */
+/* Wrapper to avoid exposing tools to ArenaId's */
 Char* VG_(strdup) ( const Char* s )
 {
    return VG_(arena_strdup) ( VG_AR_SKIN, s ); 
diff --git a/coregrind/vg_needs.c b/coregrind/vg_needs.c
index baad2a3..da4bc9c 100644
--- a/coregrind/vg_needs.c
+++ b/coregrind/vg_needs.c
@@ -1,6 +1,6 @@
 
 /*--------------------------------------------------------------------*/
-/*--- Stuff relating to skin data structures.                      ---*/
+/*--- Stuff relating to tool data structures.                      ---*/
 /*---                                                   vg_needs.c ---*/
 /*--------------------------------------------------------------------*/
 
@@ -33,7 +33,7 @@
 
 
 /* ---------------------------------------------------------------------
-   Skin data structure initialisation
+   Tool data structure initialisation
    ------------------------------------------------------------------ */
 
 /* Init with default values. */
diff --git a/coregrind/vg_replace_malloc.c b/coregrind/vg_replace_malloc.c
index 9c310dd..ce02c97 100644
--- a/coregrind/vg_replace_malloc.c
+++ b/coregrind/vg_replace_malloc.c
@@ -36,7 +36,7 @@
    have no prototypes in vg_include.h, since they are not intended to
    be called from within Valgrind.
 
-   This file can be #included into a skin that wishes to know about
+   This file can be #included into a tool that wishes to know about
    calls to malloc().  It should define functions SK_(malloc) et al
    that will be called.
    ------------------------------------------------------------------ */
diff --git a/coregrind/vg_scheduler.c b/coregrind/vg_scheduler.c
index 850f668..ce04d4d 100644
--- a/coregrind/vg_scheduler.c
+++ b/coregrind/vg_scheduler.c
@@ -1114,7 +1114,7 @@
                /* If __NR_exit, remember the supplied argument. */
                VG_(exitcode) = VG_(threads)[tid].m_ebx; /* syscall arg1 */
 
-               /* Only run __libc_freeres if the skin says it's ok and
+               /* Only run __libc_freeres if the tool says it's ok and
                   it hasn't been overridden with --run-libc-freeres=no
                   on the command line. */
 
@@ -2961,10 +2961,10 @@
          break;
       }
 
-      /* Note:  for skins that replace malloc() et al, we want to call
+      /* Note:  for tools that replace malloc() et al, we want to call
          the replacement versions.  For those that don't, we want to call
          VG_(cli_malloc)() et al.  We do this by calling SK_(malloc)(), which
-         malloc-replacing skins must replace, but have its default definition
+         malloc-replacing tools must replace, but have its default definition
          call */
 
       /* Note: for MALLOC and FREE, must set the appropriate "lock"... see
@@ -3280,7 +3280,7 @@
 	    static Bool whined = False;
 
 	    if (!whined) {
-               // Allow for requests in core, but defined by skins, which
+               // Allow for requests in core, but defined by tools, which
                // have 0 and 0 in their two high bytes.
                Char c1 = (arg[0] >> 24) & 0xff;
                Char c2 = (arg[0] >> 16) & 0xff;
diff --git a/coregrind/vg_signals.c b/coregrind/vg_signals.c
index c560564..79ca5aa 100644
--- a/coregrind/vg_signals.c
+++ b/coregrind/vg_signals.c
@@ -984,13 +984,13 @@
             "delivering signal %d (%s) to thread %d: on ALT STACK", 
             sigNo, signame(sigNo), tid );
 
-      /* Signal delivery to skins */
+      /* Signal delivery to tools */
       VG_TRACK( pre_deliver_signal, tid, sigNo, /*alt_stack*/False );
       
    } else {
       esp_top_of_frame = tst->m_esp;
 
-      /* Signal delivery to skins */
+      /* Signal delivery to tools */
       VG_TRACK( pre_deliver_signal, tid, sigNo, /*alt_stack*/True );
    }
 
@@ -1170,7 +1170,7 @@
    tst->sig_mask  = frame->mask;
    VG_(proxy_setsigmask)(tid);
 
-   /* Notify skins */
+   /* Notify tools */
    VG_TRACK( post_deliver_signal, tid, sigNo );
 
    return sigNo;
@@ -1685,7 +1685,7 @@
 	    is a permissions fault, then it means that the client is
 	    using some memory which had not previously been used.
 	    This catches those faults, makes the memory accessible,
-	    and calls the skin to initialize that page.
+	    and calls the tool to initialize that page.
 	 */
 	 static Int recursion = 0;
 
diff --git a/coregrind/vg_symtab2.c b/coregrind/vg_symtab2.c
index c779873..3c15da5 100644
--- a/coregrind/vg_symtab2.c
+++ b/coregrind/vg_symtab2.c
@@ -1544,7 +1544,7 @@
    return True;
 }
 
-/* This is available to skins... always demangle C++ names,
+/* This is available to tools... always demangle C++ names,
    match anywhere in function, but don't show offsets. */
 Bool VG_(get_fnname) ( Addr a, Char* buf, Int nbuf )
 {
@@ -1553,7 +1553,7 @@
                        /*show offset?*/False );
 }
 
-/* This is available to skins... always demangle C++ names,
+/* This is available to tools... always demangle C++ names,
    match anywhere in function, and show offset if nonzero. */
 Bool VG_(get_fnname_w_offset) ( Addr a, Char* buf, Int nbuf )
 {
@@ -1562,7 +1562,7 @@
                        /*show offset?*/True );
 }
 
-/* This is available to skins... always demangle C++ names,
+/* This is available to tools... always demangle C++ names,
    only succeed if 'a' matches first instruction of function,
    and don't show offsets. */
 Bool VG_(get_fnname_if_entry) ( Addr a, Char* buf, Int nbuf )
diff --git a/coregrind/vg_symtypes.c b/coregrind/vg_symtypes.c
index 2ce4033..f291d16 100644
--- a/coregrind/vg_symtypes.c
+++ b/coregrind/vg_symtypes.c
@@ -689,7 +689,7 @@
 	 else
 	    bufsz *= 2;
 
-	 /* use skin malloc so that the skin client can free it */
+	 /* use tool malloc so that the skin client can free it */
 	 n = VG_(malloc)(bufsz);
 	 if (buf != NULL && bufidx != 0)
 	    VG_(memcpy)(n, buf, bufidx);
diff --git a/coregrind/vg_to_ucode.c b/coregrind/vg_to_ucode.c
index cdd25e7..af83df0 100644
--- a/coregrind/vg_to_ucode.c
+++ b/coregrind/vg_to_ucode.c
@@ -7172,8 +7172,8 @@
     * in the basic block.  For them we patch in the x86 instruction size 
     * into the `extra4b' field of the basic-block-ending JMP. 
     *
-    * The INCEIPs and JMP.extra4b fields allows a skin to track x86
-    * instruction sizes, important for some skins (eg. cache simulation).
+    * The INCEIPs and JMP.extra4b fields allows a tool to track x86
+    * instruction sizes, important for some tools (eg. Cachegrind).
     */
    if (VG_(clo_single_step)) {
       eip = disInstr ( cb, eip, &isEnd );
diff --git a/include/valgrind.h b/include/valgrind.h
index 52a4f37..8cd07c9 100644
--- a/include/valgrind.h
+++ b/include/valgrind.h
@@ -159,7 +159,7 @@
              Valgrind's output to /dev/null and still count errors. */
           VG_USERREQ__COUNT_ERRORS = 0x1201,
 
-          /* These are useful and can be interpreted by any skin that tracks
+          /* These are useful and can be interpreted by any tool that tracks
              malloc() et al, by using vg_replace_malloc.c. */
           VG_USERREQ__MALLOCLIKE_BLOCK = 0x1301,
           VG_USERREQ__FREELIKE_BLOCK   = 0x1302,
@@ -273,8 +273,8 @@
    })
 
 
-/* Counts the number of errors that have been recorded by a skin.  Nb:
-   the skin must record the errors with VG_(maybe_record_error)() or
+/* Counts the number of errors that have been recorded by a tool.  Nb:
+   the tool must record the errors with VG_(maybe_record_error)() or
    VG_(unique_error)() for them to be counted. */
 #define VALGRIND_COUNT_ERRORS                                           \
    ({unsigned int _qyy_res;                                             \
diff --git a/include/vg_profile.c b/include/vg_profile.c
index cc732e1..877efad 100644
--- a/include/vg_profile.c
+++ b/include/vg_profile.c
@@ -1,7 +1,7 @@
 
 /*--------------------------------------------------------------------*/
-/*--- Profiling machinery.  #include this file into a skin to      ---*/
-/*--- enable --profile=yes, but not for release versions of skins, ---*/
+/*--- Profiling machinery.  #include this file into a tool to      ---*/
+/*--- enable --profile=yes, but not for release versions of tools, ---*/
 /*--- because it uses glibc code.                                  ---*/
 /*---                                                 vg_profile.c ---*/
 /*--------------------------------------------------------------------*/
@@ -76,7 +76,7 @@
    if (vgp_names[n] != NULL) {
       VG_(printf)("\nProfile event #%d being registered as `%s'\n"
                   "already registered as `%s'.\n"
-                  "Note that skin and core event numbers must not overlap.\n",
+                  "Note that tool and core event numbers must not overlap.\n",
                   n, name, vgp_names[n]);
       VG_(skin_panic)("profile event already registered");
    }
diff --git a/memcheck/mac_malloc_wrappers.c b/memcheck/mac_malloc_wrappers.c
index 8714bb8..b3c5353 100644
--- a/memcheck/mac_malloc_wrappers.c
+++ b/memcheck/mac_malloc_wrappers.c
@@ -44,7 +44,7 @@
 /* We want a 16B redzone on heap blocks for Addrcheck and Memcheck */
 UInt VG_(vg_malloc_redzone_szB) = 16;
 
-/* Function pointers for the two skins to track interesting events. */
+/* Function pointers for the two tools to track interesting events. */
 void (*MAC_(new_mem_heap)) ( Addr a, UInt len, Bool is_inited )  = NULL;
 void (*MAC_(ban_mem_heap)) ( Addr a, UInt len )                  = NULL;
 void (*MAC_(die_mem_heap)) ( Addr a, UInt len )                  = NULL;
diff --git a/memcheck/mac_shared.h b/memcheck/mac_shared.h
index f36175c..c968a08 100644
--- a/memcheck/mac_shared.h
+++ b/memcheck/mac_shared.h
@@ -154,7 +154,7 @@
    MAC_Chunk;
 
 /*------------------------------------------------------------*/
-/*--- Profiling of skins and memory events                 ---*/
+/*--- Profiling of tools and memory events                 ---*/
 /*------------------------------------------------------------*/
 
 typedef 
@@ -163,7 +163,7 @@
       VgpSetMem,
       VgpESPAdj
    } 
-   VgpSkinCC;
+   VgpToolCC;
 
 /* Define to collect detailed performance info. */
 /* #define MAC_PROFILE_MEMORY */
@@ -270,7 +270,7 @@
 /* For tracking malloc'd blocks */
 extern VgHashTable MAC_(malloc_list);
 
-/* Function pointers for the two skins to track interesting events. */
+/* Function pointers for the two tools to track interesting events. */
 extern void (*MAC_(new_mem_heap)) ( Addr a, UInt len, Bool is_inited );
 extern void (*MAC_(ban_mem_heap)) ( Addr a, UInt len );
 extern void (*MAC_(die_mem_heap)) ( Addr a, UInt len );
diff --git a/memcheck/memcheck.h b/memcheck/memcheck.h
index e817c13..03d7ff9 100644
--- a/memcheck/memcheck.h
+++ b/memcheck/memcheck.h
@@ -82,7 +82,7 @@
       VG_USERREQ__COUNT_LEAKS,
 
       /* These two have been moved into core, because they are useful for
-         any skin that tracks heap blocks.  Hence the suffix.  But they're
+         any tool that tracks heap blocks.  Hence the suffix.  But they're
          still here for backwards compatibility, although Valgrind will
          abort with an explanatory message if you use them. */
       VG_USERREQ__MALLOCLIKE_BLOCK__OLD_DO_NOT_USE,
diff --git a/tests/filter_stderr_basic b/tests/filter_stderr_basic
index 136db51..1150f11 100755
--- a/tests/filter_stderr_basic
+++ b/tests/filter_stderr_basic
@@ -7,7 +7,7 @@
 sed "s/\(==\|--\|\+\+\|\*\*\)[0-9]\{1,5\}\1 //"             |
 
 # Remove "<name>, a <description> for x86-linux." line and the following
-# copyright notice line.  Works for skin and core intro lines.
+# copyright notice line.  Works for tool and core intro lines.
 sed "/^.*, .* for x86-linux\./ , /./ d"                                | 
 
 # Remove other introductory lines