diff --git a/collects/scribble/eval.ss b/collects/scribble/eval.ss
index 603c7201..c2c01634 100644
--- a/collects/scribble/eval.ss
+++ b/collects/scribble/eval.ss
@@ -1,20 +1,20 @@
 
-(module eval scheme/base
+(module eval racket/base
   (require "manual.ss"
            "struct.ss"
            "scheme.ss"
            "decode.ss"
-           scheme/file
+           racket/file
            scheme/sandbox
-           scheme/promise
+           racket/promise
            mzlib/string
-           (for-syntax scheme/base))
+           (for-syntax racket/base))
 
   (provide interaction
            interaction-eval
            interaction-eval-show
-           schemeblock+eval
-           schememod+eval
+           racketblock+eval (rename-out [racketblock+eval schemeblock+eval])
+           racketmod+eval (rename-out [racketmod+eval schememod+eval])
            def+int
            defs+int
            examples
@@ -38,8 +38,8 @@
 
   (define maxlen 60)
 
-  (namespace-require 'scheme/base)
-  (namespace-require '(for-syntax scheme/base))
+  (namespace-require 'racket/base)
+  (namespace-require '(for-syntax racket/base))
 
   (define (literal-string style s)
     (let ([m (regexp-match #rx"^(.*)(  +)(.*)$" s)])
@@ -325,31 +325,31 @@
       [(_ #:eval ev e) (do-interaction-eval-show ev (quote-expr e))]
       [(_ e) (do-interaction-eval-show #f (quote-expr e))]))
 
-  (define-syntax schemeinput*
+  (define-syntax racketinput*
     (syntax-rules (eval:alts code:comment)
-      [(_ (code:comment . rest)) (schemeblock (code:comment . rest))]
-      [(_ (eval:alts a b)) (schemeinput* a)]
-      [(_ e) (schemeinput e)]))
+      [(_ (code:comment . rest)) (racketblock (code:comment . rest))]
+      [(_ (eval:alts a b)) (racketinput* a)]
+      [(_ e) (racketinput e)]))
 
-  (define-code schemeblock+line (to-paragraph/prefix (hspace 2) 
+  (define-code racketblock+line (to-paragraph/prefix (hspace 2) 
                                                      (hspace 2)
                                                      (list " ")))
 
-  (define-syntax (schemedefinput* stx)
+  (define-syntax (racketdefinput* stx)
     (syntax-case stx (define define-values define-struct)
       [(_ (define . rest))
        (syntax-case stx ()
-         [(_ e) #'(schemeblock+line e)])]
+         [(_ e) #'(racketblock+line e)])]
       [(_ (define-values . rest))
        (syntax-case stx ()
-         [(_ e) #'(schemeblock+line e)])]
+         [(_ e) #'(racketblock+line e)])]
       [(_ (define-struct . rest))
        (syntax-case stx ()
-         [(_ e) #'(schemeblock+line e)])]
+         [(_ e) #'(racketblock+line e)])]
       [(_ (code:line (define . rest) . rest2))
        (syntax-case stx ()
-         [(_ e) #'(schemeblock+line e)])]
-      [(_ e) #'(schemeinput* e)]))
+         [(_ e) #'(racketblock+line e)])]
+      [(_ e) #'(racketinput* e)]))
 
   (define (do-titled-interaction ev t shows evals)
     (interleave t
@@ -358,41 +358,41 @@
 
   (define-syntax titled-interaction
     (syntax-rules ()
-      [(_ #:eval ev t schemeinput* e ...)
-       (do-titled-interaction ev t (list (schemeinput* e) ...) (list (quote-expr e) ...))]
-      [(_ t schemeinput* e ...)
-       (titled-interaction #:eval (make-base-eval) t schemeinput* e ...)]))
+      [(_ #:eval ev t racketinput* e ...)
+       (do-titled-interaction ev t (list (racketinput* e) ...) (list (quote-expr e) ...))]
+      [(_ t racketinput* e ...)
+       (titled-interaction #:eval (make-base-eval) t racketinput* e ...)]))
 
     (define-syntax interaction
       (syntax-rules ()
-        [(_ #:eval ev e ...) (titled-interaction #:eval ev #f schemeinput* e ...)]
-        [(_ e ...) (titled-interaction #f schemeinput* e ...)]))
+        [(_ #:eval ev e ...) (titled-interaction #:eval ev #f racketinput* e ...)]
+        [(_ e ...) (titled-interaction #f racketinput* e ...)]))
 
-  (define-syntax schemeblock+eval
+  (define-syntax racketblock+eval
     (syntax-rules ()
       [(_ #:eval ev e ...)
        (let ([eva ev])
          (#%expression
           (begin (interaction-eval #:eval eva e) ...
-                 (schemeblock e ...))))]
+                 (racketblock e ...))))]
       [(_ e ...)
-       (schemeblock+eval #:eval (make-base-eval) e ...)]))
+       (racketblock+eval #:eval (make-base-eval) e ...)]))
 
-  (define-syntax schememod+eval
+  (define-syntax racketmod+eval
     (syntax-rules ()
       [(_ #:eval ev name e ...)
        (let ([eva ev])
          (#%expression
           (begin (interaction-eval #:eval eva e) ...
-                 (schememod name e ...))))]
+                 (racketmod name e ...))))]
       [(_ name e ...)
-       (schememod+eval #:eval (make-base-eval) name e ...)]))
+       (racketmod+eval #:eval (make-base-eval) name e ...)]))
 
   (define-syntax def+int
     (syntax-rules ()
       [(_ #:eval ev def e ...)
        (let ([eva ev])
-         (column (list (schemeblock+eval #:eval eva def)
+         (column (list (racketblock+eval #:eval eva def)
                        blank-line
                        (interaction #:eval eva e ...))))]
       [(_ def e ...) 
@@ -402,7 +402,7 @@
     (syntax-rules ()
       [(_ #:eval ev [def ...] e ...)
        (let ([eva ev])
-         (column (list (schemeblock+eval #:eval eva def ...)
+         (column (list (racketblock+eval #:eval eva def ...)
                        blank-line
                        (interaction #:eval eva e ...))))]
       [(_ [def ...] e ...)
@@ -421,27 +421,27 @@
   (define-syntax examples
     (syntax-rules ()
       [(_ #:eval ev e ...)
-       (titled-interaction #:eval ev (pick-example-title e ...) schemeinput* e ...)]
+       (titled-interaction #:eval ev (pick-example-title e ...) racketinput* e ...)]
       [(_ e ...)
-       (titled-interaction (pick-example-title e ...)  schemeinput* e ...)]))
+       (titled-interaction (pick-example-title e ...)  racketinput* e ...)]))
   (define-syntax examples*
     (syntax-rules ()
       [(_ #:eval ev example-title e ...)
-       (titled-interaction #:eval ev example-title schemeinput* e ...)]
+       (titled-interaction #:eval ev example-title racketinput* e ...)]
       [(_ example-title e ...)
-       (titled-interaction example-title schemeinput* e ...)]))
+       (titled-interaction example-title racketinput* e ...)]))
   (define-syntax defexamples
     (syntax-rules ()
       [(_ #:eval ev e ...)
-       (titled-interaction #:eval ev (pick-example-title e ...)  schemedefinput* e ...)]
+       (titled-interaction #:eval ev (pick-example-title e ...)  racketdefinput* e ...)]
       [(_ e ...)
-       (titled-interaction (pick-example-title e ...)  schemedefinput* e ...)]))
+       (titled-interaction (pick-example-title e ...)  racketdefinput* e ...)]))
   (define-syntax defexamples*
     (syntax-rules ()
       [(_ #:eval ev example-title e ...)
-       (titled-interaction #:eval ev example-title schemedefinput* e ...)]
+       (titled-interaction #:eval ev example-title racketdefinput* e ...)]
       [(_ example-title e ...)
-       (titled-interaction example-title schemedefinput* e ...)]))
+       (titled-interaction example-title racketdefinput* e ...)]))
 
   (define blank-line (make-paragraph (list 'nbsp)))
 
diff --git a/collects/scribble/private/manual-scheme.ss b/collects/scribble/private/manual-scheme.ss
index 622b89d6..016a2afd 100644
--- a/collects/scribble/private/manual-scheme.ss
+++ b/collects/scribble/private/manual-scheme.ss
@@ -1,38 +1,57 @@
-#lang scheme/base
+#lang racket/base
 (require "../decode.ss"
          "../struct.ss"
          "../scheme.ss"
          "../search.ss"
          "../basic.ss"
-         scheme/list
+         racket/list
          "manual-utils.ss"
          "manual-style.ss"
-         (for-syntax scheme/base)
-         (for-label scheme/base))
+         (for-syntax racket/base)
+         (for-label racket/base))
 
-(provide schemeblock SCHEMEBLOCK schemeblock/form
-         schemeblock0 SCHEMEBLOCK0 schemeblock0/form
-         schemeblockelem
-         schemeinput
-         schememod
-         scheme SCHEME scheme/form schemeresult schemeid 
-         schememodname
-         schememodlink indexed-scheme
-         schemelink)
+(provide racketblock RACKETBLOCK racketblock/form
+         racketblock0 RACKETBLOCK0 racketblock0/form
+         racketblockelem
+         racketinput
+         racketmod
+         racket RACKET racket/form racketresult racketid 
+         racketmodname
+         racketmodlink indexed-racket
+         racketlink
+         
+         (rename-out [racketblock schemeblock]
+                     [RACKETBLOCK SCHEMEBLOCK]
+                     [racketblock/form schemeblock/form]
+                     [racketblock0 schemeblock0]
+                     [RACKETBLOCK0 SCHEMEBLOCK0]
+                     [racketblock0/form schemeblock0/form]
+                     [racketblockelem schemeblockelem]
+                     [racketinput schemeinput]
+                     [racketmod schememod]
+                     [racket scheme]
+                     [RACKET SCHEME]
+                     [racket/form scheme/form]
+                     [racketresult schemeresult]
+                     [racketid schemeid]
+                     [racketmodname schememodname]
+                     [racketmodlink schememodlink]
+                     [indexed-racket indexed-scheme]
+                     [racketlink schemelink]))
 
-(define-code schemeblock0 to-paragraph)
-(define-code schemeblock (to-paragraph/prefix (hspace 2) (hspace 2) ""))
-(define-code SCHEMEBLOCK (to-paragraph/prefix (hspace 2) (hspace 2) "")
+(define-code racketblock0 to-paragraph)
+(define-code racketblock (to-paragraph/prefix (hspace 2) (hspace 2) ""))
+(define-code RACKETBLOCK (to-paragraph/prefix (hspace 2) (hspace 2) "")
                          UNSYNTAX)
-(define-code SCHEMEBLOCK0 to-paragraph UNSYNTAX)
+(define-code RACKETBLOCK0 to-paragraph UNSYNTAX)
 (define interaction-prompt (make-element 'tt (list "> " )))
-(define-code schemeinput
+(define-code racketinput
   (to-paragraph/prefix
    (make-element #f (list (hspace 2) interaction-prompt))
    (hspace 4)
    ""))
 
-(define-syntax (schememod stx)
+(define-syntax (racketmod stx)
   (syntax-case stx ()
     [(_ #:file filename lang rest ...)
      (with-syntax ([modtag (datum->syntax
@@ -45,7 +64,7 @@
                                                    `(as-modname-link
                                                      ',#'lang
                                                      (to-element ',#'lang))
-                                                   #'(scheme lang)))))
+                                                   #'(racket lang)))))
                             #'lang)]
                    [(file ...)
                     (if (syntax-e #'filename)
@@ -55,9 +74,9 @@
                           `(code:comment (unsyntax (t "In \"" ,(syntax-e #'filename) "\":")))
                           #'filename))
                         null)])
-       (syntax/loc stx (schemeblock file ... modtag rest ...)))]
+       (syntax/loc stx (racketblock file ... modtag rest ...)))]
     [(_ lang rest ...)
-     (syntax/loc stx (schememod #:file #f lang rest ...))]))
+     (syntax/loc stx (racketmod #:file #f lang rest ...))]))
 
 (define (to-element/result s)
   (make-element result-color (list (to-element/no-color s))))
@@ -91,25 +110,25 @@
     (make-shaped-parens s val)
     s))
 
-(define-code schemeblockelem to-element)
+(define-code racketblockelem to-element)
 
-(define-code scheme to-element unsyntax keep-s-expr add-sq-prop)
-(define-code SCHEME to-element UNSYNTAX keep-s-expr add-sq-prop)
-(define-code schemeresult to-element/result unsyntax keep-s-expr add-sq-prop)
-(define-code schemeid to-element/id unsyntax keep-s-expr add-sq-prop)
-(define-code *schememodname to-element unsyntax keep-s-expr add-sq-prop)
+(define-code racket to-element unsyntax keep-s-expr add-sq-prop)
+(define-code RACKET to-element UNSYNTAX keep-s-expr add-sq-prop)
+(define-code racketresult to-element/result unsyntax keep-s-expr add-sq-prop)
+(define-code racketid to-element/id unsyntax keep-s-expr add-sq-prop)
+(define-code *racketmodname to-element unsyntax keep-s-expr add-sq-prop)
 
-(define-syntax schememodname
+(define-syntax racketmodname
   (syntax-rules (unsyntax)
-    [(schememodname #,n)
+    [(racketmodname #,n)
      (let ([sym n])
        (as-modname-link sym (to-element sym)))]
-    [(schememodname n)
-     (as-modname-link 'n (*schememodname n))]))
+    [(racketmodname n)
+     (as-modname-link 'n (*racketmodname n))]))
 
-(define-syntax schememodlink
+(define-syntax racketmodlink
   (syntax-rules (unsyntax)
-    [(schememodlink n content ...)
+    [(racketmodlink n content ...)
      (*as-modname-link 'n (elem #:style #f content ...))]))
 
 (define (as-modname-link s e)
@@ -122,10 +141,10 @@
                      (list e)
                      `(mod-path ,(format "~s" s))))
 
-(define-syntax-rule (indexed-scheme x)
-  (add-scheme-index 'x (scheme x)))
+(define-syntax-rule (indexed-racket x)
+  (add-racket-index 'x (racket x)))
 
-(define (add-scheme-index s e)
+(define (add-racket-index s e)
   (let ([k (cond [(and (pair? s) (eq? (car s) 'quote)) (format "~s" (cadr s))]
                  [(string? s) s]
                  [else (format "~s" s)])])
@@ -139,11 +158,11 @@
          #'(let ([ellipses #f])
              (base a)))])))
 
-(define-/form schemeblock0/form schemeblock0)
-(define-/form schemeblock/form schemeblock)
-(define-/form scheme/form scheme)
+(define-/form racketblock0/form racketblock0)
+(define-/form racketblock/form racketblock)
+(define-/form racket/form racket)
 
-(define (*schemelink stx-id id . s)
+(define (*racketlink stx-id id . s)
   (let ([content (decode-content s)])
     (make-delayed-element
      (lambda (r p ri)
@@ -151,11 +170,11 @@
         (make-link-element
          #f
          content
-         (or (find-scheme-tag p ri stx-id #f)
+         (or (find-racket-tag p ri stx-id #f)
              `(undef ,(format "--UNDEFINED:~a--" (syntax-e stx-id)))))))
      (lambda () content)
      (lambda () content))))
 
-(define-syntax-rule (schemelink id . content)
-  (*schemelink (quote-syntax id) 'id . content))
+(define-syntax-rule (racketlink id . content)
+  (*racketlink (quote-syntax id) 'id . content))
 
diff --git a/collects/scribble/private/manual-style.ss b/collects/scribble/private/manual-style.ss
index 14ed9193..5c7087aa 100644
--- a/collects/scribble/private/manual-style.ss
+++ b/collects/scribble/private/manual-style.ss
@@ -1,4 +1,4 @@
-#lang scheme/base
+#lang racket/base
 (require "../decode.ss"
          "../struct.ss"
          "../base.ss"
@@ -7,9 +7,9 @@
          (only-in "../core.ss" make-style plain)
          "manual-utils.ss"
          "on-demand.ss"
-         scheme/list
-         scheme/contract
-         scheme/string)
+         racket/list
+         racket/contract
+         racket/string)
 
 (provide (rename-out [hyperlink link])
          (rename-out [other-doc other-manual])
@@ -23,12 +23,26 @@
   (() () #:rest (listof pre-content?) . ->* . element?))
 (define-syntax-rule (provide-styling id ...)
   (provide/contract [id styling-f/c] ...))
-(provide-styling schememodfont schemeoutput
-                 schemeerror schemefont schemevalfont schemeresultfont schemeidfont schemevarfont
-                 schemeparenfont schemekeywordfont schememetafont
+(provide-styling racketmodfont racketoutput
+                 racketerror racketfont racketvalfont racketresultfont racketidfont racketvarfont
+                 racketparenfont racketkeywordfont racketmetafont
                  onscreen defterm filepath exec envvar Flag DFlag PFlag DPFlag math
                  procedure
                  indexed-file indexed-envvar idefterm pidefterm)
+(define-syntax-rule (provide-scheme-styling [rid sid] ...)
+  (provide/contract [rename rid sid styling-f/c] ...))
+(provide-scheme-styling [racketmodfont schememodfont]
+                        [racketoutput schemeoutput]
+                        [racketerror schemeerror]
+                        [racketfont schemefont]
+                        [racketvalfont schemevalfont]
+                        [racketresultfont schemeresultfont]
+                        [racketidfont schemeidfont]
+                        [racketvarfont schemevarfont]
+                        [racketparenfont schemeparenfont]
+                        [racketkeywordfont schemekeywordfont]
+                        [racketmetafont schememetafont])
+                 
 (provide void-const
          undefined-const)
 (provide/contract
@@ -68,23 +82,23 @@
 (define (idefterm . str)
   (let ([c (decode-content str)])
     (make-element 'italic c)))
-(define (schemefont . str)
+(define (racketfont . str)
   (apply tt str))
-(define (schemevalfont . str)
+(define (racketvalfont . str)
   (make-element value-color (decode-content str)))
-(define (schemeresultfont . str)
+(define (racketresultfont . str)
   (make-element result-color (decode-content str)))
-(define (schemeidfont . str)
+(define (racketidfont . str)
   (make-element symbol-color (decode-content str)))
-(define (schemevarfont . str)
+(define (racketvarfont . str)
   (make-element variable-color (decode-content str)))
-(define (schemeparenfont . str)
+(define (racketparenfont . str)
   (make-element paren-color (decode-content str)))
-(define (schememetafont . str)
+(define (racketmetafont . str)
   (make-element meta-color (decode-content str)))
-(define (schememodfont . str)
+(define (racketmodfont . str)
   (make-element module-color (decode-content str)))
-(define (schemekeywordfont . str)
+(define (racketkeywordfont . str)
   (make-element keyword-color (decode-content str)))
 (define (filepath . str)
   (make-element 'tt (append (list "\"") (decode-content str) (list "\""))))
@@ -124,9 +138,9 @@
 (define (procedure . str)
   (make-element result-color `("#<procedure:" ,@(decode-content str) ">")))
 
-(define (schemeoutput . str)
+(define (racketoutput . str)
   (make-element output-color (decode-content str)))
-(define (schemeerror . str)
+(define (racketerror . str)
   (make-element error-color (decode-content str)))
 
 (define (t . str)
@@ -150,13 +164,13 @@
 (define (hash-lang)
   (make-link-element
    module-link-color
-   (list (schememodfont "#lang"))
+   (list (racketmodfont "#lang"))
    `(part ,(doc-prefix '(lib "scribblings/guide/guide.scrbl") "hash-lang"))))
 
 (define-on-demand void-const
-  (schemeresultfont "#<void>"))
+  (racketresultfont "#<void>"))
 (define-on-demand undefined-const
-  (schemeresultfont "#<undefined>"))
+  (racketresultfont "#<undefined>"))
 
 (define (link url 
               #:underline? [underline? #t]
diff --git a/collects/scribble/scheme.ss b/collects/scribble/scheme.ss
index 9e18e736..15ba5c77 100644
--- a/collects/scribble/scheme.ss
+++ b/collects/scribble/scheme.ss
@@ -667,7 +667,8 @@
               (null? s)
               (hash? s)
               (graph-defn? s)
-              (graph-reference? s))
+              (graph-reference? s)
+              (struct-proxy? s))
           (gen-typeset c multi-line? prefix1 prefix suffix color? qq?)
           (typeset-atom c 
                         (letrec ([mk
diff --git a/collects/scribble/search.ss b/collects/scribble/search.ss
index 796ef575..f5187add 100644
--- a/collects/scribble/search.ss
+++ b/collects/scribble/search.ss
@@ -1,10 +1,11 @@
-(module search scheme/base
+(module search racket/base
   (require "struct.ss"
            "basic.ss"
            setup/main-collects
            syntax/modcode)
 
-  (provide find-scheme-tag)
+  (provide find-racket-tag
+           (rename-out [find-racket-tag find-scheme-tag]))
 
   (define module-info-cache (make-hasheq))
 
@@ -21,7 +22,7 @@
     (with-handlers* ([exn:fail? (lambda (exn) (fail-thunk))])
       (thunk)))
 
-  (define (find-scheme-tag part ri stx/binding phase-level)
+  (define (find-racket-tag part ri stx/binding phase-level)
     ;; The phase-level argument is used only when `stx/binding'
     ;; is an identifier.
     ;;
@@ -169,7 +170,7 @@
                                               ;; have changed in inconsistent ways. So just say #f
                                               ;; for now.
                                               #;
-                                              (error 'find-scheme-tag
+                                              (error 'find-racket-tag
                                                      "dead end when looking for binding source: ~e"
                                                      id)
                                               (loop queue rqueue need-result?)))))
diff --git a/collects/scribble/urls.ss b/collects/scribble/urls.ss
index ba8f0538..c4604c25 100644
--- a/collects/scribble/urls.ss
+++ b/collects/scribble/urls.ss
@@ -1,8 +1,10 @@
+#lang racket/base
 
-(module urls mzscheme
-  (provide (all-defined))
+(provide (all-defined-out)
+         (rename-out [url:drracket url:drscheme]
+                     [url:download-drracket url:download-drscheme]))
 
-  (define url:drscheme "http://www.drscheme.org/")
-  (define url:download-drscheme "http://download.plt-scheme.org/drscheme/")
-  
-  (define url:planet "http://planet.plt-scheme.org/"))
+(define url:drracket "http://racket-lang.org/")
+(define url:download-drracket "http://racket-lang.org/")
+
+(define url:planet "http://planet.plt-scheme.org/")
diff --git a/collects/scriblib/gui-eval.ss b/collects/scriblib/gui-eval.ss
index a18629f7..49d988c4 100644
--- a/collects/scriblib/gui-eval.ss
+++ b/collects/scriblib/gui-eval.ss
@@ -1,14 +1,14 @@
-#lang scheme/base
+#lang racket/base
 
 (require scribble/eval
          scribble/core
          scribble/scheme
-         scheme/class
-         scheme/file
-         scheme/runtime-path
-         scheme/serialize
+         racket/class
+         racket/file
+         racket/runtime-path
+         racket/serialize
          "private/gui-eval-exn.ss"
-         scheme/system)
+         racket/system)
 
 (define-syntax define-mr
   (syntax-rules ()
@@ -28,13 +28,16 @@
 (define-mr gui-interaction-eval-show interaction-eval-show)
 (define-mr gui-def+int def+int)
 (define-mr gui-defs+int defs+int)
-(define-mr gui-schememod+eval schememod+eval)
-(define-mr gui-schemeblock+eval schemeblock+eval)
+(define-mr gui-racketmod+eval racketmod+eval)
+(define-mr gui-racketblock+eval racketblock+eval)
+
+(provide (rename-out [gui-racketmod+eval gui-schememod+eval]
+                     [gui-racketblock+eval gui-schemeblock+eval]))
 
 (define mred? (getenv "MREVAL"))
 
 (when mred?
-  (gui-eval '(require scheme/gui/base))
+  (gui-eval '(require racket/gui/base))
   (gui-eval '(require slideshow)))
 
 ;; This one needs to be relative, because it ends up in the