diff --git a/collects/meta/build/bundle b/collects/meta/build/bundle
index e9027fd33c..48c27820c6 100755
--- a/collects/meta/build/bundle
+++ b/collects/meta/build/bundle
@@ -13,18 +13,18 @@
 (define home/     (/-ify (expand-user-path "~scheme")))
 (define binaries/ (/-ify (build-path home/ "binaries")))
 (define target/   (/-ify (build-path home/ "pre-installers")))
-(define plt/      (/-ify (or (getenv "PLTHOME")
+(define racket/   (/-ify (or (getenv "PLTHOME")
                              (error 'bundle "PLTHOME is not defined"))))
-(define plt-base/ (/-ify (simplify-path (build-path plt/ 'up) #f)))
-(define plt/-name (let-values ([(base name dir?) (split-path plt/)])
-                    (path-element->string name)))
+(define racket-base/ (/-ify (simplify-path (build-path racket/ 'up) #f)))
+(define racket/-name (let-values ([(base name dir?) (split-path racket/)])
+                       (path-element->string name)))
 
 (define cd current-directory)
 
 (define *readme-file*
-  (build-path plt/ "README"))
+  (build-path racket/ "README"))
 (define *info-domain-file*
-  (build-path plt/ "collects" "info-domain" "compiled" "cache.rktd"))
+  (build-path racket/ "collects" "info-domain" "compiled" "cache.rktd"))
 
 (define *readme-cache* #f)
 (define *info-domain-cache* #f)
@@ -177,7 +177,7 @@
   (set! /dev/null-in  (open-input-file  "/dev/null"))
   (unless (directory-exists? target/) (make-directory target/))
   (let ([d (ormap (lambda (x) (and (not (directory-exists? x)) x))
-                  (list home/ plt/ binaries/ target/))])
+                  (list home/ racket/ binaries/ target/))])
     (when d (error 'bundle "directory not found: ~a" d)))
   (set! *platforms*
         (parameterize ([cd binaries/])
@@ -203,10 +203,10 @@
           (map (lambda (platform)
                  (dprintf ".")
                  (parameterize ([cd platform])
-                   ;; if no btgz *and* "plt" already created then use get-tree
-                   ;; (useful when debugging stuff so re-use pre made ones)
-                   ;; should work the same with an old tree
-                   (if (and (directory-exists? "plt") (not *btgz?*))
+                   ;; if no btgz *and* "racket" already created then use
+                   ;; get-tree (useful when debugging stuff so re-use pre made
+                   ;; ones) should work the same with an old tree
+                   (if (and (directory-exists? "racket") (not *btgz?*))
                      (filtered-map
                       (lambda (x) ; only directories contain stuff we need
                         (and (directory-exists? x) (get-tree x)))
@@ -225,8 +225,8 @@
               (when (null? trees)
                 (error 'binaries "no binaries found for ~s" platform)))
             *platforms* *platform-tree-lists*)
-  ;; Get the plt tree, remove junk and binary stuff
-  (set-plt-tree! plt-base/ plt/-name *platform-tree-lists*)
+  ;; Get the racket tree, remove junk and binary stuff
+  (set-racket-tree! racket-base/ racket/-name *platform-tree-lists*)
   (set-bin-files-delayed-lists!
    (delay (map (lambda (trees)
                  (sort* (mappend tree-flatten (add-trees trees))))
@@ -235,11 +235,11 @@
 (define (make-info-domain trees)
   (unless (= 1 (length trees))
     (error 'make-info-domain "got zero or multiple trees: ~e" trees))
-  (let* ([collects (or (tree-filter "/plt/collects/" (car trees))
+  (let* ([collects (or (tree-filter "/racket/collects/" (car trees))
                        (error 'make-info-domain "got no collects in tree"))]
          [info (filter (lambda (x)
                          (let ([x (path->string (bytes->path (car x)))])
-                           (pair? (tree-filter (concat "/plt/collects/" x)
+                           (pair? (tree-filter (concat "/racket/collects/" x)
                                                collects))))
                        *info-domain-cache*)])
     (lambda () (write info) (newline))))
@@ -267,13 +267,14 @@
 
 (define (create-binaries platform trees)
   (parameterize ([cd (build-path binaries/ platform)])
-    (let ([full-tgz (concat "plt-"platform"-full.tgz")]
-          [bin-tgz  (concat "plt-"platform"-binaries.tgz")]
+    (let ([full-tgz (concat "racket-"platform"-full.tgz")]
+          [bin-tgz  (concat "racket-"platform"-binaries.tgz")]
           [all-tgzs (filter input-tgz-name?
                             (map path->string (directory-list)))])
-      (unless (and (directory-exists? "plt") (not *btgz?*))
+      (unless (and (directory-exists? "racket") (not *btgz?*))
         (dprintf "Unpacking binaries in ~s ~a\n" platform all-tgzs)
-        ;; even if a "plt" directory exists, we just overwrite the same stuff
+        ;; even if a "racket" directory exists, we just overwrite the same
+        ;; stuff
         (unless (member full-tgz all-tgzs)
           (error 'create-binaries "~a/~a not found" (cd) full-tgz))
         (for ([tgz all-tgzs]) (unpack tgz trees)))
@@ -285,9 +286,9 @@
                        (current-output-port) /dev/null-in (current-error-port)
                        ;; see below for flag explanations
                        /pax "-w" "-x" "ustar" "-z" "-f" bin-tgz
-                       ;; only pack the plt dir (only exception is Libraries on
-                       ;; OSX, but that has its own dir)
-                       "plt")])
+                       ;; only pack the racket dir (only exception is Libraries
+                       ;; on OSX, but that has its own dir)
+                       "racket")])
           (subprocess-wait p))))))
 
 (define (pack archive trees prefix)
@@ -472,7 +473,7 @@
         (let ([name (format "~a-~a.tgz" name type)])
           (dprintf "Creating ~s: filtering..." name)
           (let ([trees (add-trees
-                        (cons (distribute (get-plt-tree))
+                        (cons (distribute (get-racket-tree))
                               (if bin?
                                 (tag 'in-binary-tree
                                   (map (if full?
@@ -489,8 +490,8 @@
             (chown 'root *readme-file* *info-domain-file*)
             (pack (concat target/ name) trees
                   (if bin?
-                    (format "\\(~a\\|~a~a/\\)" plt-base/ binaries/ type)
-                    plt-base/)))
+                    (format "\\(~a\\|~a~a/\\)" racket-base/ binaries/ type)
+                    racket-base/)))
           (dprintf " done.\n")))))
   '())
 (register-spec! 'distribute!
@@ -529,7 +530,7 @@
 (define (chown-dirs-to who)
   (when (and *root?* *pack?*)
     (dprintf "Changing owner to ~a..." who)
-    (for ([dir (list plt/ binaries/)])
+    (for ([dir (list racket/ binaries/)])
       (parameterize ([cd dir]) (chown #:rec #t who ".")))
     (dprintf " done.\n")))
 
diff --git a/collects/meta/check-dists.rkt b/collects/meta/check-dists.rkt
index 73cda3d5ca..700e839cf9 100644
--- a/collects/meta/check-dists.rkt
+++ b/collects/meta/check-dists.rkt
@@ -7,10 +7,13 @@
                [current-namespace (namespace-anchor->namespace checker-namespace-anchor)])
   (define (/-ify x)
     (regexp-replace #rx"/?$" (if (path? x) (path->string x) x) "/"))
-  (define plt/      (/-ify (simplify-path (build-path (collection-path "scheme") 'up 'up))))
-  (define plt-base/ (/-ify (simplify-path (build-path plt/ 'up) #f)))
-  (define plt/-name (let-values ([(base name dir?) (split-path plt/)])
-                      (path-element->string name)))
+  (define racket/
+    (/-ify (simplify-path (build-path (collection-path "scheme") 'up 'up))))
+  (define racket-base/
+    (/-ify (simplify-path (build-path racket/ 'up) #f)))
+  (define racket/-name
+    (let-values ([(base name dir?) (split-path racket/)])
+      (path-element->string name)))
 
   (register-macros!)
 
@@ -19,11 +22,11 @@
   (register-spec! 'verify! verify!)
   (register-spec! 'distribute! void)
 
-  (set-plt-tree! plt-base/ plt/-name null)
+  (set-racket-tree! racket-base/ racket/-name null)
 
-  (set-bin-files-delayed-lists! 
+  (set-bin-files-delayed-lists!
    ;; FIXME: hard-wired list of binary-specific files
-   '(("plt/collects/sgl/compiled/gl-info_ss.zo")))
+   '(("racket/collects/sgl/compiled/gl-info_ss.zo")))
 
   (expand-spec 'distributions)
 
diff --git a/collects/meta/checker.rkt b/collects/meta/checker.rkt
index 9f8c606566..fd6ab3c647 100644
--- a/collects/meta/checker.rkt
+++ b/collects/meta/checker.rkt
@@ -449,23 +449,23 @@
                  file v version))))))
 
 (define (add-dependency-contents!)
-  (define (pltpath path)
+  (define (racketpath path)
     (bytes->string/utf-8
      (apply bytes-append (cdr (mappend (lambda (p) (list #"/" p))
-                                       (list* #"plt" #"collects" path))))))
+                                       (list* #"racket" #"collects" path))))))
   (define (read-depfile file)
     (let ([x (with-input-from-file file read)])
       (unless (and (pair? x) (check-version (car x) file))
         (error 'dependencies "bad contents in ~s: ~s" file x))
       (map (lambda (x)
              (match x
-               [`(collects ,(and (? bytes?) s) ...) (pltpath s)]
-               [`(ext collects ,(and (? bytes?) s) ...) (pltpath s)]
+               [`(collects ,(and (? bytes?) s) ...) (racketpath s)]
+               [`(ext collects ,(and (? bytes?) s) ...) (racketpath s)]
                [_ (error 'dependencies "bad dependency item in ~s: ~s"
                          file x)]))
            (cddr x))))
   (dprintf "Reading dependencies...")
-  (let loop ([tree (tree-filter "*.dep" *plt-tree*)])
+  (let loop ([tree (tree-filter "*.dep" *racket-tree*)])
     (if (pair? tree)
       (for-each loop (cdr tree))
       (parameterize ([cd (prop-get tree 'base)])
@@ -490,12 +490,13 @@
 (define (check-dependencies spec distname)
   (add-dependency-contents!)
   (dprintf "Verifying dependencies for ~s..." distname)
-  (let* ([all-files (sort* (add-alts (tree-flatten (tree-filter spec *plt-tree*))))]
-         [deps0 (or (tree-filter `(and ,spec "*.dep") *plt-tree*)
+  (let* ([all-files
+          (sort* (add-alts (tree-flatten (tree-filter spec *racket-tree*))))]
+         [deps0 (or (tree-filter `(and ,spec "*.dep") *racket-tree*)
                     (error 'check-dependencies
                            "got no .dep files for ~s" distname))]
          [deps0 (tree-flatten deps0 #t)])
-    (let* ([missing (tree-filter 'must-be-empty *plt-tree*)]
+    (let* ([missing (tree-filter 'must-be-empty *racket-tree*)]
            [missing (and (pair? missing) (tree-flatten missing #t))])
       (when (pair? missing)
         (dprintf "files missing from distribution:\n")
@@ -538,11 +539,10 @@
 ;;; Start working
 
 (define *platform-tree-lists* null)
-(define *plt-tree* #f)
+(define *racket-tree* #f)
 
-(provide get-plt-tree)
-(define (get-plt-tree)
-  *plt-tree*)
+(provide get-racket-tree)
+(define (get-racket-tree) *racket-tree*)
 
 (provide verify!)
 (define (verify!)
@@ -556,12 +556,13 @@
 (provide checker-namespace-anchor)
 (define-namespace-anchor checker-namespace-anchor)
 
-(provide set-plt-tree!)
-(define (set-plt-tree! plt-base/ plt/-name tree-lists)
+(provide set-racket-tree!)
+(define (set-racket-tree! racket-base/ racket/-name tree-lists)
   (set! *platform-tree-lists* tree-lists)
   (dprintf "Scanning main tree...")
-  (set! *plt-tree*
-        (let loop ([tree  (parameterize ([cd plt-base/]) (get-tree plt/-name))]
+  (set! *racket-tree*
+        (let loop ([tree  (parameterize ([cd racket-base/])
+                            (get-tree racket/-name))]
                    [trees (apply append *platform-tree-lists*)])
           (if (null? trees)
               (tree-filter '(not junk) tree)
diff --git a/collects/meta/dist-specs.rkt b/collects/meta/dist-specs.rkt
index 8161f7dd4d..3c4666af77 100644
--- a/collects/meta/dist-specs.rkt
+++ b/collects/meta/dist-specs.rkt
@@ -3,7 +3,7 @@
 ;; -*- scheme -*-
 
 ;; ============================================================================
-;; This file holds the specifications for creating PLT distributions.  These
+;; This file holds the specifications for creating Racket distributions.  These
 ;; specifications are defined by a sequence of <sym> := <spec>... definitions
 ;; (note: no parens), which binds the symbol to a tree specification.  In
 ;; addition, a definition can use `:=tag' which will go into a special space of
@@ -75,7 +75,7 @@
 distributions := (tag "mz" bin+src+dist)
                  (tag "mr" bin+src-dist)
                  (tag "dr" bin+src-dist)
-                 (tag "plt" bin+src+dist)
+                 (tag "racket" bin+src+dist)
                  (tag ("full" "bin") (distribute!))
 bin+src+dist  := (tag "bin" (verify!) (distribute!))
                  (tag "src" (verify!) (distribute!))
@@ -141,11 +141,11 @@ distribution-filters :=
 ;; (note: this rule means that we could avoid specifying docs and just include
 ;; the whole thing -- but this way we make sure that all doc sources are
 ;; included too (since they're specified together).)
-must-be-empty := (cond docs => (- "/plt/doc/" distribution) else => none)
+must-be-empty := (cond docs => (- "/racket/doc/" distribution) else => none)
 
 compiled-filter := (- (collects: "**/compiled/")
                       (cond verifying => "*.dep"))
-                   "/plt/bin/" "/plt/lib/"
+                   "/racket/bin/" "/racket/lib/"
 src-filter      := (src: "")
 docs-filter     := (- (doc: "")   ; all docs,
                       (notes: "") ; excluding basic stuff
@@ -173,7 +173,7 @@ std-docs        := (doc: "doc-license.txt" "*-std/")
 ;; (the first line shouldn't be necessary, but be safe)
 junk := (+ ".git*" "/.mailmap" ".svn" "CVS/" "[.#]*" "*~"
            ;; binary stuff should come from the platform directories
-           "/plt/bin/" "/plt/lib/" "/plt/src/*build*/")
+           "/racket/bin/" "/racket/lib/" "/racket/src/*build*/")
 
 ;; These are handled in a special way by the bundle script: the binary trees
 ;; are scanned for paths that have "<pfx>{3m|cgc}<sfx>" where a "<pfx><sfx>"
@@ -201,13 +201,13 @@ junk := (+ ".git*" "/.mailmap" ".svn" "CVS/" "[.#]*" "*~"
 ;; covered by these templates.
 
 binary-keep/throw-templates :=
-  "/plt/{lib|include}/**/*<!>.*"
-  "/plt/bin/*<!>"
-  (cond win => "/plt/*<!>.exe"
-               "/plt/lib/**/lib*<!>???????.{dll|lib|exp}"
-        mac => "/plt/*<!>.app/"
-               "/plt/lib/*Racket*.framework/Versions/*<_!>/")
-  "/plt/collects/**/compiled/**/<!/>*.*"
+  "/racket/{lib|include}/**/*<!>.*"
+  "/racket/bin/*<!>"
+  (cond win => "/racket/*<!>.exe"
+               "/racket/lib/**/lib*<!>???????.{dll|lib|exp}"
+        mac => "/racket/*<!>.app/"
+               "/racket/lib/*Racket*.framework/Versions/*<_!>/")
+  "/racket/collects/**/compiled/**/<!/>*.*"
 
 binary-keep  := "3[mM]"
 binary-throw := "{cgc|CGC}"
@@ -216,7 +216,7 @@ binary-throw := "{cgc|CGC}"
 ;; don't follow the above (have no 3m or cgc in the name, and no keep version
 ;; of the same name that will make them disappear)
 binary-throw-more :=
-  "/plt/lib/**/libmzgc???????.{dll|lib}"
+  "/racket/lib/**/libmzgc???????.{dll|lib}"
 
 ;; ============================================================================
 ;; Convenient macros
@@ -229,7 +229,7 @@ plt-path: := (lambda (prefix . paths)
                  (when (and (pair? paths) (eq? ': (car paths)))
                    (set! suffix (cadr paths)) (set! paths (cddr paths)))
                  `(+ ,@(map (lambda (path)
-                              (concat "/plt/" prefix
+                              (concat "/racket/" prefix
                                       (regexp-replace #rx"^/" path "")
                                       suffix))
                             paths))))
@@ -282,12 +282,12 @@ srcfile: :=
 
 dll: := (lambda fs
           `(+ ,@(map (lambda (f)
-                       (concat "/plt/lib/" (regexp-replace
-                                            #rx"^/" (expand-spec-1 f) "")
+                       (concat "/racket/lib/"
+                               (regexp-replace #rx"^/" (expand-spec-1 f) "")
                                "{|3[mM]|cgc|CGC}{|???????}.dll"))
                      fs)
               ,@(map (lambda (f)
-                       (concat "/plt/lib/**/"
+                       (concat "/racket/lib/**/"
                                (regexp-replace #rx"^.*/" (expand-spec-1 f) "")
                                "{|3[mM]|cgc|CGC}{|???????}.lib"))
                      fs)))
@@ -327,9 +327,9 @@ plt := (+ dr plt-extras)
 ;; ============================================================================
 ;; Packages etc
 
-mz-base := "/plt/README"
+mz-base := "/racket/README"
            (package: "racket") (package: "mzscheme")
-           "/plt/include/"
+           "/racket/include/"
            ;; configuration stuff
            (cond (not src) => (collects: "info-domain/")) ; filtered
            (package: "config")
@@ -411,19 +411,19 @@ extra-dynlibs := (cond win => (dll: "{ssl|lib}eay32"))
 ;; This filter is used on the full compiled trees to get the binary
 ;; (platform-dependent) portion out.
 
-binaries := (+ "/plt/bin/"
-               "/plt/lib/"
-               "/plt/include/"
-               "/plt/collects/**/compiled/native/"
-               (cond unix => "/plt/bin/{|g}racket*"
-                             "/plt/bin/{mzscheme|mred}*"
-                     win  => "/plt/*.exe"
-                             "/plt/*.dll"
-                             "/plt/collects/launcher/*.exe"
-                     mac  => "/plt/bin/racket*"
-                             "/plt/bin/mzscheme*"
-                             "/plt/*.app"
-                             "/plt/collects/launcher/*.app")
+binaries := (+ "/racket/bin/"
+               "/racket/lib/"
+               "/racket/include/"
+               "/racket/collects/**/compiled/native/"
+               (cond unix => "/racket/bin/{|g}racket*"
+                             "/racket/bin/{mzscheme|mred}*"
+                     win  => "/racket/*.exe"
+                             "/racket/*.dll"
+                             "/racket/collects/launcher/*.exe"
+                     mac  => "/racket/bin/racket*"
+                             "/racket/bin/mzscheme*"
+                             "/racket/*.app"
+                             "/racket/collects/launcher/*.app")
                platform-dependent)
 
 platform-dependent := ; hook for package rules
diff --git a/collects/meta/props b/collects/meta/props
index 0ed56ea32e..b2d4b931f5 100755
--- a/collects/meta/props
+++ b/collects/meta/props
@@ -6,7 +6,7 @@ exec racket -um "$0" "$@"
 
 #|
 
-This file contains "properties" of various files and directories in the PLT
+This file contains "properties" of various files and directories in the Racket
 tree.  Its format is briefly described below, but it is mainly intended to be
 used as a command-line script -- run it with `-h' to find out how to use it.
 In addition, you can make it work as a git command -- put this in a file
@@ -31,7 +31,7 @@ sequence of path and properties for it:
 
   <path> <prop> <val> <prop> <val> ...
 
-where <path> is a "/"-delimited string (relative to the plt tree root), <prop>
+where <path> is a "/"-delimited string (relative to the racket root), <prop>
 is one of a few known property symbols, and <val> is the assigned value.  The
 value is should follow the predicate specification for the property, which is
 defined as `known-props' before the properties data block; note that it is
@@ -46,7 +46,7 @@ are set by running this file as a script).
 Requiring this file builds the data table and provides an interface for
 properties, intended to be used by meta tools.  In these functions, `path' is a
 path argument that is given as a "/"-delimited and normalized path
-string (no ".", "..", "//", or a "/" suffix) relative to the plt tree root, and
+string (no ".", "..", "//", or a "/" suffix) relative to the racket root, and
 path/s is either such a string or a list of them.
 
 * (get-prop path/s prop [default]
@@ -349,14 +349,14 @@ path/s is either such a string or a list of them.
      "This is a utility for manipulating properties in the PLT repository."
      "Each of the following subcommands expects a property name from a set of"
      "known properties.  The given paths are normalized to be relative to the"
-     "plt root for the tree holding this script *if* it is in such a tree"
+     "racket root for the tree holding this script *if* it is in such a tree"
      "(determined by inspecting a few known directories), otherwise an error"
      "is raised."
      ""
      "Note: this script holds the data that it changes, so you need to commit"
      "it after changes are made."
      ""
-     "Note: it does not depend on the plt installation that runs it -- you"
+     "Note: it does not depend on the racket installation that runs it -- you"
      "just need to use the script from the work directory that you want to"
      "deal with; if you add a git alias like:"
      "  prop = \"!$(git rev-parse --show-toplevel)/collects/meta/props\""
@@ -388,7 +388,7 @@ path/s is either such a string or a list of them.
                       p)
                  (if (> n 0)
                    (loop base (sub1 n))
-                   (error* #f "could not find the plt root from ~a"
+                   (error* #f "could not find the racket root from ~a"
                            (path-only this-file))))))))
   (define check-existing-paths? #t)
   (define (paths->list path paths)
@@ -405,7 +405,7 @@ path/s is either such a string or a list of them.
               ""
               (let ([n (path->string n)])
                 (if (regexp-match #rx"^\\.\\.(?:/|$)" n)
-                  (error* #f "path is not in the plt tree: ~s" p)
+                  (error* #f "path is not in the racket tree: ~s" p)
                   n)))))
         (if (null? paths) (norm path) (map norm (cons path paths))))))
   (define (get prop path . paths)
diff --git a/collects/meta/readme.txt b/collects/meta/readme.txt
index 921f8ac817..b8fda38770 100644
--- a/collects/meta/readme.txt
+++ b/collects/meta/readme.txt
@@ -1 +1 @@
-This directory contains code that is used to manage PLT infrastructure.
+This directory contains code that is used to manage Racket infrastructure.
diff --git a/collects/meta/spec-lang.rkt b/collects/meta/spec-lang.rkt
index 6d10b54d0f..1fe7b6a2bd 100644
--- a/collects/meta/spec-lang.rkt
+++ b/collects/meta/spec-lang.rkt
@@ -4,7 +4,7 @@
 (provide (rename-out [module-begin #%module-begin]))
 
 (define-syntax-rule (module-begin . rest)
-  (#%module-begin 
+  (#%module-begin
    (provide register-specs!)
    (define (register-specs! [param *specs*])
      (process-specs 'rest param))))