diff --git a/basis/alien/structs/fields/fields.factor b/basis/alien/structs/fields/fields.factor
new file mode 100644
index 0000000000..5273c2c7ba
--- /dev/null
+++ b/basis/alien/structs/fields/fields.factor
@@ -0,0 +1,76 @@
+! Copyright (C) 2005, 2008 Slava Pestov.
+! See http://factorcode.org/license.txt for BSD license.
+USING: accessors arrays kernel kernel.private math namespaces
+sequences strings words effects combinators alien.c-types ;
+IN: alien.structs.fields
+
+TUPLE: field-spec name offset type reader writer ;
+
+: reader-effect ( type spec -- effect )
+    [ 1array ] [ name>> 1array ] bi* <effect> ;
+
+PREDICATE: slot-reader < word "reading" word-prop >boolean ;
+
+: set-reader-props ( class spec -- )
+    2dup reader-effect
+    over reader>>
+    swap "declared-effect" set-word-prop
+    reader>> swap "reading" set-word-prop ;
+
+: writer-effect ( type spec -- effect )
+    name>> swap 2array 0 <effect> ;
+
+PREDICATE: slot-writer < word "writing" word-prop >boolean ;
+
+: set-writer-props ( class spec -- )
+    2dup writer-effect
+    over writer>>
+    swap "declared-effect" set-word-prop
+    writer>> swap "writing" set-word-prop ;
+
+: reader-word ( class name vocab -- word )
+    >r >r "-" r> 3append r> create ;
+
+: writer-word ( class name vocab -- word )
+    >r [ swap "set-" % % "-" % % ] "" make r> create ;
+
+: <field-spec> ( struct-name vocab type field-name -- spec )
+    field-spec new
+        0 >>offset
+        swap >>name
+        swap expand-constants >>type
+        3dup name>> swap reader-word >>reader
+        3dup name>> swap writer-word >>writer
+    2nip ;
+
+: align-offset ( offset type -- offset )
+    c-type-align align ;
+
+: struct-offsets ( specs -- size )
+    0 [
+        [ type>> align-offset ] keep
+        [ (>>offset) ] [ type>> heap-size + ] 2bi
+    ] reduce ;
+
+: define-struct-slot-word ( spec word quot -- )
+    rot offset>> prefix define-inline ;
+
+: define-getter ( type spec -- )
+    [ set-reader-props ] keep
+    [ ]
+    [ reader>> ]
+    [
+        type>>
+        [ c-getter ] [ c-type-boxer-quot ] bi append
+    ] tri
+    define-struct-slot-word ;
+
+: define-setter ( type spec -- )
+    [ set-writer-props ] keep
+    [ ]
+    [ writer>> ]
+    [ type>> c-setter ] tri
+    define-struct-slot-word ;
+
+: define-field ( type spec -- )
+    [ define-getter ] [ define-setter ] 2bi ;
diff --git a/basis/alien/structs/structs-docs.factor b/basis/alien/structs/structs-docs.factor
index 6f83885d9f..62b8510d17 100755
--- a/basis/alien/structs/structs-docs.factor
+++ b/basis/alien/structs/structs-docs.factor
@@ -1,75 +1,7 @@
-IN: alien.structs
 USING: accessors alien.c-types strings help.markup help.syntax
-alien.syntax sequences io arrays slots.deprecated
-kernel words slots assocs namespaces accessors ;
-
-! Deprecated code
-: ($spec-reader-values) ( slot-spec class -- element )
-    dup ?word-name swap 2array
-    over name>>
-    rot class>> 2array 2array
-    [ { $instance } swap suffix ] assoc-map ;
-
-: $spec-reader-values ( slot-spec class -- )
-    ($spec-reader-values) $values ;
-
-: $spec-reader-description ( slot-spec class -- )
-    [
-        "Outputs the value stored in the " ,
-        { $snippet } rot name>> suffix ,
-        " slot of " ,
-        { $instance } swap suffix ,
-        " instance." ,
-    ] { } make $description ;
-
-: slot-of-reader ( reader specs -- spec/f )
-    [ reader>> eq? ] with find nip ;
-
-: $spec-reader ( reader slot-specs class -- )
-    >r slot-of-reader r>
-    over [
-        2dup $spec-reader-values
-        2dup $spec-reader-description
-    ] when 2drop ;
-
-GENERIC: slot-specs ( help-type -- specs )
-
-M: word slot-specs "slots" word-prop ;
-
-: $slot-reader ( reader -- )
-    first dup "reading" word-prop [ slot-specs ] keep
-    $spec-reader ;
-
-: $spec-writer-values ( slot-spec class -- )
-    ($spec-reader-values) reverse $values ;
-
-: $spec-writer-description ( slot-spec class -- )
-    [
-        "Stores a new value to the " ,
-        { $snippet } rot name>> suffix ,
-        " slot of " ,
-        { $instance } swap suffix ,
-        " instance." ,
-    ] { } make $description ;
-
-: slot-of-writer ( writer specs -- spec/f )
-    [ writer>> eq? ] with find nip ;
-
-: $spec-writer ( writer slot-specs class -- )
-    >r slot-of-writer r>
-    over [
-        2dup $spec-writer-values
-        2dup $spec-writer-description
-        dup ?word-name 1array $side-effects
-    ] when 2drop ;
-
-: $slot-writer ( reader -- )
-    first dup "writing" word-prop [ slot-specs ] keep
-    $spec-writer ;
-
-M: string slot-specs c-type fields>> ;
-
-M: array ($instance) first ($instance) " array" write ;
+alien.syntax sequences io arrays kernel words assocs namespaces
+accessors ;
+IN: alien.structs
 
 ARTICLE: "c-structs" "C structure types"
 "A " { $snippet "struct" } " in C is essentially a block of memory with the value of each structure field stored at a fixed offset from the start of the block. The C library interface provides some utilities to define words which read and write structure fields given a base address."
diff --git a/basis/alien/structs/structs.factor b/basis/alien/structs/structs.factor
index e6a363941d..e82d663d08 100755
--- a/basis/alien/structs/structs.factor
+++ b/basis/alien/structs/structs.factor
@@ -1,43 +1,10 @@
-! Copyright (C) 2004, 2007 Slava Pestov.
+! Copyright (C) 2004, 2008 Slava Pestov.
 ! See http://factorcode.org/license.txt for BSD license.
 USING: accessors arrays generic hashtables kernel kernel.private
-math namespaces parser sequences strings words libc slots
-slots.deprecated alien.c-types cpu.architecture ;
+math namespaces parser sequences strings words libc
+alien.c-types alien.structs.fields cpu.architecture ;
 IN: alien.structs
 
-: align-offset ( offset type -- offset )
-    c-type-align align ;
-
-: struct-offsets ( specs -- size )
-    0 [
-        [ class>> align-offset ] keep
-        [ (>>offset) ] 2keep
-        class>> heap-size +
-    ] reduce ;
-
-: define-struct-slot-word ( spec word quot -- )
-    rot offset>> prefix define-inline ;
-
-: define-getter ( type spec -- )
-    [ set-reader-props ] keep
-    [ ]
-    [ reader>> ]
-    [
-        class>>
-        [ c-getter ] [ c-type-boxer-quot ] bi append
-    ] tri
-    define-struct-slot-word ;
-
-: define-setter ( type spec -- )
-    [ set-writer-props ] keep
-    [ ]
-    [ writer>> ]
-    [ class>> c-setter ] tri
-    define-struct-slot-word ;
-
-: define-field ( type spec -- )
-    2dup define-getter define-setter ;
-
 : if-value-structs? ( ctype true false -- )
     value-structs?
     [ drop call ] [ >r 2drop "void*" r> call ] if ; inline
@@ -76,17 +43,8 @@ M: struct-type stack-size
     struct-type boa
     -rot define-c-type ;
 
-: make-field ( struct-name vocab type field-name -- spec )
-    <slot-spec>
-        0 >>offset
-        swap >>name
-        swap expand-constants >>class
-        3dup name>> swap reader-word >>reader
-        3dup name>> swap writer-word >>writer
-    2nip ;
-
 : define-struct-early ( name vocab fields -- fields )
-    -rot [ rot first2 make-field ] 2curry map ;
+    -rot [ rot first2 <field-spec> ] 2curry map ;
 
 : compute-struct-align ( types -- n )
     [ c-type-align ] map supremum ;
@@ -94,7 +52,7 @@ M: struct-type stack-size
 : define-struct ( name vocab fields -- )
     pick >r
     [ struct-offsets ] keep
-    [ [ class>> ] map compute-struct-align ] keep
+    [ [ type>> ] map compute-struct-align ] keep
     [ (define-struct) ] keep
     r> [ swap define-field ] curry each ;
 
diff --git a/basis/bootstrap/image/image.factor b/basis/bootstrap/image/image.factor
index 97a95f98b8..9c99ed5cdb 100755
--- a/basis/bootstrap/image/image.factor
+++ b/basis/bootstrap/image/image.factor
@@ -358,7 +358,7 @@ M: byte-array '
 
 ! Tuples
 : (emit-tuple) ( tuple -- pointer )
-    [ tuple>array rest-slice ]
+    [ tuple-slots ]
     [ class transfer-word tuple-layout ] bi prefix [ ' ] map
     tuple type-number dup [ emit-seq ] emit-object ;
 
@@ -384,9 +384,9 @@ M: tuple-layout '
     ] cache-object ;
 
 M: tombstone '
-    delegate
-    "((tombstone))" "((empty))" ? "hashtables.private" lookup
-    def>> first [ emit-tuple ] cache-object ;
+    state>> "((tombstone))" "((empty))" ?
+    "hashtables.private" lookup def>> first
+    [ emit-tuple ] cache-object ;
 
 ! Arrays
 M: array '
diff --git a/basis/calendar/backend/backend.factor b/basis/calendar/backend/backend.factor
deleted file mode 100644
index 56ccf9e6cc..0000000000
--- a/basis/calendar/backend/backend.factor
+++ /dev/null
@@ -1,4 +0,0 @@
-USING: kernel system ;
-IN: calendar.backend
-
-HOOK: gmt-offset os ( -- hours minutes seconds )
diff --git a/basis/calendar/calendar-docs.factor b/basis/calendar/calendar-docs.factor
index 734c19f045..e3e5338820 100644
--- a/basis/calendar/calendar-docs.factor
+++ b/basis/calendar/calendar-docs.factor
@@ -1,14 +1,14 @@
 ! Copyright (C) 2008 Doug Coleman.
 ! See http://factorcode.org/license.txt for BSD license.
 USING: arrays kernel math strings help.markup help.syntax
-calendar.backend ;
+math.order ;
 IN: calendar
 
 HELP: duration
-{ $description "A duration is a period of time years, months, days, hours, minutes, and seconds.  All duration slots can store " { $link real } " numbers." } ;
+{ $description "A duration is a period of time years, months, days, hours, minutes, and seconds.  All duration slots can store " { $link real } " numbers. Compare two durations with the " { $link <=> } " word." } ;
 
 HELP: timestamp
-{ $description "A timestamp is a date and a time with a timezone offset.  Timestamp slots must store integers except for " { $snippet "seconds" } ", which stores reals, and " { $snippet "gmt-offset" } ", which stores a " { $link duration } "." } ;
+{ $description "A timestamp is a date and a time with a timezone offset.  Timestamp slots must store integers except for " { $snippet "seconds" } ", which stores reals, and " { $snippet "gmt-offset" } ", which stores a " { $link duration } ". Compare two duarionts with the " { $link <=> } " word." } ;
 
 { timestamp duration } related-words
 
@@ -128,3 +128,479 @@ HELP: >time<
 } ;
 
 { >date< >time< } related-words
+
+HELP: instant
+{ $values { "duration" duration } }
+{ $description "Pushes a " { $snippet "duration" } " of zero seconds." } ;
+
+HELP: years
+{ $values { "x" number } { "duration" duration } }
+{ $description "Creates a duration object with the specified number of years." } ;
+
+HELP: months
+{ $values { "x" number } { "duration" duration } }
+{ $description "Creates a duration object with the specified number of months." } ;
+
+HELP: days
+{ $values { "x" number } { "duration" duration } }
+{ $description "Creates a duration object with the specified number of days." } ;
+
+HELP: weeks
+{ $values { "x" number } { "duration" duration } }
+{ $description "Creates a duration object with the specified number of weeks." } ;
+
+HELP: hours
+{ $values { "x" number } { "duration" duration } }
+{ $description "Creates a duration object with the specified number of hours." } ;
+
+HELP: minutes
+{ $values { "x" number } { "duration" duration } }
+{ $description "Creates a duration object with the specified number of minutes." } ;
+
+HELP: seconds
+{ $values { "x" number } { "duration" duration } }
+{ $description "Creates a duration object with the specified number of seconds." } ;
+
+HELP: milliseconds
+{ $values { "x" number } { "duration" duration } }
+{ $description "Creates a duration object with the specified number of milliseconds." } ;
+
+{ years months days hours minutes seconds milliseconds } related-words
+
+HELP: leap-year?
+{ $values { "obj" object } { "?" "a boolean" } }
+{ $description "Returns " { $link t } " if the object represents a leap year." }
+{ $examples
+    { $example "USING: calendar prettyprint ;"
+               "2008 leap-year? ."
+               "t"
+    }
+    { $example "USING: calendar prettyprint ;"
+               "2010 1 1 <date> leap-year? ."
+               "f"
+    }
+} ;
+
+HELP: time+
+{ $values { "time1" "timestamp or duration" } { "time2" "timestamp or duration" } { "time3" "timestamp or duration" } }
+{ $description "Adds two durations to produce a duration or adds a timestamp and a duration to produce a timestamp. The calculation takes timezones into account." }
+{ $examples
+    { $example "USING: calendar math.order prettyprint ;"
+               "10 months 2 months time+ 1 years <=> ."
+               "+eq+"
+    }
+    { $example "USING: accessors calendar math.order prettyprint ;"
+               "2010 1 1 <date> 3 days time+ day>> ."
+               "4"
+    }
+} ;
+
+HELP: duration>years
+{ $values { "duration" duration } { "x" number } }
+{ $description "Calculates the length of a duration in years." }
+{ $examples
+    { $example "USING: calendar prettyprint ;"
+               "6 months duration>years ."
+               "1/2"
+    }
+} ;
+
+HELP: duration>months
+{ $values { "duration" duration } { "x" number } }
+{ $description "Calculates the length of a duration in months." }
+{ $examples
+    { $example "USING: calendar prettyprint ;"
+               "30 days duration>months ."
+               "16000/16233"
+    }
+} ;
+
+HELP: duration>days
+{ $values { "duration" duration } { "x" number } }
+{ $description "Calculates the length of a duration in days." }
+{ $examples
+    { $example "USING: calendar prettyprint ;"
+               "6 hours duration>days ."
+               "1/4"
+    }
+} ;
+
+HELP: duration>hours
+{ $values { "duration" duration } { "x" number } }
+{ $description "Calculates the length of a duration in hours." }
+{ $examples
+    { $example "USING: calendar prettyprint ;"
+               "3/4 days duration>hours ."
+               "18"
+    }
+} ;
+HELP: duration>minutes
+{ $values { "duration" duration } { "x" number } }
+{ $description "Calculates the length of a duration in minutes." }
+{ $examples
+    { $example "USING: calendar prettyprint ;"
+               "6 hours duration>minutes ."
+               "360"
+    }
+} ;
+HELP: duration>seconds
+{ $values { "duration" duration } { "x" number } }
+{ $description "Calculates the length of a duration in seconds." }
+{ $examples
+    { $example "USING: calendar prettyprint ;"
+               "6 minutes duration>seconds ."
+               "360"
+    }
+} ;
+
+HELP: duration>milliseconds
+{ $values { "duration" duration } { "x" number } }
+{ $description "Calculates the length of a duration in milliseconds." }
+{ $examples
+    { $example "USING: calendar prettyprint ;"
+               "6 seconds duration>milliseconds ."
+               "6000"
+    }
+} ;
+
+{ duration>years duration>months duration>days duration>hours duration>minutes duration>seconds duration>milliseconds } related-words
+
+
+HELP: time-
+{ $values { "time1" "timestamp or duration" } { "time2" "timestamp or duration" } { "time3" "timestamp or duration" } }
+{ $description "Subtracts two durations to produce a duration or subtracts a duration from a timestamp to produce a timestamp. The calculation takes timezones into account." }
+{ $examples
+    { $example "USING: calendar math.order prettyprint ;"
+               "10 months 2 months time- 8 months <=> ."
+               "+eq+"
+    }
+    { $example "USING: accessors calendar math.order prettyprint ;"
+               "2010 1 1 <date> 3 days time- day>> ."
+               "29"
+    }
+} ;
+
+HELP: convert-timezone
+{ $values { "timestamp" timestamp } { "duration" duration } { "timestamp" timestamp } }
+{ $description "Converts the " { $snippet "timestamp" } "'s " { $snippet "gmt-offset" } " to the GMT offset represented by the " { $snippet "duration" } "." }
+{ $examples
+    { $example "USING: accessors calendar prettyprint ;"
+               "gmt noon instant -5 >>hour convert-timezone gmt-offset>> hour>> ."
+               "-5"
+    }
+} ;
+
+HELP: >local-time
+{ $values { "timestamp" timestamp } { "timestamp" timestamp } }
+{ $description "Converts the " { $snippet "timestamp" } " to the timezone of your computer." }
+{ $examples
+    { $example "USING: accessors calendar kernel prettyprint ;"
+               "now gmt >local-time [ gmt-offset>> ] bi@ = ."
+               "t"
+    }
+} ;
+
+HELP: >gmt
+{ $values { "timestamp" timestamp } { "timestamp" timestamp } }
+{ $description "Converts the " { $snippet "timestamp" } " to the GMT timezone." }
+{ $examples
+    { $example "USING: accessors calendar kernel prettyprint ;"
+               "now >gmt gmt-offset>> hour>> ."
+               "0"
+    }
+} ;
+
+HELP: time*
+{ $values { "obj1" object } { "obj2" object } { "obj3" object } }
+{ $description "Multiplies each time slot of a timestamp or duration by a number and make a new duration from the result.  Used in the implementation of " { $link before } "." } ;
+{ time+ time- time* } related-words
+
+HELP: before
+{ $values { "duration" duration } { "-duration" duration } }
+{ $description "Negates a duration." }
+{ $examples
+    { $example "USING: accessors calendar prettyprint ;"
+               "3 hours before now noon time+ hour>> ."
+               "9"
+    }
+} ;
+
+HELP: <zero>
+{ $values { "timestamp" timestamp } }
+{ $description "Outputs a zero timestamp that consists of zeros for every slot.  Used to see if timestamps are valid." } ;
+
+HELP: valid-timestamp?
+{ $values { "timestamp" timestamp } { "?" "a boolean" } }
+{ $description "Tests if a timestamp is valid or not." } ;
+
+HELP: unix-1970
+{ $values { "timestamp" timestamp } }
+{ $description "Outputs the beginning of UNIX time, or midnight, January 1, 1970." } ;
+
+HELP: millis>timestamp
+{ $values { "x" number } { "timestamp" timestamp } }
+{ $description "Converts a number of milliseconds into a timestamp value in GMT time." }
+{ $examples
+    { $example "USING: accessors calendar prettyprint ;"
+               "1000 millis>timestamp year>> ."
+               "1970"
+    }
+} ;
+
+HELP: gmt
+{ $values { "timestamp" timestamp } }
+{ $description "Outputs the time right now, but in the GMT timezone." } ;
+
+{ gmt now } related-words
+
+HELP: now
+{ $values { "timestamp" timestamp } }
+{ $description "Outputs the time right now in your computer's timezone." }
+{ $examples
+    { $unchecked-example "USING: calendar prettyprint ;"
+        "now ."
+         "T{ timestamp f 2008 9 1 16 38 24+801/1000 T{ duration f 0 0 0 -5 0 0 } }"
+    }
+} ;
+
+HELP: hence
+{ $values { "duration" duration } { "timestamp" timestamp } }
+{ $description "Computes a time in the future that is the " { $snippet "duration" } " added to the result of " { $link now } "." }
+{ $examples
+    { $unchecked-example
+       "USING: calendar prettyprint ;"
+       "10 hours hence ."
+       "T{ timestamp f 2008 9 2 2 47 45+943/1000 T{ duration f 0 0 0 -5 0 0 } }"
+    }
+} ;
+
+HELP: ago
+{ $values { "duration" duration } { "timestamp" timestamp } }
+{ $description "Computes a time in the past that is the " { $snippet "duration" } " subtracted from the result of " { $link now } "." }
+{ $examples
+    { $unchecked-example
+       "USING: calendar prettyprint ;"
+       "3 weeks ago ."
+       "T{ timestamp f 2008 8 11 16 49 52+99/500 T{ duration f 0 0 0 -5 0 0 } }"
+    }
+} ;
+
+HELP: zeller-congruence
+{ $values { "year" integer } { "month" integer } { "day" integer } { "n" integer } }
+{ $description "An implementation of an algorithm that computes the day of the week given a date. Days are indexed starting from Sunday, which is index 0." }
+{ $notes "User code should use the " { $link day-of-week } " word, which takes a " { $snippet "timestamp" } " instead of integers." } ;
+
+HELP: days-in-year
+{ $values { "obj" "a timestamp or an integer" } { "n" integer } } 
+{ $description "Calculates the number of days in a given year." }
+{ $examples
+    { $example "USING: calendar prettyprint ;"
+               "2004 days-in-year ."
+               "366"
+    }
+} ;
+
+HELP: days-in-month
+{ $values { "timestamp" timestamp } { "n" integer } }
+{ $description "Calculates the number of days in a given month." }
+{ $examples
+    { $example "USING: calendar prettyprint ;"
+               "2008 8 24 <date> days-in-month ."
+               "31"
+    }
+} ;
+
+HELP: day-of-week
+{ $values { "timestamp" timestamp } { "n" integer } }
+{ $description "Calculates the index of the day of the week. Sunday will result in an index of 0." }
+{ $examples
+    { $example "USING: calendar prettyprint ;"
+               "now sunday day-of-week ."
+               "0"
+    }
+} ;
+
+HELP: day-of-year
+{ $values { "timestamp" timestamp } { "n" integer } }
+{ $description "Calculates the day of the year, resulting in a number from 1 to 366 (leap years)." }
+{ $examples
+    { $example "USING: calendar prettyprint ;"
+               "2008 1 4 <date> day-of-year ."
+               "4"
+    }
+} ;
+
+HELP: sunday
+{ $values { "timestamp" timestamp } { "new-timestamp" timestamp } }
+{ $description "Returns the Sunday from the current week, which starts on a Sunday." } ;
+
+HELP: monday
+{ $values { "timestamp" timestamp } { "new-timestamp" timestamp } }
+{ $description "Returns the Monday from the current week, which starts on a Sunday." } ;
+
+HELP: tuesday
+{ $values { "timestamp" timestamp } { "new-timestamp" timestamp } }
+{ $description "Returns the Tuesday from the current week, which starts on a Sunday." } ;
+
+HELP: wednesday
+{ $values { "timestamp" timestamp } { "new-timestamp" timestamp } }
+{ $description "Returns the Wednesday from the current week, which starts on a Sunday." } ;
+
+HELP: thursday
+{ $values { "timestamp" timestamp } { "new-timestamp" timestamp } }
+{ $description "Returns the Thursday from the current week, which starts on a Sunday." } ;
+
+HELP: friday
+{ $values { "timestamp" timestamp } { "new-timestamp" timestamp } }
+{ $description "Returns the Friday from the current week, which starts on a Sunday." } ;
+
+HELP: saturday
+{ $values { "timestamp" timestamp } { "new-timestamp" timestamp } }
+{ $description "Returns the Saturday from the current week, which starts on a Sunday." } ;
+
+{ sunday monday tuesday wednesday thursday friday saturday } related-words
+
+HELP: midnight
+{ $values { "timestamp" timestamp } { "new-timestamp" timestamp } }
+{ $description "Returns a timestamp that represents today at midnight, or the beginning of the day." } ;
+
+HELP: noon
+{ $values { "timestamp" timestamp } { "new-timestamp" timestamp } }
+{ $description "Returns a timestamp that represents today at noon, or the middle of the day." } ;
+
+HELP: beginning-of-month
+{ $values { "timestamp" timestamp } { "new-timestamp" timestamp } }
+{ $description "Outputs a timestamp with the day set to one." } ;
+
+HELP: beginning-of-week
+{ $values { "timestamp" timestamp } { "new-timestamp" timestamp } }
+{ $description "Outputs a timestamp where the day of the week is Sunday." } ;
+
+HELP: beginning-of-year
+{ $values { "timestamp" timestamp } { "new-timestamp" timestamp } }
+{ $description "Outputs a timestamp with the month and day set to one, or January 1 of the input timestamp." } ;
+
+HELP: time-since-midnight
+{ $values { "timestamp" timestamp } { "duration" duration } }
+{ $description "Calculates a " { $snippet "duration" } " that represents the elapsed time since midnight of the input " { $snippet "timestamp" } "." } ;
+
+ARTICLE: "calendar" "Calendar"
+"The two data types used throughout the calendar library:"
+{ $subsection timestamp }
+{ $subsection duration }
+"Durations represent spans of time:"
+{ $subsection "using-durations" }
+"Arithmetic on timestamps and durations:"
+{ $subsection "timestamp-arithmetic" }
+"Getting the current timestamp:"
+{ $subsection now }
+{ $subsection gmt }
+"Converting between timestamps:"
+{ $subsection >local-time }
+{ $subsection >gmt }
+"Converting between timezones:"
+{ $subsection convert-timezone }
+"Timestamps relative to each other:"
+{ $subsection "relative-timestamps" }
+"Operations on units of time:"
+{ $subsection "years" }
+{ $subsection "months" }
+{ $subsection "days" }
+"Meta-data about the calendar:"
+{ $subsection "calendar-facts" }
+;
+
+ARTICLE: "timestamp-arithmetic" "Timestamp arithmetic"
+"Adding timestamps and durations, or durations and durations:"
+{ $subsection time+ }
+"Subtracting:"
+{ $subsection time- }
+"Element-wise multiplication:"
+{ $subsection time* } ;
+
+ARTICLE: "using-durations" "Using durations"
+"Creating a duration object:"
+{ $subsection years }
+{ $subsection months }
+{ $subsection weeks }
+{ $subsection days }
+{ $subsection hours }
+{ $subsection minutes }
+{ $subsection seconds }
+{ $subsection milliseconds }
+{ $subsection instant }
+"Converting a duration to a number:"
+{ $subsection duration>years }
+{ $subsection duration>months }
+{ $subsection duration>days }
+{ $subsection duration>hours }
+{ $subsection duration>minutes }
+{ $subsection duration>seconds }
+{ $subsection duration>milliseconds } ;
+
+ARTICLE: "relative-timestamps" "Relative timestamps"
+"In the future:"
+{ $subsection hence }
+"In the past:"
+{ $subsection ago }
+"Invert a duration:"
+{ $subsection before }
+"Days of the week relative to " { $link now } ":"
+{ $subsection sunday }
+{ $subsection monday }
+{ $subsection tuesday }
+{ $subsection wednesday }
+{ $subsection thursday }
+{ $subsection friday }
+{ $subsection saturday }
+"New timestamps relative to calendar events:"
+{ $subsection beginning-of-year }
+{ $subsection beginning-of-month }
+{ $subsection beginning-of-week }
+{ $subsection midnight }
+{ $subsection noon }
+;
+
+ARTICLE: "days" "Day operations"
+"Naming days:"
+{ $subsection day-abbreviation2 }
+{ $subsection day-abbreviations2 }
+{ $subsection day-abbreviation3 }
+{ $subsection day-abbreviations3 }
+{ $subsection day-name }
+{ $subsection day-names }
+"Calculating a Julian day number:"
+{ $subsection julian-day-number }
+"Calculate a timestamp:"
+{ $subsection julian-day-number>date }
+;
+
+ARTICLE: "calendar-facts" "Calendar facts"
+"Calendar facts:"
+{ $subsection average-month }
+{ $subsection months-per-year }
+{ $subsection days-per-year }
+{ $subsection hours-per-year }
+{ $subsection minutes-per-year }
+{ $subsection seconds-per-year }
+{ $subsection days-in-month }
+{ $subsection day-of-year }
+{ $subsection day-of-week }
+;
+
+ARTICLE: "years" "Year operations"
+"Leap year predicate:"
+{ $subsection leap-year? }
+"Find the number of days in a year:"
+{ $subsection days-in-year }
+;
+
+ARTICLE: "months" "Month operations"
+"Naming months:"
+{ $subsection month-name }
+{ $subsection month-names }
+{ $subsection month-abbreviation }
+{ $subsection month-abbreviations }
+;
+
+ABOUT: "calendar"
diff --git a/basis/calendar/calendar-tests.factor b/basis/calendar/calendar-tests.factor
index 7d9716ae1a..995bd23c09 100755
--- a/basis/calendar/calendar-tests.factor
+++ b/basis/calendar/calendar-tests.factor
@@ -33,8 +33,8 @@ IN: calendar.tests
 
 [ t ] [ 2006 10 10 0 0 0 instant <timestamp> 10 minutes time+
         2006 10 10 0 10 0 instant <timestamp> = ] unit-test
-[ t ] [ 2006 10 10 0 0 0 instant <timestamp> 10.5 minutes time+
-        2006 10 10 0 10 30 instant <timestamp> = ] unit-test
+[ +eq+ ] [ 2006 10 10 0 0 0 instant <timestamp> 10.5 minutes time+
+        2006 10 10 0 10 30 instant <timestamp> <=> ] unit-test
 [ t ] [ 2006 10 10 0 0 0 instant <timestamp> 3/4 minutes time+
         2006 10 10 0 0 45 instant <timestamp> = ] unit-test
 [ t ] [ 2006 10 10 0 0 0 instant <timestamp> -3/4 minutes time+
diff --git a/basis/calendar/calendar.factor b/basis/calendar/calendar.factor
index af0ced7ed2..c2c386a790 100755
--- a/basis/calendar/calendar.factor
+++ b/basis/calendar/calendar.factor
@@ -1,11 +1,13 @@
 ! Copyright (C) 2007 Doug Coleman.
 ! See http://factorcode.org/license.txt for BSD license.
 USING: arrays kernel math math.functions namespaces sequences
-strings system vocabs.loader calendar.backend threads
-accessors combinators locals classes.tuple math.order
-memoize summary combinators.short-circuit ;
+strings system vocabs.loader threads accessors combinators
+locals classes.tuple math.order summary
+combinators.short-circuit ;
 IN: calendar
 
+HOOK: gmt-offset os ( -- hours minutes seconds )
+
 TUPLE: duration
     { year real }
     { month real }
@@ -60,6 +62,8 @@ PRIVATE>
 : month-abbreviation ( n -- string )
     check-month 1- month-abbreviations nth ;
 
+: day-counts { 0 31 28 31 30 31 30 31 31 30 31 30 31 } ; inline
+
 : day-names ( -- array )
     {
         "Sunday" "Monday" "Tuesday" "Wednesday" "Thursday" "Friday" "Saturday"
@@ -116,15 +120,15 @@ PRIVATE>
 : >time< ( timestamp -- hour minute second )
     [ hour>> ] [ minute>> ] [ second>> ] tri ;
 
-MEMO: instant ( -- dt ) 0 0 0 0 0 0 <duration> ;
-: years ( n -- dt ) instant clone swap >>year ;
-: months ( n -- dt ) instant clone swap >>month ;
-: days ( n -- dt ) instant clone swap >>day ;
-: weeks ( n -- dt ) 7 * days ;
-: hours ( n -- dt ) instant clone swap >>hour ;
-: minutes ( n -- dt ) instant clone swap >>minute ;
-: seconds ( n -- dt ) instant clone swap >>second ;
-: milliseconds ( n -- dt ) 1000 / seconds ;
+: instant ( -- duration ) 0 0 0 0 0 0 <duration> ;
+: years ( x -- duration ) instant clone swap >>year ;
+: months ( x -- duration ) instant clone swap >>month ;
+: days ( x -- duration ) instant clone swap >>day ;
+: weeks ( x -- duration ) 7 * days ;
+: hours ( x -- duration ) instant clone swap >>hour ;
+: minutes ( x -- duration ) instant clone swap >>minute ;
+: seconds ( x -- duration ) instant clone swap >>second ;
+: milliseconds ( x -- duration ) 1000 / seconds ;
 
 GENERIC: leap-year? ( obj -- ? )
 
@@ -218,7 +222,7 @@ M: number +second ( timestamp n -- timestamp )
 
 PRIVATE>
 
-GENERIC# time+ 1 ( time dt -- time )
+GENERIC# time+ 1 ( time1 time2 -- time3 )
 
 M: timestamp time+
     >r clone r> (time+) drop ;
@@ -236,8 +240,8 @@ M: duration time+
         2drop <duration>
     ] if ;
 
-: dt>years ( dt -- x )
-    #! Uses average month/year length since dt loses calendar
+: duration>years ( duration -- x )
+    #! Uses average month/year length since duration loses calendar
     #! data
     0 swap
     {
@@ -249,16 +253,16 @@ M: duration time+
         [ second>> seconds-per-year / + ]
     } cleave ;
 
-M: duration <=> [ dt>years ] compare ;
+M: duration <=> [ duration>years ] compare ;
 
-: dt>months ( dt -- x ) dt>years months-per-year * ;
-: dt>days ( dt -- x ) dt>years days-per-year * ;
-: dt>hours ( dt -- x ) dt>years hours-per-year * ;
-: dt>minutes ( dt -- x ) dt>years minutes-per-year * ;
-: dt>seconds ( dt -- x ) dt>years seconds-per-year * ;
-: dt>milliseconds ( dt -- x ) dt>seconds 1000 * ;
+: duration>months ( duration -- x ) duration>years months-per-year * ;
+: duration>days ( duration -- x ) duration>years days-per-year * ;
+: duration>hours ( duration -- x ) duration>years hours-per-year * ;
+: duration>minutes ( duration -- x ) duration>years minutes-per-year * ;
+: duration>seconds ( duration -- x ) duration>years seconds-per-year * ;
+: duration>milliseconds ( duration -- x ) duration>seconds 1000 * ;
 
-GENERIC: time- ( time1 time2 -- time )
+GENERIC: time- ( time1 time2 -- time3 )
 
 : convert-timezone ( timestamp duration -- timestamp )
     over gmt-offset>> over = [ drop ] [
@@ -296,23 +300,23 @@ M: timestamp time-
         } 2cleave <duration>
     ] if ;
 
-: before ( dt -- -dt )
+: before ( duration -- -duration )
     -1 time* ;
 
 M: duration time-
     before time+ ;
 
-MEMO: <zero> ( -- timestamp )
-0 0 0 0 0 0 instant <timestamp> ;
+: <zero> ( -- timestamp )
+    0 0 0 0 0 0 instant <timestamp> ;
 
 : valid-timestamp? ( timestamp -- ? )
     clone instant >>gmt-offset
     dup <zero> time- <zero> time+ = ;
 
-MEMO: unix-1970 ( -- timestamp )
+: unix-1970 ( -- timestamp )
     1970 1 1 0 0 0 instant <timestamp> ;
 
-: millis>timestamp ( n -- timestamp )
+: millis>timestamp ( x -- timestamp )
     >r unix-1970 r> milliseconds time+ ;
 
 : timestamp>millis ( timestamp -- n )
@@ -323,11 +327,8 @@ MEMO: unix-1970 ( -- timestamp )
     unix-1970 millis milliseconds time+ ;
 
 : now ( -- timestamp ) gmt >local-time ;
-
-: hence ( dt -- timestamp ) now swap time+ ;
-: ago ( dt -- timestamp ) now swap time- ;
-
-: day-counts { 0 31 28 31 30 31 30 31 31 30 31 30 31 } ; inline
+: hence ( duration -- timestamp ) now swap time+ ;
+: ago ( duration -- timestamp ) now swap time- ;
 
 : zeller-congruence ( year month day -- n )
     #! Zeller Congruence
@@ -363,19 +364,21 @@ M: timestamp days-in-year ( timestamp -- n ) year>> days-in-year ;
 : day-of-year ( timestamp -- n )
     >date< (day-of-year) ;
 
+<PRIVATE
 : day-offset ( timestamp m -- timestamp n )
     over day-of-week - ; inline
 
 : day-this-week ( timestamp n -- timestamp )
     day-offset days time+ ;
+PRIVATE>
 
-: sunday ( timestamp -- timestamp ) 0 day-this-week ;
-: monday ( timestamp -- timestamp ) 1 day-this-week ;
-: tuesday ( timestamp -- timestamp ) 2 day-this-week ;
-: wednesday ( timestamp -- timestamp ) 3 day-this-week ;
-: thursday ( timestamp -- timestamp ) 4 day-this-week ;
-: friday ( timestamp -- timestamp ) 5 day-this-week ;
-: saturday ( timestamp -- timestamp ) 6 day-this-week ;
+: sunday ( timestamp -- new-timestamp ) 0 day-this-week ;
+: monday ( timestamp -- new-timestamp ) 1 day-this-week ;
+: tuesday ( timestamp -- new-timestamp ) 2 day-this-week ;
+: wednesday ( timestamp -- new-timestamp ) 3 day-this-week ;
+: thursday ( timestamp -- new-timestamp ) 4 day-this-week ;
+: friday ( timestamp -- new-timestamp ) 5 day-this-week ;
+: saturday ( timestamp -- new-timestamp ) 6 day-this-week ;
 
 : midnight ( timestamp -- new-timestamp )
     clone 0 >>hour 0 >>minute 0 >>second ; inline
@@ -395,7 +398,6 @@ M: timestamp days-in-year ( timestamp -- n ) year>> days-in-year ;
 : time-since-midnight ( timestamp -- duration )
     dup midnight time- ;
 
-
 M: timestamp sleep-until timestamp>millis sleep-until ;
 
 M: duration sleep hence sleep-until ;
diff --git a/basis/calendar/format/format-tests.factor b/basis/calendar/format/format-tests.factor
index 3efe33e265..c433a118c2 100755
--- a/basis/calendar/format/format-tests.factor
+++ b/basis/calendar/format/format-tests.factor
@@ -3,23 +3,23 @@ io.streams.string accessors io math.order ;
 IN: calendar.format.tests
 
 [ 0 ] [
-    "Z" [ read1 read-rfc3339-gmt-offset ] with-string-reader dt>hours
+    "Z" [ read1 read-rfc3339-gmt-offset ] with-string-reader duration>hours
 ] unit-test
 
 [ 1 ] [
-    "+01" [ read1 read-rfc3339-gmt-offset ] with-string-reader dt>hours
+    "+01" [ read1 read-rfc3339-gmt-offset ] with-string-reader duration>hours
 ] unit-test
 
 [ -1 ] [
-    "-01" [ read1 read-rfc3339-gmt-offset ] with-string-reader dt>hours
+    "-01" [ read1 read-rfc3339-gmt-offset ] with-string-reader duration>hours
 ] unit-test
 
 [ -1-1/2 ] [
-    "-01:30" [ read1 read-rfc3339-gmt-offset ] with-string-reader dt>hours
+    "-01:30" [ read1 read-rfc3339-gmt-offset ] with-string-reader duration>hours
 ] unit-test
 
 [ 1+1/2 ] [
-    "+01:30" [ read1 read-rfc3339-gmt-offset ] with-string-reader dt>hours
+    "+01:30" [ read1 read-rfc3339-gmt-offset ] with-string-reader duration>hours
 ] unit-test
 
 [ ] [ now timestamp>rfc3339 drop ] unit-test
@@ -58,7 +58,7 @@ IN: calendar.format.tests
         26
         0
         37
-        42.12345
+        42+2469/20000
         T{ duration f 0 0 0 -5 0 0 }
     }
 ] [ "2008-05-26T00:37:42.12345-05:00" rfc3339>timestamp ] unit-test
diff --git a/basis/calendar/unix/unix.factor b/basis/calendar/unix/unix.factor
index 6383d4ec42..1da554e0f1 100644
--- a/basis/calendar/unix/unix.factor
+++ b/basis/calendar/unix/unix.factor
@@ -1,5 +1,5 @@
-USING: alien alien.c-types arrays calendar.backend
-kernel structs math unix.time namespaces system ;
+USING: alien alien.c-types arrays calendar kernel structs
+math unix.time namespaces system ;
 IN: calendar.unix
 
 : get-time ( -- alien )
diff --git a/basis/calendar/windows/windows.factor b/basis/calendar/windows/windows.factor
index b621d3bde3..508cbb0a49 100755
--- a/basis/calendar/windows/windows.factor
+++ b/basis/calendar/windows/windows.factor
@@ -1,5 +1,5 @@
-USING: calendar.backend namespaces alien.c-types system
-windows windows.kernel32 kernel math combinators ;
+USING: calendar namespaces alien.c-types system windows
+windows.kernel32 kernel math combinators ;
 IN: calendar.windows
 
 M: windows gmt-offset ( -- hours minutes seconds )
diff --git a/basis/channels/remote/remote.factor b/basis/channels/remote/remote.factor
index c9cfc83d27..9c1878e14d 100755
--- a/basis/channels/remote/remote.factor
+++ b/basis/channels/remote/remote.factor
@@ -4,7 +4,7 @@
 ! Remote Channels
 USING: kernel init namespaces assocs arrays random
 sequences channels match concurrency.messaging
-concurrency.distributed threads ;
+concurrency.distributed threads accessors ;
 IN: channels.remote
 
 <PRIVATE
@@ -52,13 +52,13 @@ TUPLE: remote-channel node id ;
 C: <remote-channel> remote-channel 
 
 M: remote-channel to ( value remote-channel -- )
-    [ [ \ to , remote-channel-id , , ] { } make ] keep
-    remote-channel-node "remote-channels" <remote-process> 
+    [ [ \ to , id>> , , ] { } make ] keep
+    node>> "remote-channels" <remote-process> 
     send-synchronous no-channel = [ no-channel throw ] when ;
 
 M: remote-channel from ( remote-channel -- value )
-    [ [ \ from , remote-channel-id , ] { } make ] keep
-    remote-channel-node "remote-channels" <remote-process> 
+    [ [ \ from , id>> , ] { } make ] keep
+    node>> "remote-channels" <remote-process> 
     send-synchronous dup no-channel = [ no-channel throw ] when* ;
 
 [
diff --git a/basis/cocoa/cocoa-tests.factor b/basis/cocoa/cocoa-tests.factor
index 4b56d81626..e1d6672872 100644
--- a/basis/cocoa/cocoa-tests.factor
+++ b/basis/cocoa/cocoa-tests.factor
@@ -20,10 +20,10 @@ CLASS: {
 
 test-foo
 
-[ 1 ] [ "x" get NSRect-x ] unit-test
-[ 2 ] [ "x" get NSRect-y ] unit-test
-[ 101 ] [ "x" get NSRect-w ] unit-test
-[ 102 ] [ "x" get NSRect-h ] unit-test
+[ 1.0 ] [ "x" get NSRect-x ] unit-test
+[ 2.0 ] [ "x" get NSRect-y ] unit-test
+[ 101.0 ] [ "x" get NSRect-w ] unit-test
+[ 102.0 ] [ "x" get NSRect-h ] unit-test
 
 CLASS: {
     { +superclass+ "NSObject" }
@@ -41,7 +41,7 @@ Bar [
     -> release
 ] compile-call
 
-[ 1 ] [ "x" get NSRect-x ] unit-test
-[ 2 ] [ "x" get NSRect-y ] unit-test
-[ 101 ] [ "x" get NSRect-w ] unit-test
-[ 102 ] [ "x" get NSRect-h ] unit-test
+[ 1.0 ] [ "x" get NSRect-x ] unit-test
+[ 2.0 ] [ "x" get NSRect-y ] unit-test
+[ 101.0 ] [ "x" get NSRect-w ] unit-test
+[ 102.0 ] [ "x" get NSRect-h ] unit-test
diff --git a/basis/compiler/compiler-docs.factor b/basis/compiler/compiler-docs.factor
index 418aac6560..1f941a0f88 100755
--- a/basis/compiler/compiler-docs.factor
+++ b/basis/compiler/compiler-docs.factor
@@ -27,7 +27,7 @@ ARTICLE: "compiler" "Optimizing compiler"
 "The optimizing compiler only compiles words which have a static stack effect. This means that methods defined on fundamental generic words such as " { $link nth } " should have a static stack effect; for otherwise, most of the system would be compiled with the non-optimizing compiler. See " { $link "inference" } " and " { $link "cookbook-pitfalls" } "."
 { $subsection "compiler-usage" }
 { $subsection "compiler-errors" }
-{ $subsection "optimizer" }
+{ $subsection "hints" }
 { $subsection "generator" } ;
 
 ABOUT: "compiler"
diff --git a/basis/compiler/compiler.factor b/basis/compiler/compiler.factor
index d340c21663..2dd6e440d5 100755
--- a/basis/compiler/compiler.factor
+++ b/basis/compiler/compiler.factor
@@ -43,8 +43,8 @@ SYMBOL: +failed+
     [
         dup crossref?
         [
-            dependencies get
-            generic-dependencies get
+            dependencies get >alist
+            generic-dependencies get >alist
             compiled-xref
         ] [ drop ] if
     ] tri ;
diff --git a/basis/compiler/tree/intrinsics/intrinsics.factor b/basis/compiler/intrinsics/intrinsics.factor
similarity index 95%
rename from basis/compiler/tree/intrinsics/intrinsics.factor
rename to basis/compiler/intrinsics/intrinsics.factor
index 5bcc58626b..b995e6d737 100644
--- a/basis/compiler/tree/intrinsics/intrinsics.factor
+++ b/basis/compiler/intrinsics/intrinsics.factor
@@ -2,7 +2,7 @@
 ! See http://factorcode.org/license.txt for BSD license.
 USING: kernel classes.tuple classes.tuple.private math arrays 
 byte-arrays words stack-checker.known-words ;
-IN: compiler.tree.intrinsics
+IN: compiler.intrinsics
 
 : (tuple) ( layout -- tuple )
     "BUG: missing (tuple) intrinsic" throw ;
diff --git a/basis/compiler/tests/alien.factor b/basis/compiler/tests/alien.factor
old mode 100644
new mode 100755
index 9d2b43c1df..18f7f67787
--- a/basis/compiler/tests/alien.factor
+++ b/basis/compiler/tests/alien.factor
@@ -84,6 +84,13 @@ FUNCTION: tiny ffi_test_17 int x ;
 
 [ 3 ] [ "ffi_test_1" f dlsym indirect-test-1 ] unit-test
 
+: indirect-test-1' ( ptr -- )
+    "int" { } "cdecl" alien-indirect drop ;
+
+{ 1 0 } [ indirect-test-1' ] must-infer-as
+
+[ ] [ "ffi_test_1" f dlsym indirect-test-1' ] unit-test
+
 [ -1 indirect-test-1 ] must-fail
 
 : indirect-test-2 ( x y ptr -- result )
@@ -102,7 +109,7 @@ unit-test
 << "f-stdcall" f "stdcall" add-library >>
 
 [ f ] [ "f-stdcall" load-library ] unit-test
-[ "stdcall" ] [ "f-stdcall" library library-abi ] unit-test
+[ "stdcall" ] [ "f-stdcall" library abi>> ] unit-test
 
 : ffi_test_18 ( w x y z -- int )
     "int" "f-stdcall" "ffi_test_18" { "int" "int" "int" "int" }
diff --git a/basis/compiler/tests/optimizer.factor b/basis/compiler/tests/optimizer.factor
index 9f42ad201f..4c39da0479 100755
--- a/basis/compiler/tests/optimizer.factor
+++ b/basis/compiler/tests/optimizer.factor
@@ -210,10 +210,10 @@ USE: binary-search.private
 
 : old-binsearch ( elt quot seq -- elt quot i )
     dup length 1 <= [
-        slice-from
+        from>>
     ] [
         [ midpoint swap call ] 3keep roll dup zero?
-        [ drop dup slice-from swap midpoint@ + ]
+        [ drop dup from>> swap midpoint@ + ]
         [ dup midpoint@ cut-slice old-binsearch ] if
     ] if ; inline
 
diff --git a/basis/compiler/tests/stack-trace.factor b/basis/compiler/tests/stack-trace.factor
index 1085feb0c6..c6cbb79ce5 100755
--- a/basis/compiler/tests/stack-trace.factor
+++ b/basis/compiler/tests/stack-trace.factor
@@ -1,10 +1,10 @@
 IN: compiler.tests
 USING: compiler tools.test namespaces sequences
 kernel.private kernel math continuations continuations.private
-words splitting grouping sorting ;
+words splitting grouping sorting accessors ;
 
 : symbolic-stack-trace ( -- newseq )
-    error-continuation get continuation-call callstack>array
+    error-continuation get call>> callstack>array
     2 group flip first ;
 
 : foo ( -- * ) 3 throw 7 ;
diff --git a/basis/compiler/tree/cleanup/cleanup-tests.factor b/basis/compiler/tree/cleanup/cleanup-tests.factor
index 8072a4229e..bb30cda685 100644
--- a/basis/compiler/tree/cleanup/cleanup-tests.factor
+++ b/basis/compiler/tree/cleanup/cleanup-tests.factor
@@ -229,10 +229,6 @@ M: float detect-float ;
     \ detect-float inlined?
 ] unit-test
 
-[ t ] [
-    [ 3 + = ] \ equal? inlined?
-] unit-test
-
 [ f ] [
     [ { fixnum fixnum } declare 7 bitand neg shift ]
     \ fixnum-shift-fast inlined?
diff --git a/basis/compiler/tree/cleanup/cleanup.factor b/basis/compiler/tree/cleanup/cleanup.factor
index 8056e75b3e..cc5f0619cd 100644
--- a/basis/compiler/tree/cleanup/cleanup.factor
+++ b/basis/compiler/tree/cleanup/cleanup.factor
@@ -4,8 +4,9 @@ USING: kernel accessors sequences sequences.deep combinators fry
 classes.algebra namespaces assocs words math math.private
 math.partial-dispatch math.intervals classes classes.tuple
 classes.tuple.private layouts definitions stack-checker.state
-stack-checker.branches compiler.tree
-compiler.tree.intrinsics
+stack-checker.branches
+compiler.intrinsics
+compiler.tree
 compiler.tree.combinators
 compiler.tree.propagation.info
 compiler.tree.propagation.branches ;
diff --git a/basis/compiler/tree/dead-code/simple/simple.factor b/basis/compiler/tree/dead-code/simple/simple.factor
old mode 100644
new mode 100755
index 3ea9139e5f..9ebf064f79
--- a/basis/compiler/tree/dead-code/simple/simple.factor
+++ b/basis/compiler/tree/dead-code/simple/simple.factor
@@ -81,11 +81,19 @@ M: #alien-indirect compute-live-values* nip look-at-inputs ;
         drop-values
     ] ;
 
-: drop-dead-outputs ( node -- nodes )
+: drop-dead-outputs ( node -- #shuffle )
     dup out-d>> drop-dead-values tuck in-d>> >>out-d drop ;
 
+: some-outputs-dead? ( #call -- ? )
+    out-d>> [ live-value? not ] contains? ;
+
+: maybe-drop-dead-outputs ( node -- nodes )
+    dup some-outputs-dead? [
+        dup drop-dead-outputs 2array
+    ] when ;
+
 M: #introduce remove-dead-code* ( #introduce -- nodes )
-    dup drop-dead-outputs 2array ;
+    maybe-drop-dead-outputs ;
 
 M: #>r remove-dead-code*
     [ filter-live ] change-out-r
@@ -110,17 +118,9 @@ M: #push remove-dead-code*
     [ in-d>> #drop remove-dead-code* ]
     bi ;
 
-: some-outputs-dead? ( #call -- ? )
-    out-d>> [ live-value? not ] contains? ;
-
 M: #call remove-dead-code*
-    dup dead-flushable-call? [
-        remove-flushable-call
-    ] [
-        dup some-outputs-dead? [
-            dup drop-dead-outputs 2array
-        ] when
-    ] if ;
+    dup dead-flushable-call?
+    [ remove-flushable-call ] [ maybe-drop-dead-outputs ] if ;
 
 M: #shuffle remove-dead-code*
     [ filter-live ] change-in-d
@@ -136,3 +136,9 @@ M: #copy remove-dead-code*
 M: #terminate remove-dead-code*
     [ filter-live ] change-in-d
     [ filter-live ] change-in-r ;
+
+M: #alien-invoke remove-dead-code*
+    maybe-drop-dead-outputs ;
+
+M: #alien-indirect remove-dead-code*
+    maybe-drop-dead-outputs ;
diff --git a/basis/compiler/tree/escape-analysis/escape-analysis-tests.factor b/basis/compiler/tree/escape-analysis/escape-analysis-tests.factor
index 0b7db5b36a..f51046c6cb 100644
--- a/basis/compiler/tree/escape-analysis/escape-analysis-tests.factor
+++ b/basis/compiler/tree/escape-analysis/escape-analysis-tests.factor
@@ -6,7 +6,7 @@ compiler.tree.propagation compiler.tree.cleanup
 compiler.tree.combinators compiler.tree sequences math math.private
 kernel tools.test accessors slots.private quotations.private
 prettyprint classes.tuple.private classes classes.tuple
-compiler.tree.intrinsics namespaces compiler.tree.propagation.info
+compiler.intrinsics namespaces compiler.tree.propagation.info
 stack-checker.errors kernel.private ;
 
 \ escape-analysis must-infer
diff --git a/basis/compiler/tree/escape-analysis/simple/simple.factor b/basis/compiler/tree/escape-analysis/simple/simple.factor
index d69f6cab9e..0324b31199 100644
--- a/basis/compiler/tree/escape-analysis/simple/simple.factor
+++ b/basis/compiler/tree/escape-analysis/simple/simple.factor
@@ -4,8 +4,8 @@ USING: kernel accessors sequences classes.tuple
 classes.tuple.private arrays math math.private slots.private
 combinators deques search-deques namespaces fry classes
 classes.algebra stack-checker.state
+compiler.intrinsics
 compiler.tree
-compiler.tree.intrinsics
 compiler.tree.propagation.info
 compiler.tree.escape-analysis.nodes
 compiler.tree.escape-analysis.allocations ;
@@ -23,9 +23,8 @@ DEFER: record-literal-allocation
     [ <slot-value> [ swap record-literal-allocation ] keep ] map ;
 
 : object-slots ( object -- slots/f )
-    #! Delegation
     {
-        { [ dup class immutable-tuple-class? ] [ tuple-slots rest-slice ] }
+        { [ dup class immutable-tuple-class? ] [ tuple-slots ] }
         { [ dup complex? ] [ [ real-part ] [ imaginary-part ] bi 2array ] }
         [ drop f ]
     } cond ;
@@ -37,7 +36,6 @@ DEFER: record-literal-allocation
     if* ;
 
 M: #push escape-analysis*
-    #! Delegation.
     [ out-d>> first ] [ literal>> ] bi record-literal-allocation ;
 
 : record-unknown-allocation ( #call -- )
@@ -59,7 +57,7 @@ M: #push escape-analysis*
     [ second node-value-info literal>> ] 2bi
     dup fixnum? [
         {
-            { [ over tuple class<= ] [ 3 - ] }
+            { [ over tuple class<= ] [ 2 - ] }
             { [ over complex class<= ] [ 1 - ] }
             [ drop f ]
         } cond nip
diff --git a/basis/compiler/tree/finalization/finalization.factor b/basis/compiler/tree/finalization/finalization.factor
index 08734ec095..5aaeed360a 100644
--- a/basis/compiler/tree/finalization/finalization.factor
+++ b/basis/compiler/tree/finalization/finalization.factor
@@ -1,9 +1,32 @@
 ! Copyright (C) 2008 Slava Pestov.
 ! See http://factorcode.org/license.txt for BSD license.
-USING: kernel accessors sequences
-compiler.tree compiler.tree.combinators ;
+USING: kernel arrays accessors sequences sequences.private words
+fry namespaces math math.order memoize classes.builtin
+classes.tuple.private slots.private combinators layouts
+byte-arrays alien.accessors
+compiler.intrinsics
+compiler.tree
+compiler.tree.builder
+compiler.tree.normalization
+compiler.tree.propagation
+compiler.tree.propagation.info
+compiler.tree.cleanup
+compiler.tree.def-use
+compiler.tree.dead-code
+compiler.tree.combinators ;
 IN: compiler.tree.finalization
 
+! This pass runs after propagation, so that it can expand
+! built-in type predicates and memory allocation; these cannot
+! be expanded before propagation since we need to see 'fixnum?'
+! instead of 'tag 0 eq?' and so on, for semantic reasoning.
+! We also delete empty stack shuffles and copies to facilitate
+! tail call optimization in the code generator. After this pass
+! runs, stack flow information is no longer accurate, since we
+! punt in 'splice-quot' and don't update everything that we
+! should; this simplifies the code, improves performance, and we
+! don't need the stack flow information after this pass anyway.
+
 GENERIC: finalize* ( node -- nodes )
 
 M: #copy finalize* drop f ;
@@ -13,6 +36,92 @@ M: #shuffle finalize*
     [ in>> ] [ out>> ] bi sequence=
     [ drop f ] when ;
 
+: splice-quot ( quot -- nodes )
+    [
+        build-tree
+        normalize
+        propagate
+        cleanup
+        compute-def-use
+        remove-dead-code
+        but-last
+    ] with-scope ;
+
+: builtin-predicate? ( #call -- ? )
+    word>> "predicating" word-prop builtin-class? ;
+
+MEMO: builtin-predicate-expansion ( word -- nodes )
+    def>> splice-quot ;
+
+: expand-builtin-predicate ( #call -- nodes )
+    word>> builtin-predicate-expansion ;
+
+: first-literal ( #call -- obj ) node-input-infos first literal>> ;
+
+: last-literal ( #call -- obj ) node-input-infos peek literal>> ;
+
+: expand-tuple-boa? ( #call -- ? )
+    dup word>> \ <tuple-boa> eq? [
+        last-literal tuple-layout?
+    ] [ drop f ] if ;
+
+MEMO: (tuple-boa-expansion) ( n -- quot )
+    [
+        [ 2 + ] map <reversed>
+        [ '[ [ , set-slot ] keep ] % ] each
+    ] [ ] make ;
+
+: tuple-boa-expansion ( layout -- quot )
+    #! No memoization here since otherwise we'd hang on to
+    #! tuple layout objects.
+    size>> (tuple-boa-expansion) \ (tuple) prefix splice-quot ;
+
+: expand-tuple-boa ( #call -- node )
+    last-literal tuple-boa-expansion ;
+
+MEMO: <array>-expansion ( n -- quot )
+    [
+        [ swap (array) ] %
+        [ \ 2dup , , [ swap set-array-nth ] % ] each
+        \ nip ,
+    ] [ ] make splice-quot ;
+
+: expand-<array>? ( #call -- ? )
+    dup word>> \ <array> eq? [
+        first-literal dup integer?
+        [ 0 32 between? ] [ drop f ] if
+    ] [ drop f ] if ;
+
+: expand-<array> ( #call -- node )
+    first-literal <array>-expansion ;
+
+: bytes>cells ( m -- n ) cell align cell /i ;
+
+MEMO: <byte-array>-expansion ( n -- quot )
+    [
+        [ (byte-array) ] %
+        bytes>cells [ cell * ] map
+        [ [ 0 over ] % , [ set-alien-unsigned-cell ] % ] each
+    ] [ ] make splice-quot ;
+
+: expand-<byte-array>? ( #call -- ? )
+    dup word>> \ <byte-array> eq? [
+        first-literal dup integer?
+        [ 0 128 between? ] [ drop f ] if
+    ] [ drop f ] if ;
+
+: expand-<byte-array> ( #call -- nodes )
+    first-literal <byte-array>-expansion ;
+
+M: #call finalize*
+    {
+        { [ dup builtin-predicate? ] [ expand-builtin-predicate ] }
+        { [ dup expand-tuple-boa? ] [ expand-tuple-boa ] }
+        { [ dup expand-<array>? ] [ expand-<array> ] }
+        { [ dup expand-<byte-array>? ] [ expand-<byte-array> ] }
+        [ ]
+    } cond ;
+
 M: node finalize* ;
 
 : finalize ( nodes -- nodes' ) [ finalize* ] map-nodes ;
diff --git a/basis/compiler/tree/propagation/info/info.factor b/basis/compiler/tree/propagation/info/info.factor
index f3ecd7ae65..8f2220aaaf 100644
--- a/basis/compiler/tree/propagation/info/info.factor
+++ b/basis/compiler/tree/propagation/info/info.factor
@@ -12,8 +12,6 @@ IN: compiler.tree.propagation.info
 
 : null-class? ( class -- ? ) null class<= ;
 
-SYMBOL: +interval+
-
 GENERIC: eql? ( obj1 obj2 -- ? )
 M: object eql? eq? ;
 M: fixnum eql? eq? ;
@@ -40,7 +38,7 @@ slots ;
 
 : class-interval ( class -- interval )
     dup real class<=
-    [ +interval+ word-prop [-inf,inf] or ] [ drop f ] if ;
+    [ "interval" word-prop [-inf,inf] or ] [ drop f ] if ;
 
 : interval>literal ( class interval -- literal literal? )
     #! If interval has zero length and the class is sufficiently
@@ -61,10 +59,34 @@ slots ;
 
 : <value-info> ( -- info ) \ value-info new ;
 
+: read-only-slots ( values class -- slots )
+    all-slots
+    [ read-only>> [ drop f ] unless ] 2map
+    f prefix ;
+
+DEFER: <literal-info>
+
+: init-literal-info ( info -- info )
+    dup literal>> class >>class
+    dup literal>> dup real? [ [a,a] >>interval ] [
+        [ [-inf,inf] >>interval ] dip
+        {
+            { [ dup complex? ] [
+                [ real-part <literal-info> ]
+                [ imaginary-part <literal-info> ] bi
+                2array >>slots
+            ] }
+            { [ dup tuple? ] [
+                [ tuple-slots [ <literal-info> ] map ] [ class ] bi
+                read-only-slots >>slots
+            ] }
+            [ drop ]
+        } cond
+    ] if ; inline
+
 : init-value-info ( info -- info )
     dup literal?>> [
-        dup literal>> class >>class
-        dup literal>> dup real? [ [a,a] ] [ drop [-inf,inf] ] if >>interval
+        init-literal-info
     ] [
         dup [ class>> null-class? ] [ interval>> empty-interval eq? ] bi or [
             null >>class
@@ -75,7 +97,7 @@ slots ;
             dup [ class>> ] [ interval>> ] bi interval>literal
             [ >>literal ] [ >>literal? ] bi*
         ] if
-    ] if ;
+    ] if ; inline
 
 : <class/interval-info> ( class interval -- info )
     <value-info>
@@ -84,7 +106,7 @@ slots ;
     init-value-info ; foldable
 
 : <class-info> ( class -- info )
-    dup word? [ dup +interval+ word-prop ] [ f ] if [-inf,inf] or
+    dup word? [ dup "interval" word-prop ] [ f ] if [-inf,inf] or
     <class/interval-info> ; foldable
 
 : <interval-info> ( interval -- info )
diff --git a/basis/compiler/tree/propagation/inlining/inlining.factor b/basis/compiler/tree/propagation/inlining/inlining.factor
index 09f50b21ea..4f93769b7f 100644
--- a/basis/compiler/tree/propagation/inlining/inlining.factor
+++ b/basis/compiler/tree/propagation/inlining/inlining.factor
@@ -1,9 +1,9 @@
 ! Copyright (C) 2008 Slava Pestov.
 ! See http://factorcode.org/license.txt for BSD license.
 USING: accessors kernel arrays sequences math math.order
-math.partial-dispatch generic generic.standard classes.algebra
-classes.union sets quotations assocs combinators words
-namespaces
+math.partial-dispatch generic generic.standard generic.math
+classes.algebra classes.union sets quotations assocs combinators
+words namespaces
 compiler.tree
 compiler.tree.builder
 compiler.tree.normalization
@@ -145,3 +145,13 @@ SYMBOL: history
 
 : always-inline-word? ( word -- ? )
     { curry compose } memq? ;
+
+: do-inlining ( #call word -- ? )
+    {
+        { [ dup always-inline-word? ] [ inline-word ] }
+        { [ dup standard-generic? ] [ inline-standard-method ] }
+        { [ dup math-generic? ] [ inline-math-method ] }
+        { [ dup math-partial? ] [ inline-math-partial ] }
+        { [ dup method-body? ] [ inline-method-body ] }
+        [ 2drop f ]
+    } cond ;
diff --git a/basis/compiler/tree/propagation/known-words/known-words.factor b/basis/compiler/tree/propagation/known-words/known-words.factor
index 23323e107d..d31de354d1 100644
--- a/basis/compiler/tree/propagation/known-words/known-words.factor
+++ b/basis/compiler/tree/propagation/known-words/known-words.factor
@@ -7,6 +7,7 @@ classes.algebra combinators generic.math splitting fry locals
 classes.tuple alien.accessors classes.tuple.private slots.private
 definitions
 stack-checker.state
+compiler.intrinsics
 compiler.tree.comparisons
 compiler.tree.propagation.info
 compiler.tree.propagation.nodes
@@ -17,11 +18,11 @@ IN: compiler.tree.propagation.known-words
 
 \ fixnum
 most-negative-fixnum most-positive-fixnum [a,b]
-+interval+ set-word-prop
+"interval" set-word-prop
 
 \ array-capacity
 0 max-array-capacity [a,b]
-+interval+ set-word-prop
+"interval" set-word-prop
 
 { + - * / }
 [ { number number } "input-classes" set-word-prop ] each
@@ -66,17 +67,17 @@ most-negative-fixnum most-positive-fixnum [a,b]
     over interval>> [ [ clone ] dip change-interval ] [ 2drop ] if ; inline
 
 { bitnot fixnum-bitnot bignum-bitnot } [
-    [ [ interval-bitnot ] ?change-interval ] +outputs+ set-word-prop
+    [ [ interval-bitnot ] ?change-interval ] "outputs" set-word-prop
 ] each
 
-\ abs [ [ interval-abs ] ?change-interval ] +outputs+ set-word-prop
+\ abs [ [ interval-abs ] ?change-interval ] "outputs" set-word-prop
 
 : math-closure ( class -- newclass )
     { fixnum bignum integer rational float real number object }
     [ class<= ] with find nip ;
 
 : fits? ( interval class -- ? )
-    +interval+ word-prop interval-subset? ;
+    "interval" word-prop interval-subset? ;
 
 : binary-op-class ( info1 info2 -- newclass )
     [ class>> ] bi@
@@ -120,7 +121,7 @@ most-negative-fixnum most-positive-fixnum [a,b]
         [ binary-op-class ] [ , binary-op-interval ] 2bi
         @
         <class/interval-info>
-    ] +outputs+ set-word-prop ;
+    ] "outputs" set-word-prop ;
 
 \ + [ [ interval+ ] [ may-overflow number-valued ] binary-op ] each-derived-op
 \ + [ [ interval+ ] [ number-valued ] binary-op ] each-fast-derived-op
@@ -158,7 +159,7 @@ most-negative-fixnum most-positive-fixnum [a,b]
     in1 in2 op negate-comparison (comparison-constraints) out f--> /\ ;
 
 : define-comparison-constraints ( word op -- )
-    '[ , comparison-constraints ] +constraints+ set-word-prop ;
+    '[ , comparison-constraints ] "constraints" set-word-prop ;
 
 comparison-ops
 [ dup '[ , define-comparison-constraints ] each-derived-op ] each
@@ -178,13 +179,13 @@ generic-comparison-ops [
 
 comparison-ops [
     dup '[
-        [ , fold-comparison ] +outputs+ set-word-prop
+        [ , fold-comparison ] "outputs" set-word-prop
     ] each-derived-op
 ] each
 
 generic-comparison-ops [
     dup specific-comparison
-    '[ , fold-comparison ] +outputs+ set-word-prop
+    '[ , fold-comparison ] "outputs" set-word-prop
 ] each
 
 : maybe-or-never ( ? -- info )
@@ -196,7 +197,7 @@ generic-comparison-ops [
 { number= bignum= float= } [
     [
         info-intervals-intersect? maybe-or-never
-    ] +outputs+ set-word-prop
+    ] "outputs" set-word-prop
 ] each
 
 : info-classes-intersect? ( info1 info2 -- ? )
@@ -206,13 +207,13 @@ generic-comparison-ops [
     over value-info literal>> fixnum? [
         [ value-info literal>> is-equal-to ] dip t-->
     ] [ 3drop f ] if
-] +constraints+ set-word-prop
+] "constraints" set-word-prop
 
 \ eq? [
     [ info-intervals-intersect? ]
     [ info-classes-intersect? ]
-    2bi or maybe-or-never
-] +outputs+ set-word-prop
+    2bi and maybe-or-never
+] "outputs" set-word-prop
 
 {
     { >fixnum fixnum }
@@ -226,7 +227,7 @@ generic-comparison-ops [
             interval-intersect
         ] 2bi
         <class/interval-info>
-    ] +outputs+ set-word-prop
+    ] "outputs" set-word-prop
 ] assoc-each
 
 {
@@ -250,36 +251,36 @@ generic-comparison-ops [
         }
     } cond
     [ fixnum fits? fixnum integer ? ] keep <class/interval-info>
-    [ 2nip ] curry +outputs+ set-word-prop
+    [ 2nip ] curry "outputs" set-word-prop
 ] each
 
-{ <tuple> <tuple-boa> } [
+{ <tuple> <tuple-boa> (tuple) } [
     [
         literal>> dup tuple-layout? [ class>> ] [ drop tuple ] if <class-info>
         [ clear ] dip
-    ] +outputs+ set-word-prop
+    ] "outputs" set-word-prop
 ] each
 
 \ new [
     literal>> dup tuple-class? [ drop tuple ] unless <class-info>
-] +outputs+ set-word-prop
+] "outputs" set-word-prop
 
 ! the output of clone has the same type as the input
 { clone (clone) } [
     [ clone f >>literal f >>literal? ]
-    +outputs+ set-word-prop
+    "outputs" set-word-prop
 ] each
 
 \ slot [
     dup literal?>>
     [ literal>> swap value-info-slot ] [ 2drop object-info ] if
-] +outputs+ set-word-prop
+] "outputs" set-word-prop
 
 \ instance? [
     [ value-info ] dip over literal>> class? [
         [ literal>> ] dip predicate-constraints
     ] [ 3drop f ] if
-] +constraints+ set-word-prop
+] "constraints" set-word-prop
 
 \ instance? [
     ! We need to force the caller word to recompile when the class
@@ -292,4 +293,4 @@ generic-comparison-ops [
         [ predicate-output-infos ]
         bi
     ] [ 2drop object-info ] if
-] +outputs+ set-word-prop
+] "outputs" set-word-prop
diff --git a/basis/compiler/tree/propagation/nodes/nodes.factor b/basis/compiler/tree/propagation/nodes/nodes.factor
index 358944d1b7..9e4d99e462 100644
--- a/basis/compiler/tree/propagation/nodes/nodes.factor
+++ b/basis/compiler/tree/propagation/nodes/nodes.factor
@@ -6,9 +6,6 @@ compiler.tree.propagation.copy
 compiler.tree.propagation.info ;
 IN: compiler.tree.propagation.nodes
 
-SYMBOL: +constraints+
-SYMBOL: +outputs+
-
 GENERIC: propagate-before ( node -- )
 
 GENERIC: propagate-after ( node -- )
diff --git a/basis/compiler/tree/propagation/propagation-tests.factor b/basis/compiler/tree/propagation/propagation-tests.factor
index 503c633077..f04460f32a 100644
--- a/basis/compiler/tree/propagation/propagation-tests.factor
+++ b/basis/compiler/tree/propagation/propagation-tests.factor
@@ -411,6 +411,14 @@ TUPLE: mixed-mutable-immutable { x integer } { y sequence read-only } ;
     ] final-classes
 ] unit-test
 
+[ V{ integer array } ] [
+    [
+        [ 2drop T{ mixed-mutable-immutable f 3 { } } ]
+        [ { array } declare mixed-mutable-immutable boa ] if
+        [ x>> ] [ y>> ] bi
+    ] final-classes
+] unit-test
+
 ! Recursive propagation
 : recursive-test-1 ( a -- b ) recursive-test-1 ; inline recursive
 
@@ -573,6 +581,18 @@ MIXIN: empty-mixin
 
 [ V{ fixnum } ] [ [ [ bignum-shift drop ] keep ] final-classes ] unit-test
 
+[ V{ float } ] [
+    [
+        [ { float float } declare <complex> ]
+        [ 2drop C{ 0.0 0.0 } ]
+        if real-part
+    ] final-classes
+] unit-test
+
+[ V{ POSTPONE: f } ] [
+    [ { float } declare 0 eq? ] final-classes
+] unit-test
+
 ! [ V{ string } ] [
 !     [ dup string? t xor [ "A" throw ] [ ] if ] final-classes
 ! ] unit-test
diff --git a/basis/compiler/tree/propagation/simple/simple.factor b/basis/compiler/tree/propagation/simple/simple.factor
index d664ae5ccf..809a85a51f 100644
--- a/basis/compiler/tree/propagation/simple/simple.factor
+++ b/basis/compiler/tree/propagation/simple/simple.factor
@@ -3,8 +3,7 @@
 USING: fry accessors kernel sequences sequences.private assocs words
 namespaces classes.algebra combinators classes classes.tuple
 classes.tuple.private continuations arrays
-math math.partial-dispatch math.private slots generic definitions
-generic.standard generic.math
+math math.private slots generic definitions
 stack-checker.state
 compiler.tree
 compiler.tree.propagation.info
@@ -52,7 +51,7 @@ M: #declare propagate-before
     with-datastack first assume ;
 
 : compute-constraints ( #call word -- )
-    dup +constraints+ word-prop [ nip custom-constraints ] [
+    dup "constraints" word-prop [ nip custom-constraints ] [
         dup predicate? [
             [ [ in-d>> first ] [ out-d>> first ] bi ]
             [ "predicating" word-prop ] bi*
@@ -61,19 +60,22 @@ M: #declare propagate-before
     ] if* ;
 
 : call-outputs-quot ( #call word -- infos )
-    [ in-d>> [ value-info ] map ] [ +outputs+ word-prop ] bi*
+    [ in-d>> [ value-info ] map ] [ "outputs" word-prop ] bi*
     with-datastack ;
 
 : foldable-call? ( #call word -- ? )
     "foldable" word-prop
     [ in-d>> [ value-info literal?>> ] all? ] [ drop f ] if ;
 
-: fold-call ( #call word -- infos )
+: (fold-call) ( #call word -- info )
     [ [ out-d>> ] [ in-d>> [ value-info literal>> ] map ] bi ] [ '[ , execute ] ] bi*
     '[ , , with-datastack [ <literal-info> ] map nip ]
     [ drop [ object-info ] replicate ]
     recover ;
 
+: fold-call ( #call word -- )
+    [ (fold-call) ] [ drop out-d>> ] 2bi set-value-infos ;
+
 : predicate-output-infos ( info class -- info )
     [ class>> ] dip {
         { [ 2dup class<= ] [ t <literal-info> ] }
@@ -95,30 +97,23 @@ M: #declare propagate-before
 
 : output-value-infos ( #call word -- infos )
     {
-        { [ 2dup foldable-call? ] [ fold-call ] }
         { [ dup tuple-constructor? ] [ propagate-tuple-constructor ] }
         { [ dup sequence-constructor? ] [ propagate-sequence-constructor ] }
         { [ dup predicate? ] [ propagate-predicate ] }
-        { [ dup +outputs+ word-prop ] [ call-outputs-quot ] }
+        { [ dup "outputs" word-prop ] [ call-outputs-quot ] }
         [ default-output-value-infos ]
     } cond ;
 
-: do-inlining ( #call word -- ? )
-    {
-        { [ dup always-inline-word? ] [ inline-word ] }
-        { [ dup standard-generic? ] [ inline-standard-method ] }
-        { [ dup math-generic? ] [ inline-math-method ] }
-        { [ dup math-partial? ] [ inline-math-partial ] }
-        { [ dup method-body? ] [ inline-method-body ] }
-        [ 2drop f ]
-    } cond ;
-
 M: #call propagate-before
-    dup word>> 2dup do-inlining [ 2drop ] [
-        [ [ output-value-infos ] [ drop out-d>> ] 2bi set-value-infos ]
-        [ compute-constraints ]
-        2bi
-    ] if ;
+    dup word>> {
+        { [ 2dup foldable-call? ] [ fold-call ] }
+        { [ 2dup do-inlining ] [ 2drop ] }
+        [
+            [ [ output-value-infos ] [ drop out-d>> ] 2bi set-value-infos ]
+            [ compute-constraints ]
+            2bi
+        ]
+    } cond ;
 
 M: #call annotate-node
     dup [ in-d>> ] [ out-d>> ] bi append (annotate-node) ;
diff --git a/basis/compiler/tree/propagation/slots/slots.factor b/basis/compiler/tree/propagation/slots/slots.factor
index 5e3480be2f..08a8520d0a 100644
--- a/basis/compiler/tree/propagation/slots/slots.factor
+++ b/basis/compiler/tree/propagation/slots/slots.factor
@@ -31,26 +31,19 @@ UNION: fixed-length-sequence array byte-array string ;
 : tuple-constructor? ( word -- ? )
     { <tuple-boa> <complex> } memq? ;
 
-: read-only-slots ( values class -- slots )
-    #! Delegation.
-    all-slots rest-slice
-    [ read-only>> [ drop f ] unless ] 2map
-    { f f } prepend ;
-
 : fold-<tuple-boa> ( values class -- info )
-    [ , f , [ literal>> ] map % ] { } make >tuple
+    [ [ literal>> ] map ] dip prefix >tuple
     <literal-info> ;
 
 : (propagate-tuple-constructor) ( values class -- info )
     [ [ value-info ] map ] dip [ read-only-slots ] keep
-    over 2 tail-slice [ dup [ literal?>> ] when ] all? [
-        [ 2 tail-slice ] dip fold-<tuple-boa>
+    over rest-slice [ dup [ literal?>> ] when ] all? [
+        [ rest-slice ] dip fold-<tuple-boa>
     ] [
         <tuple-info>
     ] if ;
 
 : propagate-<tuple-boa> ( #call -- info )
-    #! Delegation
     in-d>> unclip-last
     value-info literal>> class>> (propagate-tuple-constructor) ;
 
@@ -75,7 +68,6 @@ UNION: fixed-length-sequence array byte-array string ;
     [ 1 = ] [ length>> ] bi* and ;
 
 : value-info-slot ( slot info -- info' )
-    #! Delegation.
     {
         { [ over 0 = ] [ 2drop fixnum <class-info> ] }
         { [ 2dup length-accessor? ] [ nip length>> ] }
diff --git a/basis/compiler/tree/tuple-unboxing/tuple-unboxing-tests.factor b/basis/compiler/tree/tuple-unboxing/tuple-unboxing-tests.factor
index 334fcb11f0..858e40347f 100644
--- a/basis/compiler/tree/tuple-unboxing/tuple-unboxing-tests.factor
+++ b/basis/compiler/tree/tuple-unboxing/tuple-unboxing-tests.factor
@@ -30,7 +30,7 @@ TUPLE: empty-tuple ;
     [ dup cons boa 10 [ nip dup cons boa ] each-integer car>> ]
     [ 2 cons boa { [ ] [ ] } dispatch ]
     [ dup [ drop f ] [ "A" throw ] if ]
-    [ [ ] [ ] curry curry dup 3 slot swap 4 slot dup 3 slot swap 4 slot drop ]
+    [ [ ] [ ] curry curry dup 2 slot swap 3 slot dup 2 slot swap 3 slot drop ]
     [ [ ] [ ] curry curry call ]
     [ <complex> <complex> dup 1 slot drop 2 slot drop ]
     [ 1 cons boa over [ "A" throw ] when car>> ]
diff --git a/basis/compiler/tree/tuple-unboxing/tuple-unboxing.factor b/basis/compiler/tree/tuple-unboxing/tuple-unboxing.factor
index 97b4e2aee2..6fc0e76310 100644
--- a/basis/compiler/tree/tuple-unboxing/tuple-unboxing.factor
+++ b/basis/compiler/tree/tuple-unboxing/tuple-unboxing.factor
@@ -4,8 +4,8 @@ USING: namespaces assocs accessors kernel combinators
 classes.algebra sequences sequences.deep slots.private
 classes.tuple.private math math.private arrays
 stack-checker.branches
+compiler.intrinsics
 compiler.tree
-compiler.tree.intrinsics
 compiler.tree.combinators
 compiler.tree.propagation.info
 compiler.tree.escape-analysis.simple
diff --git a/basis/concurrency/distributed/distributed.factor b/basis/concurrency/distributed/distributed.factor
index 4da079e812..5e2f1bb6d1 100755
--- a/basis/concurrency/distributed/distributed.factor
+++ b/basis/concurrency/distributed/distributed.factor
@@ -37,7 +37,7 @@ M: remote-process send ( message thread -- )
     send-remote-message ;
 
 M: thread (serialize) ( obj -- )
-    thread-id local-node get-global <remote-process>
+    id>> local-node get-global <remote-process>
     (serialize) ;
 
 : stop-node ( node -- )
diff --git a/basis/cpu/ppc/architecture/architecture.factor b/basis/cpu/ppc/architecture/architecture.factor
index 00bdb4b7c9..0aee836cf1 100755
--- a/basis/cpu/ppc/architecture/architecture.factor
+++ b/basis/cpu/ppc/architecture/architecture.factor
@@ -18,13 +18,13 @@ IN: cpu.ppc.architecture
 : ds-reg 14 ; inline
 : rs-reg 15 ; inline
 
-: reserved-area-size
+: reserved-area-size ( -- n )
     os {
         { linux [ 2 ] }
         { macosx [ 6 ] }
     } case cells ; foldable
 
-: lr-save
+: lr-save ( -- n )
     os {
         { linux [ 1 ] }
         { macosx [ 2 ] }
@@ -32,12 +32,12 @@ IN: cpu.ppc.architecture
 
 : param@ ( n -- x ) reserved-area-size + ; inline
 
-: param-save-size 8 cells ; foldable
+: param-save-size ( -- n ) 8 cells ; foldable
 
 : local@ ( n -- x )
     reserved-area-size param-save-size + + ; inline
 
-: factor-area-size 2 cells ;
+: factor-area-size ( -- n ) 2 cells ; foldable
 
 : next-save ( n -- i ) cell - ;
 
@@ -96,9 +96,9 @@ M: ppc %epilogue ( n -- )
     1 1 rot ADDI
     0 MTLR ;
 
-: (%call) 11 MTLR BLRL ;
+: (%call) ( -- ) 11 MTLR BLRL ;
 
-: (%jump) 11 MTCTR BCTR ;
+: (%jump) ( -- ) 11 MTCTR BCTR ;
 
 : %load-dlsym ( symbol dll register -- )
     0 swap LOAD32 rc-absolute-ppc-2/2 rel-dlsym ;
@@ -218,7 +218,7 @@ M: ppc %box-long-long ( n func -- )
         4 1 rot cell + local@ LWZ
     ] when* r> f %alien-invoke ;
 
-: temp@ stack-frame* factor-area-size - swap - ;
+: temp@ ( m -- n ) stack-frame* factor-area-size - swap - ;
 
 : struct-return@ ( size n -- n ) [ local@ ] [ temp@ ] ?if ;
 
diff --git a/basis/cpu/ppc/intrinsics/intrinsics.factor b/basis/cpu/ppc/intrinsics/intrinsics.factor
index 6413cf839c..634040b0d0 100755
--- a/basis/cpu/ppc/intrinsics/intrinsics.factor
+++ b/basis/cpu/ppc/intrinsics/intrinsics.factor
@@ -4,24 +4,28 @@ USING: accessors alien alien.accessors alien.c-types arrays
 cpu.ppc.assembler cpu.ppc.architecture cpu.ppc.allot
 cpu.architecture kernel kernel.private math math.private
 namespaces sequences words generic quotations byte-arrays
-hashtables hashtables.private compiler.generator
-compiler.generator.registers compiler.generator.fixup
+hashtables hashtables.private
 sequences.private sbufs vectors system layouts
-math.floats.private classes slots.private combinators
-compiler.constants ;
+math.floats.private classes slots.private
+combinators
+compiler.constants
+compiler.intrinsics
+compiler.generator
+compiler.generator.fixup
+compiler.generator.registers ;
 IN: cpu.ppc.intrinsics
 
-: %slot-literal-known-tag
+: %slot-literal-known-tag ( -- out value offset )
     "val" operand
     "obj" operand
     "n" get cells
     "obj" get operand-tag - ;
 
-: %slot-literal-any-tag
+: %slot-literal-any-tag ( -- out value offset )
     "obj" operand "scratch1" operand %untag
     "val" operand "scratch1" operand "n" get cells ;
 
-: %slot-any
+: %slot-any ( -- out value offset )
     "obj" operand "scratch1" operand %untag
     "offset" operand "n" operand 1 SRAWI
     "scratch1" operand "val" operand "offset" operand ;
@@ -188,7 +192,7 @@ IN: cpu.ppc.intrinsics
     }
 } define-intrinsics
 
-: generate-fixnum-mod
+: generate-fixnum-mod ( -- )
     #! PowerPC doesn't have a MOD instruction; so we compute
     #! x-(x/y)*y. Puts the result in "s" operand.
     "s" operand "r" operand "y" operand MULLW
@@ -259,7 +263,7 @@ IN: cpu.ppc.intrinsics
 \ fixnum+ \ ADD \ ADDO. overflow-template
 \ fixnum- \ SUBF \ SUBFO. overflow-template
 
-: generate-fixnum/i
+: generate-fixnum/i ( -- )
     #! This VOP is funny. If there is an overflow, it falls
     #! through to the end, and the result is in "x" operand.
     #! Otherwise it jumps to the "no-overflow" label and the
@@ -437,44 +441,44 @@ IN: cpu.ppc.intrinsics
     { +clobber+ { "n" } }
 } define-intrinsic
 
-! \ (tuple) [
-!     tuple "layout" get size>> 2 + cells %allot
-!     ! Store layout
-!     "layout" get 12 load-indirect
-!     12 11 cell STW
-!     ! Store tagged ptr in reg
-!     "tuple" get tuple %store-tagged
-! ] H{
-!     { +input+ { { [ ] "layout" } } }
-!     { +scratch+ { { f "tuple" } } }
-!     { +output+ { "tuple" } }
-! } define-intrinsic
-! 
-! \ (array) [
-!     array "n" get 2 + cells %allot
-!     ! Store length
-!     "n" operand 12 LI
-!     12 11 cell STW
-!     ! Store tagged ptr in reg
-!     "array" get object %store-tagged
-! ] H{
-!     { +input+ { { [ ] "n" } } }
-!     { +scratch+ { { f "array" } } }
-!     { +output+ { "array" } }
-! } define-intrinsic
-! 
-! \ (byte-array) [
-!     byte-array "n" get 2 cells + %allot
-!     ! Store length
-!     "n" operand 12 LI
-!     12 11 cell STW
-!     ! Store tagged ptr in reg
-!     "array" get object %store-tagged
-! ] H{
-!     { +input+ { { [ ] "n" } } }
-!     { +scratch+ { { f "array" } } }
-!     { +output+ { "array" } }
-! } define-intrinsic
+\ (tuple) [
+    tuple "layout" get size>> 2 + cells %allot
+    ! Store layout
+    "layout" get 12 load-indirect
+    12 11 cell STW
+    ! Store tagged ptr in reg
+    "tuple" get tuple %store-tagged
+] H{
+    { +input+ { { [ ] "layout" } } }
+    { +scratch+ { { f "tuple" } } }
+    { +output+ { "tuple" } }
+} define-intrinsic
+
+\ (array) [
+    array "n" get 2 + cells %allot
+    ! Store length
+    "n" operand 12 LI
+    12 11 cell STW
+    ! Store tagged ptr in reg
+    "array" get object %store-tagged
+] H{
+    { +input+ { { [ ] "n" } } }
+    { +scratch+ { { f "array" } } }
+    { +output+ { "array" } }
+} define-intrinsic
+
+\ (byte-array) [
+    byte-array "n" get 2 cells + %allot
+    ! Store length
+    "n" operand 12 LI
+    12 11 cell STW
+    ! Store tagged ptr in reg
+    "array" get object %store-tagged
+] H{
+    { +input+ { { [ ] "n" } } }
+    { +scratch+ { { f "array" } } }
+    { +output+ { "array" } }
+} define-intrinsic
 
 \ <ratio> [
     ratio 3 cells %allot
@@ -514,8 +518,8 @@ IN: cpu.ppc.intrinsics
 ! Alien intrinsics
 : %alien-accessor ( quot -- )
     "offset" operand dup %untag-fixnum
-    "offset" operand dup "alien" operand ADD
-    "value" operand "offset" operand 0 roll call ; inline
+    "scratch" operand "offset" operand "alien" operand ADD
+    "value" operand "scratch" operand 0 roll call ; inline
 
 : alien-integer-get-template
     H{
@@ -523,7 +527,7 @@ IN: cpu.ppc.intrinsics
             { unboxed-c-ptr "alien" c-ptr }
             { f "offset" fixnum }
         } }
-        { +scratch+ { { f "value" } } }
+        { +scratch+ { { f "value" } { f "scratch" } } }
         { +output+ { "value" } }
         { +clobber+ { "offset" } }
     } ;
@@ -539,6 +543,7 @@ IN: cpu.ppc.intrinsics
             { unboxed-c-ptr "alien" c-ptr }
             { f "offset" fixnum }
         } }
+        { +scratch+ { { f "scratch" } } }
         { +clobber+ { "value" "offset" } }
     } ;
 
@@ -579,7 +584,7 @@ define-alien-integer-intrinsics
         { unboxed-c-ptr "alien" c-ptr }
         { f "offset" fixnum }
     } }
-    { +scratch+ { { unboxed-alien "value" } } }
+    { +scratch+ { { unboxed-alien "value" } { f "scratch" } } }
     { +output+ { "value" } }
     { +clobber+ { "offset" } }
 } define-intrinsic
@@ -592,6 +597,7 @@ define-alien-integer-intrinsics
         { unboxed-c-ptr "alien" c-ptr }
         { f "offset" fixnum }
     } }
+    { +scratch+ { { f "scratch" } } }
     { +clobber+ { "offset" } }
 } define-intrinsic
 
@@ -601,7 +607,7 @@ define-alien-integer-intrinsics
             { unboxed-c-ptr "alien" c-ptr }
             { f "offset" fixnum }
         } }
-        { +scratch+ { { float "value" } } }
+        { +scratch+ { { float "value" } { f "scratch" } } }
         { +output+ { "value" } }
         { +clobber+ { "offset" } }
     } ;
@@ -613,6 +619,7 @@ define-alien-integer-intrinsics
             { unboxed-c-ptr "alien" c-ptr }
             { f "offset" fixnum }
         } }
+        { +scratch+ { { f "scratch" } } }
         { +clobber+ { "offset" } }
     } ;
 
diff --git a/basis/cpu/x86/64/64.factor b/basis/cpu/x86/64/64.factor
index c1697f1d98..6e864ab968 100755
--- a/basis/cpu/x86/64/64.factor
+++ b/basis/cpu/x86/64/64.factor
@@ -178,7 +178,7 @@ stack-params "__stack_value" c-type (>>reg-class) >>
 
 : struct-types&offset ( struct-type -- pairs )
     fields>> [
-        [ class>> ] [ offset>> ] bi 2array
+        [ type>> ] [ offset>> ] bi 2array
     ] map ;
 
 : split-struct ( pairs -- seq )
diff --git a/basis/cpu/x86/intrinsics/intrinsics.factor b/basis/cpu/x86/intrinsics/intrinsics.factor
index 536b914f39..a0cfd1b01e 100755
--- a/basis/cpu/x86/intrinsics/intrinsics.factor
+++ b/basis/cpu/x86/intrinsics/intrinsics.factor
@@ -4,10 +4,14 @@ USING: accessors alien alien.accessors arrays cpu.x86.assembler
 cpu.x86.allot cpu.x86.architecture cpu.architecture kernel
 kernel.private math math.private namespaces quotations sequences
 words generic byte-arrays hashtables hashtables.private
-compiler.generator compiler.generator.registers
-compiler.generator.fixup sequences.private sbufs sbufs.private
+sequences.private sbufs sbufs.private
 vectors vectors.private layouts system strings.private
-slots.private compiler.constants ;
+slots.private 
+compiler.constants
+compiler.intrinsics
+compiler.generator
+compiler.generator.fixup
+compiler.generator.registers ;
 IN: cpu.x86.intrinsics
 
 ! Type checks
@@ -289,45 +293,45 @@ IN: cpu.x86.intrinsics
     { +clobber+ { "n" } }
 } define-intrinsic
 
-! \ (tuple) [
-!     tuple "layout" get size>> 2 + cells [
-!         ! Store layout
-!         "layout" get "scratch" get load-literal
-!         1 object@ "scratch" operand MOV
-!         ! Store tagged ptr in reg
-!         "tuple" get tuple %store-tagged
-!     ] %allot
-! ] H{
-!     { +input+ { { [ ] "layout" } } }
-!     { +scratch+ { { f "tuple" } { f "scratch" } } }
-!     { +output+ { "tuple" } }
-! } define-intrinsic
-! 
-! \ (array) [
-!     array "n" get 2 + cells [
-!         ! Store length
-!         1 object@ "n" operand MOV
-!         ! Store tagged ptr in reg
-!         "array" get object %store-tagged
-!     ] %allot
-! ] H{
-!     { +input+ { { [ ] "n" } } }
-!     { +scratch+ { { f "array" } } }
-!     { +output+ { "array" } }
-! } define-intrinsic
-! 
-! \ (byte-array) [
-!     byte-array "n" get 2 cells + [
-!         ! Store length
-!         1 object@ "n" operand MOV
-!         ! Store tagged ptr in reg
-!         "array" get object %store-tagged
-!     ] %allot
-! ] H{
-!     { +input+ { { [ ] "n" } } }
-!     { +scratch+ { { f "array" } } }
-!     { +output+ { "array" } }
-! } define-intrinsic
+\ (tuple) [
+    tuple "layout" get size>> 2 + cells [
+        ! Store layout
+        "layout" get "scratch" get load-literal
+        1 object@ "scratch" operand MOV
+        ! Store tagged ptr in reg
+        "tuple" get tuple %store-tagged
+    ] %allot
+] H{
+    { +input+ { { [ ] "layout" } } }
+    { +scratch+ { { f "tuple" } { f "scratch" } } }
+    { +output+ { "tuple" } }
+} define-intrinsic
+
+\ (array) [
+    array "n" get 2 + cells [
+        ! Store length
+        1 object@ "n" operand MOV
+        ! Store tagged ptr in reg
+        "array" get object %store-tagged
+    ] %allot
+] H{
+    { +input+ { { [ ] "n" } } }
+    { +scratch+ { { f "array" } } }
+    { +output+ { "array" } }
+} define-intrinsic
+
+\ (byte-array) [
+    byte-array "n" get 2 cells + [
+        ! Store length
+        1 object@ "n" operand MOV
+        ! Store tagged ptr in reg
+        "array" get object %store-tagged
+    ] %allot
+] H{
+    { +input+ { { [ ] "n" } } }
+    { +scratch+ { { f "array" } } }
+    { +output+ { "array" } }
+} define-intrinsic
 
 \ <ratio> [
     ratio 3 cells [
diff --git a/extra/csv/authors.txt b/basis/csv/authors.txt
similarity index 100%
rename from extra/csv/authors.txt
rename to basis/csv/authors.txt
diff --git a/extra/csv/csv-docs.factor b/basis/csv/csv-docs.factor
similarity index 100%
rename from extra/csv/csv-docs.factor
rename to basis/csv/csv-docs.factor
diff --git a/extra/csv/csv-tests.factor b/basis/csv/csv-tests.factor
similarity index 100%
rename from extra/csv/csv-tests.factor
rename to basis/csv/csv-tests.factor
diff --git a/extra/csv/csv.factor b/basis/csv/csv.factor
similarity index 100%
rename from extra/csv/csv.factor
rename to basis/csv/csv.factor
diff --git a/extra/csv/summary.txt b/basis/csv/summary.txt
similarity index 100%
rename from extra/csv/summary.txt
rename to basis/csv/summary.txt
diff --git a/basis/calendar/backend/authors.txt b/basis/db/authors.txt
old mode 100755
new mode 100644
similarity index 100%
rename from basis/calendar/backend/authors.txt
rename to basis/db/authors.txt
diff --git a/extra/db/db-tests.factor b/basis/db/db-tests.factor
similarity index 96%
rename from extra/db/db-tests.factor
rename to basis/db/db-tests.factor
index 0d95e3aea7..3f1dab2c37 100755
--- a/extra/db/db-tests.factor
+++ b/basis/db/db-tests.factor
@@ -1,5 +1,5 @@
-IN: db.tests
 USING: tools.test db kernel ;
+IN: db.tests
 
 { 1 0 } [ [ drop ] query-each ] must-infer-as
 { 1 1 } [ [ ] query-map ] must-infer-as
diff --git a/extra/db/db.factor b/basis/db/db.factor
similarity index 86%
rename from extra/db/db.factor
rename to basis/db/db.factor
index c52d1db148..c269341240 100755
--- a/extra/db/db.factor
+++ b/basis/db/db.factor
@@ -2,7 +2,7 @@
 ! See http://factorcode.org/license.txt for BSD license.
 USING: arrays assocs classes continuations destructors kernel math
 namespaces sequences sequences.lib classes.tuple words strings
-tools.walker accessors combinators.lib ;
+tools.walker accessors combinators.lib combinators ;
 IN: db
 
 TUPLE: db
@@ -15,24 +15,25 @@ TUPLE: db
     new
         H{ } clone >>insert-statements
         H{ } clone >>update-statements
-        H{ } clone >>delete-statements ;
+        H{ } clone >>delete-statements ; inline
 
-GENERIC: make-db* ( seq class -- db )
+GENERIC: make-db* ( seq db -- db )
 
-: make-db ( seq class -- db )
-    new-db make-db* ;
+: make-db ( seq class -- db ) new-db make-db* ;
 
 GENERIC: db-open ( db -- db )
 HOOK: db-close db ( handle -- )
 
 : dispose-statements ( assoc -- ) values dispose-each ;
 
-: dispose-db ( db -- ) 
+: db-dispose ( db -- ) 
     dup db [
-        dup insert-statements>> dispose-statements
-        dup update-statements>> dispose-statements
-        dup delete-statements>> dispose-statements
-        handle>> db-close
+        {
+            [ insert-statements>> dispose-statements ]
+            [ update-statements>> dispose-statements ]
+            [ delete-statements>> dispose-statements ]
+            [ handle>> db-close ]
+        } cleave
     ] with-variable ;
 
 TUPLE: statement handle sql in-params out-params bind-params bound? type retries ;
@@ -47,8 +48,8 @@ TUPLE: result-set sql in-params out-params handle n max ;
         swap >>in-params
         swap >>sql ;
 
-HOOK: <simple-statement> db ( str in out -- statement )
-HOOK: <prepared-statement> db ( str in out -- statement )
+HOOK: <simple-statement> db ( string in out -- statement )
+HOOK: <prepared-statement> db ( string in out -- statement )
 GENERIC: prepare-statement ( statement -- )
 GENERIC: bind-statement* ( statement -- )
 GENERIC: low-level-bind ( statement -- )
diff --git a/extra/db/errors/errors.factor b/basis/db/errors/errors.factor
similarity index 99%
rename from extra/db/errors/errors.factor
rename to basis/db/errors/errors.factor
index 1e0d1e7fb4..da6301639f 100644
--- a/extra/db/errors/errors.factor
+++ b/basis/db/errors/errors.factor
@@ -6,6 +6,5 @@ IN: db.errors
 ERROR: db-error ;
 ERROR: sql-error ;
 
-
 ERROR: table-exists ;
 ERROR: bad-schema ;
diff --git a/extra/db/pools/pools-tests.factor b/basis/db/pools/pools-tests.factor
similarity index 87%
rename from extra/db/pools/pools-tests.factor
rename to basis/db/pools/pools-tests.factor
index 34e072c3a5..f07d1e8468 100644
--- a/extra/db/pools/pools-tests.factor
+++ b/basis/db/pools/pools-tests.factor
@@ -13,7 +13,7 @@ USE: db.sqlite
 
 [ "pool-test.db" temp-file delete-file ] ignore-errors
 
-[ ] [ "pool-test.db" sqlite-db <db-pool> "pool" set ] unit-test
+[ ] [ "pool-test.db" temp-file sqlite-db <db-pool> "pool" set ] unit-test
 
 [ ] [ "pool" get expired>> t >>expired drop ] unit-test
 
diff --git a/extra/db/pools/pools.factor b/basis/db/pools/pools.factor
similarity index 100%
rename from extra/db/pools/pools.factor
rename to basis/db/pools/pools.factor
diff --git a/basis/editors/gvim/backend/authors.txt b/basis/db/postgresql/authors.txt
old mode 100755
new mode 100644
similarity index 100%
rename from basis/editors/gvim/backend/authors.txt
rename to basis/db/postgresql/authors.txt
diff --git a/extra/db/postgresql/ffi/ffi.factor b/basis/db/postgresql/ffi/ffi.factor
similarity index 100%
rename from extra/db/postgresql/ffi/ffi.factor
rename to basis/db/postgresql/ffi/ffi.factor
diff --git a/extra/db/postgresql/lib/lib.factor b/basis/db/postgresql/lib/lib.factor
similarity index 100%
rename from extra/db/postgresql/lib/lib.factor
rename to basis/db/postgresql/lib/lib.factor
diff --git a/extra/db/postgresql/postgresql-tests.factor b/basis/db/postgresql/postgresql-tests.factor
similarity index 100%
rename from extra/db/postgresql/postgresql-tests.factor
rename to basis/db/postgresql/postgresql-tests.factor
diff --git a/extra/db/postgresql/postgresql.factor b/basis/db/postgresql/postgresql.factor
similarity index 99%
rename from extra/db/postgresql/postgresql.factor
rename to basis/db/postgresql/postgresql.factor
index e57efbc360..692241fab0 100755
--- a/extra/db/postgresql/postgresql.factor
+++ b/basis/db/postgresql/postgresql.factor
@@ -16,7 +16,7 @@ TUPLE: postgresql-statement < statement ;
 
 TUPLE: postgresql-result-set < result-set ;
 
-M: postgresql-db make-db* ( seq tuple -- db )
+M: postgresql-db make-db* ( seq db -- db )
     >r first4 r>
         swap >>db
         swap >>pass
diff --git a/extra/db/queries/queries.factor b/basis/db/queries/queries.factor
similarity index 97%
rename from extra/db/queries/queries.factor
rename to basis/db/queries/queries.factor
index 3a751a9736..e5334703f6 100644
--- a/extra/db/queries/queries.factor
+++ b/basis/db/queries/queries.factor
@@ -43,13 +43,6 @@ M: random-id-generator eval-generator ( singleton -- obj )
 : interval-comparison ( ? str -- str )
     "from" = " >" " <" ? swap [ "= " append ] when ;
 
-: fp-infinity? ( float -- ? )
-    dup float? [
-        double>bits -52 shift 11 2^ 1- [ bitand ] keep =
-    ] [
-        drop f
-    ] if ;
-
 : (infinite-interval?) ( interval -- ?1 ?2 )
     [ from>> ] [ to>> ] bi
     [ first fp-infinity? ] bi@ ;
diff --git a/extra/db/sql/sql-tests.factor b/basis/db/sql/sql-tests.factor
similarity index 100%
rename from extra/db/sql/sql-tests.factor
rename to basis/db/sql/sql-tests.factor
diff --git a/extra/db/sql/sql.factor b/basis/db/sql/sql.factor
similarity index 100%
rename from extra/db/sql/sql.factor
rename to basis/db/sql/sql.factor
diff --git a/extra/db/sqlite/authors.txt b/basis/db/sqlite/authors.txt
similarity index 100%
rename from extra/db/sqlite/authors.txt
rename to basis/db/sqlite/authors.txt
diff --git a/extra/db/sqlite/ffi/ffi.factor b/basis/db/sqlite/ffi/ffi.factor
similarity index 98%
rename from extra/db/sqlite/ffi/ffi.factor
rename to basis/db/sqlite/ffi/ffi.factor
index b443f53e78..9f033a1d3c 100755
--- a/extra/db/sqlite/ffi/ffi.factor
+++ b/basis/db/sqlite/ffi/ffi.factor
@@ -118,6 +118,7 @@ FUNCTION: int sqlite3_bind_blob ( sqlite3_stmt* pStmt, int index, void* ptr, int
 FUNCTION: int sqlite3_bind_double ( sqlite3_stmt* pStmt, int index, double x ) ;
 FUNCTION: int sqlite3_bind_int ( sqlite3_stmt* pStmt, int index, int n ) ;
 FUNCTION: int sqlite3_bind_int64 ( sqlite3_stmt* pStmt, int index, sqlite3_int64 n ) ;
+! Bind the same function as above, but for unsigned 64bit integers
 : sqlite3-bind-uint64 ( pStmt index in64 -- int )
     "int" "sqlite" "sqlite3_bind_int64"
     { "sqlite3_stmt*" "int" "sqlite3_uint64" } alien-invoke ;
@@ -131,6 +132,7 @@ FUNCTION: int sqlite3_column_bytes ( sqlite3_stmt* pStmt, int col ) ;
 FUNCTION: char* sqlite3_column_decltype ( sqlite3_stmt* pStmt, int col ) ;
 FUNCTION: int sqlite3_column_int ( sqlite3_stmt* pStmt, int col ) ;
 FUNCTION: sqlite3_int64 sqlite3_column_int64 ( sqlite3_stmt* pStmt, int col ) ;
+! Bind the same function as above, but for unsigned 64bit integers
 : sqlite3-column-uint64 ( pStmt col -- uint64 )
     "sqlite3_uint64" "sqlite" "sqlite3_column_int64"
     { "sqlite3_stmt*" "int" } alien-invoke ;
diff --git a/extra/db/sqlite/lib/lib.factor b/basis/db/sqlite/lib/lib.factor
similarity index 100%
rename from extra/db/sqlite/lib/lib.factor
rename to basis/db/sqlite/lib/lib.factor
diff --git a/extra/db/sqlite/sqlite-tests.factor b/basis/db/sqlite/sqlite-tests.factor
similarity index 99%
rename from extra/db/sqlite/sqlite-tests.factor
rename to basis/db/sqlite/sqlite-tests.factor
index b30cb4ba80..67eac2702b 100755
--- a/extra/db/sqlite/sqlite-tests.factor
+++ b/basis/db/sqlite/sqlite-tests.factor
@@ -57,8 +57,7 @@ IN: db.sqlite.tests
     ] with-db
 ] unit-test
 
-[
-] [
+[ ] [
     test.db [
         [
             "insert into person(name, country) values('Jose', 'Mexico')"
diff --git a/extra/db/sqlite/sqlite.factor b/basis/db/sqlite/sqlite.factor
similarity index 97%
rename from extra/db/sqlite/sqlite.factor
rename to basis/db/sqlite/sqlite.factor
index 794ff5bacd..49d79b1b8c 100755
--- a/extra/db/sqlite/sqlite.factor
+++ b/basis/db/sqlite/sqlite.factor
@@ -19,7 +19,7 @@ M: sqlite-db db-open ( db -- db )
     dup path>> sqlite-open >>handle ;
 
 M: sqlite-db db-close ( handle -- ) sqlite-close ;
-M: sqlite-db dispose ( db -- ) dispose-db ;
+M: sqlite-db dispose ( db -- ) db-dispose ;
 
 TUPLE: sqlite-statement < statement ;
 
@@ -52,12 +52,12 @@ M: sqlite-result-set dispose ( result-set -- )
     handle>> [ sqlite3_reset drop ] [ sqlite3_clear_bindings drop ] bi ;
 
 M: sqlite-statement low-level-bind ( statement -- )
-    [ statement-bind-params ] [ statement-handle ] bi
+    [ bind-params>> ] [ handle>> ] bi
     [ swap [ key>> ] [ value>> ] [ type>> ] tri sqlite-bind-type ] curry each ;
 
 M: sqlite-statement bind-statement* ( statement -- )
     sqlite-maybe-prepare
-    dup statement-bound? [ dup reset-bindings ] when
+    dup bound?>> [ dup reset-bindings ] when
     low-level-bind ;
 
 GENERIC: sqlite-bind-conversion ( tuple obj -- array )
diff --git a/extra/db/sqlite/test.txt b/basis/db/sqlite/test.txt
similarity index 100%
rename from extra/db/sqlite/test.txt
rename to basis/db/sqlite/test.txt
diff --git a/extra/db/summary.txt b/basis/db/summary.txt
similarity index 100%
rename from extra/db/summary.txt
rename to basis/db/summary.txt
diff --git a/extra/db/tags.txt b/basis/db/tags.txt
similarity index 100%
rename from extra/db/tags.txt
rename to basis/db/tags.txt
diff --git a/extra/db/tuples/tuples-tests.factor b/basis/db/tuples/tuples-tests.factor
similarity index 99%
rename from extra/db/tuples/tuples-tests.factor
rename to basis/db/tuples/tuples-tests.factor
index f5b74b51c8..5dd3ec8ae0 100755
--- a/extra/db/tuples/tuples-tests.factor
+++ b/basis/db/tuples/tuples-tests.factor
@@ -41,9 +41,9 @@ SYMBOL: person4
     
     [ ] [ person1 get insert-tuple ] unit-test
 
-    [ 1 ] [ person1 get person-the-id ] unit-test
+    [ 1 ] [ person1 get the-id>> ] unit-test
 
-    [ ] [ 200 person1 get set-person-the-number ] unit-test
+    [ ] [ person1 get 200 >>the-number drop ] unit-test
 
     [ ] [ person1 get update-tuple ] unit-test
 
diff --git a/extra/db/tuples/tuples.factor b/basis/db/tuples/tuples.factor
similarity index 100%
rename from extra/db/tuples/tuples.factor
rename to basis/db/tuples/tuples.factor
diff --git a/extra/db/types/types.factor b/basis/db/types/types.factor
similarity index 89%
rename from extra/db/types/types.factor
rename to basis/db/types/types.factor
index c3480093c5..2efa41c401 100755
--- a/extra/db/types/types.factor
+++ b/basis/db/types/types.factor
@@ -8,7 +8,7 @@ classes.singleton accessors quotations random ;
 IN: db.types
 
 HOOK: persistent-table db ( -- hash )
-HOOK: compound db ( str obj -- hash )
+HOOK: compound db ( string obj -- hash )
 
 TUPLE: sql-spec class slot-name column-name type primary-key modifiers ;
 
@@ -78,7 +78,7 @@ FACTOR-BLOB NULL URL ;
         swap >>class
     dup normalize-spec ;
 
-: number>string* ( n/str -- str )
+: number>string* ( n/string -- string )
     dup number? [ number>string ] when ;
 
 : remove-db-assigned-id ( specs -- obj )
@@ -97,7 +97,7 @@ FACTOR-BLOB NULL URL ;
 
 ERROR: unknown-modifier ;
 
-: lookup-modifier ( obj -- str )
+: lookup-modifier ( obj -- string )
     {
         { [ dup array? ] [ unclip lookup-modifier swap compound ] }
         [ persistent-table at* [ unknown-modifier ] unless third ]
@@ -105,43 +105,43 @@ ERROR: unknown-modifier ;
 
 ERROR: no-sql-type ;
 
-: (lookup-type) ( obj -- str )
+: (lookup-type) ( obj -- string )
     persistent-table at* [ no-sql-type ] unless ;
 
-: lookup-type ( obj -- str )
+: lookup-type ( obj -- string )
     dup array? [
         unclip (lookup-type) first nip
     ] [
         (lookup-type) first
     ] if ;
 
-: lookup-create-type ( obj -- str )
+: lookup-create-type ( obj -- string )
     dup array? [
         unclip (lookup-type) second swap compound
     ] [
         (lookup-type) second
     ] if ;
 
-: single-quote ( str -- newstr )
+: single-quote ( string -- new-string )
     "'" swap "'" 3append ;
 
-: double-quote ( str -- newstr )
+: double-quote ( string -- new-string )
     "\"" swap "\"" 3append ;
 
-: paren ( str -- newstr )
+: paren ( string -- new-string )
     "(" swap ")" 3append ;
 
-: join-space ( str1 str2 -- newstr )
+: join-space ( string1 string2 -- new-string )
     " " swap 3append ;
 
-: modifiers ( spec -- str )
+: modifiers ( spec -- string )
     modifiers>> [ lookup-modifier ] map " " join
     dup empty? [ " " prepend ] unless ;
 
 HOOK: bind% db ( spec -- )
 HOOK: bind# db ( spec obj -- )
 
-: offset-of-slot ( str obj -- n )
+: offset-of-slot ( string obj -- n )
     class superclasses [ "slots" word-prop ] map concat
     slot-named offset>> ;
 
diff --git a/basis/debugger/debugger-docs.factor b/basis/debugger/debugger-docs.factor
index 72463caf26..f8897712e7 100755
--- a/basis/debugger/debugger-docs.factor
+++ b/basis/debugger/debugger-docs.factor
@@ -1,7 +1,7 @@
 USING: alien arrays generic generic.math help.markup help.syntax
 kernel math memory strings sbufs vectors io io.files classes
-help generic.standard continuations system debugger.private
-io.files.private listener ;
+help generic.standard continuations system io.files.private
+listener ;
 IN: debugger
 
 ARTICLE: "debugger" "The debugger"
@@ -22,8 +22,6 @@ ARTICLE: "debugger" "The debugger"
 { $subsection :2 }
 { $subsection :3 }
 { $subsection :res }
-"Assertions:"
-{ $subsection "errors-assert" }
 "You can read more about error handling in " { $link "errors" } "." ;
 
 ABOUT: "debugger"
diff --git a/basis/debugger/threads/threads.factor b/basis/debugger/threads/threads.factor
index 093d231d08..7bb240859e 100644
--- a/basis/debugger/threads/threads.factor
+++ b/basis/debugger/threads/threads.factor
@@ -10,14 +10,17 @@ IN: debugger.threads
         dup id>> #
         " (" % dup name>> %
         ", " % dup quot>> unparse-short % ")" %
-    ] "" make swap write-object ":" print nl ;
+    ] "" make swap write-object ":" print ;
 
 M: thread error-in-thread ( error thread -- )
     initial-thread get-global eq? [
         die drop
     ] [
         global [
-            error-thread get-global error-in-thread. print-error flush
+            error-thread get-global error-in-thread. nl
+            print-error nl
+            :c
+            flush
         ] bind
     ] if ;
 
diff --git a/basis/delegate/delegate-tests.factor b/basis/delegate/delegate-tests.factor
index 09a90121bd..d1e7d31656 100755
--- a/basis/delegate/delegate-tests.factor
+++ b/basis/delegate/delegate-tests.factor
@@ -15,7 +15,7 @@ GENERIC# whoa 1 ( s t -- w )
 PROTOCOL: baz foo { bar 0 } { whoa 1 } ;
 
 : hello-test ( hello/goodbye -- array )
-    [ hello? ] [ hello-this ] [ hello-that ] tri 3array ;
+    [ hello? ] [ this>> ] [ that>> ] tri 3array ;
 
 CONSULT: baz goodbye these>> ;
 M: hello foo this>> ;
@@ -34,8 +34,8 @@ M: hello bing hello-test ;
 [ 3 ] [ 1 0 <hello> 2 whoa ] unit-test
 [ 3 ] [ 1 0 <hello> f <goodbye> 2 whoa ] unit-test
 
-[ ] [ 3 [ "USE: delegate IN: delegate.tests CONSULT: baz goodbye goodbye-these ;" eval ] times ] unit-test
-[ H{ { goodbye [ goodbye-these ] } } ] [ baz protocol-consult ] unit-test
+[ ] [ 3 [ "USING: accessors delegate ; IN: delegate.tests CONSULT: baz goodbye these>> ;" eval ] times ] unit-test
+[ H{ { goodbye [ these>> ] } } ] [ baz protocol-consult ] unit-test
 [ H{ } ] [ bee protocol-consult ] unit-test
 
 [ "USING: delegate ;\nIN: delegate.tests\nPROTOCOL: baz foo bar { whoa 1 } ;\n" ] [ [ baz see ] with-string-writer ] unit-test
diff --git a/basis/editors/gvim/backend/backend.factor b/basis/editors/gvim/backend/backend.factor
deleted file mode 100644
index e2e2f0626e..0000000000
--- a/basis/editors/gvim/backend/backend.factor
+++ /dev/null
@@ -1,4 +0,0 @@
-USING: io.backend ;
-IN: editors.gvim.backend
-
-HOOK: gvim-path io-backend ( -- path )
diff --git a/basis/editors/gvim/backend/tags.txt b/basis/editors/gvim/backend/tags.txt
deleted file mode 100644
index 6bf68304bb..0000000000
--- a/basis/editors/gvim/backend/tags.txt
+++ /dev/null
@@ -1 +0,0 @@
-unportable
diff --git a/basis/editors/gvim/gvim.factor b/basis/editors/gvim/gvim.factor
index 041f3db675..4cc9de17a1 100755
--- a/basis/editors/gvim/gvim.factor
+++ b/basis/editors/gvim/gvim.factor
@@ -1,10 +1,12 @@
 USING: io.backend io.files kernel math math.parser
 namespaces sequences system combinators
-editors.vim editors.gvim.backend vocabs.loader ;
+editors.vim vocabs.loader ;
 IN: editors.gvim
 
 SINGLETON: gvim
 
+HOOK: gvim-path io-backend ( -- path )
+
 M: gvim vim-command ( file line -- string )
     [ gvim-path , swap , "+" swap number>string append , ] { } make ;
 
diff --git a/basis/editors/gvim/unix/unix.factor b/basis/editors/gvim/unix/unix.factor
index 3b8f7454c1..82b6bf199d 100644
--- a/basis/editors/gvim/unix/unix.factor
+++ b/basis/editors/gvim/unix/unix.factor
@@ -1,4 +1,4 @@
-USING: io.unix.backend kernel namespaces editors.gvim.backend
+USING: io.unix.backend kernel namespaces editors.gvim
 system ;
 IN: editors.gvim.unix
 
diff --git a/basis/editors/gvim/windows/windows.factor b/basis/editors/gvim/windows/windows.factor
index daf5409c94..8c4e1aaacb 100755
--- a/basis/editors/gvim/windows/windows.factor
+++ b/basis/editors/gvim/windows/windows.factor
@@ -1,4 +1,4 @@
-USING: editors.gvim.backend io.files io.windows kernel namespaces
+USING: editors.gvim io.files io.windows kernel namespaces
 sequences windows.shell32 io.paths system ;
 IN: editors.gvim.windows
 
diff --git a/basis/float-vectors/float-vectors-tests.factor b/basis/float-vectors/float-vectors-tests.factor
index 383dd4bcf2..1483b269e0 100755
--- a/basis/float-vectors/float-vectors-tests.factor
+++ b/basis/float-vectors/float-vectors-tests.factor
@@ -1,10 +1,10 @@
+USING: tools.test float-vectors vectors sequences kernel math ;
 IN: float-vectors.tests
-USING: tools.test float-vectors vectors sequences kernel ;
 
 [ 0 ] [ 123 <float-vector> length ] unit-test
 
 : do-it
-    12345 [ over push ] each ;
+    12345 [ >float over push ] each ;
 
 [ t ] [
     3 <float-vector> do-it
diff --git a/basis/help/definitions/definitions-tests.factor b/basis/help/definitions/definitions-tests.factor
index 2c894c3812..1b8bcccce7 100755
--- a/basis/help/definitions/definitions-tests.factor
+++ b/basis/help/definitions/definitions-tests.factor
@@ -1,6 +1,6 @@
 USING: math definitions help.topics help tools.test
 prettyprint parser io.streams.string kernel source-files
-assocs namespaces words io sequences eval ;
+assocs namespaces words io sequences eval accessors ;
 IN: help.definitions.tests
 
 [ ] [ \ + >link see ] unit-test
@@ -10,7 +10,7 @@ IN: help.definitions.tests
         "IN: help.definitions.tests USING: help.syntax ; : hello ; HELP: hello \"test\" ; ARTICLE: \"hello\" \"world\" ; ARTICLE: \"hello2\" \"world\" ;" <string-reader> "foo"
         parse-stream drop
 
-        "foo" source-file source-file-definitions first assoc-size
+        "foo" source-file definitions>> first assoc-size
     ] unit-test
 
     [ t ] [ "hello" articles get key? ] unit-test
@@ -23,7 +23,7 @@ IN: help.definitions.tests
         "IN: help.definitions.tests USING: help.syntax ; : hello ; ARTICLE: \"hello\" \"world\" ;" <string-reader> "foo"
         parse-stream drop
 
-        "foo" source-file source-file-definitions first assoc-size
+        "foo" source-file definitions>> first assoc-size
     ] unit-test
 
     [ t ] [ "hello" articles get key? ] unit-test
diff --git a/basis/help/help-docs.factor b/basis/help/help-docs.factor
index d329fa5d42..47cc2987d7 100755
--- a/basis/help/help-docs.factor
+++ b/basis/help/help-docs.factor
@@ -399,5 +399,5 @@ HELP: ABOUT:
 { $description "Defines the main documentation article for the current vocabulary." } ;
 
 HELP: vocab-help
-{ $values { "vocab" "a vocabulary specifier" } { "help" "a help article" } }
+{ $values { "vocab-spec" "a vocabulary specifier" } { "help" "a help article" } }
 { $description "Outputs the main help article for a vocabulary. The main help article can be set with " { $link POSTPONE: ABOUT:  } "." } ;
diff --git a/basis/help/lint/lint.factor b/basis/help/lint/lint.factor
index 14d3420a68..b12dcaa807 100755
--- a/basis/help/lint/lint.factor
+++ b/basis/help/lint/lint.factor
@@ -1,6 +1,6 @@
 ! Copyright (C) 2006, 2008 Slava Pestov.
 ! See http://factorcode.org/license.txt for BSD license.
-USING: accessors sequences parser kernel help help.markup
+USING: fry accessors sequences parser kernel help help.markup
 help.topics words strings classes tools.vocabs namespaces io
 io.streams.string prettyprint definitions arrays vectors
 combinators combinators.short-circuit splitting debugger
@@ -39,7 +39,7 @@ IN: help.lint
         $predicate
         $class-description
         $error-description
-    } swap [ elements f like ] curry contains? ;
+    } swap '[ , elements empty? not ] contains? ;
 
 : check-values ( word element -- )
     {
@@ -108,12 +108,10 @@ M: help-error error.
     articles get keys
     vocabs [ dup vocab-docs-path swap ] H{ } map>assoc
     H{ } clone [
-        [
-            [ dup >link where dup ] 2dip
-            [ >r >r first r> at r> push-at ] 2curry
-            [ 2drop ]
-            if
-        ] 2curry each
+        '[
+            dup >link where dup
+            [ first , at , push-at ] [ 2drop ] if
+        ] each
     ] keep ;
 
 : check-about ( vocab -- )
diff --git a/basis/help/markup/markup-tests.factor b/basis/help/markup/markup-tests.factor
index 6b138a18ab..222c4e7d3f 100644
--- a/basis/help/markup/markup-tests.factor
+++ b/basis/help/markup/markup-tests.factor
@@ -1,13 +1,13 @@
 USING: definitions help help.markup kernel sequences tools.test
-words parser namespaces assocs generic io.streams.string ;
+words parser namespaces assocs generic io.streams.string accessors ;
 IN: help.markup.tests
 
 TUPLE: blahblah quux ;
 
 [ "an int" ] [ [ { "int" } $instance ] with-string-writer ] unit-test
 
-[ ] [ \ blahblah-quux help ] unit-test
-[ ] [ \ set-blahblah-quux help ] unit-test
+[ ] [ \ quux>> help ] unit-test
+[ ] [ \ >>quux help ] unit-test
 [ ] [ \ blahblah? help ] unit-test
 
 : fooey "fooey" throw ;
diff --git a/basis/help/syntax/syntax-tests.factor b/basis/help/syntax/syntax-tests.factor
index 68306263a5..e7438edd4d 100755
--- a/basis/help/syntax/syntax-tests.factor
+++ b/basis/help/syntax/syntax-tests.factor
@@ -1,5 +1,6 @@
+USING: kernel tools.test parser vocabs help.syntax namespaces
+eval accessors ;
 IN: help.syntax.tests
-USING: tools.test parser vocabs help.syntax namespaces eval ;
 
 [
     [ "foobar" ] [
@@ -12,5 +13,5 @@ USING: tools.test parser vocabs help.syntax namespaces eval ;
         "help.syntax.tests" vocab vocab-help
     ] unit-test
     
-    [ ] [ f "help.syntax.tests" vocab set-vocab-help ] unit-test
+    [ ] [ "help.syntax.tests" vocab f >>help drop ] unit-test
 ] with-file-vocabs
diff --git a/basis/help/topics/topics-docs.factor b/basis/help/topics/topics-docs.factor
index f2f3e8e82f..08195ee07d 100644
--- a/basis/help/topics/topics-docs.factor
+++ b/basis/help/topics/topics-docs.factor
@@ -1,5 +1,6 @@
-USING: help.markup help.syntax help.topics help.crossref help io
-io.styles hashtables ;
+USING: help.markup help.syntax help.crossref help io io.styles
+hashtables strings ;
+IN: help.topics
 
 HELP: articles
 { $var-description "Hashtable mapping article names to " { $link article } " instances." } ;
@@ -14,11 +15,11 @@ HELP: article
 { $description "Outputs a named " { $link article } " object." } ;
 
 HELP: article-title
-{ $values { "article" "an article name or a word" } { "title" "a string" } }
+{ $values { "topic" "an article name or a word" } { "string" string } }
 { $description "Outputs the title of a specific help article." } ;
 
 HELP: article-content
-{ $values { "article" "an article name or a word" } { "content" "a markup element" } }
+{ $values { "topic" "an article name or a word" } { "content" "a markup element" } }
 { $description "Outputs the content of a specific help article." } ;
 
 HELP: all-articles
diff --git a/basis/help/topics/topics-tests.factor b/basis/help/topics/topics-tests.factor
index c52d5e347f..f53bdee9c7 100644
--- a/basis/help/topics/topics-tests.factor
+++ b/basis/help/topics/topics-tests.factor
@@ -1,6 +1,6 @@
-USING: definitions help help.topics help.crossref help.markup
-help.syntax kernel sequences tools.test words parser namespaces
-assocs source-files eval ;
+USING: accessors definitions help help.topics help.crossref
+help.markup help.syntax kernel sequences tools.test words parser
+namespaces assocs source-files eval ;
 IN: help.topics.tests
 
 \ article-name must-infer
@@ -16,7 +16,7 @@ IN: help.topics.tests
 
 SYMBOL: foo
 
-[ ] [ { "test" "a" } "Test A" { { $subsection foo } } <article> add-article ] unit-test
+[ ] [ "Test A" { { $subsection foo } } <article> { "test" "a" } add-article ] unit-test
 
 ! Test article location recording
 
diff --git a/basis/hints/hints-docs.factor b/basis/hints/hints-docs.factor
index e6ca1ff26b..99c4a2ddfc 100644
--- a/basis/hints/hints-docs.factor
+++ b/basis/hints/hints-docs.factor
@@ -12,7 +12,6 @@ $nl
 $nl
 "Type hints are declared with a parsing word:"
 { $subsection POSTPONE: HINTS: }
-$nl
 "The specialized version of a word which will be compiled by the compiler can be inspected:"
 { $subsection specialized-def } ;
 
diff --git a/basis/io/buffers/buffers-tests.factor b/basis/io/buffers/buffers-tests.factor
index 74a1797efc..b3c5c4ee90 100755
--- a/basis/io/buffers/buffers-tests.factor
+++ b/basis/io/buffers/buffers-tests.factor
@@ -4,7 +4,7 @@ sequences tools.test namespaces byte-arrays strings accessors
 destructors ;
 
 : buffer-set ( string buffer -- )
-    over >byte-array over buffer-ptr byte-array>memory
+    over >byte-array over ptr>> byte-array>memory
     >r length r> buffer-reset ;
 
 : string>buffer ( string -- buffer )
diff --git a/basis/io/encodings/ascii/ascii-docs.factor b/basis/io/encodings/ascii/ascii-docs.factor
index 9c9c3a5234..fa496a3526 100644
--- a/basis/io/encodings/ascii/ascii-docs.factor
+++ b/basis/io/encodings/ascii/ascii-docs.factor
@@ -2,5 +2,10 @@ USING: help.markup help.syntax ;
 IN: io.encodings.ascii
 
 HELP: ascii
-{ $class-description "This is the encoding descriptor which denotes an ASCII encoding. By default, if there's a non-ASCII character in an input stream, it will be replaced with a replacement character (U+FFFD), and if a non-ASCII character is used in output, an exception is thrown." }
-{ $see-also "encodings-introduction" } ;
+{ $class-description "ASCII encoding descriptor." } ;
+
+ARTICLE: "ascii" "ASCII encoding"
+"By default, if there's a non-ASCII character in an input stream, it will be replaced with a replacement character (U+FFFD), and if a non-ASCII character is used in output, an exception is thrown."
+{ $subsection ascii } ;
+
+ABOUT: "ascii"
diff --git a/basis/io/encodings/utf16/utf16-docs.factor b/basis/io/encodings/utf16/utf16-docs.factor
index f37a9d1d58..dc499b5ed4 100644
--- a/basis/io/encodings/utf16/utf16-docs.factor
+++ b/basis/io/encodings/utf16/utf16-docs.factor
@@ -1,7 +1,7 @@
 USING: help.markup help.syntax io.encodings strings ;
 IN: io.encodings.utf16
 
-ARTICLE: "io.encodings.utf16" "UTF-16"
+ARTICLE: "io.encodings.utf16" "UTF-16 encoding"
 "The UTF-16 encoding is a variable-width encoding. Unicode code points are encoded as 2 or 4 byte sequences. There are three encoding descriptor classes for working with UTF-16, depending on endianness or the presence of a BOM:"
 { $subsection utf16 }
 { $subsection utf16le }
diff --git a/basis/io/servers/connection/connection-tests.factor b/basis/io/servers/connection/connection-tests.factor
index 84e0d684ac..aa8df0b16c 100755
--- a/basis/io/servers/connection/connection-tests.factor
+++ b/basis/io/servers/connection/connection-tests.factor
@@ -13,7 +13,7 @@ concurrency.promises io.encodings.ascii io threads calendar ;
 ] unit-test
 
 [ t ] [
-    T{ inet4 "1.2.3.4" 1234 } T{ inet4 "1.2.3.5" 1235 }
+    T{ inet4 f "1.2.3.4" 1234 } T{ inet4 f "1.2.3.5" 1235 }
     [ log-connection ] 2keep
     [ remote-address get = ] [ local-address get = ] bi*
     and
diff --git a/basis/io/sockets/sockets.factor b/basis/io/sockets/sockets.factor
index 9968014993..0e49ca86ec 100755
--- a/basis/io/sockets/sockets.factor
+++ b/basis/io/sockets/sockets.factor
@@ -72,8 +72,8 @@ M: inet4 sockaddr-type drop "sockaddr-in" c-type ;
 M: inet4 make-sockaddr ( inet -- sockaddr )
     "sockaddr-in" <c-object>
     AF_INET over set-sockaddr-in-family
-    over inet4-port htons over set-sockaddr-in-port
-    over inet4-host
+    over port>> htons over set-sockaddr-in-port
+    over host>>
     "0.0.0.0" or
     rot inet-pton *uint over set-sockaddr-in-addr ;
 
@@ -134,8 +134,8 @@ M: inet6 sockaddr-type drop "sockaddr-in6" c-type ;
 M: inet6 make-sockaddr ( inet -- sockaddr )
     "sockaddr-in6" <c-object>
     AF_INET6 over set-sockaddr-in6-family
-    over inet6-port htons over set-sockaddr-in6-port
-    over inet6-host "::" or
+    over port>> htons over set-sockaddr-in6-port
+    over host>> "::" or
     rot inet-pton over set-sockaddr-in6-addr ;
 
 M: inet6 parse-sockaddr
diff --git a/basis/io/windows/launcher/launcher.factor b/basis/io/windows/launcher/launcher.factor
index 9442fa9a72..eabd044bb4 100755
--- a/basis/io/windows/launcher/launcher.factor
+++ b/basis/io/windows/launcher/launcher.factor
@@ -6,7 +6,7 @@ windows.types math windows.kernel32
 namespaces io.launcher kernel sequences windows.errors
 splitting system threads init strings combinators
 io.backend accessors concurrency.flags io.files assocs
-io.files.private windows destructors classes.tuple.lib ;
+io.files.private windows destructors ;
 IN: io.windows.launcher
 
 TUPLE: CreateProcess-args
@@ -30,7 +30,19 @@ TUPLE: CreateProcess-args
     0 >>dwCreateFlags ;
 
 : call-CreateProcess ( CreateProcess-args -- )
-    CreateProcess-args >tuple< CreateProcess win32-error=0/f ;
+    {
+        [ lpApplicationName>> ]
+        [ lpCommandLine>> ]
+        [ lpProcessAttributes>> ]
+        [ lpThreadAttributes>> ]
+        [ bInheritHandles>> ]
+        [ dwCreateFlags>> ]
+        [ lpEnvironment>> ]
+        [ lpCurrentDirectory>> ]
+        [ lpStartupInfo>> ]
+        [ lpProcessInformation>> ]
+    } cleave
+    CreateProcess win32-error=0/f ;
 
 : count-trailing-backslashes ( str n -- str n )
     >r "\\" ?tail r> swap [
@@ -139,13 +151,13 @@ M: windows kill-process* ( handle -- )
     swap win32-error=0/f ;
 
 : process-exited ( process -- )
-    dup process-handle exit-code
-    over process-handle dispose-process
+    dup handle>> exit-code
+    over handle>> dispose-process
     notify-exit ;
 
 M: windows wait-for-processes ( -- ? )
     processes get keys dup
-    [ process-handle PROCESS_INFORMATION-hProcess ] map
+    [ handle>> PROCESS_INFORMATION-hProcess ] map
     dup length swap >c-void*-array 0 0
     WaitForMultipleObjects
     dup HEX: ffffffff = [ win32-error ] when
diff --git a/basis/io/windows/nt/backend/backend.factor b/basis/io/windows/nt/backend/backend.factor
index e9df2ddab9..7fbc1dbcf9 100755
--- a/basis/io/windows/nt/backend/backend.factor
+++ b/basis/io/windows/nt/backend/backend.factor
@@ -1,9 +1,8 @@
 USING: alien alien.c-types arrays assocs combinators
 continuations destructors io io.backend io.ports io.timeouts
 io.windows io.windows.files libc kernel math namespaces
-sequences threads classes.tuple.lib windows windows.errors
-windows.kernel32 strings splitting io.files
-io.buffers qualified ascii system
+sequences threads windows windows.errors windows.kernel32
+strings splitting io.files io.buffers qualified ascii system
 accessors locals ;
 QUALIFIED: windows.winsock
 IN: io.windows.nt.backend
diff --git a/basis/io/windows/nt/sockets/sockets.factor b/basis/io/windows/nt/sockets/sockets.factor
index a31c41942f..41c5e88f5f 100755
--- a/basis/io/windows/nt/sockets/sockets.factor
+++ b/basis/io/windows/nt/sockets/sockets.factor
@@ -1,9 +1,8 @@
 USING: alien alien.accessors alien.c-types byte-arrays
 continuations destructors io.ports io.timeouts io.sockets
 io.sockets io namespaces io.streams.duplex io.windows
-io.windows.sockets
-io.windows.nt.backend windows.winsock kernel libc math sequences
-threads classes.tuple.lib system combinators accessors ;
+io.windows.sockets io.windows.nt.backend windows.winsock kernel
+libc math sequences threads system combinators accessors ;
 IN: io.windows.nt.sockets
 
 : malloc-int ( object -- object )
@@ -28,71 +27,89 @@ M: winnt WSASocket-flags ( -- DWORD )
     ] keep *void* ;
 
 TUPLE: ConnectEx-args port
-    s* name* namelen* lpSendBuffer* dwSendDataLength*
-    lpdwBytesSent* lpOverlapped* ptr* ;
+    s name namelen lpSendBuffer dwSendDataLength
+    lpdwBytesSent lpOverlapped ptr ;
 
 : wait-for-socket ( args -- n )
-    [ lpOverlapped*>> ] [ port>> ] bi twiddle-thumbs ;
+    [ lpOverlapped>> ] [ port>> ] bi twiddle-thumbs ; inline
 
 : <ConnectEx-args> ( sockaddr size -- ConnectEx )
     ConnectEx-args new
-        swap >>namelen*
-        swap >>name*
-        f >>lpSendBuffer*
-        0 >>dwSendDataLength*
-        f >>lpdwBytesSent*
-        (make-overlapped) >>lpOverlapped* ;
+        swap >>namelen
+        swap >>name
+        f >>lpSendBuffer
+        0 >>dwSendDataLength
+        f >>lpdwBytesSent
+        (make-overlapped) >>lpOverlapped ; inline
 
 : call-ConnectEx ( ConnectEx -- )
-    ConnectEx-args >tuple*<
+    {
+        [ s>> ]
+        [ name>> ]
+        [ namelen>> ]
+        [ lpSendBuffer>> ]
+        [ dwSendDataLength>> ]
+        [ lpdwBytesSent>> ]
+        [ lpOverlapped>> ]
+        [ ptr>> ]
+    } cleave
     "int"
     { "SOCKET" "sockaddr_in*" "int" "PVOID" "DWORD" "LPDWORD" "void*" }
     "stdcall" alien-indirect drop
-    winsock-error-string [ throw ] when* ;
+    winsock-error-string [ throw ] when* ; inline
 
 M: object establish-connection ( client-out remote -- )
     make-sockaddr/size <ConnectEx-args>
         swap >>port
-        dup port>> handle>> handle>> >>s*
-        dup s*>> get-ConnectEx-ptr >>ptr*
+        dup port>> handle>> handle>> >>s
+        dup s>> get-ConnectEx-ptr >>ptr
         dup call-ConnectEx
         wait-for-socket drop ;
 
 TUPLE: AcceptEx-args port
-    sListenSocket* sAcceptSocket* lpOutputBuffer* dwReceiveDataLength*
-    dwLocalAddressLength* dwRemoteAddressLength* lpdwBytesReceived* lpOverlapped* ;
+    sListenSocket sAcceptSocket lpOutputBuffer dwReceiveDataLength
+    dwLocalAddressLength dwRemoteAddressLength lpdwBytesReceived lpOverlapped ;
 
 : init-accept-buffer ( addr AcceptEx -- )
     swap sockaddr-type heap-size 16 +
-        [ >>dwLocalAddressLength* ] [ >>dwRemoteAddressLength* ] bi
-        dup dwLocalAddressLength*>> 2 * malloc &free >>lpOutputBuffer*
-        drop ;
+        [ >>dwLocalAddressLength ] [ >>dwRemoteAddressLength ] bi
+        dup dwLocalAddressLength>> 2 * malloc &free >>lpOutputBuffer
+        drop ; inline
 
 : <AcceptEx-args> ( server addr -- AcceptEx )
     AcceptEx-args new
         2dup init-accept-buffer
-        swap SOCK_STREAM open-socket |dispose handle>> >>sAcceptSocket*
-        over handle>> handle>> >>sListenSocket*
+        swap SOCK_STREAM open-socket |dispose handle>> >>sAcceptSocket
+        over handle>> handle>> >>sListenSocket
         swap >>port
-        0 >>dwReceiveDataLength*
-        f >>lpdwBytesReceived*
-        (make-overlapped) >>lpOverlapped* ;
+        0 >>dwReceiveDataLength
+        f >>lpdwBytesReceived
+        (make-overlapped) >>lpOverlapped ; inline
 
 : call-AcceptEx ( AcceptEx -- )
-    AcceptEx-args >tuple*< AcceptEx drop
-    winsock-error-string [ throw ] when* ;
+    {
+        [ sListenSocket>> ]
+        [ sAcceptSocket>> ]
+        [ lpOutputBuffer>> ]
+        [ dwReceiveDataLength>> ]
+        [ dwLocalAddressLength>> ]
+        [ dwRemoteAddressLength>> ]
+        [ lpdwBytesReceived>> ]
+        [ lpOverlapped>> ]
+    } cleave AcceptEx drop
+    winsock-error-string [ throw ] when* ; inline
 
 : extract-remote-address ( AcceptEx -- sockaddr )
     {
-        [ lpOutputBuffer*>> ]
-        [ dwReceiveDataLength*>> ]
-        [ dwLocalAddressLength*>> ]
-        [ dwRemoteAddressLength*>> ]
+        [ lpOutputBuffer>> ]
+        [ dwReceiveDataLength>> ]
+        [ dwLocalAddressLength>> ]
+        [ dwRemoteAddressLength>> ]
     } cleave
     f <void*>
     0 <int>
     f <void*>
-    [ 0 <int> GetAcceptExSockaddrs ] keep *void* ;
+    [ 0 <int> GetAcceptExSockaddrs ] keep *void* ; inline
 
 M: object (accept) ( server addr -- handle sockaddr )
     [
@@ -100,39 +117,49 @@ M: object (accept) ( server addr -- handle sockaddr )
         {
             [ call-AcceptEx ]
             [ wait-for-socket drop ]
-            [ sAcceptSocket*>> <win32-socket> ]
+            [ sAcceptSocket>> <win32-socket> ]
             [ extract-remote-address ]
         } cleave
     ] with-destructors ;
 
 TUPLE: WSARecvFrom-args port
-       s* lpBuffers* dwBufferCount* lpNumberOfBytesRecvd*
-       lpFlags* lpFrom* lpFromLen* lpOverlapped* lpCompletionRoutine* ;
+       s lpBuffers dwBufferCount lpNumberOfBytesRecvd
+       lpFlags lpFrom lpFromLen lpOverlapped lpCompletionRoutine ;
 
 : make-receive-buffer ( -- WSABUF )
     "WSABUF" malloc-object &free
     default-buffer-size get over set-WSABUF-len
-    default-buffer-size get malloc &free over set-WSABUF-buf ;
+    default-buffer-size get malloc &free over set-WSABUF-buf ; inline
 
 : <WSARecvFrom-args> ( datagram -- WSARecvFrom )
     WSARecvFrom-args new
         swap >>port
-        dup port>> handle>> handle>> >>s*
+        dup port>> handle>> handle>> >>s
         dup port>> addr>> sockaddr-type heap-size
-            [ malloc &free >>lpFrom* ]
-            [ malloc-int &free >>lpFromLen* ] bi
-        make-receive-buffer >>lpBuffers*
-        1 >>dwBufferCount*
-        0 malloc-int &free >>lpFlags*
-        0 malloc-int &free >>lpNumberOfBytesRecvd*
-        (make-overlapped) >>lpOverlapped* ;
+            [ malloc &free >>lpFrom ]
+            [ malloc-int &free >>lpFromLen ] bi
+        make-receive-buffer >>lpBuffers
+        1 >>dwBufferCount
+        0 malloc-int &free >>lpFlags
+        0 malloc-int &free >>lpNumberOfBytesRecvd
+        (make-overlapped) >>lpOverlapped ; inline
 
 : call-WSARecvFrom ( WSARecvFrom -- )
-    WSARecvFrom-args >tuple*< WSARecvFrom socket-error* ;
+    {
+        [ s>> ]
+        [ lpBuffers>> ]
+        [ dwBufferCount>> ]
+        [ lpNumberOfBytesRecvd>> ]
+        [ lpFlags>> ]
+        [ lpFrom>> ]
+        [ lpFromLen>> ]
+        [ lpOverlapped>> ]
+        [ lpCompletionRoutine>> ]
+    } cleave WSARecvFrom socket-error* ; inline
 
 : parse-WSARecvFrom ( n WSARecvFrom -- packet sockaddr )
-    [ lpBuffers*>> WSABUF-buf swap memory>byte-array ]
-    [ [ lpFrom*>> ] [ lpFromLen*>> *int ] bi memory>byte-array ] bi ;
+    [ lpBuffers>> WSABUF-buf swap memory>byte-array ]
+    [ [ lpFrom>> ] [ lpFromLen>> *int ] bi memory>byte-array ] bi ; inline
 
 M: winnt (receive) ( datagram -- packet addrspec )
     [
@@ -144,31 +171,41 @@ M: winnt (receive) ( datagram -- packet addrspec )
     ] with-destructors ;
 
 TUPLE: WSASendTo-args port
-       s* lpBuffers* dwBufferCount* lpNumberOfBytesSent*
-       dwFlags* lpTo* iToLen* lpOverlapped* lpCompletionRoutine* ;
+       s lpBuffers dwBufferCount lpNumberOfBytesSent
+       dwFlags lpTo iToLen lpOverlapped lpCompletionRoutine ;
 
 : make-send-buffer ( packet -- WSABUF )
     "WSABUF" malloc-object &free
     [ >r malloc-byte-array &free r> set-WSABUF-buf ]
     [ >r length r> set-WSABUF-len ]
     [ nip ]
-    2tri ;
+    2tri ; inline
 
 : <WSASendTo-args> ( packet addrspec datagram -- WSASendTo )
     WSASendTo-args new
         swap >>port
-        dup port>> handle>> handle>> >>s*
+        dup port>> handle>> handle>> >>s
         swap make-sockaddr/size
             >r malloc-byte-array &free
-            r> [ >>lpTo* ] [ >>iToLen* ] bi*
-        swap make-send-buffer >>lpBuffers*
-        1 >>dwBufferCount*
-        0 >>dwFlags*
-        0 <uint> >>lpNumberOfBytesSent*
-        (make-overlapped) >>lpOverlapped* ;
+            r> [ >>lpTo ] [ >>iToLen ] bi*
+        swap make-send-buffer >>lpBuffers
+        1 >>dwBufferCount
+        0 >>dwFlags
+        0 <uint> >>lpNumberOfBytesSent
+        (make-overlapped) >>lpOverlapped ; inline
 
 : call-WSASendTo ( WSASendTo -- )
-    WSASendTo-args >tuple*< WSASendTo socket-error* ;
+    {
+        [ s>> ]
+        [ lpBuffers>> ]
+        [ dwBufferCount>> ]
+        [ lpNumberOfBytesSent>> ]
+        [ dwFlags>> ]
+        [ lpTo>> ]
+        [ iToLen>> ]
+        [ lpOverlapped>> ]
+        [ lpCompletionRoutine>> ]
+    } cleave WSASendTo socket-error* ; inline
 
 M: winnt (send) ( packet addrspec datagram -- )
     [
diff --git a/basis/macros/expander/expander.factor b/basis/macros/expander/expander.factor
index f538412937..0a1703de58 100644
--- a/basis/macros/expander/expander.factor
+++ b/basis/macros/expander/expander.factor
@@ -32,8 +32,8 @@ M: wrapper expand-macros* wrapped>> literal ;
     stack get pop >quotation end (expand-macros) ;
 
 : expand-macro? ( word -- quot ? )
-    dup [ "macro" word-prop ] [ +transform-quot+ word-prop ] bi or dup [
-        swap [ stack-effect in>> length ] [ +transform-n+ word-prop ] bi or
+    dup [ "macro" word-prop ] [ "transform-quot" word-prop ] bi or dup [
+        swap [ stack-effect in>> length ] [ "transform-n" word-prop ] bi or
         stack get length <=
     ] [ 2drop f f ] if ;
 
diff --git a/basis/math/complex/complex-docs.factor b/basis/math/complex/complex-docs.factor
index d723d55cb3..bed3a655b1 100755
--- a/basis/math/complex/complex-docs.factor
+++ b/basis/math/complex/complex-docs.factor
@@ -2,18 +2,24 @@ USING: help.markup help.syntax math math.private math.functions
 math.complex.private ;
 IN: math.complex
 
+ARTICLE: "complex-numbers-zero" "Embedding of real numbers in complex numbers"
+"Constructing a complex number with an imaginary component equal to an integer zero simply returns the real number corresponding to the real component:"
+{ $example "USING: math prettyprint ;" "C{ 1 2 } C{ 3 -2 } + ." "4" }
+"Constructing a complex number with an imaginary component equal to floating point zero will still output a new complex number, however:"
+{ $example "USING: math prettyprint ;" "C{ 0.0 2.0 } C{ 0.0 1.0 } * ." "C{ 2.0 0.0 }" }
+"Unlike math, where all real numbers are also complex numbers, Factor only considers a number to be a complex number if its imaginary part is non-zero. However, complex number operations are fully supported for real numbers; they are treated as having an imaginary part of zero." ;
+
 ARTICLE: "complex-numbers" "Complex numbers"
 { $subsection complex }
 "Complex numbers arise as solutions to quadratic equations whose graph does not intersect the " { $emphasis "x" } " axis. Their literal syntax is covered in " { $link "syntax-complex-numbers" } "."
 $nl
-"Unlike math, where all real numbers are also complex numbers, Factor only considers a number to be a complex number if its imaginary part is non-zero. However, complex number operations are fully supported for real numbers; they are treated as having an imaginary part of zero."
-$nl
 "Complex numbers can be taken apart:"
 { $subsection real-part }
 { $subsection imaginary-part }
 { $subsection >rect }
 "Complex numbers can be constructed from real numbers:"
 { $subsection rect> }
+{ $subsection "complex-numbers-zero" }
 { $see-also "syntax-complex-numbers" } ;
 HELP: complex
 { $class-description "The class of complex numbers with non-zero imaginary part." } ;
diff --git a/basis/math/complex/complex-tests.factor b/basis/math/complex/complex-tests.factor
index 063871ce5b..4b0481eca1 100755
--- a/basis/math/complex/complex-tests.factor
+++ b/basis/math/complex/complex-tests.factor
@@ -5,9 +5,14 @@ IN: math.complex.tests
 [ 1 C{ 0 1 } rect> ] must-fail
 [ C{ 0 1 } 1 rect> ] must-fail
 
-[ f ] [ C{ 5 12.5 } 5  = ] unit-test
-[ t ] [ C{ 1.0 2.0 } C{ 1 2 }  = ] unit-test
-[ f ] [ C{ 1.0 2.3 } C{ 1 2 }  = ] unit-test
+[ f ] [ C{ 5 12.5 } 5 = ] unit-test
+[ f ] [ C{ 5 12.5 } 5 number= ] unit-test
+
+[ f ] [ C{ 1.0 2.0 } C{ 1 2 } = ] unit-test
+[ t ] [ C{ 1.0 2.0 } C{ 1 2 } number= ] unit-test
+
+[ f ] [ C{ 1.0 2.3 } C{ 1 2 } = ] unit-test
+[ f ] [ C{ 1.0 2.3 } C{ 1 2 } number= ] unit-test
 
 [ C{ 2 5 } ] [ 2 5  rect> ] unit-test
 [ 2 5 ] [ C{ 2 5 }  >rect ] unit-test
@@ -30,7 +35,7 @@ IN: math.complex.tests
 
 [ C{ 0 1 } ] [ C{ 0 1 } 1  * ] unit-test
 [ C{ 0 1 } ] [ 1 C{ 0 1 }  * ] unit-test
-[ C{ 0 1.0 } ] [ 1.0 C{ 0 1 }  * ] unit-test
+[ C{ 0.0 1.0 } ] [ 1.0 C{ 0 1 }  * ] unit-test
 [ -1 ] [ C{ 0 1 } C{ 0 1 }  * ] unit-test
 [ C{ 0 1 } ] [ 1 C{ 0 1 }  * ] unit-test
 [ C{ 0 1 } ] [ C{ 0 1 } 1  * ] unit-test
@@ -45,18 +50,18 @@ IN: math.complex.tests
 
 [ C{ -3 4 } ] [ C{ 3 -4 }  neg ] unit-test
 
-[ 5 ] [ C{ 3 4 } abs ] unit-test
-[ 5 ] [ -5.0 abs ] unit-test
+[ 5.0 ] [ C{ 3 4 } abs ] unit-test
+[ 5.0 ] [ -5.0 abs ] unit-test
 
 ! Make sure arguments are sane
-[ 0 ] [ 0 arg ] unit-test
-[ 0 ] [ 1 arg ] unit-test
+[ 0.0 ] [ 0 arg ] unit-test
+[ 0.0 ] [ 1 arg ] unit-test
 [ t ] [ -1 arg 3.14 3.15 between? ] unit-test
 [ t ] [ C{ 0 1 } arg 1.57 1.58 between? ] unit-test
 [ t ] [ C{ 0 -1 } arg -1.58 -1.57 between? ] unit-test
 
-[ 1 0 ] [ 1 >polar ] unit-test
-[ 1 ] [ -1 >polar drop ] unit-test
+[ 1.0 0.0 ] [ 1 >polar ] unit-test
+[ 1.0 ] [ -1 >polar drop ] unit-test
 [ t ] [ -1 >polar nip 3.14 3.15 between? ] unit-test
 
 ! I broke something
diff --git a/basis/math/complex/complex.factor b/basis/math/complex/complex.factor
index cef0676d12..ff5c0feb78 100755
--- a/basis/math/complex/complex.factor
+++ b/basis/math/complex/complex.factor
@@ -17,6 +17,14 @@ M: complex absq >rect [ sq ] bi@ + ;
     [ [ real-part ] bi@ ] 2keep
     [ imaginary-part ] bi@ ; inline
 
+M: complex hashcode*
+    nip >rect [ hashcode ] bi@ bitxor ;
+
+M: complex equal?
+    over complex? [
+        2>rect = [ = ] [ 2drop f ] if
+    ] [ 2drop f ] if ;
+
 M: complex number=
     2>rect number= [ number= ] [ 2drop f ] if ;
 
@@ -36,8 +44,6 @@ M: complex abs absq >float fsqrt ;
 
 M: complex sqrt >polar swap fsqrt swap 2.0 / polar> ;
 
-M: complex hashcode* nip >rect >fixnum swap >fixnum bitxor ;
-
 IN: syntax
 
 : C{ \ } [ first2 rect> ] parse-literal ; parsing
diff --git a/basis/math/functions/functions-docs.factor b/basis/math/functions/functions-docs.factor
index c023258105..bbfd8f41be 100755
--- a/basis/math/functions/functions-docs.factor
+++ b/basis/math/functions/functions-docs.factor
@@ -106,7 +106,7 @@ HELP: (rect>)
 
 HELP: rect>
 { $values { "x" real } { "y" real } { "z" number } }
-{ $description "Creates a complex number from real and imaginary components." } ;
+{ $description "Creates a complex number from real and imaginary components. If " { $snippet "z" } " is an integer zero, this will simply output " { $snippet "x" } "." } ;
 
 HELP: >rect
 { $values { "z" number } { "x" real } { "y" real } }
diff --git a/basis/math/functions/functions-tests.factor b/basis/math/functions/functions-tests.factor
index f2d26e330d..d5bdac761f 100755
--- a/basis/math/functions/functions-tests.factor
+++ b/basis/math/functions/functions-tests.factor
@@ -12,10 +12,11 @@ IN: math.functions.tests
 [ 0.25 ] [ 2.0 -2.0 fpow ] unit-test
 
 [ 4.0 ] [ 16 sqrt ] unit-test
-[ C{ 0 4.0 } ] [ -16 sqrt ] unit-test
+[ 2.0 ] [ 4.0 0.5 ^ ] unit-test
+[ C{ 0.0 4.0 } ] [ -16 sqrt ] unit-test
 
-[ 4.0 ] [ 2 2 ^ ] unit-test
-[ 0.25 ] [ 2 -2 ^ ] unit-test
+[ 4 ] [ 2 2 ^ ] unit-test
+[ 1/4 ] [ 2 -2 ^ ] unit-test
 [ t ] [ 2 0.5 ^ 2 ^ 2 2.00001 between? ] unit-test
 [ t ] [ e pi i* ^ real-part -1.0 = ] unit-test
 [ t ] [ e pi i* ^ imaginary-part -0.00001 0.00001 between? ] unit-test
@@ -27,6 +28,8 @@ IN: math.functions.tests
 [ 0 ] [ 0 3.0 ^ ] unit-test
 [ 0 ] [ 0 3 ^ ] unit-test
 
+[ 0.0 ] [ 1 log ] unit-test
+
 [ 1.0 ] [ 0 cosh ] unit-test
 [ 0.0 ] [ 1 acosh ] unit-test
             
diff --git a/basis/math/functions/functions.factor b/basis/math/functions/functions.factor
index 4d71b25174..8516292e9d 100755
--- a/basis/math/functions/functions.factor
+++ b/basis/math/functions/functions.factor
@@ -7,7 +7,7 @@ IN: math.functions
 <PRIVATE
 
 : (rect>) ( x y -- z )
-    dup zero? [ drop ] [ <complex> ] if ; inline
+    dup 0 = [ drop ] [ <complex> ] if ; inline
 
 PRIVATE>
 
@@ -24,29 +24,57 @@ M: real sqrt
     >float dup 0.0 < [ neg fsqrt 0.0 swap rect> ] [ fsqrt ] if ;
 
 : each-bit ( n quot: ( ? -- ) -- )
-    over 0 number= pick -1 number= or [
+    over 0 = pick -1 = or [
         2drop
     ] [
         2dup >r >r >r odd? r> call r> 2/ r> each-bit
     ] if ; inline recursive
 
-GENERIC: (^) ( x y -- z ) foldable
-
 : ^n ( z w -- z^w )
     1 swap [
         [ dupd * ] when >r sq r>
     ] each-bit nip ; inline
 
-M: integer (^)
-    dup 0 < [ neg ^n recip ] [ ^n ] if ;
+: integer^ ( x y -- z )
+    dup 0 > [ ^n ] [ neg ^n recip ] if ; inline
+
+: >rect ( z -- x y )
+    [ real-part ] [ imaginary-part ] bi ; inline
+
+: >float-rect ( z -- x y )
+    >rect [ >float ] bi@ ; inline
+
+: >polar ( z -- abs arg )
+    >float-rect [ [ sq ] bi@ + fsqrt ] [ swap fatan2 ] 2bi ;
+    inline
+
+: cis ( arg -- z ) dup fcos swap fsin rect> ; inline
+
+: polar> ( abs arg -- z ) cis * ; inline
+
+: ^mag ( w abs arg -- magnitude )
+    >r >r >float-rect swap r> swap fpow r> rot * fexp /f ;
+    inline
+
+: ^theta ( w abs arg -- theta )
+    >r >r >float-rect r> flog * swap r> * + ; inline
+
+: ^complex ( x y -- z )
+    swap >polar [ ^mag ] [ ^theta ] 3bi polar> ; inline
+
+: real^? ( x y -- ? )
+    2dup [ real? ] both? [ drop 0 >= ] [ 2drop f ] if ; inline
+
+: 0^ ( x -- z )
+    dup zero? [ drop 0./0. ] [ 0 < 1./0. 0 ? ] if ; inline
 
 : ^ ( x y -- z )
-    over zero? [
-        dup zero?
-        [ 2drop 0.0 0.0 / ] [ 0 < [ drop 1.0 0.0 / ] when ] if
-    ] [
-        (^)
-    ] if ; inline
+    {
+        { [ over zero? ] [ nip 0^ ] }
+        { [ dup integer? ] [ integer^ ] }
+        { [ 2dup real^? ] [ fpow ] }
+        [ ^complex ]
+    } cond ;
 
 : (^mod) ( n x y -- z )
     1 swap [
@@ -98,42 +126,27 @@ M: real absq sq ;
         [ ~abs ]
     } cond ;
 
-: >rect ( z -- x y ) dup real-part swap imaginary-part ; inline
-
 : conjugate ( z -- z* ) >rect neg rect> ; inline
 
-: >float-rect ( z -- x y )
-    >rect swap >float swap >float ; inline
-
 : arg ( z -- arg ) >float-rect swap fatan2 ; inline
 
-: >polar ( z -- abs arg )
-    >float-rect [ [ sq ] bi@ + fsqrt ] 2keep swap fatan2 ;
-    inline
-
-: cis ( arg -- z ) dup fcos swap fsin rect> ; inline
-
-: polar> ( abs arg -- z ) cis * ; inline
-
-: ^mag ( w abs arg -- magnitude )
-    >r >r >float-rect swap r> swap fpow r> rot * fexp /f ;
-    inline
-
-: ^theta ( w abs arg -- theta )
-    >r >r >float-rect r> flog * swap r> * + ; inline
-
-M: number (^)
-    swap >polar 3dup ^theta >r ^mag r> polar> ;
-
 : [-1,1]? ( x -- ? )
     dup complex? [ drop f ] [ abs 1 <= ] if ; inline
 
 : >=1? ( x -- ? )
     dup complex? [ drop f ] [ 1 >= ] if ; inline
 
-: exp ( x -- y ) >rect swap fexp swap polar> ; inline
+GENERIC: exp ( x -- y )
 
-: log ( x -- y ) >polar swap flog swap rect> ; inline
+M: real exp fexp ;
+
+M: complex exp >rect swap fexp swap polar> ;
+
+GENERIC: log ( x -- y )
+
+M: real log dup 0.0 >= [ flog ] [ 0.0 rect> log ] if ;
+
+M: complex log >polar swap flog swap rect> ;
 
 : cos ( x -- y )
     dup complex? [
diff --git a/basis/math/geometry/rect/rect-docs.factor b/basis/math/geometry/rect/rect-docs.factor
index 3e21dfe307..a892940363 100644
--- a/basis/math/geometry/rect/rect-docs.factor
+++ b/basis/math/geometry/rect/rect-docs.factor
@@ -17,11 +17,6 @@ HELP: <rect> ( loc dim -- rect )
 
 { <zero-rect> <rect> <extent-rect> } related-words
 
-HELP: set-rect-dim ( dim rect -- )
-{ $values { "dim" "a pair of integers" } { "rect" rect } }
-{ $description "Modifies the dimensions of a rectangle." }
-{ $side-effects "rect" } ;
-
 HELP: rect-bounds
 { $values { "rect" rect } { "loc" "a pair of integers" } { "dim" "a pair of integers" } }
 { $description "Outputs the location and dimensions of a rectangle." } ;
diff --git a/basis/math/geometry/rect/rect.factor b/basis/math/geometry/rect/rect.factor
index 7f0bb94092..dd634f4a3b 100644
--- a/basis/math/geometry/rect/rect.factor
+++ b/basis/math/geometry/rect/rect.factor
@@ -7,6 +7,9 @@ IN: math.geometry.rect
 
 TUPLE: rect loc dim ;
 
+GENERIC: rect-loc ( obj -- loc )
+GENERIC: rect-dim ( obj -- dim )
+
 : init-rect ( rect -- rect ) { 0 0 } clone >>loc { 0 0 } clone >>dim ;
 
 : <rect> ( loc dim -- rect ) rect boa ;
@@ -17,6 +20,10 @@ M: array rect-loc ;
 
 M: array rect-dim drop { 0 0 } ;
 
+M: rect rect-loc loc>> ;
+
+M: rect rect-dim dim>> ;
+
 : rect-bounds ( rect -- loc dim ) dup rect-loc swap rect-dim ;
 
 : rect-extent ( rect -- loc ext ) rect-bounds over v+ ;
diff --git a/basis/math/intervals/intervals-tests.factor b/basis/math/intervals/intervals-tests.factor
index 806b0961ca..7d8d496737 100755
--- a/basis/math/intervals/intervals-tests.factor
+++ b/basis/math/intervals/intervals-tests.factor
@@ -60,11 +60,11 @@ IN: math.intervals.tests
 ] unit-test
 
 [ t ] [
-    1 2 [a,b] -0.5 0.5 [a,b] interval* -1 1 [a,b] =
+    1 2 [a,b] -0.5 0.5 [a,b] interval* -1.0 1.0 [a,b] =
 ] unit-test
 
 [ t ] [
-    1 2 [a,b] -0.5 0.5 (a,b] interval* -1 1 (a,b] =
+    1 2 [a,b] -0.5 0.5 (a,b] interval* -1.0 1.0 (a,b] =
 ] unit-test
 
 [ t ] [
@@ -131,7 +131,7 @@ IN: math.intervals.tests
 
 "math.ratios.private" vocab [
     [ t ] [
-        -1 1 (a,b) 0.5 1 (a,b) interval/ -2 2 (a,b) =
+        -1 1 (a,b) 0.5 1 (a,b) interval/ -2.0 2.0 (a,b) =
     ] unit-test
 ] when
 
diff --git a/extra/math/points/points.factor b/basis/math/points/points.factor
similarity index 100%
rename from extra/math/points/points.factor
rename to basis/math/points/points.factor
diff --git a/basis/math/ratios/ratios-tests.factor b/basis/math/ratios/ratios-tests.factor
index 28801fa2e9..c01e7377b2 100755
--- a/basis/math/ratios/ratios-tests.factor
+++ b/basis/math/ratios/ratios-tests.factor
@@ -81,8 +81,8 @@ unit-test
 [ -1/2 ] [ 1/2 1- ] unit-test
 [ 3/2 ] [ 1/2 1+ ] unit-test
 
-[ 1 ] [ 0.5 1/2 + ] unit-test
-[ 1 ] [ 1/2 0.5 + ] unit-test
+[ 1.0 ] [ 0.5 1/2 + ] unit-test
+[ 1.0 ] [ 1/2 0.5 + ] unit-test
 
 [ 1/268435456 ] [ -1 -268435456 >fixnum / ] unit-test
 [ 268435456 ] [ -268435456 >fixnum -1 / ] unit-test
diff --git a/basis/math/ratios/ratios.factor b/basis/math/ratios/ratios.factor
index 6569ee9540..5dde4fbb99 100755
--- a/basis/math/ratios/ratios.factor
+++ b/basis/math/ratios/ratios.factor
@@ -30,6 +30,14 @@ M: integer /
         2dup gcd nip tuck /i >r /i r> fraction>
     ] if ;
 
+M: ratio hashcode*
+    nip >fraction [ hashcode ] bi@ bitxor ;
+
+M: ratio equal?
+    over ratio? [
+        2>fraction = [ = ] [ 2drop f ] if
+    ] [ 2drop f ] if ;
+
 M: ratio number=
     2>fraction number= [ number= ] [ 2drop f ] if ;
 
diff --git a/basis/mirrors/mirrors-docs.factor b/basis/mirrors/mirrors-docs.factor
index 55896a9811..d6a8d51fbe 100755
--- a/basis/mirrors/mirrors-docs.factor
+++ b/basis/mirrors/mirrors-docs.factor
@@ -30,7 +30,7 @@ HELP: <mirror> ( object -- mirror )
         "TUPLE: circle center radius ;"
         "C: <circle> circle"
         "{ 100 50 } 15 <circle> <mirror> >alist ."
-        "{ { \"delegate\" f } { \"center\" { 100 50 } } { \"radius\" 15 } }"
+        "{ { \"center\" { 100 50 } } { \"radius\" 15 } }"
     }
 } ;
 
diff --git a/basis/mirrors/mirrors-tests.factor b/basis/mirrors/mirrors-tests.factor
index 2eda136ae5..aad033600a 100755
--- a/basis/mirrors/mirrors-tests.factor
+++ b/basis/mirrors/mirrors-tests.factor
@@ -6,16 +6,16 @@ TUPLE: foo bar baz ;
 
 C: <foo> foo
 
-[ 3 ] [ 1 2 <foo> <mirror> assoc-size ] unit-test
+[ 2 ] [ 1 2 <foo> <mirror> assoc-size ] unit-test
 
-[ { "delegate" "bar" "baz" } ] [ 1 2 <foo> <mirror> keys ] unit-test
+[ { "bar" "baz" } ] [ 1 2 <foo> <mirror> keys ] unit-test
 
 [ 1 t ] [ "bar" 1 2 <foo> <mirror> at* ] unit-test
 
 [ f f ] [ "hi" 1 2 <foo> <mirror> at* ] unit-test
 
 [ 3 ] [
-    3 "baz" 1 2 <foo> [ <mirror> set-at ] keep foo-baz
+    3 "baz" 1 2 <foo> [ <mirror> set-at ] keep baz>>
 ] unit-test
 
 [ 3 "hi" 1 2 <foo> <mirror> set-at ] must-fail
diff --git a/basis/models/compose/compose-tests.factor b/basis/models/compose/compose-tests.factor
index 25ba001d5d..16a5ab339c 100755
--- a/basis/models/compose/compose-tests.factor
+++ b/basis/models/compose/compose-tests.factor
@@ -1,6 +1,6 @@
-IN: models.compose.tests
 USING: arrays generic kernel math models namespaces sequences assocs
-tools.test models.compose ;
+tools.test models.compose accessors ;
+IN: models.compose.tests
 
 ! Test compose
 [ ] [
@@ -11,14 +11,14 @@ tools.test models.compose ;
 
 [ ] [ "c" get activate-model ] unit-test
 
-[ { 1 2 } ] [ "c" get model-value ] unit-test
+[ { 1 2 } ] [ "c" get value>> ] unit-test
 
 [ ] [ 3 "b" get set-model ] unit-test
 
-[ { 1 3 } ] [ "c" get model-value ] unit-test
+[ { 1 3 } ] [ "c" get value>> ] unit-test
 
 [ ] [ { 4 5 } "c" get set-model ] unit-test
 
-[ { 4 5 } ] [ "c" get model-value ] unit-test
+[ { 4 5 } ] [ "c" get value>> ] unit-test
 
 [ ] [ "c" get deactivate-model ] unit-test
diff --git a/basis/models/compose/compose.factor b/basis/models/compose/compose.factor
index 015986fad0..a2c3385248 100755
--- a/basis/models/compose/compose.factor
+++ b/basis/models/compose/compose.factor
@@ -18,12 +18,12 @@ TUPLE: compose < model ;
 
 M: compose model-changed
     nip
-    [ [ model-value ] composed-value ] keep set-model ;
+    [ [ value>> ] composed-value ] keep set-model ;
 
 M: compose model-activated dup model-changed ;
 
 M: compose update-model
-    dup model-value swap [ set-model ] set-composed-value ;
+    dup value>> swap [ set-model ] set-composed-value ;
 
 M: compose range-value
     [ range-value ] composed-value ;
diff --git a/basis/models/filter/filter-tests.factor b/basis/models/filter/filter-tests.factor
index bdf3273fae..ad43568e06 100755
--- a/basis/models/filter/filter-tests.factor
+++ b/basis/models/filter/filter-tests.factor
@@ -1,18 +1,18 @@
-IN: models.filter.tests
 USING: arrays generic kernel math models namespaces sequences assocs
-tools.test models.filter ;
+tools.test models.filter accessors ;
+IN: models.filter.tests
 
 ! Test multiple filters
 3 <model> "x" set
 "x" get [ 2 * ] <filter> dup "z" set
 [ 1+ ] <filter> "y" set
 [ ] [ "y" get activate-model ] unit-test
-[ t ] [ "z" get "x" get model-connections memq? ] unit-test
-[ 7 ] [ "y" get model-value ] unit-test
+[ t ] [ "z" get "x" get connections>> memq? ] unit-test
+[ 7 ] [ "y" get value>> ] unit-test
 [ ] [ 4 "x" get set-model ] unit-test
-[ 9 ] [ "y" get model-value ] unit-test
+[ 9 ] [ "y" get value>> ] unit-test
 [ ] [ "y" get deactivate-model ] unit-test
-[ f ] [ "z" get "x" get model-connections memq? ] unit-test
+[ f ] [ "z" get "x" get connections>> memq? ] unit-test
 
 3 <model> "x" set
 "x" get [ sq ] <filter> "y" set
@@ -20,5 +20,5 @@ tools.test models.filter ;
 4 "x" get set-model
 
 "y" get activate-model
-[ 16 ] [ "y" get model-value ] unit-test
+[ 16 ] [ "y" get value>> ] unit-test
 "y" get deactivate-model
diff --git a/basis/models/history/history-tests.factor b/basis/models/history/history-tests.factor
index 40d1176667..c89dd5c5b3 100755
--- a/basis/models/history/history-tests.factor
+++ b/basis/models/history/history-tests.factor
@@ -1,37 +1,37 @@
-IN: models.history.tests
 USING: arrays generic kernel math models namespaces sequences assocs
-tools.test models.history ;
+tools.test models.history accessors ;
+IN: models.history.tests
 
 f <history> "history" set
 
 "history" get add-history
 
-[ t ] [ "history" get history-back empty? ] unit-test
-[ t ] [ "history" get history-forward empty? ] unit-test
+[ t ] [ "history" get back>> empty? ] unit-test
+[ t ] [ "history" get forward>> empty? ] unit-test
 
 "history" get add-history
 3 "history" get set-model
 
-[ t ] [ "history" get history-back empty? ] unit-test
-[ t ] [ "history" get history-forward empty? ] unit-test
+[ t ] [ "history" get back>> empty? ] unit-test
+[ t ] [ "history" get forward>> empty? ] unit-test
 
 "history" get add-history
 4 "history" get set-model
 
-[ f ] [ "history" get history-back empty? ] unit-test
-[ t ] [ "history" get history-forward empty? ] unit-test
+[ f ] [ "history" get back>> empty? ] unit-test
+[ t ] [ "history" get forward>> empty? ] unit-test
 
 "history" get go-back
 
-[ 3 ] [ "history" get model-value ] unit-test
+[ 3 ] [ "history" get value>> ] unit-test
 
-[ t ] [ "history" get history-back empty? ] unit-test
-[ f ] [ "history" get history-forward empty? ] unit-test
+[ t ] [ "history" get back>> empty? ] unit-test
+[ f ] [ "history" get forward>> empty? ] unit-test
 
 "history" get go-forward
 
-[ 4 ] [ "history" get model-value ] unit-test
+[ 4 ] [ "history" get value>> ] unit-test
 
-[ f ] [ "history" get history-back empty? ] unit-test
-[ t ] [ "history" get history-forward empty? ] unit-test
+[ f ] [ "history" get back>> empty? ] unit-test
+[ t ] [ "history" get forward>> empty? ] unit-test
 
diff --git a/basis/models/mapping/mapping-tests.factor b/basis/models/mapping/mapping-tests.factor
index 43c1883bb1..6e1a1dc8d0 100755
--- a/basis/models/mapping/mapping-tests.factor
+++ b/basis/models/mapping/mapping-tests.factor
@@ -1,6 +1,6 @@
-IN: models.mapping.tests
 USING: arrays generic kernel math models namespaces sequences assocs
-tools.test models.mapping ;
+tools.test models.mapping accessors ;
+IN: models.mapping.tests
 
 ! Test mapping
 [ ] [
@@ -14,7 +14,7 @@ tools.test models.mapping ;
 [ ] [ "m" get activate-model ] unit-test
 
 [ H{ { "one" 1 } { "two" 2 } } ] [
-    "m" get model-value
+    "m" get value>>
 ] unit-test
 
 [ ] [
@@ -23,12 +23,12 @@ tools.test models.mapping ;
 ] unit-test
 
 [ H{ { "one" 3 } { "two" 4 } } ] [
-    "m" get model-value
+    "m" get value>>
 ] unit-test
 
 [ H{ { "one" 5 } { "two" 4 } } ] [
-    5 "one" "m" get mapping-assoc at set-model
-    "m" get model-value
+    5 "one" "m" get assoc>> at set-model
+    "m" get value>>
 ] unit-test
 
 [ ] [ "m" get deactivate-model ] unit-test
diff --git a/basis/models/models-tests.factor b/basis/models/models-tests.factor
index ee1bb542f0..fe10d3ab8e 100755
--- a/basis/models/models-tests.factor
+++ b/basis/models/models-tests.factor
@@ -1,13 +1,12 @@
-IN: models.tests
 USING: arrays generic kernel math models models.compose
-namespaces sequences assocs
-tools.test ;
+namespaces sequences assocs accessors tools.test ;
+IN: models.tests
 
 TUPLE: model-tester hit? ;
 
 : <model-tester> model-tester new ;
 
-M: model-tester model-changed nip t swap set-model-tester-hit? ;
+M: model-tester model-changed nip t >>hit? drop ;
 
 [ T{ model-tester f t } ]
 [
@@ -20,7 +19,7 @@ M: model-tester model-changed nip t swap set-model-tester-hit? ;
 "model-a" get "model-b" get 2array <compose> "model-c" set
 
 "model-c" get activate-model
-[ { 3 4 } ] [ "model-c" get model-value  ] unit-test
+[ { 3 4 } ] [ "model-c" get value>>  ] unit-test
 "model-c" get deactivate-model
 
 T{ model-tester f f } "tester" set
@@ -30,5 +29,5 @@ T{ model-tester f f } "tester" set
     "tester" get "model-c" get add-connection
     6 "model-a" get set-model
     "tester" get
-    "model-c" get model-value
+    "model-c" get value>>
 ] unit-test
diff --git a/basis/opengl/capabilities/capabilities.factor b/basis/opengl/capabilities/capabilities.factor
index d658235cf6..806935d5c9 100755
--- a/basis/opengl/capabilities/capabilities.factor
+++ b/basis/opengl/capabilities/capabilities.factor
@@ -5,9 +5,9 @@ continuations math.parser math arrays sets math.order ;
 IN: opengl.capabilities
 
 : (require-gl) ( thing require-quot make-error-quot -- )
-    >r dupd call
-    [ r> 2drop ]
-    [ r> " " make throw ]
+    -rot dupd call
+    [ 2drop ]
+    [ swap " " make throw ]
     if ; inline
 
 : gl-extensions ( -- seq )
diff --git a/basis/prettyprint/backend/backend.factor b/basis/prettyprint/backend/backend.factor
index 8e5e932666..87f6d3122e 100755
--- a/basis/prettyprint/backend/backend.factor
+++ b/basis/prettyprint/backend/backend.factor
@@ -163,10 +163,12 @@ M: byte-vector >pprint-sequence ;
 M: curry >pprint-sequence ;
 M: compose >pprint-sequence ;
 M: hashtable >pprint-sequence >alist ;
-M: tuple >pprint-sequence tuple>array ;
 M: wrapper >pprint-sequence wrapped>> 1array ;
 M: callstack >pprint-sequence callstack>array ;
 
+M: tuple >pprint-sequence
+    [ class f 2array ] [ tuple-slots ] bi append ;
+
 GENERIC: pprint-narrow? ( obj -- ? )
 
 M: object pprint-narrow? drop f ;
diff --git a/basis/stack-checker/known-words/known-words.factor b/basis/stack-checker/known-words/known-words.factor
index c01236fba9..1c25df4112 100755
--- a/basis/stack-checker/known-words/known-words.factor
+++ b/basis/stack-checker/known-words/known-words.factor
@@ -108,7 +108,7 @@ M: object infer-call*
 
 : infer-<tuple-boa> ( -- )
     \ <tuple-boa>
-    peek-d literal value>> size>> { tuple } <effect>
+    peek-d literal value>> size>> 1+ { tuple } <effect>
     apply-word/effect ;
 
 : infer-(throw) ( -- )
@@ -173,15 +173,13 @@ do-primitive alien-invoke alien-indirect alien-callback
 { call execute dispatch load-locals get-local drop-locals }
 [ t "no-compile" set-word-prop ] each
 
-SYMBOL: +primitive+
-
 : non-inline-word ( word -- )
     dup called-dependency depends-on
     {
         { [ dup "shuffle" word-prop ] [ infer-shuffle-word ] }
         { [ dup "special" word-prop ] [ infer-special ] }
-        { [ dup +primitive+ word-prop ] [ infer-primitive ] }
-        { [ dup +transform-quot+ word-prop ] [ apply-transform ] }
+        { [ dup "primitive" word-prop ] [ infer-primitive ] }
+        { [ dup "transform-quot" word-prop ] [ apply-transform ] }
         { [ dup "macro" word-prop ] [ apply-macro ] }
         { [ dup "cannot-infer" word-prop ] [ cannot-infer-effect ] }
         { [ dup "inferred-effect" word-prop ] [ cached-infer ] }
@@ -190,7 +188,7 @@ SYMBOL: +primitive+
     } cond ;
 
 : define-primitive ( word inputs outputs -- )
-    [ 2drop t +primitive+ set-word-prop ]
+    [ 2drop t "primitive" set-word-prop ]
     [ drop "input-classes" set-word-prop ]
     [ nip "default-output-classes" set-word-prop ]
     3tri ;
@@ -600,8 +598,6 @@ SYMBOL: +primitive+
 
 \ (set-os-envs) { array } { } define-primitive
 
-\ do-primitive [ \ do-primitive cannot-infer-effect ] "infer" set-word-prop
-
 \ dll-valid? { object } { object } define-primitive
 
 \ modify-code-heap { array object } { } define-primitive
diff --git a/basis/stack-checker/stack-checker-tests.factor b/basis/stack-checker/stack-checker-tests.factor
index dc049ee1a4..9bf8ed62f0 100755
--- a/basis/stack-checker/stack-checker-tests.factor
+++ b/basis/stack-checker/stack-checker-tests.factor
@@ -148,7 +148,7 @@ M: fixnum potential-hang dup [ potential-hang ] when ;
 
 TUPLE: funny-cons car cdr ;
 GENERIC: iterate ( obj -- )
-M: funny-cons iterate funny-cons-cdr iterate ;
+M: funny-cons iterate cdr>> iterate ;
 M: f iterate drop ;
 M: real iterate drop ;
 
diff --git a/basis/stack-checker/state/state.factor b/basis/stack-checker/state/state.factor
index 3d3db980e1..0d0de7f19b 100755
--- a/basis/stack-checker/state/state.factor
+++ b/basis/stack-checker/state/state.factor
@@ -89,8 +89,11 @@ SYMBOL: meta-r
 SYMBOL: dependencies
 
 : depends-on ( word how -- )
-    dependencies get dup
-    [ swap '[ , strongest-dependency ] change-at ] [ 3drop ] if ;
+    over primitive? [ 2drop ] [
+        dependencies get dup [
+            swap '[ , strongest-dependency ] change-at
+        ] [ 3drop ] if
+    ] if ;
 
 ! Generic words that the current quotation depends on
 SYMBOL: generic-dependencies
diff --git a/basis/stack-checker/transforms/transforms.factor b/basis/stack-checker/transforms/transforms.factor
index 200b5d9c43..2773b8b4e4 100755
--- a/basis/stack-checker/transforms/transforms.factor
+++ b/basis/stack-checker/transforms/transforms.factor
@@ -8,9 +8,6 @@ stack-checker.backend stack-checker.state stack-checker.visitor
 stack-checker.errors ;
 IN: stack-checker.transforms
 
-SYMBOL: +transform-quot+
-SYMBOL: +transform-n+
-
 : give-up-transform ( word -- )
     dup recursive-label
     [ call-recursive-word ]
@@ -48,8 +45,8 @@ SYMBOL: +transform-n+
 : apply-transform ( word -- )
     [ inlined-dependency depends-on ] [
         [ ]
-        [ +transform-quot+ word-prop ]
-        [ +transform-n+ word-prop ]
+        [ "transform-quot" word-prop ]
+        [ "transform-n" word-prop ]
         tri
         (apply-transform)
     ] bi ;
@@ -64,8 +61,8 @@ SYMBOL: +transform-n+
     ] bi ;
 
 : define-transform ( word quot n -- )
-    [ drop +transform-quot+ set-word-prop ]
-    [ nip +transform-n+ set-word-prop ]
+    [ drop "transform-quot" set-word-prop ]
+    [ nip "transform-n" set-word-prop ]
     3bi ;
 
 ! Combinators
@@ -108,8 +105,11 @@ SYMBOL: +transform-n+
 \ new [
     dup tuple-class? [
         dup inlined-dependency depends-on
-        dup all-slots rest-slice ! delegate slot
-        [ [ initial>> literalize , ] each literalize , \ boa , ] [ ] make
+        [
+            [ all-slots [ initial>> literalize , ] each ]
+            [ literalize , ] bi
+            \ boa ,
+        ] [ ] make
     ] [ drop f ] if
 ] 1 define-transform
 
diff --git a/basis/tools/deploy/shaker/shaker.factor b/basis/tools/deploy/shaker/shaker.factor
index eaa0342c25..833528018b 100755
--- a/basis/tools/deploy/shaker/shaker.factor
+++ b/basis/tools/deploy/shaker/shaker.factor
@@ -85,8 +85,11 @@ IN: tools.deploy.shaker
     [
         strip-dictionary? [
             {
+                "cannot-infer"
                 "coercer"
+                "combination"
                 "compiled-effect"
+                "compiled-generic-uses"
                 "compiled-uses"
                 "constraints"
                 "declared-effect"
@@ -94,38 +97,51 @@ IN: tools.deploy.shaker
                 "default-method"
                 "default-output-classes"
                 "derived-from"
-                "identities"
+                "engines"
                 "if-intrinsics"
                 "infer"
                 "inferred-effect"
+                "inline"
+                "inlined-block"
                 "input-classes"
                 "interval"
                 "intrinsics"
+                "lambda"
                 "loc"
+                "local-reader"
+                "local-reader?"
+                "local-writer"
+                "local-writer?"
+                "local?"
+                "macro"
                 "members"
-                "methods"
+                "memo-quot"
                 "method-class"
                 "method-generic"
-                "combination"
-                "cannot-infer"
+                "methods"
                 "no-compile"
                 "optimizer-hooks"
-                "output-classes"
+                "outputs"
                 "participants"
                 "predicate"
                 "predicate-definition"
                 "predicating"
-                "tuple-dispatch-generic"
-                "slots"
+                "reader"
+                "reading"
+                "recursive"
+                "shuffle"
                 "slot-names"
+                "slots"
+                "special"
                 "specializer"
                 "step-into"
                 "step-into?"
-                "superclass"
-                "reading"
-                "writing"
+                "transform-n"
+                "transform-quot"
+                "tuple-dispatch-generic"
                 "type"
-                "engines"
+                "writer"
+                "writing"
             } %
         ] when
         
@@ -211,6 +227,7 @@ IN: tools.deploy.shaker
                 classes:update-map
                 command-line:main-vocab-hook
                 compiled-crossref
+                compiled-generic-crossref
                 compiler.units:recompile-hook
                 compiler.units:update-tuples-hook
                 definitions:crossref
@@ -229,7 +246,7 @@ IN: tools.deploy.shaker
                 word
             } %
 
-            { } { "optimizer.math.partial" } strip-vocab-globals %
+            { } { "math.partial-dispatch" } strip-vocab-globals %
         ] when
 
         strip-prettyprint? [
diff --git a/basis/tools/deploy/test/1/deploy.factor b/basis/tools/deploy/test/1/deploy.factor
index 490c21a067..098e99719e 100755
--- a/basis/tools/deploy/test/1/deploy.factor
+++ b/basis/tools/deploy/test/1/deploy.factor
@@ -1,15 +1,15 @@
 USING: tools.deploy.config ;
 H{
-    { deploy-word-defs? f }
-    { deploy-random? f }
-    { deploy-name "tools.deploy.test.1" }
-    { deploy-threads? t }
-    { deploy-compiler? t }
-    { deploy-math? t }
     { deploy-c-types? f }
+    { deploy-name "tools.deploy.test.1" }
     { deploy-io 2 }
-    { deploy-reflection 1 }
-    { deploy-ui? f }
+    { deploy-random? f }
+    { deploy-math? t }
+    { deploy-compiler? t }
+    { deploy-reflection 2 }
     { "stop-after-last-window?" t }
+    { deploy-threads? t }
+    { deploy-ui? f }
     { deploy-word-props? f }
+    { deploy-word-defs? f }
 }
diff --git a/basis/tools/deploy/test/2/deploy.factor b/basis/tools/deploy/test/2/deploy.factor
index aeec8e94f7..c6f46eede6 100755
--- a/basis/tools/deploy/test/2/deploy.factor
+++ b/basis/tools/deploy/test/2/deploy.factor
@@ -1,15 +1,15 @@
 USING: tools.deploy.config ;
 H{
-    { deploy-math? t }
-    { deploy-compiler? t }
-    { deploy-reflection 2 }
+    { deploy-io 2 }
     { deploy-ui? f }
-    { deploy-word-props? f }
     { deploy-threads? t }
     { deploy-c-types? f }
-    { deploy-random? f }
-    { "stop-after-last-window?" t }
     { deploy-name "tools.deploy.test.2" }
-    { deploy-io 2 }
+    { deploy-compiler? t }
+    { deploy-word-props? f }
+    { deploy-reflection 2 }
     { deploy-word-defs? f }
+    { "stop-after-last-window?" t }
+    { deploy-random? f }
+    { deploy-math? t }
 }
diff --git a/basis/tools/deploy/test/3/deploy.factor b/basis/tools/deploy/test/3/deploy.factor
index dde8291658..5f45b87e0d 100755
--- a/basis/tools/deploy/test/3/deploy.factor
+++ b/basis/tools/deploy/test/3/deploy.factor
@@ -1,15 +1,15 @@
 USING: tools.deploy.config ;
 H{
-    { deploy-word-defs? f }
-    { deploy-random? f }
-    { deploy-name "tools.deploy.test.3" }
-    { deploy-threads? t }
-    { deploy-compiler? t }
-    { deploy-math? t }
-    { deploy-c-types? f }
     { deploy-io 3 }
-    { deploy-reflection 1 }
     { deploy-ui? f }
-    { "stop-after-last-window?" t }
+    { deploy-threads? t }
+    { deploy-c-types? f }
+    { deploy-name "tools.deploy.test.3" }
+    { deploy-compiler? t }
     { deploy-word-props? f }
+    { deploy-reflection 2 }
+    { deploy-word-defs? f }
+    { "stop-after-last-window?" t }
+    { deploy-random? f }
+    { deploy-math? t }
 }
diff --git a/basis/tools/deploy/test/4/deploy.factor b/basis/tools/deploy/test/4/deploy.factor
index 65ead56e2b..ea899e64c0 100644
--- a/basis/tools/deploy/test/4/deploy.factor
+++ b/basis/tools/deploy/test/4/deploy.factor
@@ -1,15 +1,15 @@
 USING: tools.deploy.config ;
 H{
-    { deploy-math? t }
-    { deploy-reflection 1 }
     { deploy-io 2 }
-    { deploy-c-types? f }
-    { deploy-random? f }
     { deploy-ui? f }
-    { deploy-name "tools.deploy.test.4" }
-    { deploy-word-defs? f }
-    { "stop-after-last-window?" t }
     { deploy-threads? t }
+    { deploy-c-types? f }
+    { deploy-name "tools.deploy.test.4" }
     { deploy-compiler? t }
     { deploy-word-props? f }
+    { deploy-reflection 2 }
+    { deploy-word-defs? f }
+    { "stop-after-last-window?" t }
+    { deploy-random? f }
+    { deploy-math? t }
 }
diff --git a/basis/tools/deploy/test/5/deploy.factor b/basis/tools/deploy/test/5/deploy.factor
index bb4580b7ae..797116e09b 100644
--- a/basis/tools/deploy/test/5/deploy.factor
+++ b/basis/tools/deploy/test/5/deploy.factor
@@ -1,15 +1,15 @@
 USING: tools.deploy.config ;
 H{
-    { deploy-math? t }
-    { deploy-reflection 1 }
     { deploy-io 3 }
-    { deploy-c-types? f }
-    { deploy-random? f }
     { deploy-ui? f }
-    { deploy-name "tools.deploy.test.5" }
-    { deploy-word-defs? f }
-    { "stop-after-last-window?" t }
     { deploy-threads? t }
+    { deploy-c-types? f }
+    { deploy-name "tools.deploy.test.5" }
     { deploy-compiler? t }
     { deploy-word-props? f }
+    { deploy-reflection 2 }
+    { deploy-word-defs? f }
+    { "stop-after-last-window?" t }
+    { deploy-random? f }
+    { deploy-math? t }
 }
diff --git a/basis/tools/scaffold/authors.txt b/basis/tools/scaffold/authors.txt
new file mode 100644
index 0000000000..b4bd0e7b35
--- /dev/null
+++ b/basis/tools/scaffold/authors.txt
@@ -0,0 +1 @@
+Doug Coleman
\ No newline at end of file
diff --git a/basis/tools/scaffold/scaffold.factor b/basis/tools/scaffold/scaffold.factor
new file mode 100644
index 0000000000..1c1a48ff9d
--- /dev/null
+++ b/basis/tools/scaffold/scaffold.factor
@@ -0,0 +1,195 @@
+! Copyright (C) 2008 Doug Coleman.
+! See http://factorcode.org/license.txt for BSD license.
+USING: assocs io.files hashtables kernel namespaces sequences
+vocabs.loader io combinators io.encodings.utf8 calendar accessors
+math.parser io.streams.string ui.tools.operations quotations
+strings arrays prettyprint words vocabs sorting sets cords
+sequences.lib combinators.lib ;
+IN: tools.scaffold
+
+SYMBOL: developer-name
+SYMBOL: using
+
+ERROR: not-a-vocab-root string ;
+
+: root? ( string -- ? )
+    vocab-roots get member?  ;
+
+ERROR: vocab-name-contains-separator path ;
+ERROR: vocab-name-contains-dot path ;
+: check-vocab-name ( string -- string )
+    dup dup [ CHAR: . = ] trim [ length ] bi@ =
+    [ vocab-name-contains-dot ] unless
+    ".." over subseq? [ vocab-name-contains-dot ] when
+    dup [ path-separator? ] contains?
+    [ vocab-name-contains-separator ] when ;
+
+: check-root ( string -- string )
+    check-vocab-name
+    dup "resource:" head? [ "resource:" prepend ] unless
+    dup root? [ not-a-vocab-root ] unless ;
+
+: directory-exists ( path -- )
+    "Not creating a directory, it already exists: " write print ;
+
+: scaffold-directory ( path -- )
+    dup exists? [ directory-exists ] [ make-directories ] if ;
+
+: not-scaffolding ( path -- )
+    "Not creating scaffolding for " write <pathname> . ;
+
+: scaffolding ( path -- )
+    "Creating scaffolding for " write <pathname> . ;
+
+: scaffold-path ( path string -- path ? )
+    dupd [ file-name ] dip append append-path
+    dup exists? [ dup not-scaffolding f ] [ dup scaffolding t ] if ;
+
+: scaffold-copyright ( -- )
+    "! Copyright (C) " write now year>> number>string write
+    developer-name get [ "Your name" ] unless* bl write "." print
+    "! See http://factorcode.org/license.txt for BSD license." print ;
+
+: main-file-string ( vocab -- string )
+    [
+        scaffold-copyright
+        "USING: ;" print
+        "IN: " write print
+    ] with-string-writer ;
+
+: set-scaffold-main-file ( path vocab -- )
+    main-file-string swap utf8 set-file-contents ;
+
+: scaffold-main ( path vocab -- )
+    [ ".factor" scaffold-path ] dip
+    swap [ set-scaffold-main-file ] [ 2drop ] if ;
+
+: tests-file-string ( vocab -- string )
+    [
+        scaffold-copyright
+        "USING: tools.test " write dup write " ;" print
+        "IN: " write write ".tests" print
+    ] with-string-writer ;
+
+: set-scaffold-tests-file ( path vocab -- )
+    tests-file-string swap utf8 set-file-contents ;
+
+: scaffold-tests ( path vocab -- )
+    [ "-tests.factor" scaffold-path ] dip
+    swap [ set-scaffold-tests-file ] [ 2drop ] if ;
+
+: scaffold-authors ( path -- )
+    "authors.txt" append-path dup exists? [
+        not-scaffolding
+    ] [
+        dup scaffolding
+        developer-name get swap utf8 set-file-contents
+    ] if ;
+
+: lookup-type ( string -- object/string ? )
+    H{
+        { "object" object } { "obj" object }
+        { "obj1" object } { "obj2" object }
+        { "obj3" object } { "obj4" object }
+        { "quot" quotation } { "quot1" quotation }
+        { "quot2" quotation } { "quot3" quotation }
+        { "string" string } { "string1" string }
+        { "string2" string } { "string3" string }
+        { "str" string }
+        { "str1" string } { "str2" string } { "str3" string }
+        { "hash" hashtable }
+        { "hashtable" hashtable }
+        { "?" "a boolean" }
+        { "ch" "a character" }
+        { "word" word }
+        { "array" array }
+        { "path" "a pathname string" }
+        { "vocab" "a vocabulary specifier" }
+        { "vocab-root" "a vocabulary root string" }
+    } at* ;
+
+: add-using ( object -- )
+    vocabulary>> using get conjoin ;
+
+: ($values.) ( array -- )
+    [
+        " { " write
+        dup array? [ first ] when
+        dup lookup-type [
+            [ unparse write bl ]
+            [ [ pprint ] [ dup string? [ drop ] [ add-using ] if ] bi ] bi*
+        ] [
+            drop unparse write bl null pprint
+            null add-using
+        ] if
+        " }" write
+    ] each ;
+
+: $values. ( word -- )
+    "declared-effect" word-prop [
+        [ in>> ] [ out>> ] bi
+        2dup [ empty? ] bi@ and [
+            2drop
+        ] [
+            "{ $values" print
+            [ "    " write ($values.) ]
+            [ [ nl "    " write ($values.) ] unless-empty ] bi*
+            " }" write nl
+        ] if
+    ] when* ;
+
+: $description. ( word -- )
+    drop
+    "{ $description } ;" print ;
+
+: help-header. ( word -- )
+    "HELP: " write name>> print ;
+
+: help. ( word -- )
+    [ help-header. ] [ $values. ] [ $description. ] tri ;
+
+: help-file-string ( str1 -- str2 )
+    [
+        [ "IN: " write print nl ]
+        [ words natural-sort [ help. nl ] each ]
+        [ "ARTICLE: " write unparse dup write bl print ";" print nl ]
+        [ "ABOUT: " write unparse print ] quad
+    ] with-string-writer ;
+
+: write-using ( -- )
+    "USING:" write
+    using get keys
+    { "help.markup" "help.syntax" } cord-append natural-sort 
+    [ bl write ] each
+    " ;" print ;
+
+: set-scaffold-help-file ( path vocab -- )
+    swap utf8 <file-writer> [
+        scaffold-copyright help-file-string write-using write
+    ] with-output-stream ;
+
+: check-scaffold ( vocab-root string -- vocab-root string )
+    [ check-root ] [ check-vocab-name ] bi* ;
+
+: vocab>scaffold-path ( vocab-root string -- path )
+    path-separator first CHAR: . associate substitute
+    append-path ;
+
+: prepare-scaffold ( vocab-root string -- string path )
+    check-scaffold [ vocab>scaffold-path ] keep ;
+
+: scaffold-help ( vocab-root string -- )
+    H{ } clone using [
+        prepare-scaffold
+        [ "-docs.factor" scaffold-path ] dip
+        swap [ set-scaffold-help-file ] [ 2drop ] if
+    ] with-variable ;
+
+: scaffold-vocab ( vocab-root string -- )
+    prepare-scaffold
+    {
+        [ drop scaffold-directory ]
+        [ scaffold-main ]
+        [ scaffold-tests ]
+        [ drop scaffold-authors ]
+    } 2cleave ;
diff --git a/basis/tuple-arrays/tuple-arrays-tests.factor b/basis/tuple-arrays/tuple-arrays-tests.factor
index 4c288b1c9e..7aa49b880f 100755
--- a/basis/tuple-arrays/tuple-arrays-tests.factor
+++ b/basis/tuple-arrays/tuple-arrays-tests.factor
@@ -1,4 +1,5 @@
-USING: tuple-arrays sequences tools.test namespaces kernel math accessors ;
+USING: tuple-arrays sequences tools.test namespaces kernel
+math accessors ;
 IN: tuple-arrays.tests
 
 SYMBOL: mat
@@ -6,14 +7,14 @@ TUPLE: foo bar ;
 C: <foo> foo
 [ 2 ] [ 2 foo <tuple-array> dup mat set length ] unit-test
 [ T{ foo } ] [ mat get first ] unit-test
-[ T{ foo 2 1 } ] [ T{ foo 2 1 } 0 mat get [ set-nth ] keep first ] unit-test
+[ T{ foo f 2 } ] [ T{ foo f 2 } 0 mat get [ set-nth ] keep first ] unit-test
 [ t ] [ { T{ foo f 1 } T{ foo f 2 } } >tuple-array dup mat set tuple-array? ] unit-test
 [ T{ foo f 3 } t ] 
-[ mat get [ foo-bar 2 + <foo> ] map [ first ] keep tuple-array? ] unit-test
+[ mat get [ bar>> 2 + <foo> ] map [ first ] keep tuple-array? ] unit-test
 
 [ 2 ] [ 2 foo <tuple-array> dup mat set length ] unit-test
 [ T{ foo } ] [ mat get first ] unit-test
-[ T{ foo 2 1 } ] [ T{ foo 2 1 } 0 mat get [ set-nth ] keep first ] unit-test
+[ T{ foo f 1 } ] [ T{ foo f 1 } 0 mat get [ set-nth ] keep first ] unit-test
 
 TUPLE: baz { bing integer } bong ;
 [ 0 ] [ 1 baz <tuple-array> first bing>> ] unit-test
diff --git a/basis/ui/cocoa/cocoa.factor b/basis/ui/cocoa/cocoa.factor
index 8d176b9c63..1a05d23aa0 100755
--- a/basis/ui/cocoa/cocoa.factor
+++ b/basis/ui/cocoa/cocoa.factor
@@ -24,10 +24,10 @@ TUPLE: pasteboard handle ;
 C: <pasteboard> pasteboard
 
 M: pasteboard clipboard-contents
-    pasteboard-handle pasteboard-string ;
+    handle>> pasteboard-string ;
 
 M: pasteboard set-clipboard-contents
-    pasteboard-handle set-pasteboard-string ;
+    handle>> set-pasteboard-string ;
 
 : init-clipboard ( -- )
     NSPasteboard -> generalPasteboard <pasteboard>
@@ -44,29 +44,29 @@ M: pasteboard set-clipboard-contents
         dup install-window-delegate
         over -> release
         <handle>
-    ] keep set-world-handle ;
+    ] keep (>>handle) ;
 
 M: cocoa-ui-backend set-title ( string world -- )
-    world-handle handle-window swap <NSString> -> setTitle: ;
+    handle>> window>> swap <NSString> -> setTitle: ;
 
 : enter-fullscreen ( world -- )
-    world-handle handle-view
+    handle>> view>>
     NSScreen -> mainScreen
     f -> enterFullScreenMode:withOptions:
     drop ;
 
 : exit-fullscreen ( world -- )
-    world-handle handle-view f -> exitFullScreenModeWithOptions: ;
+    handle>> view>> f -> exitFullScreenModeWithOptions: ;
 
 M: cocoa-ui-backend set-fullscreen* ( ? world -- )
     swap [ enter-fullscreen ] [ exit-fullscreen ] if ;
 
 M: cocoa-ui-backend fullscreen* ( world -- ? )
-    world-handle handle-view -> isInFullScreenMode zero? not ;
+    handle>> view>> -> isInFullScreenMode zero? not ;
 
 : auto-position ( world -- )
     dup window-loc>> { 0 0 } = [
-        world-handle handle-window -> center
+        handle>> window>> -> center
     ] [
         drop
     ] if ;
@@ -74,29 +74,29 @@ M: cocoa-ui-backend fullscreen* ( world -- ? )
 M: cocoa-ui-backend (open-window) ( world -- )
     dup gadget-window
     dup auto-position
-    world-handle handle-window f -> makeKeyAndOrderFront: ;
+    handle>> window>> f -> makeKeyAndOrderFront: ;
 
 M: cocoa-ui-backend (close-window) ( handle -- )
-    handle-window -> release ;
+    window>> -> release ;
 
 M: cocoa-ui-backend close-window ( gadget -- )
     find-world [
-        world-handle [
-            handle-window f -> performClose:
+        handle>> [
+            window>> f -> performClose:
         ] when*
     ] when* ;
 
 M: cocoa-ui-backend raise-window* ( world -- )
-    world-handle [
-        handle-window dup f -> orderFront: -> makeKeyWindow
+    handle>> [
+        window>> dup f -> orderFront: -> makeKeyWindow
         NSApp 1 -> activateIgnoringOtherApps:
     ] when* ;
 
 M: cocoa-ui-backend select-gl-context ( handle -- )
-    handle-view -> openGLContext -> makeCurrentContext ;
+    view>> -> openGLContext -> makeCurrentContext ;
 
 M: cocoa-ui-backend flush-gl-context ( handle -- )
-    handle-view -> openGLContext -> flushBuffer ;
+    view>> -> openGLContext -> flushBuffer ;
 
 M: cocoa-ui-backend beep ( -- )
     NSBeep ;
diff --git a/basis/ui/freetype/freetype.factor b/basis/ui/freetype/freetype.factor
index 7bda548a26..d2dfe56ed4 100755
--- a/basis/ui/freetype/freetype.factor
+++ b/basis/ui/freetype/freetype.factor
@@ -184,7 +184,7 @@ M: freetype-renderer string-height ( open-font string -- h )
 : draw-char ( open-font sprites char loc -- )
     GL_MODELVIEW [
         0 0 glTranslated
-        char-sprite sprite-dlist glCallList
+        char-sprite dlist>> glCallList
     ] do-matrix ;
 
 : char-widths ( open-font string -- widths )
diff --git a/basis/ui/gadgets/borders/borders.factor b/basis/ui/gadgets/borders/borders.factor
index da21c06a1b..4609562af4 100644
--- a/basis/ui/gadgets/borders/borders.factor
+++ b/basis/ui/gadgets/borders/borders.factor
@@ -41,7 +41,7 @@ M: border pref-dim*
 
 M: border layout*
     dup border-child-rect swap gadget-child
-    over loc>> over set-rect-loc
+    over loc>> >>loc
     swap dim>> swap (>>dim) ;
 
 M: border focusable-child*
diff --git a/basis/ui/gadgets/buttons/buttons-tests.factor b/basis/ui/gadgets/buttons/buttons-tests.factor
index 6c5d757dd4..bdd9ebaf13 100755
--- a/basis/ui/gadgets/buttons/buttons-tests.factor
+++ b/basis/ui/gadgets/buttons/buttons-tests.factor
@@ -1,6 +1,7 @@
-IN: ui.gadgets.buttons.tests
 USING: ui.commands ui.gadgets.buttons ui.gadgets.labels
-ui.gadgets tools.test namespaces sequences kernel models ;
+ui.gadgets tools.test namespaces sequences kernel models
+accessors ;
+IN: ui.gadgets.buttons.tests
 
 TUPLE: foo-gadget ;
 
@@ -15,7 +16,7 @@ TUPLE: foo-gadget ;
 
 T{ foo-gadget } <toolbar> "t" set
 
-[ 2 ] [ "t" get gadget-children length ] unit-test
+[ 2 ] [ "t" get children>> length ] unit-test
 [ "Foo A" ] [ "t" get gadget-child gadget-child label-string ] unit-test
 
 [ ] [
@@ -34,7 +35,7 @@ T{ foo-gadget } <toolbar> "t" set
 \ <checkbox> must-infer
 
 [ 0 ] [
-    "religion" get gadget-child radio-control-value
+    "religion" get gadget-child value>>
 ] unit-test
 
 [ 2 ] [
diff --git a/basis/ui/gadgets/buttons/buttons.factor b/basis/ui/gadgets/buttons/buttons.factor
index b5e8e8a1e1..e04e385a23 100755
--- a/basis/ui/gadgets/buttons/buttons.factor
+++ b/basis/ui/gadgets/buttons/buttons.factor
@@ -67,9 +67,12 @@ M: button-paint draw-interior
 M: button-paint draw-boundary
     button-paint draw-boundary ;
 
+: align-left ( button -- button )
+    { 0 1/2 } >>align ; inline
+
 : roll-button-theme ( button -- button )
     f black <solid> dup f <button-paint> >>boundary
-    { 0 1/2 } >>align ; inline
+    align-left ; inline
 
 : <roll-button> ( label quot -- button )
     <button> roll-button-theme ;
@@ -141,10 +144,11 @@ TUPLE: checkbox < button ;
     <checkmark> label-on-right checkbox-theme
     [ model>> toggle-model ]
     checkbox new-button
-        swap >>model ;
+        swap >>model
+        align-left ;
 
 M: checkbox model-changed
-    swap model-value over (>>selected?) relayout-1 ;
+    swap value>> over (>>selected?) relayout-1 ;
 
 TUPLE: radio-paint color ;
 
@@ -179,10 +183,11 @@ TUPLE: radio-control < button value ;
     [ [ value>> ] keep set-control-value ]
     radio-control new-button
         swap >>model
-        swap >>value ; inline
+        swap >>value
+        align-left ; inline
 
 M: radio-control model-changed
-    swap model-value
+    swap value>>
     over value>> =
     over (>>selected?)
     relayout-1 ;
diff --git a/basis/ui/gadgets/canvas/canvas-tests.factor b/basis/ui/gadgets/canvas/canvas-tests.factor
new file mode 100755
index 0000000000..bc87064c92
--- /dev/null
+++ b/basis/ui/gadgets/canvas/canvas-tests.factor
@@ -0,0 +1,4 @@
+IN: ui.gadgets.canvas.tests
+USING: ui.gadgets.canvas tools.test kernel ;
+
+{ 1 0 } [ [ drop ] draw-canvas ] must-infer-as
diff --git a/basis/ui/gadgets/canvas/canvas.factor b/basis/ui/gadgets/canvas/canvas.factor
old mode 100644
new mode 100755
index ba5aeaf95b..85149f4551
--- a/basis/ui/gadgets/canvas/canvas.factor
+++ b/basis/ui/gadgets/canvas/canvas.factor
@@ -2,7 +2,7 @@
 ! See http://factorcode.org/license.txt for BSD license.
 USING: ui.backend ui.gadgets ui.gadgets.theme ui.gadgets.lib
 ui.gadgets.worlds ui.render opengl opengl.gl kernel namespaces
-classes.tuple colors ;
+classes.tuple colors accessors ;
 IN: ui.gadgets.canvas
 
 TUPLE: canvas < gadget dlist ;
@@ -11,16 +11,16 @@ TUPLE: canvas < gadget dlist ;
     new-gadget black solid-interior ; inline
 
 : delete-canvas-dlist ( canvas -- )
-    dup find-gl-context
-    dup canvas-dlist [ delete-dlist ] when*
-    f swap set-canvas-dlist ;
+    [ find-gl-context ]
+    [ dlist>> [ delete-dlist ] when* ]
+    [ f >>dlist drop ] tri ;
 
 : make-canvas-dlist ( canvas quot -- dlist )
-    over >r GL_COMPILE swap make-dlist dup r>
-    set-canvas-dlist ;
+    [ drop ] [ GL_COMPILE swap make-dlist ] 2bi
+    [ >>dlist drop ] keep ; inline
 
 : cache-canvas-dlist ( canvas quot -- dlist )
-    over canvas-dlist dup
+    over dlist>> dup
     [ 2nip ] [ drop make-canvas-dlist ] if ; inline
 
 : draw-canvas ( canvas quot -- )
diff --git a/basis/ui/gadgets/editors/editors-tests.factor b/basis/ui/gadgets/editors/editors-tests.factor
index 166e6c264b..274d62ea46 100755
--- a/basis/ui/gadgets/editors/editors-tests.factor
+++ b/basis/ui/gadgets/editors/editors-tests.factor
@@ -2,6 +2,7 @@ USING: accessors ui.gadgets.editors tools.test kernel io
 io.streams.plain definitions namespaces ui.gadgets
 ui.gadgets.grids prettyprint documents ui.gestures tools.test.ui
 models ;
+IN: ui.gadgets.editors.tests
 
 [ "foo bar" ] [
     <editor> "editor" set
@@ -34,7 +35,7 @@ models ;
     <editor> "editor" set
     "editor" get [
         "bar\nbaz quux" "editor" get set-editor-string
-        { 0 3 } "editor" get editor-caret set-model
+        { 0 3 } "editor" get caret>> set-model
         "editor" get select-word
         "editor" get gadget-selection
     ] with-grafted-gadget
@@ -45,5 +46,5 @@ models ;
 "hello" <model> <field> "field" set
 
 "field" get [
-    [ "hello" ] [ "field" get field-model>> model-value ] unit-test
+    [ "hello" ] [ "field" get field-model>> value>> ] unit-test
 ] with-grafted-gadget
diff --git a/basis/ui/gadgets/editors/editors.factor b/basis/ui/gadgets/editors/editors.factor
index 06a8b4886a..8142297318 100755
--- a/basis/ui/gadgets/editors/editors.factor
+++ b/basis/ui/gadgets/editors/editors.factor
@@ -55,9 +55,9 @@ M: editor ungraft*
     dup caret>> deactivate-editor-model
     dup mark>> deactivate-editor-model ;
 
-: editor-caret* ( editor -- loc ) caret>> model-value ;
+: editor-caret* ( editor -- loc ) caret>> value>> ;
 
-: editor-mark* ( editor -- loc ) mark>> model-value ;
+: editor-mark* ( editor -- loc ) mark>> value>> ;
 
 : set-caret ( loc editor -- )
     [ model>> validate-loc ] keep
@@ -501,7 +501,7 @@ TUPLE: field < wrapper field-model editor ;
         swap >>field-model ;
 
 M: field graft*
-    [ [ field-model>> model-value ] [ editor>> ] bi set-editor-string ]
+    [ [ field-model>> value>> ] [ editor>> ] bi set-editor-string ]
     [ dup editor>> model>> add-connection ]
     bi ;
 
diff --git a/basis/ui/gadgets/gadgets-tests.factor b/basis/ui/gadgets/gadgets-tests.factor
index 0bce366fcc..a1602effe9 100755
--- a/basis/ui/gadgets/gadgets-tests.factor
+++ b/basis/ui/gadgets/gadgets-tests.factor
@@ -1,8 +1,8 @@
-IN: ui.gadgets.tests
 USING: accessors ui.gadgets ui.gadgets.packs ui.gadgets.worlds
 tools.test namespaces models kernel dlists deques math sets
 math.parser ui sequences hashtables assocs io arrays prettyprint
 io.streams.string math.geometry.rect ;
+IN: ui.gadgets.tests
 
 [ { 300 300 } ]
 [
@@ -14,24 +14,24 @@ io.streams.string math.geometry.rect ;
     "b" get "c" get swap add-gadget drop
 
     ! position a and b
-    { 100 200 } "a" get set-rect-loc
-    { 200 100 } "b" get set-rect-loc
+    "a" get { 100 200 } >>loc drop
+    "b" get { 200 100 } >>loc drop
 
     ! give c a loc, it doesn't matter
-    { -1000 23 } "c" get set-rect-loc
+    "c" get { -1000 23 } >>loc drop
 
     ! what is the location of a inside c?
     "a" get "c" get relative-loc
 ] unit-test
 
 <gadget> "g1" set
-{ 10 10 } "g1" get set-rect-loc
-{ 30 30 } "g1" get set-rect-dim
+"g1" get { 10 10 } >>loc
+         { 30 30 } >>dim drop
 <gadget> "g2" set
-{ 20 20 } "g2" get set-rect-loc
-{ 50 500 } "g2" get set-rect-dim
+"g2" get { 20 20 } >>loc
+         { 50 500 } >>dim drop
 <gadget> "g3" set
-{ 100 200 } "g3" get set-rect-dim
+"g3" get { 100 200 } >>dim drop
 
 "g1" get "g2" get swap add-gadget drop
 "g2" get "g3" get swap add-gadget drop
@@ -47,15 +47,15 @@ io.streams.string math.geometry.rect ;
 [ { 100 200 } ] [ "g3" get screen-rect rect-dim ] unit-test
 
 <gadget> "g1" set
-{ 300 300 } "g1" get set-rect-dim
+"g1" get { 300 300 } >>dim drop
 <gadget> "g2" set
 "g2" get "g1" get swap add-gadget drop
-{ 20 20 } "g2" get set-rect-loc
-{ 20 20 } "g2" get set-rect-dim
+"g2" get { 20 20 } >>loc
+         { 20 20 } >>dim drop
 <gadget> "g3" set
 "g3" get "g1" get swap add-gadget drop
-{ 100 100 } "g3" get set-rect-loc
-{ 20 20 } "g3" get set-rect-dim
+"g3" get { 100 100 } >>loc
+         { 20 20 } >>dim drop
 
 [ t ] [ { 30 30 } "g2" get inside? ] unit-test
 
@@ -67,8 +67,8 @@ io.streams.string math.geometry.rect ;
 
 <gadget> "g4" set
 "g4" get "g2" get swap add-gadget drop
-{ 5 5 } "g4" get set-rect-loc
-{ 1 1 } "g4" get set-rect-dim
+"g4" get { 5 5 } >>loc
+         { 1 1 } >>dim drop
 
 [ t ] [ { 25 25 } "g1" get pick-up "g4" get eq? ] unit-test
 
@@ -78,12 +78,10 @@ TUPLE: mock-gadget < gadget graft-called ungraft-called ;
     mock-gadget new-gadget 0 >>graft-called 0 >>ungraft-called ;
 
 M: mock-gadget graft*
-    dup mock-gadget-graft-called 1+
-    swap set-mock-gadget-graft-called ;
+    [ 1+ ] change-graft-called drop ;
 
 M: mock-gadget ungraft*
-    dup mock-gadget-ungraft-called 1+
-    swap set-mock-gadget-ungraft-called ;
+    [ 1+ ] change-ungraft-called drop ;
 
 ! We can't print to output-stream here because that might be a pane
 ! stream, and our graft-queue rebinding here would be captured
@@ -100,35 +98,35 @@ M: mock-gadget ungraft*
         <mock-gadget> "g" set
         [ ] [ "g" get queue-graft ] unit-test
         [ f ] [ graft-queue deque-empty? ] unit-test
-        [ { f t } ] [ "g" get gadget-graft-state ] unit-test
+        [ { f t } ] [ "g" get graft-state>> ] unit-test
         [ ] [ "g" get graft-later ] unit-test
-        [ { f t } ] [ "g" get gadget-graft-state ] unit-test
+        [ { f t } ] [ "g" get graft-state>> ] unit-test
         [ ] [ "g" get ungraft-later ] unit-test
-        [ { f f } ] [ "g" get gadget-graft-state ] unit-test
+        [ { f f } ] [ "g" get graft-state>> ] unit-test
         [ t ] [ graft-queue deque-empty? ] unit-test
         [ ] [ "g" get ungraft-later ] unit-test
         [ ] [ "g" get graft-later ] unit-test
         [ ] [ notify-queued ] unit-test
-        [ { t t } ] [ "g" get gadget-graft-state ] unit-test
+        [ { t t } ] [ "g" get graft-state>> ] unit-test
         [ t ] [ graft-queue deque-empty? ] unit-test
         [ ] [ "g" get graft-later ] unit-test
-        [ 1 ] [ "g" get mock-gadget-graft-called ] unit-test
+        [ 1 ] [ "g" get graft-called>> ] unit-test
         [ ] [ "g" get ungraft-later ] unit-test
-        [ { t f } ] [ "g" get gadget-graft-state ] unit-test
+        [ { t f } ] [ "g" get graft-state>> ] unit-test
         [ ] [ notify-queued ] unit-test
-        [ 1 ] [ "g" get mock-gadget-ungraft-called ] unit-test
-        [ { f f } ] [ "g" get gadget-graft-state ] unit-test
+        [ 1 ] [ "g" get ungraft-called>> ] unit-test
+        [ { f f } ] [ "g" get graft-state>> ] unit-test
     ] with-variable
 
     : add-some-children
         3 [
-            <mock-gadget> over <model> over set-gadget-model
+            <mock-gadget> over <model> >>model
             dup "g" get swap add-gadget drop
             swap 1+ number>string set
         ] each ;
 
     : status-flags
-        { "g" "1" "2" "3" } [ get gadget-graft-state ] map prune ;
+        { "g" "1" "2" "3" } [ get graft-state>> ] map prune ;
 
     : notify-combo ( ? ? -- )
         nl "===== Combo: " write 2dup 2array . nl
@@ -140,12 +138,12 @@ M: mock-gadget ungraft*
             [ V{ { f t } } ] [ status-flags ] unit-test
             dup [ [ ] [ notify-queued ] unit-test ] when
             [ ] [ "g" get clear-gadget ] unit-test
-            [ [ 1 ] [ graft-queue dlist-length ] unit-test ] unless
+            [ [ 1 ] [ graft-queue length>> ] unit-test ] unless
             [ [ ] [ notify-queued ] unit-test ] when
             [ ] [ add-some-children ] unit-test
-            [ { f t } ] [ "1" get gadget-graft-state ] unit-test
-            [ { f t } ] [ "2" get gadget-graft-state ] unit-test
-            [ { f t } ] [ "3" get gadget-graft-state ] unit-test
+            [ { f t } ] [ "1" get graft-state>> ] unit-test
+            [ { f t } ] [ "2" get graft-state>> ] unit-test
+            [ { f t } ] [ "3" get graft-state>> ] unit-test
             [ ] [ graft-queue [ "x" print notify ] slurp-deque ] unit-test
             [ ] [ notify-queued ] unit-test
             [ V{ { t t } } ] [ status-flags ] unit-test
diff --git a/basis/ui/gadgets/gadgets.factor b/basis/ui/gadgets/gadgets.factor
index bcf908571c..15850ae357 100755
--- a/basis/ui/gadgets/gadgets.factor
+++ b/basis/ui/gadgets/gadgets.factor
@@ -50,7 +50,7 @@ M: gadget model-changed 2drop ;
     dup model>> dup [ 2dup remove-connection ] when 2drop ;
 
 : control-value ( control -- value )
-    model>> model-value ;
+    model>> value>> ;
 
 : set-control-value ( value control -- )
     model>> set-model ;
diff --git a/basis/ui/gadgets/grids/grids-tests.factor b/basis/ui/gadgets/grids/grids-tests.factor
index cfca5d5a93..9015b7ec1b 100644
--- a/basis/ui/gadgets/grids/grids-tests.factor
+++ b/basis/ui/gadgets/grids/grids-tests.factor
@@ -1,10 +1,10 @@
 USING: ui.gadgets ui.gadgets.grids tools.test kernel arrays
-namespaces math.geometry.rect ;
+namespaces math.geometry.rect accessors ;
 IN: ui.gadgets.grids.tests
 
 [ { 0 0 } ] [ { } <grid> pref-dim ] unit-test
 
-: 100x100 <gadget> { 100 100 } over set-rect-dim ;
+: 100x100 <gadget> { 100 100 } >>dim ;
 
 [ { 100 100 } ] [
     100x100
@@ -38,7 +38,7 @@ IN: ui.gadgets.grids.tests
     100x100 dup "a" set
     100x100 dup "b" set
     2array 1array <grid>
-    { 10 10 } over set-grid-gap
+    { 10 10 } >>gap
     dup prefer
     dup layout
     rect-dim
diff --git a/basis/ui/gadgets/grids/grids.factor b/basis/ui/gadgets/grids/grids.factor
index 83e5e73662..42e8cfdfdf 100644
--- a/basis/ui/gadgets/grids/grids.factor
+++ b/basis/ui/gadgets/grids/grids.factor
@@ -62,7 +62,7 @@ M: grid pref-dim*
 : position-grid ( grid horiz vert -- )
     pick >r
     >r over r> grid-positions >r grid-positions r>
-    pair-up r> [ set-rect-loc ] do-grid ;
+    pair-up r> [ (>>loc) ] do-grid ;
 
 : resize-grid ( grid horiz vert -- )
     pick fill?>> [
diff --git a/basis/ui/gadgets/handler/handler.factor b/basis/ui/gadgets/handler/handler.factor
index 1ad5063013..1c12142593 100644
--- a/basis/ui/gadgets/handler/handler.factor
+++ b/basis/ui/gadgets/handler/handler.factor
@@ -8,4 +8,4 @@ TUPLE: handler < wrapper table ;
 : <handler> ( child -- handler ) handler new-wrapper ;
 
 M: handler handle-gesture ( gesture gadget -- ? )
-   over table>> at dup [ call f ] [ 2drop t ] if ;
\ No newline at end of file
+   tuck table>> at dup [ call f ] [ 2drop t ] if ;
\ No newline at end of file
diff --git a/basis/ui/gadgets/incremental/incremental.factor b/basis/ui/gadgets/incremental/incremental.factor
index 77b88959c9..4d67080775 100755
--- a/basis/ui/gadgets/incremental/incremental.factor
+++ b/basis/ui/gadgets/incremental/incremental.factor
@@ -37,11 +37,11 @@ M: incremental pref-dim*
     [ next-cursor ] keep (>>cursor) ;
 
 : incremental-loc ( gadget incremental -- )
-    dup cursor>> swap orientation>> v*
-    swap set-rect-loc ;
+    [ cursor>> ] [ orientation>> ] bi v*
+    >>loc drop ;
 
 : prefer-incremental ( gadget -- )
-    dup forget-pref-dim dup pref-dim swap set-rect-dim ;
+    dup forget-pref-dim dup pref-dim >>dim drop ;
 
 : add-incremental ( gadget incremental -- )
     not-in-layout
diff --git a/basis/ui/gadgets/labels/labels.factor b/basis/ui/gadgets/labels/labels.factor
index af7dff0039..ed951824b8 100755
--- a/basis/ui/gadgets/labels/labels.factor
+++ b/basis/ui/gadgets/labels/labels.factor
@@ -43,7 +43,7 @@ M: label gadget-text* label-string % ;
 TUPLE: label-control < label ;
 
 M: label-control model-changed
-    swap model-value over set-label-string relayout ;
+    swap value>> over set-label-string relayout ;
 
 : <label-control> ( model -- gadget )
     "" label-control new-label
diff --git a/basis/ui/gadgets/lib/lib.factor b/basis/ui/gadgets/lib/lib.factor
index 12385f0808..866369b0af 100644
--- a/basis/ui/gadgets/lib/lib.factor
+++ b/basis/ui/gadgets/lib/lib.factor
@@ -1,6 +1,8 @@
 
-USING: ui.backend ui.gadgets.worlds ;
+USING: accessors kernel ui.backend ui.gadgets.worlds ;
 
 IN: ui.gadgets.lib
 
-: find-gl-context ( gadget -- ) find-world world-handle select-gl-context ;
+ERROR: no-world-found ;
+: find-gl-context ( gadget -- )
+    find-world dup [ handle>> select-gl-context ] [ no-world-found ] if ;
diff --git a/basis/ui/gadgets/menus/menus.factor b/basis/ui/gadgets/menus/menus.factor
index 932353e428..26e405f6db 100644
--- a/basis/ui/gadgets/menus/menus.factor
+++ b/basis/ui/gadgets/menus/menus.factor
@@ -14,7 +14,7 @@ TUPLE: menu-glass < gadget ;
 
 : <menu-glass> ( menu world -- glass )
     menu-glass new-gadget
-    >r over menu-loc over set-rect-loc r>
+    >r over menu-loc >>loc r>
     [ swap add-gadget drop ] keep ;
 
 M: menu-glass layout* gadget-child prefer ;
diff --git a/basis/ui/gadgets/packs/packs.factor b/basis/ui/gadgets/packs/packs.factor
index ed64c1e990..207708afdf 100755
--- a/basis/ui/gadgets/packs/packs.factor
+++ b/basis/ui/gadgets/packs/packs.factor
@@ -32,7 +32,7 @@ TUPLE: pack < gadget
 : pack-layout ( pack sizes -- )
     round-dims over children>>
     >r dupd packed-dims r> 2dup [ (>>dim) ] 2each
-    >r packed-locs r> [ set-rect-loc ] 2each ;
+    >r packed-locs r> [ (>>loc) ] 2each ;
 
 : <pack> ( orientation -- pack )
     pack new-gadget
diff --git a/basis/ui/gadgets/panes/panes-tests.factor b/basis/ui/gadgets/panes/panes-tests.factor
index fd1ee0f573..109c0a1461 100755
--- a/basis/ui/gadgets/panes/panes-tests.factor
+++ b/basis/ui/gadgets/panes/panes-tests.factor
@@ -1,18 +1,18 @@
-IN: ui.gadgets.panes.tests
 USING: alien ui.gadgets.panes ui.gadgets namespaces
 kernel sequences io io.styles io.streams.string tools.test
 prettyprint definitions help help.syntax help.markup
 help.stylesheet splitting tools.test.ui models math summary
-inspector ;
+inspector accessors ;
+IN: ui.gadgets.panes.tests
 
-: #children "pane" get gadget-children length ;
+: #children "pane" get children>> length ;
 
 [ ] [ <pane> "pane" set ] unit-test
 
 [ ] [ #children "num-children" set ] unit-test
 
 [ ] [
-    "pane" get <pane-stream> [ 10000 [ . ] each ] with-output-stream*
+    "pane" get <pane-stream> [ 100 [ . ] each ] with-output-stream*
 ] unit-test
 
 [ t ] [ #children "num-children" get = ] unit-test
diff --git a/basis/ui/gadgets/panes/panes.factor b/basis/ui/gadgets/panes/panes.factor
index 0fca412d1f..7f00084104 100755
--- a/basis/ui/gadgets/panes/panes.factor
+++ b/basis/ui/gadgets/panes/panes.factor
@@ -60,10 +60,10 @@ M: gadget draw-selection ( loc gadget -- )
     swap offset-rect [ rect-extent gl-fill-rect ] if-fits ;
 
 M: node draw-selection ( loc node -- )
-    2dup node-value swap offset-rect [
+    2dup value>> swap offset-rect [
         drop 2dup
-        [ node-value rect-loc v+ ] keep
-        node-children [ draw-selection ] with each
+        [ value>> rect-loc v+ ] keep
+        children>> [ draw-selection ] with each
     ] if-fits 2drop ;
 
 M: pane draw-gadget*
diff --git a/basis/ui/gadgets/paragraphs/paragraphs.factor b/basis/ui/gadgets/paragraphs/paragraphs.factor
index 5e87484b2d..fed1fb97f1 100644
--- a/basis/ui/gadgets/paragraphs/paragraphs.factor
+++ b/basis/ui/gadgets/paragraphs/paragraphs.factor
@@ -69,4 +69,4 @@ M: paragraph pref-dim*
     [ 2drop ] do-wrap ;
 
 M: paragraph layout*
-    [ swap dup prefer set-rect-loc ] do-wrap drop ;
+    [ swap dup prefer (>>loc) ] do-wrap drop ;
diff --git a/basis/ui/gadgets/presentations/presentations-tests.factor b/basis/ui/gadgets/presentations/presentations-tests.factor
index fcbc65725a..358bf2b791 100644
--- a/basis/ui/gadgets/presentations/presentations-tests.factor
+++ b/basis/ui/gadgets/presentations/presentations-tests.factor
@@ -1,7 +1,7 @@
-IN: ui.gadgets.presentations.tests
 USING: math ui.gadgets.presentations ui.gadgets tools.test
 prettyprint ui.gadgets.buttons io io.streams.string kernel
-classes.tuple ;
+classes.tuple accessors ;
+IN: ui.gadgets.presentations.tests
 
 [ t ] [
     "Hi" \ + <presentation> gadget?
@@ -9,6 +9,6 @@ classes.tuple ;
 
 [ "+" ] [
     [
-        \ + f \ pprint <command-button> dup button-quot call
+        \ + f \ pprint <command-button> dup quot>> call
     ] with-string-writer
 ] unit-test
diff --git a/basis/ui/gadgets/scrollers/scrollers-tests.factor b/basis/ui/gadgets/scrollers/scrollers-tests.factor
index fb3e6cec23..48251c4927 100755
--- a/basis/ui/gadgets/scrollers/scrollers-tests.factor
+++ b/basis/ui/gadgets/scrollers/scrollers-tests.factor
@@ -1,9 +1,9 @@
-IN: ui.gadgets.scrollers.tests
 USING: ui.gadgets ui.gadgets.scrollers namespaces tools.test
 kernel models models.compose models.range ui.gadgets.viewports
 ui.gadgets.labels ui.gadgets.grids ui.gadgets.frames
 ui.gadgets.sliders math math.vectors arrays sequences
-tools.test.ui math.geometry.rect ;
+tools.test.ui math.geometry.rect accessors ;
+IN: ui.gadgets.scrollers.tests
 
 [ ] [
     <gadget> "g" set
@@ -12,11 +12,11 @@ tools.test.ui math.geometry.rect ;
 
 [ { 100 200 } ] [
     { 100 200 } "g" get scroll>rect
-    "s" get scroller-follows rect-loc
+    "s" get follows>> rect-loc
 ] unit-test
 
 [ ] [ "s" get scroll>bottom ] unit-test
-[ t ] [ "s" get scroller-follows ] unit-test
+[ t ] [ "s" get follows>> ] unit-test
 
 [ ] [
     <gadget> dup "g" set
@@ -25,46 +25,46 @@ tools.test.ui math.geometry.rect ;
 ] unit-test
 
 "v" get [
-    [ { 10 20 } ] [ "v" get gadget-model range-value ] unit-test
+    [ { 10 20 } ] [ "v" get model>> range-value ] unit-test
 
     [ { 10 20 } ] [ "g" get rect-loc vneg { 3 3 } v+ ] unit-test
 ] with-grafted-gadget
 
 [ ] [
-    <gadget> { 100 100 } over set-rect-dim
+    <gadget> { 100 100 } >>dim
     dup "g" set <scroller> "s" set
 ] unit-test
 
-[ ] [ { 50 50 } "s" get set-rect-dim ] unit-test
+[ ] [ "s" get { 50 50 } >>dim drop ] unit-test
 
 [ ] [ "s" get layout ] unit-test
 
 "s" get [
-    [ { 34 34 } ] [ "s" get scroller-viewport rect-dim ] unit-test
+    [ { 34 34 } ] [ "s" get viewport>> rect-dim ] unit-test
 
-    [ { 106 106 } ] [ "s" get scroller-viewport viewport-dim ] unit-test
+    [ { 106 106 } ] [ "s" get viewport>> viewport-dim ] unit-test
 
     [ ] [ { 0 0 } "s" get scroll ] unit-test
 
-    [ { 0 0 } ] [ "s" get gadget-model range-min-value ] unit-test
+    [ { 0 0 } ] [ "s" get model>> range-min-value ] unit-test
 
-    [ { 106 106 } ] [ "s" get gadget-model range-max-value ] unit-test
+    [ { 106 106 } ] [ "s" get model>> range-max-value ] unit-test
 
     [ ] [ { 10 20 } "s" get scroll ] unit-test
 
-    [ { 10 20 } ] [ "s" get gadget-model range-value ] unit-test
+    [ { 10 20 } ] [ "s" get model>> range-value ] unit-test
 
-    [ { 10 20 } ] [ "s" get scroller-viewport gadget-model range-value ] unit-test
+    [ { 10 20 } ] [ "s" get viewport>> model>> range-value ] unit-test
 
     [ { 10 20 } ] [ "g" get rect-loc vneg { 3 3 } v+ ] unit-test
 ] with-grafted-gadget
 
-<gadget> { 600 400 } over set-rect-dim "g1" set
-<gadget> { 600 10 } over set-rect-dim "g2" set
+<gadget> { 600 400 } >>dim "g1" set
+<gadget> { 600 10 } >>dim "g2" set
 "g2" get "g1" get swap add-gadget drop
 
 "g1" get <scroller>
-{ 300 300 } over set-rect-dim
+{ 300 300 } >>dim
 dup layout
 "s" set
 
@@ -80,9 +80,9 @@ dup layout
 [ ] [ "Hi" <label> dup "l" set <scroller> "s" set ] unit-test
 
 [ t ] [ "l" get find-scroller "s" get eq? ] unit-test
-[ t ] [ "l" get dup find-scroller scroller-viewport swap child? ] unit-test
+[ t ] [ "l" get dup find-scroller viewport>> swap child? ] unit-test
 [ t ] [ "l" get find-scroller* "s" get eq? ] unit-test
-[ f ] [ "s" get scroller-viewport find-scroller* ] unit-test
+[ f ] [ "s" get viewport>> find-scroller* ] unit-test
 [ t ] [ "s" get @right grid-child slider? ] unit-test
 [ f ] [ "s" get @right grid-child find-scroller* ] unit-test
 
diff --git a/basis/ui/gadgets/sliders/sliders.factor b/basis/ui/gadgets/sliders/sliders.factor
index 08551f3834..8d673e66ad 100755
--- a/basis/ui/gadgets/sliders/sliders.factor
+++ b/basis/ui/gadgets/sliders/sliders.factor
@@ -104,7 +104,7 @@ elevator H{
 
 : layout-thumb-loc ( slider -- )
     dup thumb-loc (layout-thumb)
-    >r [ floor ] map r> set-rect-loc ;
+    >r [ floor ] map r> (>>loc) ;
 
 : layout-thumb-dim ( slider -- )
     dup dup thumb-dim (layout-thumb) >r
diff --git a/basis/ui/gadgets/status-bar/status-bar-docs.factor b/basis/ui/gadgets/status-bar/status-bar-docs.factor
index 3f08c04e95..6203cd474e 100755
--- a/basis/ui/gadgets/status-bar/status-bar-docs.factor
+++ b/basis/ui/gadgets/status-bar/status-bar-docs.factor
@@ -5,4 +5,4 @@ IN: ui.gadgets.status-bar
 HELP: <status-bar>
 { $values { "model" model } { "gadget" "a new " { $link gadget } } }
 { $description "Creates a new " { $link gadget } " displaying the model value, which must be a string or " { $link f } "." }
-{ $notes "If the " { $snippet "model" } " is " { $link world-status } ", this gadget will display  mouse over help for " { $link "ui.gadgets.presentations" } "." } ;
+{ $notes "If the " { $snippet "model" } " is " { $snippet "status" } ", this gadget will display mouse over help for " { $link "ui.gadgets.presentations" } "." } ;
diff --git a/basis/ui/gadgets/viewports/viewports.factor b/basis/ui/gadgets/viewports/viewports.factor
index 79aca6bd35..c6e4b044cd 100755
--- a/basis/ui/gadgets/viewports/viewports.factor
+++ b/basis/ui/gadgets/viewports/viewports.factor
@@ -38,7 +38,7 @@ M: viewport model-changed
     dup relayout-1
     dup scroller-value
     vneg viewport-gap v+
-    swap gadget-child set-rect-loc ;
+    swap gadget-child (>>loc) ;
 
 : visible-dim ( gadget -- dim )
     dup parent>> viewport?
diff --git a/basis/ui/gadgets/worlds/worlds-docs.factor b/basis/ui/gadgets/worlds/worlds-docs.factor
index f3b85a2861..122d14eed7 100755
--- a/basis/ui/gadgets/worlds/worlds-docs.factor
+++ b/basis/ui/gadgets/worlds/worlds-docs.factor
@@ -46,7 +46,7 @@ HELP: <world>
 { $description "Creates a new " { $link world } " delegating to the given gadget." } ;
 
 HELP: find-world
-{ $values { "gadget" gadget } { "world" "a " { $link world } " or " { $link f } } }
+{ $values { "gadget" gadget } { "world/f" "a " { $link world } " or " { $link f } } }
 { $description "Finds the " { $link world } " containing the gadget, or outputs " { $link f } " if the gadget is not grafted." } ;
 
 HELP: draw-world
diff --git a/basis/ui/gadgets/worlds/worlds-tests.factor b/basis/ui/gadgets/worlds/worlds-tests.factor
index 4ce54c583f..dbaaa33a51 100644
--- a/basis/ui/gadgets/worlds/worlds-tests.factor
+++ b/basis/ui/gadgets/worlds/worlds-tests.factor
@@ -1,6 +1,6 @@
-IN: ui.gadgets.worlds.tests
 USING: ui.gadgets ui.gadgets.packs ui.gadgets.worlds tools.test
-namespaces models kernel ;
+namespaces models kernel accessors ;
+IN: ui.gadgets.worlds.tests
 
 ! Test focus behavior
 <gadget> "g1" set
@@ -14,7 +14,7 @@ namespaces models kernel ;
 
 [ ] [ "g1" get request-focus ] unit-test
 
-[ t ] [ "w" get gadget-focus "g1" get eq? ] unit-test
+[ t ] [ "w" get focus>> "g1" get eq? ] unit-test
 
 <gadget> "g1" set
 <gadget> "g2" set
@@ -26,9 +26,9 @@ namespaces models kernel ;
 
 [ ] [ "g1" get request-focus ] unit-test
 
-[ t ] [ "w" get gadget-focus "g2" get eq? ] unit-test
-[ t ] [ "g2" get gadget-focus "g1" get eq? ] unit-test
-[ f ] [ "g1" get gadget-focus ] unit-test
+[ t ] [ "w" get focus>> "g2" get eq? ] unit-test
+[ t ] [ "g2" get focus>> "g1" get eq? ] unit-test
+[ f ] [ "g1" get focus>> ] unit-test
 
 <gadget> "g1" set
 <gadget> "g2" set
@@ -42,7 +42,7 @@ namespaces models kernel ;
 
 [ ] [ "g1" get request-focus ] unit-test
 [ ] [ "g2" get unparent ] unit-test
-[ t ] [ "g3" get gadget-focus "g1" get eq? ] unit-test
+[ t ] [ "g3" get focus>> "g1" get eq? ] unit-test
 
 [ t ] [ <gadget> dup <test-world> focusable-child eq? ] unit-test
 
@@ -63,6 +63,6 @@ M: focus-test focusable-child* gadget-child ;
 
 [ ] [ "f" get <test-world> request-focus ] unit-test
 
-[ t ] [ "f" get gadget-focus "f" get gadget-child eq? ] unit-test
+[ t ] [ "f" get focus>> "f" get gadget-child eq? ] unit-test
 
 [ t ] [ "f" get gadget-child focusing? ] unit-test
diff --git a/basis/ui/gadgets/worlds/worlds.factor b/basis/ui/gadgets/worlds/worlds.factor
index 80228691ec..bf4c275dc2 100755
--- a/basis/ui/gadgets/worlds/worlds.factor
+++ b/basis/ui/gadgets/worlds/worlds.factor
@@ -13,12 +13,12 @@ title status
 fonts handle
 window-loc ;
 
-: find-world ( gadget -- world ) [ world? ] find-parent ;
-
-M: f world-status ;
+: find-world ( gadget -- world/f ) [ world? ] find-parent ;
 
 : show-status ( string/f gadget -- )
-    find-world world-status [ set-model ] [ drop ] if* ;
+    find-world dup [
+        status>> dup [ set-model ] [ 2drop ] if
+    ] [ 2drop ] if ;
 
 : hide-status ( gadget -- ) f swap show-status ;
 
diff --git a/basis/ui/gestures/gestures-docs.factor b/basis/ui/gestures/gestures-docs.factor
index bcf7eb5ca8..0575ff17f0 100644
--- a/basis/ui/gestures/gestures-docs.factor
+++ b/basis/ui/gestures/gestures-docs.factor
@@ -30,13 +30,13 @@ HELP: motion
 { $examples { $code "T{ motion }" } } ;
 
 HELP: drag
-{ $class-description "Mouse drag gesture. The " { $link drag-# } " slot is either set to a mouse button number, or " { $link f } " indicating no specific button is expected." } ;
+{ $class-description "Mouse drag gesture. The " { $snippet "#" } " slot is either set to a mouse button number, or " { $link f } " indicating no specific button is expected." } ;
 
 HELP: button-up
 { $class-description "Mouse button up gesture. Instances have two slots:"
     { $list
-        { { $link button-up-mods } " - a sequence of modifiers; see " { $link "keyboard-gestures" } }
-        { { $link button-up-# } " - a mouse button number, or " { $link f } " indicating no specific button is expected" }
+        { { $snippet "mods" } " - a sequence of modifiers; see " { $link "keyboard-gestures" } }
+        { { $snippet "#" } " - a mouse button number, or " { $link f } " indicating no specific button is expected" }
     }
 }
 { $examples { $code "T{ button-up f f 1 }" "T{ button-up }" } } ;
@@ -44,8 +44,8 @@ HELP: button-up
 HELP: button-down
 { $class-description "Mouse button down gesture. Instances have two slots:"
     { $list
-        { { $link button-down-mods } " - a sequence of modifiers; see " { $link "keyboard-gestures" } }
-        { { $link button-down-# } " - a mouse button number, or " { $link f } " indicating no specific button is expected" }
+        { { $snippet "mods" } " - a sequence of modifiers; see " { $link "keyboard-gestures" } }
+        { { $snippet "#" } " - a mouse button number, or " { $link f } " indicating no specific button is expected" }
     }
 }
 { $examples { $code "T{ button-down f f 1 }" "T{ button-down }" } } ;
@@ -109,8 +109,8 @@ HELP: S+
 HELP: key-down
 { $class-description "Key down gesture. Instances have two slots:"
     { $list
-        { { $link key-down-mods } " - a sequence of modifiers; see " { $link "keyboard-gestures" } }
-    { { $link key-down-sym } " - a string denoting the key pressed; see " { $link "keyboard-gestures" } }
+        { { $snippet "mods" } " - a sequence of modifiers; see " { $link "keyboard-gestures" } }
+    { { $snippet "sym" } " - a string denoting the key pressed; see " { $link "keyboard-gestures" } }
     }
 }
 { $examples { $code "T{ key-down f { C+ } \"a\" }" "T{ key-down f f \"TAB\" }" } } ;
@@ -118,8 +118,8 @@ HELP: key-down
 HELP: key-up
 { $class-description "Key up gesture. Instances have two slots:"
     { $list
-        { { $link key-up-mods } " - a sequence of modifiers; see " { $link "keyboard-gestures" } }
-    { { $link key-up-sym } " - a string denoting the key pressed; see " { $link "keyboard-gestures" } }
+        { { $snippet "mods" } " - a sequence of modifiers; see " { $link "keyboard-gestures" } }
+    { { $snippet "sym" } " - a string denoting the key pressed; see " { $link "keyboard-gestures" } }
     }
 }
 { $examples { $code "T{ key-up f { C+ } \"a\" }" "T{ key-up f f \"TAB\" }" } } ;
diff --git a/basis/ui/gestures/gestures.factor b/basis/ui/gestures/gestures.factor
index 95417ac71f..6b53d25ea1 100755
--- a/basis/ui/gestures/gestures.factor
+++ b/basis/ui/gestures/gestures.factor
@@ -226,14 +226,14 @@ SYMBOL: drag-timer
 : send-button-down ( gesture loc world -- )
     move-hand
     start-drag-timer
-    dup button-down-#
+    dup #>>
     dup update-click# hand-buttons get-global push
     update-clicked
     button-gesture ;
 
 : send-button-up ( gesture loc world -- )
     move-hand
-    dup button-up-# hand-buttons get-global delete
+    dup #>> hand-buttons get-global delete
     stop-drag-timer
     button-gesture ;
 
@@ -261,21 +261,21 @@ GENERIC: gesture>string ( gesture -- string/f )
     [ name>> ] map concat >string ;
 
 M: key-down gesture>string
-    dup key-down-mods modifiers>string
-    swap key-down-sym append ;
+    dup mods>> modifiers>string
+    swap sym>> append ;
 
 M: button-up gesture>string
     [
-        dup button-up-mods modifiers>string %
+        dup mods>> modifiers>string %
         "Click Button" %
-        button-up-# [ " " % # ] when*
+        #>> [ " " % # ] when*
     ] "" make ;
 
 M: button-down gesture>string
     [
-        dup button-down-mods modifiers>string %
+        dup mods>> modifiers>string %
         "Press Button" %
-        button-down-# [ " " % # ] when*
+        #>> [ " " % # ] when*
     ] "" make ;
 
 M: left-action gesture>string drop "Swipe left" ;
diff --git a/basis/ui/operations/operations-docs.factor b/basis/ui/operations/operations-docs.factor
index 5f7ed60f38..ebdf3eee1f 100644
--- a/basis/ui/operations/operations-docs.factor
+++ b/basis/ui/operations/operations-docs.factor
@@ -22,11 +22,11 @@ HELP: operation
 $nl
 "Operations have the following slots:"
 { $list
-    { { $link operation-predicate } " - a quotation with stack effect " { $snippet "( obj -- ? )" } }
-    { { $link operation-command } " - a " { $link word } }
-    { { $link operation-translator } " - a quotation with stack effect " { $snippet "( obj -- newobj )" } ", or " { $link f } }
-    { { $link operation-hook } " - a quotation with stack effect " { $snippet "( obj -- newobj )" } ", or " { $link f } }
-    { { $link operation-listener? } " - a boolean" }
+    { { $snippet "predicate" } " - a quotation with stack effect " { $snippet "( obj -- ? )" } }
+    { { $snippet "command" } " - a " { $link word } }
+    { { $snippet "translator" } " - a quotation with stack effect " { $snippet "( obj -- newobj )" } ", or " { $link f } }
+    { { $snippet "hook" } " - a quotation with stack effect " { $snippet "( obj -- newobj )" } ", or " { $link f } }
+    { { $snippet "listener?" } " - a boolean" }
 } } ;
 
 HELP: operation-gesture
@@ -38,7 +38,7 @@ HELP: operations
 
 HELP: object-operations
 { $values { "obj" object } { "operations" "a sequence of " { $link operation } " instances" } }
-{ $description "Outputs a sequence of operations applicable to the given object, by testing each defined operation's " { $link operation-predicate } " quotation in turn." } ;
+{ $description "Outputs a sequence of operations applicable to the given object, by testing each defined operation's " { $snippet "predicate" } " quotation in turn." } ;
 
 HELP: primary-operation
 { $values { "obj" object } { "operation" "an " { $link operation  } " or " { $link f } } }
diff --git a/basis/ui/operations/operations-tests.factor b/basis/ui/operations/operations-tests.factor
index 1072340cce..6e4e7c3a5d 100755
--- a/basis/ui/operations/operations-tests.factor
+++ b/basis/ui/operations/operations-tests.factor
@@ -1,14 +1,14 @@
 IN: ui.operations.tests
 USING: ui.operations ui.commands prettyprint kernel namespaces
 tools.test ui.gadgets ui.gadgets.editors parser io
-io.streams.string math help help.markup ;
+io.streams.string math help help.markup accessors ;
 
 : my-pprint pprint ;
 
 [ drop t ] \ my-pprint [ ] [ ] f operation boa "op" set
 
 [ [ 3 my-pprint ] ] [
-    3 "op" get operation-command command-quot
+    3 "op" get command>> command-quot
 ] unit-test
 
 [ "3" ] [ [ 3 "op" get invoke-command ] with-string-writer ] unit-test
diff --git a/basis/ui/operations/operations.factor b/basis/ui/operations/operations.factor
index 5a47f9e80b..8b4817dcac 100755
--- a/basis/ui/operations/operations.factor
+++ b/basis/ui/operations/operations.factor
@@ -19,34 +19,34 @@ TUPLE: operation predicate command translator hook listener? ;
         swap >>predicate ;
 
 PREDICATE: listener-operation < operation
-    dup operation-command listener-command?
-    swap operation-listener? or ;
+    dup command>> listener-command?
+    swap listener?>> or ;
 
 M: operation command-name
-    operation-command command-name ;
+    command>> command-name ;
 
 M: operation command-description
-    operation-command command-description ;
+    command>> command-description ;
 
-M: operation command-word operation-command command-word ;
+M: operation command-word command>> command-word ;
 
 : operation-gesture ( operation -- gesture )
-    operation-command +keyboard+ word-prop ;
+    command>> +keyboard+ word-prop ;
 
 SYMBOL: operations
 
 : object-operations ( obj -- operations )
-    operations get [ operation-predicate call ] with filter ;
+    operations get [ predicate>> call ] with filter ;
 
 : find-operation ( obj quot -- command )
     >r object-operations r> find-last nip ; inline
 
 : primary-operation ( obj -- operation )
-    [ operation-command +primary+ word-prop ] find-operation ;
+    [ command>> +primary+ word-prop ] find-operation ;
 
 : secondary-operation ( obj -- operation )
     dup
-    [ operation-command +secondary+ word-prop ] find-operation
+    [ command>> +secondary+ word-prop ] find-operation
     [ ] [ primary-operation ] ?if ;
 
 : default-flags ( -- assoc )
@@ -59,9 +59,9 @@ SYMBOL: operations
 
 : modify-operation ( hook translator operation -- operation )
     clone
-    tuck set-operation-translator
-    tuck set-operation-hook
-    t over set-operation-listener? ;
+    tuck (>>translator)
+    tuck (>>hook)
+    t over (>>listener?) ;
 
 : modify-operations ( operations hook translator -- operations )
     rot [ >r 2dup r> modify-operation ] map 2nip ;
@@ -76,9 +76,9 @@ SYMBOL: operations
 : operation-quot ( target command -- quot )
     [
         swap literalize ,
-        dup operation-translator %
-        operation-command ,
+        dup translator>> %
+        command>> ,
     ] [ ] make ;
 
 M: operation invoke-command ( target command -- )
-    [ operation-hook call ] keep operation-quot call ;
+    [ hook>> call ] keep operation-quot call ;
diff --git a/basis/ui/render/render-docs.factor b/basis/ui/render/render-docs.factor
index 04b623672d..fc16ed9345 100755
--- a/basis/ui/render/render-docs.factor
+++ b/basis/ui/render/render-docs.factor
@@ -38,16 +38,16 @@ HELP: draw-boundary
 { $contract "Draws the boundary of a gadget by making OpenGL calls. The " { $snippet "boundary" } " slot may be set to objects implementing this generic word." } ;
 
 HELP: solid
-{ $class-description "A class implementing the " { $link draw-boundary } " and " { $link draw-interior } " generic words to draw a solid outline or a solid fill, respectively. The " { $link solid-color } " slot stores a color specifier." } ;
+{ $class-description "A class implementing the " { $link draw-boundary } " and " { $link draw-interior } " generic words to draw a solid outline or a solid fill, respectively. The " { $snippet "color" } " slot stores a color specifier." } ;
 
 HELP: gradient
-{ $class-description "A class implementing the " { $link draw-interior } " generic word to draw a smoothly shaded transition between colors. The " { $link gradient-colors } " slot stores a sequence of color specifiers and the gradient is drawn in the direction given by the " { $snippet "orientation" } " slot of the gadget." } ;
+{ $class-description "A class implementing the " { $link draw-interior } " generic word to draw a smoothly shaded transition between colors. The " { $snippet "colors" } " slot stores a sequence of color specifiers and the gradient is drawn in the direction given by the " { $snippet "orientation" } " slot of the gadget." } ;
 
 HELP: polygon
 { $class-description "A class implementing the " { $link draw-boundary } " and " { $link draw-interior } " generic words to draw a solid outline or a solid filled polygon, respectively. Instances of " { $link polygon } " have two slots:"
     { $list
-        { { $link polygon-color } " - a color specifier" }
-        { { $link polygon-points } " - a sequence of points" }
+        { { $snippet "color" } " - a color specifier" }
+        { { $snippet "points" } " - a sequence of points" }
     }
 } ;
 
diff --git a/basis/ui/render/render.factor b/basis/ui/render/render.factor
index c7bfc99024..2147fc2b53 100644
--- a/basis/ui/render/render.factor
+++ b/basis/ui/render/render.factor
@@ -95,7 +95,7 @@ C: <solid> solid
 
 ! Solid pen
 : (solid) ( gadget paint -- loc dim )
-    solid-color set-color rect-dim >r origin get dup r> v+ ;
+    color>> set-color rect-dim >r origin get dup r> v+ ;
 
 M: solid draw-interior (solid) gl-fill-rect ;
 
@@ -109,7 +109,7 @@ C: <gradient> gradient
 M: gradient draw-interior
     origin get [
         over orientation>>
-        swap gradient-colors
+        swap colors>>
         rot rect-dim
         gl-gradient
     ] with-translation ;
@@ -121,7 +121,7 @@ C: <polygon> polygon
 
 : draw-polygon ( polygon quot -- )
     origin get [
-        >r dup polygon-color set-color polygon-points r> call
+        >r dup color>> set-color points>> r> call
     ] with-translation ; inline
 
 M: polygon draw-boundary
@@ -138,7 +138,7 @@ M: polygon draw-interior
 
 : <polygon-gadget> ( color points -- gadget )
     dup max-dim
-    >r <polygon> <gadget> r> over set-rect-dim
+    >r <polygon> <gadget> r> >>dim
     [ (>>interior) ] keep ;
 
 ! Font rendering
diff --git a/basis/ui/tools/browser/browser.factor b/basis/ui/tools/browser/browser.factor
index 8f180714c8..33523701aa 100755
--- a/basis/ui/tools/browser/browser.factor
+++ b/basis/ui/tools/browser/browser.factor
@@ -39,17 +39,17 @@ M: browser-gadget ungraft*
 
 : showing-definition? ( defspec assoc -- ? )
     [ key? ] 2keep
-    [ >r dup word-link? [ link-name ] when r> key? ] 2keep
+    [ >r dup word-link? [ name>> ] when r> key? ] 2keep
     >r dup vocab-link? [ vocab ] when r> key?
     or or ;
 
 M: browser-gadget definitions-changed ( assoc browser -- )
     history>>
-    dup model-value rot showing-definition?
+    dup value>> rot showing-definition?
     [ notify-connections ] [ drop ] if ;
 
 : help-action ( browser-gadget -- link )
-    history>> model-value >link ;
+    history>> value>> >link ;
 
 : com-follow ( link -- ) browser-gadget call-tool ;
 
diff --git a/basis/ui/tools/debugger/debugger.factor b/basis/ui/tools/debugger/debugger.factor
index 203406c6cb..4ba4374bb8 100644
--- a/basis/ui/tools/debugger/debugger.factor
+++ b/basis/ui/tools/debugger/debugger.factor
@@ -11,7 +11,7 @@ USING: accessors arrays ui ui.commands ui.gestures ui.gadgets
 IN: ui.tools.debugger
 
 : <restart-list> ( restarts restart-hook -- gadget )
-    [ restart-name ] rot <model> <list> ;
+    [ name>> ] rot <model> <list> ;
 
 TUPLE: debugger < track restarts ;
 
@@ -29,7 +29,7 @@ TUPLE: debugger < track restarts ;
         -rot <restart-list> >>restarts
         dup restarts>> rot <debugger-display> <scroller> 1 track-add ;
 
-M: debugger focusable-child* debugger-restarts ;
+M: debugger focusable-child* restarts>> ;
 
 : debugger-window ( error -- )
     #! No restarts for the debugger window
diff --git a/basis/ui/tools/deploy/deploy.factor b/basis/ui/tools/deploy/deploy.factor
index b68e5162a3..285757e390 100755
--- a/basis/ui/tools/deploy/deploy.factor
+++ b/basis/ui/tools/deploy/deploy.factor
@@ -65,13 +65,13 @@ TUPLE: deploy-gadget < pack vocab settings ;
     [ deploy-gadget? ] find-parent ;
 
 : find-deploy-vocab ( gadget -- vocab )
-    find-deploy-gadget deploy-gadget-vocab ;
+    find-deploy-gadget vocab>> ;
 
 : find-deploy-config ( gadget -- config )
     find-deploy-vocab deploy-config ;
 
 : find-deploy-settings ( gadget -- settings )
-    find-deploy-gadget deploy-gadget-settings ;
+    find-deploy-gadget settings>> ;
 
 : com-revert ( gadget -- )
     dup find-deploy-config
diff --git a/basis/ui/tools/inspector/inspector.factor b/basis/ui/tools/inspector/inspector.factor
index bb0f02ec7e..273d6bc549 100644
--- a/basis/ui/tools/inspector/inspector.factor
+++ b/basis/ui/tools/inspector/inspector.factor
@@ -47,4 +47,4 @@ inspector-gadget "multi-touch" f {
 } define-command-map
 
 M: inspector-gadget tool-scroller
-    inspector-gadget-pane find-scroller ;
+    pane>> find-scroller ;
diff --git a/basis/ui/tools/interactor/interactor.factor b/basis/ui/tools/interactor/interactor.factor
index 20428a39b6..a36610a7f5 100755
--- a/basis/ui/tools/interactor/interactor.factor
+++ b/basis/ui/tools/interactor/interactor.factor
@@ -61,7 +61,7 @@ M: interactor ungraft*
 
 M: interactor model-changed
     2dup help>> eq? [
-        swap model-value over word-at-loc swap show-summary
+        swap value>> over word-at-loc swap show-summary
     ] [
         call-next-method
     ] if ;
@@ -76,7 +76,7 @@ M: interactor model-changed
     ] with-output-stream* ;
 
 : add-interactor-history ( str interactor -- )
-    over empty? [ 2drop ] [ interactor-history adjoin ] if ;
+    over empty? [ 2drop ] [ history>> adjoin ] if ;
 
 : interactor-continue ( obj interactor -- )
     mailbox>> mailbox-put ;
diff --git a/basis/ui/tools/listener/listener-tests.factor b/basis/ui/tools/listener/listener-tests.factor
index e3363a7321..dff45251d1 100755
--- a/basis/ui/tools/listener/listener-tests.factor
+++ b/basis/ui/tools/listener/listener-tests.factor
@@ -30,7 +30,7 @@ IN: ui.tools.listener.tests
     ] unit-test
     
     [ t ] [
-        "i" get gadget-model doc-end
+        "i" get model>> doc-end
         "i" get editor-caret* =
     ] unit-test
 
diff --git a/basis/ui/tools/listener/listener.factor b/basis/ui/tools/listener/listener.factor
index 1ae99b800d..683eff9457 100755
--- a/basis/ui/tools/listener/listener.factor
+++ b/basis/ui/tools/listener/listener.factor
@@ -64,7 +64,7 @@ M: listener-command invoke-command ( target command -- )
     command-quot call-listener ;
 
 M: listener-operation invoke-command ( target command -- )
-    [ operation-hook call ] keep operation-quot call-listener ;
+    [ hook>> call ] keep operation-quot call-listener ;
 
 : eval-listener ( string -- )
     get-workspace
@@ -110,7 +110,7 @@ M: engine-word word-completion-string
     ] [ 2drop ] if ;
 
 : insert-word ( word -- )
-    get-workspace workspace-listener input>>
+    get-workspace listener>> input>>
     [ >r word-completion-string r> user-input ]
     [ interactor-use use-if-necessary ]
     2bi ;
@@ -131,10 +131,10 @@ TUPLE: stack-display < track ;
     1 track-add ;
 
 M: stack-display tool-scroller
-    find-workspace workspace-listener tool-scroller ;
+    find-workspace listener>> tool-scroller ;
 
 : ui-listener-hook ( listener -- )
-    >r datastack r> listener-gadget-stack set-model ;
+    >r datastack r> stack>> set-model ;
 
 : ui-error-hook ( error listener -- )
     find-workspace debugger-popup ;
@@ -168,7 +168,7 @@ M: stack-display tool-scroller
     } cleave ;
 
 : init-listener ( listener -- )
-    f <model> swap set-listener-gadget-stack ;
+    f <model> swap (>>stack) ;
 
 : <listener-gadget> ( -- gadget )
   { 0 1 } listener-gadget new-track
diff --git a/basis/ui/tools/profiler/profiler.factor b/basis/ui/tools/profiler/profiler.factor
index f440bd8766..98717fc7bc 100755
--- a/basis/ui/tools/profiler/profiler.factor
+++ b/basis/ui/tools/profiler/profiler.factor
@@ -14,7 +14,7 @@ TUPLE: profiler-gadget < track pane ;
     dup pane>> <scroller> 1 track-add ;
     
 : with-profiler-pane ( gadget quot -- )
-    >r profiler-gadget-pane r> with-pane ;
+    >r pane>> r> with-pane ;
 
 : com-full-profile ( gadget -- )
     [ profile. ] with-profiler-pane ;
@@ -39,10 +39,10 @@ profiler-gadget "toolbar" f {
 GENERIC: profiler-presentation ( obj -- quot )
 
 M: usage-profile profiler-presentation
-    usage-profile-word [ usage-profile. ] curry ;
+    word>> [ usage-profile. ] curry ;
 
 M: vocab-profile profiler-presentation
-    vocab-profile-vocab [ vocab-profile. ] curry ;
+    vocab>> [ vocab-profile. ] curry ;
 
 M: f profiler-presentation
     drop [ vocabs-profile. ] ;
diff --git a/basis/ui/tools/search/search-tests.factor b/basis/ui/tools/search/search-tests.factor
index 34e1823a42..dcfb7346b4 100755
--- a/basis/ui/tools/search/search-tests.factor
+++ b/basis/ui/tools/search/search-tests.factor
@@ -1,6 +1,6 @@
 USING: assocs ui.tools.search help.topics io.files io.styles
 kernel namespaces sequences source-files threads
-tools.test ui.gadgets ui.gestures vocabs
+tools.test ui.gadgets ui.gestures vocabs accessors
 vocabs.loader words tools.test.ui debugger ;
 IN: ui.tools.search.tests
 
@@ -15,7 +15,7 @@ IN: ui.tools.search.tests
 : update-live-search ( search -- seq )
     dup [
         300 sleep
-        live-search-list control-value
+        list>> control-value
     ] with-grafted-gadget ;
 
 : test-live-search ( gadget quot -- ? )
@@ -29,7 +29,7 @@ IN: ui.tools.search.tests
 [ t ] [
     "" all-words t <definition-search>
     dup [
-        { "set-word-prop" } over live-search-field set-control-value
+        { "set-word-prop" } over field>> set-control-value
         300 sleep
         search-value \ set-word-prop eq?
     ] with-grafted-gadget
diff --git a/basis/ui/tools/search/search.factor b/basis/ui/tools/search/search.factor
index 407484ba97..5237813fe0 100755
--- a/basis/ui/tools/search/search.factor
+++ b/basis/ui/tools/search/search.factor
@@ -14,7 +14,7 @@ IN: ui.tools.search
 TUPLE: live-search < track field list ;
 
 : search-value ( live-search -- value )
-    live-search-list list-value ;
+    list>> list-value ;
 
 : search-gesture ( gesture live-search -- operation/f )
     search-value object-operations
@@ -32,7 +32,7 @@ M: live-search handle-gesture ( gesture live-search -- ? )
     [ live-search? ] find-parent ;
 
 : find-search-list ( gadget -- list )
-    find-live-search live-search-list ;
+    find-live-search list>> ;
 
 TUPLE: search-field < editor ;
 
@@ -70,12 +70,12 @@ search-field H{
     over field>> set-editor-string
   dup field>> end-of-document ;
 
-M: live-search focusable-child* live-search-field ;
+M: live-search focusable-child* field>> ;
 
 M: live-search pref-dim* drop { 400 200 } ;
 
 : current-word ( workspace -- string )
-    workspace-listener listener-gadget-input selected-word ;
+    listener>> input>> selected-word ;
 
 : definition-candidates ( words -- candidates )
     [ dup synopsis >lower ] { } map>assoc sort-values ;
@@ -118,7 +118,7 @@ M: live-search pref-dim* drop { 400 200 } ;
 
 : <source-file-search> ( string files -- gadget )
     source-file-candidates
-    f [ pathname-string ] <live-search> ;
+    f [ string>> ] <live-search> ;
 
 : all-source-files ( -- seq )
     source-files get keys natural-sort ;
@@ -146,13 +146,13 @@ M: live-search pref-dim* drop { 400 200 } ;
 
 : <history-search> ( string seq -- gadget )
     history-candidates
-    f [ input-string ] <live-search> ;
+    f [ string>> ] <live-search> ;
 
 : listener-history ( listener -- seq )
-    listener-gadget-input interactor-history <reversed> ;
+    input>> history>> <reversed> ;
 
 : com-history ( workspace -- )
-    "" over workspace-listener listener-history <history-search>
+    "" over listener>> listener-history <history-search>
     "History search" show-titled-popup ;
 
 workspace "toolbar" f {
diff --git a/basis/ui/tools/tools-tests.factor b/basis/ui/tools/tools-tests.factor
index e9c907a33f..b38dd52b6e 100755
--- a/basis/ui/tools/tools-tests.factor
+++ b/basis/ui/tools/tools-tests.factor
@@ -14,7 +14,7 @@ IN: ui.tools.tests
 [ ] [ "w" get com-scroll-up ] unit-test
 [ ] [ "w" get com-scroll-down ] unit-test
 [ t ] [
-    "w" get workspace-book gadget-children
+    "w" get book>> children>>
     [ tool-scroller ] map sift [ scroller? ] all?
 ] unit-test
 [ ] [ "w" get hide-popup ] unit-test
@@ -35,8 +35,8 @@ IN: ui.tools.tests
 
     [ ] [ notify-queued ] unit-test
 
-    [ ] [ "w" get workspace-popup closable-gadget-content
-    live-search-list gadget-child "p" set ] unit-test
+    [ ] [ "w" get popup>> content>>
+    list>> gadget-child "p" set ] unit-test
 
     [ t ] [ "p" get presentation? ] unit-test
 
@@ -47,7 +47,7 @@ IN: ui.tools.tests
     [ t ] [ "c" get button? ] unit-test
 
     [ ] [
-        "w" get workspace-listener listener-gadget-input
+        "w" get listener>> input>>
         3 handle-parse-error
     ] unit-test
 
diff --git a/basis/ui/tools/tools.factor b/basis/ui/tools/tools.factor
index a437c2dbb6..21fa44b593 100755
--- a/basis/ui/tools/tools.factor
+++ b/basis/ui/tools/tools.factor
@@ -54,7 +54,7 @@ IN: ui.tools
 
 M: workspace model-changed
     nip
-    dup workspace-listener listener-gadget-output scroll>bottom
+    dup listener>> output>> scroll>bottom
     dup resize-workspace
     request-focus ;
 
diff --git a/basis/ui/tools/traceback/traceback.factor b/basis/ui/tools/traceback/traceback.factor
index 05cb043e49..92c5e09a88 100755
--- a/basis/ui/tools/traceback/traceback.factor
+++ b/basis/ui/tools/traceback/traceback.factor
@@ -9,15 +9,15 @@ USING: accessors continuations kernel models namespaces
 IN: ui.tools.traceback
 
 : <callstack-display> ( model -- gadget )
-    [ [ continuation-call callstack. ] when* ]
+    [ [ call>> callstack. ] when* ]
     t "Call stack" <labelled-pane> ;
 
 : <datastack-display> ( model -- gadget )
-    [ [ continuation-data stack. ] when* ]
+    [ [ data>> stack. ] when* ]
     t "Data stack" <labelled-pane> ;
 
 : <retainstack-display> ( model -- gadget )
-    [ [ continuation-retain stack. ] when* ]
+    [ [ retain>> stack. ] when* ]
     t "Retain stack" <labelled-pane> ;
 
 TUPLE: traceback-gadget < track ;
@@ -39,7 +39,7 @@ M: traceback-gadget pref-dim* drop { 550 600 } ;
     dup <toolbar> f track-add ;
 
 : <namestack-display> ( model -- gadget )
-    [ [ continuation-name namestack. ] when* ]
+    [ [ name>> namestack. ] when* ]
     <pane-control> ;
 
 : <variables-gadget> ( model -- gadget )
diff --git a/basis/ui/tools/walker/walker.factor b/basis/ui/tools/walker/walker.factor
index c667e6918d..51091c576d 100755
--- a/basis/ui/tools/walker/walker.factor
+++ b/basis/ui/tools/walker/walker.factor
@@ -41,7 +41,7 @@ M: walker-gadget focusable-child*
 : walker-state-string ( status thread -- string )
     [
         "Thread: " %
-        dup thread-name %
+        dup name>> %
         " (" %
         swap {
             { +stopped+ "Stopped" }
@@ -84,7 +84,7 @@ walker-gadget "toolbar" f {
 : walker-for-thread? ( thread gadget -- ? )
     {
         { [ dup walker-gadget? not ] [ 2drop f ] }
-        { [ dup walker-gadget-closing? ] [ 2drop f ] }
+        { [ dup closing?>> ] [ 2drop f ] }
         [ thread>> eq? ]
     } cond ;
 
@@ -92,7 +92,7 @@ walker-gadget "toolbar" f {
     [ swap walker-for-thread? ] curry find-window ;
 
 : walker-window ( status continuation thread -- )
-    [ <walker-gadget> ] [ thread-name ] bi open-status-window ;
+    [ <walker-gadget> ] [ name>> ] bi open-status-window ;
 
 [
     dup find-walker-window dup
diff --git a/basis/ui/tools/workspace/workspace.factor b/basis/ui/tools/workspace/workspace.factor
index bc758e9eb8..ab6b3fe1cf 100755
--- a/basis/ui/tools/workspace/workspace.factor
+++ b/basis/ui/tools/workspace/workspace.factor
@@ -29,7 +29,7 @@ M: gadget tool-scroller drop f ;
   book>> children>> [ class eq? ] with find ;
 
 : show-tool ( class workspace -- tool )
-    [ find-tool swap ] keep workspace-book model>>
+    [ find-tool swap ] keep book>> model>>
     set-model ;
 
 : select-tool ( workspace class -- ) swap show-tool drop ;
@@ -81,10 +81,10 @@ SYMBOL: workspace-dim
 M: workspace pref-dim* drop workspace-dim get ;
 
 M: workspace focusable-child*
-    dup workspace-popup [ ] [ workspace-listener ] ?if ;
+    dup popup>> [ ] [ listener>> ] ?if ;
 
 : workspace-page ( workspace -- gadget )
-    workspace-book current-page ;
+    book>> current-page ;
 
 M: workspace tool-scroller ( workspace -- scroller )
     workspace-page tool-scroller ;
diff --git a/basis/ui/traverse/traverse-tests.factor b/basis/ui/traverse/traverse-tests.factor
index 5e6ac4125b..8486aaff21 100755
--- a/basis/ui/traverse/traverse-tests.factor
+++ b/basis/ui/traverse/traverse-tests.factor
@@ -1,14 +1,14 @@
-IN: ui.traverse.tests
-USING: ui.gadgets ui.gadgets.labels namespaces sequences kernel
+USING: accessors ui.gadgets ui.gadgets.labels namespaces sequences kernel
 math arrays tools.test io ui.gadgets.panes ui.traverse
 definitions compiler.units ;
+IN: ui.traverse.tests
 
-M: array gadget-children ;
+M: array children>> ;
 
 GENERIC: (flatten-tree) ( node -- )
 
 M: node (flatten-tree)
-    node-children [ (flatten-tree) ] each ;
+    children>> [ (flatten-tree) ] each ;
 
 M: object (flatten-tree) , ;
 
@@ -62,4 +62,4 @@ M: object (flatten-tree) , ;
     { 0 1 } { 2 0 1 } { { "a" "b" "c" "d" } { "e" "f" "g" } { { "h" "i" } "j" } } gadgets-in-range
 ] unit-test
 
-[ { array gadget-children } forget ] with-compilation-unit
+[ { array children>> } forget ] with-compilation-unit
diff --git a/basis/ui/traverse/traverse.factor b/basis/ui/traverse/traverse.factor
index 791bad4e0f..440f6487c2 100644
--- a/basis/ui/traverse/traverse.factor
+++ b/basis/ui/traverse/traverse.factor
@@ -77,7 +77,7 @@ DEFER: (gadget-subtree)
     [ (gadget-subtree) ] { } make ;
 
 M: node gadget-text*
-    dup node-children swap node-value gadget-seq-text ;
+    dup children>> swap value>> gadget-seq-text ;
 
 : gadget-text-range ( frompath topath gadget -- str )
     gadget-subtree gadget-text ;
diff --git a/basis/ui/ui-docs.factor b/basis/ui/ui-docs.factor
index 344b9caa76..e086b7ebae 100755
--- a/basis/ui/ui-docs.factor
+++ b/basis/ui/ui-docs.factor
@@ -237,14 +237,12 @@ $nl
 ;
 
 ARTICLE: "ui-null-layout" "Manual layouts"
-"When automatic layout is not appropriate, gadgets can be added to a parent with no layout policy, and then positioned and sized manually:"
-{ $subsection set-rect-loc } ;
+"When automatic layout is not appropriate, gadgets can be added to a parent with no layout policy, and then positioned and sized manually by setting the " { $snippet "loc" } " field." ;
 
 ARTICLE: "ui-layout-impl" "Implementing layout gadgets"
 "The relayout process proceeds top-down, with parents laying out their children, which in turn lay out their children. Custom layout policy is implemented by defining a method on a generic word:"
 { $subsection layout* }
-"When a " { $link layout* } " method is called, the size and location of the gadget has already been determined by its parent, and the method's job is to lay out the gadget's children. Children can be positioned and resized with a pair of words:"
-{ $subsection set-rect-loc }
+"When a " { $link layout* } " method is called, the size and location of the gadget has already been determined by its parent, and the method's job is to lay out the gadget's children. Children can be positioned and resized by setting a pair of slots, " { $snippet "loc" } " and " { $snippet "dim" } "." $nl
 "Some assorted utility words which are useful for implementing layout logic:"
 { $subsection pref-dim }
 { $subsection pref-dims }
diff --git a/basis/ui/windows/windows.factor b/basis/ui/windows/windows.factor
index 44bfbf3877..5f67ed4a4b 100755
--- a/basis/ui/windows/windows.factor
+++ b/basis/ui/windows/windows.factor
@@ -208,7 +208,7 @@ SYMBOLS: msg-obj class-name-ptr mouse-captured ;
     hWnd window-focus send-gesture drop ;
 
 :: set-window-active ( hwnd uMsg wParam lParam ? -- n )
-    ? hwnd window set-world-active?
+    ? hwnd window (>>active?)
     hwnd uMsg wParam lParam DefWindowProc ;
 
 : handle-wm-syscommand ( hWnd uMsg wParam lParam -- n )
@@ -221,14 +221,14 @@ SYMBOLS: msg-obj class-name-ptr mouse-captured ;
     } cond ;
 
 : cleanup-window ( handle -- )
-    dup win-title [ free ] when*
-    dup win-hRC wglDeleteContext win32-error=0/f
-    dup win-hWnd swap win-hDC ReleaseDC win32-error=0/f ;
+    dup title>> [ free ] when*
+    dup hRC>> wglDeleteContext win32-error=0/f
+    dup hWnd>> swap hDC>> ReleaseDC win32-error=0/f ;
 
 M: windows-ui-backend (close-window)
-    dup win-hWnd unregister-window
+    dup hWnd>> unregister-window
     dup cleanup-window
-    win-hWnd DestroyWindow win32-error=0/f ;
+    hWnd>> DestroyWindow win32-error=0/f ;
 
 : handle-wm-close ( hWnd uMsg wParam lParam -- )
     3drop window ungraft ;
@@ -472,28 +472,28 @@ M: windows-ui-backend do-events
 M: windows-ui-backend (open-window) ( world -- )
     [ create-window dup setup-gl ] keep
     [ f <win> ] keep
-    [ swap win-hWnd register-window ] 2keep
-    dupd set-world-handle
-    win-hWnd show-window ;
+    [ swap hWnd>> register-window ] 2keep
+    dupd (>>handle)
+    hWnd>> show-window ;
 
 M: windows-ui-backend select-gl-context ( handle -- )
-    [ win-hDC ] keep win-hRC wglMakeCurrent win32-error=0/f ;
+    [ hDC>> ] keep hRC>> wglMakeCurrent win32-error=0/f ;
 
 M: windows-ui-backend flush-gl-context ( handle -- )
-    win-hDC SwapBuffers win32-error=0/f ;
+    hDC>> SwapBuffers win32-error=0/f ;
 
 ! Move window to front
 M: windows-ui-backend raise-window* ( world -- )
-    world-handle [
-        win-hWnd SetFocus drop
+    handle>> [
+        hWnd>> SetFocus drop
     ] when* ;
 
 M: windows-ui-backend set-title ( string world -- )
-    world-handle
-    dup win-title [ free ] when*
+    handle>>
+    dup title>> [ free ] when*
     >r utf16n malloc-string r>
-    2dup set-win-title
-    win-hWnd WM_SETTEXT 0 roll alien-address SendMessage drop ;
+    2dup (>>title)
+    hWnd>> WM_SETTEXT 0 roll alien-address SendMessage drop ;
 
 M: windows-ui-backend ui
     [
diff --git a/basis/ui/x11/x11.factor b/basis/ui/x11/x11.factor
index b34a349d3a..854a0b0c62 100755
--- a/basis/ui/x11/x11.factor
+++ b/basis/ui/x11/x11.factor
@@ -69,7 +69,7 @@ M: world configure-event
 
 : key-down-event>gesture ( event world -- string gesture )
     dupd
-    handle>> x11-handle-xic lookup-string
+    handle>> xic>> lookup-string
     >r swap event-modifiers r> key-code <key-down> ;
 
 M: world key-down-event
@@ -116,14 +116,14 @@ M: world motion-event
 
 M: world focus-in-event
     nip
-    dup handle>> x11-handle-xic XSetICFocus focus-world ;
+    dup handle>> xic>> XSetICFocus focus-world ;
 
 M: world focus-out-event
     nip
-    dup handle>> x11-handle-xic XUnsetICFocus unfocus-world ;
+    dup handle>> xic>> XUnsetICFocus unfocus-world ;
 
 M: world selection-notify-event
-    [ handle>> x11-handle-window selection-from-event ] keep
+    [ handle>> window>> selection-from-event ] keep
     world-focus user-input ;
 
 : supported-type? ( atom -- ? )
@@ -149,7 +149,7 @@ M: world selection-notify-event
     >r 8 PropModeReplace r>
     [
         XSelectionRequestEvent-selection
-        clipboard-for-atom x-clipboard-contents
+        clipboard-for-atom contents>>
     ] keep encode-clipboard dup length XChangeProperty drop ;
 
 M: world selection-request-event
@@ -161,9 +161,9 @@ M: world selection-request-event
     } cond ;
 
 M: x11-ui-backend (close-window) ( handle -- )
-    dup x11-handle-xic XDestroyIC
-    dup x11-handle-glx destroy-glx
-    x11-handle-window dup unregister-window
+    dup xic>> XDestroyIC
+    dup glx>> destroy-glx
+    window>> dup unregister-window
     destroy-window ;
 
 M: world client-event
@@ -172,7 +172,7 @@ M: world client-event
 : gadget-window ( world -- )
     dup window-loc>> over rect-dim glx-window
     over "Factor" create-xic <x11-handle>
-    2dup x11-handle-window register-window
+    2dup window>> register-window
     swap (>>handle) ;
 
 : wait-event ( -- event )
@@ -188,16 +188,16 @@ M: x11-ui-backend do-events
     [ [ 2dup handle-event ] assert-depth ] when 2drop ;
 
 : x-clipboard@ ( gadget clipboard -- prop win )
-    x-clipboard-atom swap
-    find-world handle>> x11-handle-window ;
+    atom>> swap
+    find-world handle>> window>> ;
 
 M: x-clipboard copy-clipboard
     [ x-clipboard@ own-selection ] keep
-    set-x-clipboard-contents ;
+    (>>contents) ;
 
 M: x-clipboard paste-clipboard
-    >r find-world handle>> x11-handle-window
-    r> x-clipboard-atom convert-selection ;
+    >r find-world handle>> window>>
+    r> atom>> convert-selection ;
 
 : init-clipboard ( -- )
     XA_PRIMARY <x-clipboard> selection set-global
@@ -212,11 +212,11 @@ M: x-clipboard paste-clipboard
     r> utf8 encode dup length XChangeProperty drop ;
 
 M: x11-ui-backend set-title ( string world -- )
-    handle>> x11-handle-window swap dpy get -rot
+    handle>> window>> swap dpy get -rot
     3dup set-title-old set-title-new ;
     
 M: x11-ui-backend set-fullscreen* ( ? world -- )
-    handle>> x11-handle-window "XClientMessageEvent" <c-object>
+    handle>> window>> "XClientMessageEvent" <c-object>
     tuck set-XClientMessageEvent-window
     swap _NET_WM_STATE_ADD _NET_WM_STATE_REMOVE ?
     over set-XClientMessageEvent-data0
@@ -230,20 +230,20 @@ M: x11-ui-backend set-fullscreen* ( ? world -- )
 
 M: x11-ui-backend (open-window) ( world -- )
     dup gadget-window
-    handle>> x11-handle-window dup set-closable map-window ;
+    handle>> window>> dup set-closable map-window ;
 
 M: x11-ui-backend raise-window* ( world -- )
     handle>> [
-        dpy get swap x11-handle-window XRaiseWindow drop
+        dpy get swap window>> XRaiseWindow drop
     ] when* ;
 
 M: x11-ui-backend select-gl-context ( handle -- )
     dpy get swap
-    dup x11-handle-window swap x11-handle-glx glXMakeCurrent
+    dup window>> swap glx>> glXMakeCurrent
     [ "Failed to set current GLX context" throw ] unless ;
 
 M: x11-ui-backend flush-gl-context ( handle -- )
-    dpy get swap x11-handle-window glXSwapBuffers ;
+    dpy get swap window>> glXSwapBuffers ;
 
 M: x11-ui-backend ui ( -- )
     [
diff --git a/basis/windows/time/time.factor b/basis/windows/time/time.factor
index 63b12de1ff..5e23f8cc01 100644
--- a/basis/windows/time/time.factor
+++ b/basis/windows/time/time.factor
@@ -1,7 +1,7 @@
 ! Copyright (C) 2007 Doug Coleman.
 ! See http://factorcode.org/license.txt for BSD license.
 USING: alien alien.c-types kernel math windows windows.kernel32
-namespaces calendar calendar.backend ;
+namespaces calendar ;
 IN: windows.time
 
 : >64bit ( lo hi -- n )
diff --git a/basis/xml-rpc/xml-rpc.factor b/basis/xml-rpc/xml-rpc.factor
index ade9b34d93..9472f5e09d 100755
--- a/basis/xml-rpc/xml-rpc.factor
+++ b/basis/xml-rpc/xml-rpc.factor
@@ -48,7 +48,7 @@ TUPLE: base64 string ;
 C: <base64> base64
 
 M: base64 item>xml
-    base64-string >base64 "base64" build-tag ;
+    string>> >base64 "base64" build-tag ;
 
 : params ( seq -- xml )
     [ item>xml "value" build-tag "param" build-tag ] map
@@ -80,11 +80,11 @@ C: <rpc-fault> rpc-fault
 
 GENERIC: send-rpc ( rpc -- xml )
 M: rpc-method send-rpc
-    [ rpc-method-name ] keep rpc-method-params method-call ;
+    [ name>> ] [ params>> ] bi method-call ;
 M: rpc-response send-rpc
-    rpc-response-params return-params ;
+    params>> return-params ;
 M: rpc-fault send-rpc
-    [ rpc-fault-code ] keep rpc-fault-string return-fault ;
+    [ code>> ] [ string>> ] bi return-fault ;
 
 ! * Recieving RPC requests
 ! this needs to have much better error checking
@@ -96,8 +96,8 @@ TUPLE: server-error tag message ;
 
 M: server-error error.
     "Error in XML supplied to server" print
-    "Description: " write dup server-error-message print
-    "Tag: " write server-error-tag xml>string print ;
+    "Description: " write dup message>> print
+    "Tag: " write tag>> xml>string print ;
 
 PROCESS: xml>item ( tag -- object )
 
@@ -139,8 +139,8 @@ TAG: array xml>item
     first-child-tag params>array ;
 
 : parse-method ( xml -- string array )
-    children-tags dup first children>string
-    swap second params>array ;
+    children-tags first2
+    [ children>string ] [ params>array ] bi* ;
 
 : parse-fault ( xml -- fault-code fault-string )
     first-child-tag first-child-tag first-child-tag
diff --git a/basis/xml/data/data.factor b/basis/xml/data/data.factor
index 1bab8d0374..0af2ec4700 100755
--- a/basis/xml/data/data.factor
+++ b/basis/xml/data/data.factor
@@ -2,7 +2,7 @@
 ! See http://factorcode.org/license.txt for BSD license.
 USING: kernel sequences sequences.private assocs arrays
 delegate.protocols delegate vectors accessors multiline
-macros words quotations combinators ;
+macros words quotations combinators slots ;
 IN: xml.data
 
 TUPLE: name space main url ;
@@ -89,7 +89,7 @@ TUPLE: tag name attrs children ;
     tag boa ;
 
 ! For convenience, tags follow the assoc protocol too (for attrs)
-CONSULT: assoc-protocol tag tag-attrs ;
+CONSULT: assoc-protocol tag attrs>> ;
 INSTANCE: tag assoc
 
 ! They also follow the sequence protocol (for children)
@@ -100,14 +100,14 @@ CONSULT: name tag name>> ;
 
 M: tag like
     over tag? [ drop ] [
-        [ name>> ] keep tag-attrs
+        [ name>> ] keep attrs>>
         rot dup [ V{ } like ] when <tag>
     ] if ;
 
 MACRO: clone-slots ( class -- tuple )
     [
         "slots" word-prop
-        [ reader>> 1quotation [ clone ] compose ] map
+        [ name>> reader-word 1quotation [ clone ] compose ] map
         [ cleave ] curry
     ] [ [ boa ] curry ] bi compose ;
 
diff --git a/basis/xml/errors/errors.factor b/basis/xml/errors/errors.factor
index 1ef26883e3..bafa325e89 100644
--- a/basis/xml/errors/errors.factor
+++ b/basis/xml/errors/errors.factor
@@ -53,7 +53,7 @@ M: mismatched summary ( obj -- str )
 TUPLE: unclosed < parsing-error tags ;
 : <unclosed> ( -- unclosed )
     unclosed parsing-error
-        xml-stack get rest-slice [ first opener-name ] map >>tags ;
+        xml-stack get rest-slice [ first name>> ] map >>tags ;
 M: unclosed summary ( obj -- str )
     [
         dup call-next-method write
@@ -171,7 +171,7 @@ M: bad-directive summary ( obj -- str )
     [
         dup call-next-method write
         "Misplaced directive:" print
-        bad-directive-dir write-item nl
+        dir>> write-item nl
     ] with-string-writer ;
 
 UNION: xml-parse-error multitags notags extra-attrs nonexist-ns
diff --git a/basis/xml/tests/test.factor b/basis/xml/tests/test.factor
index 2dd2b848be..f2bd5ce1e3 100644
--- a/basis/xml/tests/test.factor
+++ b/basis/xml/tests/test.factor
@@ -21,7 +21,7 @@ SYMBOL: xml-file
 [ t ] [ xml-file get children>> second contained-tag? ] unit-test
 [ "<a></b>" string>xml ] [ xml-parse-error? ] must-fail-with
 [ T{ comment f "This is where the fun begins!" } ] [
-    xml-file get xml-before [ comment? ] find nip
+    xml-file get before>> [ comment? ] find nip
 ] unit-test
 [ "xsl stylesheet=\"that-one.xsl\"" ] [
     xml-file get after>> [ instruction? ] find nip text>>
diff --git a/basis/xml/tokenize/tokenize.factor b/basis/xml/tokenize/tokenize.factor
index 284f53023d..2e91c23f60 100644
--- a/basis/xml/tokenize/tokenize.factor
+++ b/basis/xml/tokenize/tokenize.factor
@@ -49,7 +49,7 @@ SYMBOL: ns-stack
 ! Parsing names
 
 : version=1.0? ( -- ? )
-    prolog-data get prolog-version "1.0" = ;
+    prolog-data get version>> "1.0" = ;
 
 ! version=1.0? is calculated once and passed around for efficiency
 
@@ -69,7 +69,7 @@ SYMBOL: ns-stack
 
 : (parse-entity) ( string -- )
     dup entities at [ , ] [ 
-        prolog-data get prolog-standalone
+        prolog-data get standalone>>
         [ <no-entity> throw ] [
             dup extra-entities get at
             [ , ] [ <no-entity> throw ] ?if
diff --git a/basis/xml/writer/writer.factor b/basis/xml/writer/writer.factor
index 13f0be431c..8bda10102d 100644
--- a/basis/xml/writer/writer.factor
+++ b/basis/xml/writer/writer.factor
@@ -110,6 +110,9 @@ M: instruction write-item
         [ after>> write-chunk ]
     } cleave ;
 
+M: xml write-item
+    body>> write-item ;
+
 : print-xml ( xml -- )
     write-xml nl ;
 
diff --git a/core/bootstrap/primitives.factor b/core/bootstrap/primitives.factor
index 8d9f812cee..ad56dbd296 100755
--- a/core/bootstrap/primitives.factor
+++ b/core/bootstrap/primitives.factor
@@ -281,18 +281,12 @@ bi
 "tuple" "kernel" create
 [ { } define-builtin ]
 [ define-tuple-layout ]
-[
-    { "delegate" } make-slots
-    [ drop ] [ finalize-tuple-slots ] 2bi
-    [ "slots" set-word-prop ]
-    [ define-accessors ]
-    2bi
-] tri
+bi
 
 ! Create special tombstone values
 "tombstone" "hashtables.private" create
 tuple
-{ } define-tuple-class
+{ "state" } define-tuple-class
 
 "((empty))" "hashtables.private" create
 "tombstone" "hashtables.private" lookup f
diff --git a/core/byte-arrays/byte-arrays.factor b/core/byte-arrays/byte-arrays.factor
index 5461da2b84..0bcea2651a 100755
--- a/core/byte-arrays/byte-arrays.factor
+++ b/core/byte-arrays/byte-arrays.factor
@@ -19,3 +19,11 @@ M: byte-array resize
     resize-byte-array ;
 
 INSTANCE: byte-array sequence
+
+: 1byte-array ( x -- array ) 1 <byte-array> [ set-first ] keep ; inline
+
+: 2byte-array ( x y -- array ) B{ } 2sequence ; inline
+
+: 3byte-array ( x y z -- array ) B{ } 3sequence ; inline
+
+: 4byte-array ( w x y z -- array ) B{ } 4sequence ; inline
diff --git a/core/classes/mixin/mixin.factor b/core/classes/mixin/mixin.factor
index 56e995899b..d569103d97 100755
--- a/core/classes/mixin/mixin.factor
+++ b/core/classes/mixin/mixin.factor
@@ -62,10 +62,13 @@ TUPLE: check-mixin-class mixin ;
     ] if-mixin-member? ;
 
 : remove-mixin-instance ( class mixin -- )
+    #! The order of the three clauses is important here. The last
+    #! one must come after the other two so that the entries it
+    #! adds to changed-generics are not overwritten.
     [
-        [ class-usages update-methods ]
         [ [ swap remove ] change-mixin-class ]
         [ nip update-classes ]
+        [ class-usages update-methods ]
         2tri
     ] [ 2drop ] if-mixin-member? ;
 
diff --git a/core/classes/tuple/parser/parser.factor b/core/classes/tuple/parser/parser.factor
index 47363378fa..e85910d18d 100644
--- a/core/classes/tuple/parser/parser.factor
+++ b/core/classes/tuple/parser/parser.factor
@@ -58,3 +58,10 @@ ERROR: invalid-slot-name name ;
     } case
     dup check-duplicate-slots
     3dup check-slot-shadowing ;
+
+: literal>tuple ( seq -- tuple )
+    {
+        { [ dup length 1 = ] [ first new ] }
+        { [ dup second not ] [ [ 2 tail ] [ first ] bi slots>tuple ] }
+        [ "Not implemented" throw ]
+    } cond ;
diff --git a/core/classes/tuple/tuple-tests.factor b/core/classes/tuple/tuple-tests.factor
index 2c584b7378..5c91bdf8dd 100755
--- a/core/classes/tuple/tuple-tests.factor
+++ b/core/classes/tuple/tuple-tests.factor
@@ -46,13 +46,13 @@ C: <point> point
 
 [ ] [ "p" get 300 ">>z" "accessors" lookup execute drop ] unit-test
 
-[ 4 ] [ "p" get tuple-size ] unit-test
+[ 3 ] [ "p" get tuple-size ] unit-test
 
 [ 300 ] [ "p" get "z>>" "accessors" lookup execute ] unit-test
 
 [ ] [ "IN: classes.tuple.tests TUPLE: point z y ;" eval ] unit-test
 
-[ 3 ] [ "p" get tuple-size ] unit-test
+[ 2 ] [ "p" get tuple-size ] unit-test
 
 [ "p" get x>> ] must-fail
 [ 200 ] [ "p" get y>> ] unit-test
@@ -425,7 +425,7 @@ C: <constructor-update-2> constructor-update-2
 
 { 5 1 } [ <constructor-update-2> ] must-infer-as
 
-[ { f 1 2 3 4 5 } ] [ 1 2 3 4 5 <constructor-update-2> tuple-slots ] unit-test
+[ { 1 2 3 4 5 } ] [ 1 2 3 4 5 <constructor-update-2> tuple-slots ] unit-test
 
 ! Redefinition problem
 TUPLE: redefinition-problem ;
@@ -478,7 +478,7 @@ USE: vocabs
 ] unit-test
 
 [ "USE: words T{ word }" eval ]
-[ error>> T{ no-method f word slots>tuple } = ]
+[ error>> T{ no-method f word new } = ]
 must-fail-with
 
 ! Accessors not being forgotten...
@@ -592,10 +592,10 @@ GENERIC: break-me ( obj -- )
 TUPLE: declared-types { n fixnum } { m string } ;
 
 [ T{ declared-types f 0 "hi" } ]
-[ { declared-types f 0 "hi" } >tuple ]
+[ { declared-types 0 "hi" } >tuple ]
 unit-test
 
-[ { declared-types f "hi" 0 } >tuple ]
+[ { declared-types "hi" 0 } >tuple ]
 [ T{ bad-slot-value f "hi" fixnum } = ]
 must-fail-with
 
@@ -701,3 +701,11 @@ DEFER: error-y
 [ ] [
     "IN: sequences TUPLE: reversed { seq read-only } ;" eval
 ] unit-test
+
+TUPLE: bogus-hashcode-1 x ;
+
+TUPLE: bogus-hashcode-2 x ;
+
+M: bogus-hashcode-1 hashcode* 2drop 0 >bignum ;
+
+[ ] [ T{ bogus-hashcode-2 f T{ bogus-hashcode-1 } } hashcode drop ] unit-test
diff --git a/core/classes/tuple/tuple.factor b/core/classes/tuple/tuple.factor
index 8a9d230a7c..89e4e80460 100755
--- a/core/classes/tuple/tuple.factor
+++ b/core/classes/tuple/tuple.factor
@@ -3,8 +3,8 @@
 USING: arrays definitions hashtables kernel kernel.private math
 namespaces sequences sequences.private strings vectors words
 quotations memory combinators generic classes classes.algebra
-classes.builtin classes.private slots.deprecated slots.private
-slots compiler.units math.private accessors assocs effects ;
+classes.builtin classes.private slots.private slots
+compiler.units math.private accessors assocs effects ;
 IN: classes.tuple
 
 PREDICATE: tuple-class < class
@@ -21,8 +21,7 @@ ERROR: not-a-tuple object ;
     superclasses [ "slots" word-prop ] map concat ;
 
 PREDICATE: immutable-tuple-class < tuple-class ( class -- ? )
-    #! Delegation
-    all-slots rest-slice [ read-only>> ] all? ;
+    all-slots [ read-only>> ] all? ;
 
 <PRIVATE
 
@@ -126,26 +125,24 @@ ERROR: bad-superclass class ;
     } cond ;
 
 : boa-check-quot ( class -- quot )
-    all-slots 1 tail [ class>> instance-check-quot ] map spread>quot ;
+    all-slots [ class>> instance-check-quot ] map spread>quot ;
 
 : define-boa-check ( class -- )
     dup boa-check-quot "boa-check" set-word-prop ;
 
 : tuple-prototype ( class -- prototype )
     [ initial-values ] keep
-    over [ ] all? [ 2drop f ] [ slots>tuple ] if ;
+    over [ ] contains? [ slots>tuple ] [ 2drop f ] if ;
 
 : define-tuple-prototype ( class -- )
     dup tuple-prototype "prototype" set-word-prop ;
 
 : finalize-tuple-slots ( class slots -- slots )
-    over superclass-size 2 + finalize-slots deprecated-slots ;
+    swap superclass-size 2 + finalize-slots ;
 
 : define-tuple-slots ( class -- )
     dup dup "slots" word-prop finalize-tuple-slots
-    [ define-accessors ] ! new
-    [ define-slots ] ! old
-    2bi ;
+    define-accessors ;
 
 : make-tuple-layout ( class -- layout )
     [ ]
diff --git a/core/compiler/units/units.factor b/core/compiler/units/units.factor
index fa29a5a519..cb361ec9e6 100755
--- a/core/compiler/units/units.factor
+++ b/core/compiler/units/units.factor
@@ -110,8 +110,7 @@ SYMBOL: update-tuples-hook
 : (compiled-generic-usages) ( generic class -- assoc )
     dup class? [
         [ compiled-generic-usage ] dip
-        [ [ classes-intersect? ] [ null class<= ] bi or nip ]
-        curry assoc-filter
+        [ classes-intersect? nip ] curry assoc-filter
     ] [ 2drop f ] if ;
 
 : compiled-generic-usages ( assoc -- assocs )
diff --git a/core/destructors/destructors-tests.factor b/core/destructors/destructors-tests.factor
index f442e27a04..e09a88aee4 100755
--- a/core/destructors/destructors-tests.factor
+++ b/core/destructors/destructors-tests.factor
@@ -28,7 +28,7 @@ TUPLE: dummy-destructor obj ;
 C: <dummy-destructor> dummy-destructor
 
 M: dummy-destructor dispose ( obj -- )
-    dummy-destructor-obj t swap set-dummy-obj-destroyed? ;
+    obj>> t >>destroyed? drop ;
 
 : destroy-always
     <dummy-destructor> &dispose drop ;
@@ -39,13 +39,13 @@ M: dummy-destructor dispose ( obj -- )
 [ t ] [
     [
         <dummy-obj> dup destroy-always
-    ] with-destructors dummy-obj-destroyed? 
+    ] with-destructors destroyed?>>
 ] unit-test
 
 [ f ] [
     [
         <dummy-obj> dup destroy-later
-    ] with-destructors dummy-obj-destroyed? 
+    ] with-destructors destroyed?>>
 ] unit-test
 
 [ t ] [
@@ -54,7 +54,7 @@ M: dummy-destructor dispose ( obj -- )
             dup destroy-always
             "foo" throw
         ] with-destructors
-    ] ignore-errors dummy-obj-destroyed? 
+    ] ignore-errors destroyed?>>
 ] unit-test
 
 [ t ] [
@@ -63,6 +63,6 @@ M: dummy-destructor dispose ( obj -- )
             dup destroy-later
             "foo" throw
         ] with-destructors
-    ] ignore-errors dummy-obj-destroyed? 
+    ] ignore-errors destroyed?>>
 ] unit-test
 
diff --git a/core/generic/generic.factor b/core/generic/generic.factor
index 553ced5800..f2c154b3b2 100755
--- a/core/generic/generic.factor
+++ b/core/generic/generic.factor
@@ -105,6 +105,10 @@ M: method-body crossref?
         drop [ <method> dup ] 2keep reveal-method
     ] if ;
 
+PREDICATE: default-method < word "default" word-prop ;
+
+M: default-method irrelevant? drop t ;
+
 : <default-method> ( generic combination -- method )
     [ drop object bootstrap-word swap <method> ] [ make-default-method ] 2bi
     [ define ] [ drop t "default" set-word-prop ] [ drop ] 2tri ;
@@ -137,7 +141,7 @@ M: method-body definer
 M: method-body forget*
     dup "forgotten" word-prop [ drop ] [
         [
-            dup "default" word-prop [ drop ] [
+            dup default-method? [ drop ] [
                 [
                     [ "method-class" word-prop ]
                     [ "method-generic" word-prop ] bi
diff --git a/core/generic/standard/standard-tests.factor b/core/generic/standard/standard-tests.factor
index e5f3ac8394..52d73a9a4c 100644
--- a/core/generic/standard/standard-tests.factor
+++ b/core/generic/standard/standard-tests.factor
@@ -81,7 +81,7 @@ M: parallelogram perimiter
 M: circle perimiter 2 * pi * ;
 
 [ 14 ] [ 4 3 <rectangle> perimiter ] unit-test
-[ 30 ] [ 10 4 3 <parallelogram> perimiter ] unit-test
+[ 30.0 ] [ 10 4 3 <parallelogram> perimiter ] unit-test
 
 GENERIC: big-mix-test ( obj -- obj' )
 
diff --git a/core/generic/standard/standard.factor b/core/generic/standard/standard.factor
index 503c72290a..860781e5e2 100644
--- a/core/generic/standard/standard.factor
+++ b/core/generic/standard/standard.factor
@@ -26,10 +26,6 @@ ERROR: no-method object generic ;
 : error-method ( word -- quot )
     picker swap [ no-method ] curry append ;
 
-: default-method ( word -- pair )
-    "default-method" word-prop
-    object bootstrap-word swap 2array ;
-
 : push-method ( method specializer atomic assoc -- )
     [
         [ H{ } clone <predicate-dispatch-engine> ] unless*
diff --git a/core/hashtables/hashtables-tests.factor b/core/hashtables/hashtables-tests.factor
index 32684b92dc..abf3747244 100755
--- a/core/hashtables/hashtables-tests.factor
+++ b/core/hashtables/hashtables-tests.factor
@@ -28,7 +28,6 @@ unit-test
 
 [ t ] [ 12 hashcode 12 hashcode = ] unit-test
 [ t ] [ 12 >bignum hashcode 12 hashcode = ] unit-test
-[ t ] [ 12.0 hashcode 12 >bignum hashcode = ] unit-test
 
 ! Test various odd keys to see if they work.
 
diff --git a/core/io/encodings/binary/binary-docs.factor b/core/io/encodings/binary/binary-docs.factor
index 85045d8984..4da1e0811f 100644
--- a/core/io/encodings/binary/binary-docs.factor
+++ b/core/io/encodings/binary/binary-docs.factor
@@ -2,5 +2,10 @@ USING: help.syntax help.markup ;
 IN: io.encodings.binary
 
 HELP: binary
-{ $class-description "This is the encoding descriptor for binary I/O. Making an encoded stream with the binary encoding is a no-op; streams with this encoding deal with byte-arrays, not strings." }
-{ $see-also "encodings-introduction" } ;
+{ $class-description "Encoding descriptor for binary I/O." } ;
+
+ARTICLE: "io.encodings.binary" "Binary encoding"
+"Making an encoded stream with the binary encoding is a no-op; streams with this encoding deal with byte-arrays, not strings." 
+{ $subsection binary } ;
+
+ABOUT: "io.encodings.binary"
diff --git a/core/io/encodings/utf8/utf8-docs.factor b/core/io/encodings/utf8/utf8-docs.factor
index 1ac0252dbb..7e185fff69 100755
--- a/core/io/encodings/utf8/utf8-docs.factor
+++ b/core/io/encodings/utf8/utf8-docs.factor
@@ -2,5 +2,10 @@ USING: help.markup help.syntax ;
 IN: io.encodings.utf8
 
 HELP: utf8
-{ $class-description "This is the encoding descriptor for a UTF-8 encoding. UTF-8 is a variable-width encoding. 7-bit ASCII characters are encoded as single bytes, and other Unicode code points are encoded as 2 to 4 byte sequences." }
-{ $see-also "encodings-introduction" } ;
+{ $class-description "Encoding descriptor for UTF-8 encoding." } ;
+
+ARTICLE: "io.encodings.utf8" "UTF-8 encoding"
+"UTF-8 is a variable-width encoding. 7-bit ASCII characters are encoded as single bytes, and other Unicode code points are encoded as 2 to 4 byte sequences."
+{ $subsection utf8 } ;
+
+ABOUT: "io.encodings.utf8"
diff --git a/core/kernel/kernel-docs.factor b/core/kernel/kernel-docs.factor
index 7a575c0d7a..8483293274 100755
--- a/core/kernel/kernel-docs.factor
+++ b/core/kernel/kernel-docs.factor
@@ -251,13 +251,15 @@ ARTICLE: "conditionals" "Conditionals and logic"
 { $see-also "booleans" "bitwise-arithmetic" both? either? } ;
 
 ARTICLE: "equality" "Equality"
-"There are two distinct notions of ``sameness'' when it comes to objects. You can test if two references point to the same object (" { $emphasis "identity comparison" } "), or you can test if two objects are equal in a domain-specific sense, usually by being instances of the same class, and having equal slot values (" { $emphasis "value comparison" } "). Both notions of equality are equality relations in the mathematical sense."
+"There are two distinct notions of ``sameness'' when it comes to objects."
 $nl
-"Identity comparison:"
+"You can test if two references point to the same object (" { $emphasis "identity comparison" } "). This is rarely used; it is mostly useful with large, mutable objects where the object identity matters but the value is transient:"
 { $subsection eq? }
-"Value comparison:"
+"You can test if two objects are equal in a domain-specific sense, usually by being instances of the same class, and having equal slot values (" { $emphasis "value comparison" } "):"
 { $subsection = }
-"Custom value comparison methods:"
+"A third form of equality is provided by " { $link number= } ". It compares numeric value while disregarding types."
+$nl
+"Custom value comparison methods for use with " { $link = } " can be defined on a generic word:"
 { $subsection equal? }
 "Utility class:"
 { $subsection identity-tuple }
@@ -367,6 +369,13 @@ HELP: =
 { $values { "obj1" object } { "obj2" object } { "?" "a boolean" } }
 { $description
     "Tests if two objects are equal. If " { $snippet "obj1" } " and " { $snippet "obj2" } " point to the same object, outputs " { $link t } ". Otherwise, calls the " { $link equal? } " generic word."
+}
+{ $examples
+    { $example "USING: kernel prettyprint ;" "5 5 = ." "t" }
+    { $example "USING: kernel prettyprint ;" "5 005 = ." "t" }
+    { $example "USING: kernel prettyprint ;" "5 5.0 = ." "f" }
+    { $example "USING: arrays kernel prettyprint ;" "{ \"a\" \"b\" } \"a\" \"b\" 2array = ." "t" }
+    { $example "USING: arrays kernel prettyprint ;" "{ \"a\" \"b\" } [ \"a\" \"b\" ] = ." "f" }
 } ;
 
 HELP: equal?
@@ -381,8 +390,13 @@ HELP: equal?
         { { $snippet "a = b" } " implies " { $snippet "b = a" } }
         { { $snippet "a = b" } " and " { $snippet "b = c" } " implies " { $snippet "a = c" } }
     }
-    $nl
     "If a class defines a custom equality comparison test, it should also define a compatible method for the " { $link hashcode* } " generic word."
+}
+{ $examples
+    "An example demonstrating why this word should only be used to define methods on, and never called directly:"
+    { $example "USING: kernel prettyprint ;" "5 5 equal? ." "f" }
+    "Using " { $link = } " gives the expected behavior:"
+    { $example "USING: kernel prettyprint ;" "5 5 = ." "t" }
 } ;
 
 HELP: identity-tuple
@@ -906,3 +920,7 @@ HELP: assert
 { $values { "got" "the obtained value" } { "expect" "the expected value" } }
 { $description "Throws an " { $link assert } " error." }
 { $error-description "Thrown when a unit test or other assertion fails." } ;
+
+HELP: assert=
+{ $values { "a" object } { "b" object } }
+{ $description "Throws an " { $link assert } " error if " { $snippet "a" } " does not equal " { $snippet "b" } "." } ;
diff --git a/core/kernel/kernel.factor b/core/kernel/kernel.factor
index 6c9b64b192..55ed67e0fa 100755
--- a/core/kernel/kernel.factor
+++ b/core/kernel/kernel.factor
@@ -199,10 +199,3 @@ ERROR: assert got expect ;
 : do-primitive ( number -- ) "Improper primitive call" throw ;
 
 PRIVATE>
-
-! Deprecated
-GENERIC: delegate ( obj -- delegate )
-
-M: tuple delegate 2 slot ;
-
-M: object delegate drop f ;
diff --git a/core/math/floats/floats-tests.factor b/core/math/floats/floats-tests.factor
index 095392ed81..bd3f951b02 100755
--- a/core/math/floats/floats-tests.factor
+++ b/core/math/floats/floats-tests.factor
@@ -5,10 +5,17 @@ IN: math.floats.tests
 [ t ] [ 3.1415 number? ] unit-test
 [ f ] [ 12 float? ] unit-test
 
-[ t ] [ 1 1.0 = ] unit-test
-[ t ] [ 1 >bignum 1.0 = ] unit-test
-[ t ] [ 1.0 1 = ] unit-test
-[ t ] [ 1.0 1 >bignum = ] unit-test
+[ f ] [ 1 1.0 = ] unit-test
+[ t ] [ 1 1.0 number= ] unit-test
+
+[ f ] [ 1 >bignum 1.0 = ] unit-test
+[ t ] [ 1 >bignum 1.0 number= ] unit-test
+
+[ f ] [ 1.0 1 = ] unit-test
+[ t ] [ 1.0 1 number= ] unit-test
+
+[ f ] [ 1.0 1 >bignum = ] unit-test
+[ t ] [ 1.0 1 >bignum number= ] unit-test
 
 [ f ] [ 1 1.3 = ] unit-test
 [ f ] [ 1 >bignum 1.3 = ] unit-test
@@ -45,13 +52,10 @@ unit-test
 [ 2.0 ] [ 1.0 1+ ] unit-test
 [ 0.0 ] [ 1.0 1- ] unit-test
 
-! [ t ] [ -0.0 -0.0 = ] unit-test
-! [ f ] [ 0.0 -0.0 = ] unit-test
-
 [ t ] [ 0.0 zero? ] unit-test
 [ t ] [ -0.0 zero? ] unit-test
 
-! [ t ] [ 0.0/0.0 0.0/0.0 = ] unit-test
+! [ f ] [ 0.0/0.0 0.0/0.0 number= ] unit-test
 
 [ 0 ] [ 1/0. >bignum ] unit-test
 
diff --git a/core/math/floats/floats.factor b/core/math/floats/floats.factor
index 5cd6f067a9..9dcff9eb90 100755
--- a/core/math/floats/floats.factor
+++ b/core/math/floats/floats.factor
@@ -10,11 +10,14 @@ M: float >fixnum float>fixnum ;
 M: float >bignum float>bignum ;
 M: float >float ;
 
+M: float hashcode* nip float>bits ;
+M: float equal? over float? [ float= ] [ 2drop f ] if ;
+M: float number= float= ;
+
 M: float < float< ;
 M: float <= float<= ;
 M: float > float> ;
 M: float >= float>= ;
-M: float number= float= ;
 
 M: float + float+ ;
 M: float - float- ;
diff --git a/core/math/integers/integers.factor b/core/math/integers/integers.factor
index 1e27d5f16c..74a93d39bd 100755
--- a/core/math/integers/integers.factor
+++ b/core/math/integers/integers.factor
@@ -1,4 +1,4 @@
-! Copyright (C) 2004, 2007 Slava Pestov.
+! Copyright (C) 2004, 2008 Slava Pestov.
 ! Copyright (C) 2008, Doug Coleman.
 ! See http://factorcode.org/license.txt for BSD license.
 USING: kernel kernel.private sequences
@@ -12,6 +12,8 @@ M: fixnum >fixnum ;
 M: fixnum >bignum fixnum>bignum ;
 M: fixnum >integer ;
 
+M: fixnum hashcode* nip ;
+M: fixnum equal? over bignum? [ >bignum bignum= ] [ 2drop f ] if ;
 M: fixnum number= eq? ;
 
 M: fixnum < fixnum< ;
@@ -47,7 +49,15 @@ M: fixnum (log2) 0 swap (fixnum-log2) ;
 M: bignum >fixnum bignum>fixnum ;
 M: bignum >bignum ;
 
+M: bignum hashcode* nip >fixnum ;
+
+M: bignum equal?
+    over bignum? [ bignum= ] [
+        swap dup fixnum? [ >bignum bignum= ] [ 2drop f ] if
+    ] if ;
+
 M: bignum number= bignum= ;
+
 M: bignum < bignum< ;
 M: bignum <= bignum<= ;
 M: bignum > bignum> ;
diff --git a/core/math/math-docs.factor b/core/math/math-docs.factor
index 697f3d81be..b38baa5cc9 100755
--- a/core/math/math-docs.factor
+++ b/core/math/math-docs.factor
@@ -26,7 +26,9 @@ $nl
 { $subsection < }
 { $subsection <= }
 { $subsection > }
-{ $subsection >= } ;
+{ $subsection >= }
+"Numbers can be compared for equality using " { $link = } ", or a less precise test which disregards types:"
+{ $subsection number= } ;
 
 ARTICLE: "modular-arithmetic" "Modular arithmetic"
 { $subsection mod }
@@ -60,8 +62,12 @@ ABOUT: "arithmetic"
 
 HELP: number=
 { $values { "x" number } { "y" number } { "?" "a boolean" } }
-{ $description "Tests if two numbers have the same numerical value. If either input is not a number, outputs " { $link f } "." }
-{ $notes "Do not call this word directly. Calling " { $link = } " has the same effect and is more concise." } ;
+{ $description "Tests if two numbers have the same numeric value." }
+{ $notes "This word differs from " { $link = } " in that it disregards differences in type when comparing numbers." }
+{ $examples
+    { $example "USING: math prettyprint ;" "3.0 3 number= ." "t" }
+    { $example "USING: kernel math prettyprint ;" "3.0 3 = ." "f" }
+} ;
 
 HELP: <
 { $values { "x" real } { "y" real } { "?" "a boolean" } }
@@ -286,19 +292,37 @@ HELP: zero?
 HELP: times
 { $values { "n" integer } { "quot" quotation } }
 { $description "Calls the quotation " { $snippet "n" } " times." }
-{ $notes "If you need to pass the current index to the quotation, use " { $link each } "." } ;
+{ $notes "If you need to pass the current index to the quotation, use " { $link each } "." }
+{ $examples
+    { $example "USING: io math ;" "3 [ \"Hi\" print ] times" "Hi\nHi\nHi" }
+} ;
 
 HELP: fp-nan?
 { $values { "x" real } { "?" "a boolean" } }
 { $description "Tests if " { $snippet "x" } " is an IEEE Not-a-Number value. While " { $snippet "x" } " can be any real number, this word will only ever yield true if " { $snippet "x" } " is a " { $link float } "." } ;
 
+HELP: fp-infinity?
+{ $values { "x" real } { "?" "a boolean" } }
+{ $description "Tests if " { $snippet "x" } " is an IEEE Infinity value. While " { $snippet "x" } " can be any real number, this word will only ever yield true if " { $snippet "x" } " is a " { $link float } "." }
+{ $examples
+    { $example "USING: math prettyprint ;" "1/0. fp-infinity? ." "t" }
+    { $example "USING: io kernel math ;" "-1/0. [ fp-infinity? ] [ 0 < ] bi [ \"negative infinity\" print ] when" "negative infinity" }
+} ;
+
+{ fp-nan? fp-infinity? } related-words
+
 HELP: real-part
 { $values { "z" number } { "x" real } }
-{ $description "Outputs the real part of a complex number. This acts as the identity on real numbers." } ;
+{ $description "Outputs the real part of a complex number. This acts as the identity on real numbers." }
+{ $examples { $example "USING: math prettyprint ; C{ 1 2 } real-part ." "1" } } ;
 
 HELP: imaginary-part
 { $values { "z" number } { "y" real } }
-{ $description "Outputs the imaginary part of a complex number. This outputs zero for real numbers." } ;
+{ $description "Outputs the imaginary part of a complex number. This outputs zero for real numbers." }
+{ $examples
+    { $example "USING: math prettyprint ; C{ 1 2 } imaginary-part ." "2" }
+    { $example "USING: math prettyprint ; 3 imaginary-part ." "0" }
+} ;
 
 HELP: real
 { $class-description "The class of real numbers, which is a disjoint union of rationals and floats." } ;
diff --git a/core/math/math-tests.factor b/core/math/math-tests.factor
index fcd3b929ea..d72bb67970 100644
--- a/core/math/math-tests.factor
+++ b/core/math/math-tests.factor
@@ -9,3 +9,10 @@ IN: math.tests
 [ [ 0 1 2 3 4 ] ] [ [ 5 [ , ] each-integer ] [ ] make ] unit-test
 [ [ ] ] [ [ -1 [ , ] each-integer ] [ ] make ] unit-test
 
+[ f ] [ 1/0. fp-nan? ] unit-test
+[ f ] [ -1/0. fp-nan? ] unit-test
+[ t ] [ -0/0. fp-nan? ] unit-test
+
+[ t ] [ 1/0. fp-infinity? ] unit-test
+[ t ] [ -1/0. fp-infinity? ] unit-test
+[ f ] [ -0/0. fp-infinity? ] unit-test
diff --git a/core/math/math.factor b/core/math/math.factor
index 4efca0ef2f..6efdd53825 100755
--- a/core/math/math.factor
+++ b/core/math/math.factor
@@ -1,4 +1,4 @@
-! Copyright (C) 2003, 2007 Slava Pestov.
+! Copyright (C) 2003, 2008 Slava Pestov.
 ! See http://factorcode.org/license.txt for BSD license.
 USING: kernel math.private ;
 IN: math
@@ -82,18 +82,26 @@ UNION: real rational float ;
 
 UNION: number real complex ;
 
-M: number equal? number= ;
-
-M: real hashcode* nip >fixnum ;
-
 GENERIC: fp-nan? ( x -- ? )
 
 M: object fp-nan?
     drop f ;
 
 M: float fp-nan?
-    double>bits -51 shift BIN: 111111111111 [ bitand ] keep
-    number= ;
+    double>bits -51 shift HEX: fff [ bitand ] keep = ;
+
+GENERIC: fp-infinity? ( x -- ? )
+
+M: object fp-infinity?
+    drop f ;
+
+M: float fp-infinity? ( float -- ? )
+    double>bits
+    dup -52 shift HEX: 7ff [ bitand ] keep = [
+        HEX: fffffffffffff bitand 0 =
+    ] [
+        drop f
+    ] if ;
 
 : (next-power-of-2) ( i n -- n )
     2dup >= [
diff --git a/core/parser/parser-tests.factor b/core/parser/parser-tests.factor
index 2d4073d107..c4fb977ebb 100755
--- a/core/parser/parser-tests.factor
+++ b/core/parser/parser-tests.factor
@@ -3,7 +3,6 @@ io.streams.string namespaces classes effects source-files
 assocs sequences strings io.files definitions continuations
 sorting classes.tuple compiler.units debugger vocabs
 vocabs.loader accessors eval combinators ;
-
 IN: parser.tests
 
 [
@@ -63,7 +62,7 @@ IN: parser.tests
     : baz ( a b -- * ) 2array throw ;
 
     [ t ]
-    [ \ baz "declared-effect" word-prop effect-terminated? ]
+    [ \ baz "declared-effect" word-prop terminated?>> ]
     unit-test
 
     [ ] [ "IN: parser.tests USE: math : effect-parsing-test ( a b -- d ) - ;" eval ] unit-test
@@ -121,7 +120,7 @@ IN: parser.tests
         "IN: parser.tests : smudge-me ;" <string-reader> "foo"
         parse-stream drop
 
-        "foo" source-file source-file-definitions first assoc-size
+        "foo" source-file definitions>> first assoc-size
     ] unit-test
 
     [ t ] [ "smudge-me" "parser.tests" lookup >boolean ] unit-test
@@ -138,21 +137,21 @@ IN: parser.tests
         "IN: parser.tests USING: math strings ; GENERIC: smudge-me M: integer smudge-me ; M: string smudge-me ;" <string-reader> "foo"
         parse-stream drop
 
-        "foo" source-file source-file-definitions first assoc-size
+        "foo" source-file definitions>> first assoc-size
     ] unit-test
 
     [ 1 ] [
         "IN: parser.tests USING: arrays ; M: array smudge-me ;" <string-reader> "bar"
         parse-stream drop
 
-        "bar" source-file source-file-definitions first assoc-size
+        "bar" source-file definitions>> first assoc-size
     ] unit-test
 
     [ 2 ] [
         "IN: parser.tests USING: math strings ; GENERIC: smudge-me M: integer smudge-me ;" <string-reader> "foo"
         parse-stream drop
 
-        "foo" source-file source-file-definitions first assoc-size
+        "foo" source-file definitions>> first assoc-size
     ] unit-test
     
     [ t ] [
@@ -401,7 +400,7 @@ IN: parser.tests
 ] times
 
 [ "resource:core/parser/test/assert-depth.factor" run-file ]
-[ relative-overflow-stack { 1 2 3 } sequence= ]
+[ stack>> { 1 2 3 } sequence= ]
 must-fail-with
 
 2 [
diff --git a/core/quotations/quotations-docs.factor b/core/quotations/quotations-docs.factor
index 74c296d94c..1a16d0f92a 100755
--- a/core/quotations/quotations-docs.factor
+++ b/core/quotations/quotations-docs.factor
@@ -17,7 +17,7 @@ $nl
 "Wrappers are used to push words on the data stack; they evaluate to the object being wrapped:"
 { $subsection wrapper }
 { $subsection literalize }
-{ $see-also "basic-combinators" "combinators" } ;
+{ $see-also "dataflow" "combinators" } ;
 
 ABOUT: "quotations"
 
diff --git a/core/quotations/quotations.factor b/core/quotations/quotations.factor
index 617dac3323..31e5e4753d 100755
--- a/core/quotations/quotations.factor
+++ b/core/quotations/quotations.factor
@@ -7,9 +7,9 @@ IN: quotations
 
 <PRIVATE
 
-: uncurry dup 3 slot swap 4 slot ; inline
+: uncurry dup 2 slot swap 3 slot ; inline
 
-: uncompose dup 3 slot swap 4 slot ; inline
+: uncompose dup 2 slot swap 3 slot ; inline
 
 PRIVATE>
 
diff --git a/core/sequences/sequences-tests.factor b/core/sequences/sequences-tests.factor
index 82dfbbd629..4b7b8a3151 100755
--- a/core/sequences/sequences-tests.factor
+++ b/core/sequences/sequences-tests.factor
@@ -69,7 +69,7 @@ unit-test
 [ f ] [ [ { 2 } { } { } ] all-equal? ] unit-test
 [ t ] [ [ ] all-equal? ] unit-test
 [ t ] [ [ 1234 ] all-equal? ] unit-test
-[ t ] [ [ 1.0 1 1 ] all-equal? ] unit-test
+[ f ] [ [ 1.0 1 1 ] all-equal? ] unit-test
 [ t ] [ { 1 2 3 4 } [ < ] monotonic? ] unit-test
 [ f ] [ { 1 2 3 4 } [ > ] monotonic? ] unit-test
 [ [ 2 3 4 ] ] [ [ 1 2 3 ] 1 [ + ] curry map ] unit-test
@@ -251,3 +251,9 @@ unit-test
 [ { "a" "b" "c" "d" } ] [ { "a" "b" "c" "d" } { 0 1 2 3 } nths ] unit-test
 [ { "d" "c" "b" "a" } ] [ { "a" "b" "c" "d" } { 3 2 1 0 } nths ] unit-test
 [ { "d" "a" "b" "c" } ] [ { "a" "b" "c" "d" } { 3 0 1 2 } nths ] unit-test
+
+TUPLE: bogus-hashcode ;
+
+M: bogus-hashcode hashcode* 2drop 0 >bignum ;
+
+[ 0 ] [ { T{ bogus-hashcode } } hashcode ] unit-test
diff --git a/core/sequences/sequences.factor b/core/sequences/sequences.factor
index f7a078fe4d..73c9289415 100755
--- a/core/sequences/sequences.factor
+++ b/core/sequences/sequences.factor
@@ -499,15 +499,13 @@ M: sequence <=>
     [ mismatch not ] [ 2drop f ] if ; inline
 
 : sequence-hashcode-step ( oldhash newpart -- newhash )
-    swap [
+    >fixnum swap [
         dup -2 fixnum-shift-fast swap 5 fixnum-shift-fast
         fixnum+fast fixnum+fast
     ] keep fixnum-bitxor ; inline
 
 : sequence-hashcode ( n seq -- x )
-    0 -rot [
-        hashcode* >fixnum sequence-hashcode-step
-    ] with each ; inline
+    0 -rot [ hashcode* sequence-hashcode-step ] with each ; inline
 
 M: reversed equal? over reversed? [ sequence= ] [ 2drop f ] if ;
 
diff --git a/core/slots/deprecated/deprecated.factor b/core/slots/deprecated/deprecated.factor
deleted file mode 100755
index df16f0baa8..0000000000
--- a/core/slots/deprecated/deprecated.factor
+++ /dev/null
@@ -1,81 +0,0 @@
-! Copyright (C) 2005, 2008 Slava Pestov.
-! See http://factorcode.org/license.txt for BSD license.
-USING: accessors arrays kernel kernel.private math namespaces
-sequences strings words effects generic generic.standard
-classes slots.private combinators slots ;
-IN: slots.deprecated
-
-: reader-effect ( class spec -- effect )
-    >r ?word-name 1array r> name>> 1array <effect> ;
-
-PREDICATE: slot-reader < word "reading" word-prop >boolean ;
-
-: set-reader-props ( class spec -- )
-    2dup reader-effect
-    over reader>>
-    swap "declared-effect" set-word-prop
-    reader>> swap "reading" set-word-prop ;
-
-: define-slot-word ( class word quot -- )
-    [
-        dup define-simple-generic
-        create-method
-    ] dip define ;
-
-: define-reader ( class spec -- )
-    dup reader>> [
-        [ set-reader-props ] 2keep
-        dup reader>>
-        swap reader-quot
-        define-slot-word
-    ] [
-        2drop
-    ] if ;
-
-: writer-effect ( class spec -- effect )
-    name>> swap ?word-name 2array 0 <effect> ;
-
-PREDICATE: slot-writer < word "writing" word-prop >boolean ;
-
-: set-writer-props ( class spec -- )
-    2dup writer-effect
-    over writer>>
-    swap "declared-effect" set-word-prop
-    writer>> swap "writing" set-word-prop ;
-
-: define-writer ( class spec -- )
-    dup writer>> [
-        [ set-writer-props ] 2keep
-        dup writer>>
-        swap writer-quot
-        define-slot-word
-    ] [
-        2drop
-    ] if ;
-
-: define-slot ( class spec -- )
-    2dup define-reader define-writer ;
-
-: define-slots ( class specs -- )
-    [ define-slot ] with each ;
-
-: reader-word ( class name vocab -- word )
-    >r >r "-" r> 3append r> create ;
-
-: writer-word ( class name vocab -- word )
-    >r [ swap "set-" % % "-" % % ] "" make r> create ;
-
-: (simple-slot-word) ( class name -- class name vocab )
-    over vocabulary>> >r >r name>> r> r> ;
-
-: simple-reader-word ( class name -- word )
-    (simple-slot-word) reader-word ;
-
-: simple-writer-word ( class name -- word )
-    (simple-slot-word) writer-word ;
-
-: deprecated-slots ( class slot-specs -- slot-specs' )
-    [
-        2dup name>> simple-reader-word >>reader
-        2dup name>> simple-writer-word >>writer
-    ] map nip ;
diff --git a/core/slots/slots-docs.factor b/core/slots/slots-docs.factor
index 5b454c2e76..d2d7dc1102 100755
--- a/core/slots/slots-docs.factor
+++ b/core/slots/slots-docs.factor
@@ -131,7 +131,7 @@ HELP: define-typecheck
         "GENERIC: generic"
         "M: class generic quot ;"
     }
-    "It checks if the top of the stack is an instance of " { $snippet "class" } ", and if so, executes the quotation. Delegation is respected."
+    "It checks if the top of the stack is an instance of " { $snippet "class" } ", and if so, executes the quotation."
 }
 { $notes "This word is used internally to wrap unsafe low-level code in a type-checking stub." } ;
 
diff --git a/core/slots/slots.factor b/core/slots/slots.factor
index 8754444ce0..6f831c30c5 100755
--- a/core/slots/slots.factor
+++ b/core/slots/slots.factor
@@ -6,7 +6,7 @@ classes.algebra slots.private combinators accessors words
 sequences.private assocs alien ;
 IN: slots
 
-TUPLE: slot-spec name offset class initial read-only reader writer ;
+TUPLE: slot-spec name offset class initial read-only ;
 
 PREDICATE: reader < word "reader" word-prop ;
 
diff --git a/core/syntax/syntax-docs.factor b/core/syntax/syntax-docs.factor
index df0c1b67e8..57dec876a5 100755
--- a/core/syntax/syntax-docs.factor
+++ b/core/syntax/syntax-docs.factor
@@ -390,7 +390,7 @@ HELP: P"
 { $syntax "P\" pathname\"" }
 { $values { "pathname" "a pathname string" } }
 { $description "Reads from the input string until the next occurrence of " { $link POSTPONE: " } ", creates a new " { $link pathname } ", and appends it to the parse tree." }
-{ $examples { $example "USING: io io.files ;" "P\" foo.txt\" pathname-string print" "foo.txt" } } ;
+{ $examples { $example "USING: accessors io io.files ;" "P\" foo.txt\" string>> print" "foo.txt" } } ;
 
 HELP: (
 { $syntax "( inputs -- outputs )" }
diff --git a/core/syntax/syntax.factor b/core/syntax/syntax.factor
index e156832923..1617617b44 100755
--- a/core/syntax/syntax.factor
+++ b/core/syntax/syntax.factor
@@ -83,7 +83,7 @@ IN: bootstrap.syntax
     "B{" [ \ } [ >byte-array ] parse-literal ] define-syntax
     "BV{" [ \ } [ >byte-vector ] parse-literal ] define-syntax
     "H{" [ \ } [ >hashtable ] parse-literal ] define-syntax
-    "T{" [ \ } [ >tuple ] parse-literal ] define-syntax
+    "T{" [ \ } [ literal>tuple ] parse-literal ] define-syntax
     "W{" [ \ } [ first <wrapper> ] parse-literal ] define-syntax
 
     "POSTPONE:" [ scan-word parsed ] define-syntax
diff --git a/core/system/system-docs.factor b/core/system/system-docs.factor
index 5aac0a8e8c..49886492ec 100755
--- a/core/system/system-docs.factor
+++ b/core/system/system-docs.factor
@@ -14,8 +14,7 @@ ARTICLE: "system" "System interface"
 "Getting the current time:"
 { $subsection millis }
 "Exiting the Factor VM:"
-{ $subsection exit }
-{ $see-also "io.files" "io.mmap" "io.monitors" "network-streams" "io.launcher" } ;
+{ $subsection exit } ;
 
 ARTICLE: "environment-variables" "Environment variables"
 "Reading environment variables:"
diff --git a/core/vocabs/loader/loader-docs.factor b/core/vocabs/loader/loader-docs.factor
index e4cc6ac11f..ebaf8b3c8f 100755
--- a/core/vocabs/loader/loader-docs.factor
+++ b/core/vocabs/loader/loader-docs.factor
@@ -50,7 +50,7 @@ HELP: load-vocab
 { $error-description "Thrown by " { $link POSTPONE: USE: } " and " { $link POSTPONE: USING: } " when a given vocabulary does not exist. Vocabularies must be created by " { $link POSTPONE: IN: } " before being used." } ;
 
 HELP: vocab-main
-{ $values { "vocab" "a vocabulary specifier" } { "main" word } }
+{ $values { "vocab-spec" "a vocabulary specifier" } { "main" word } }
 { $description "Outputs the main entry point for a vocabulary. The entry point can be executed with " { $link run } " and set with " { $link POSTPONE: MAIN: } "." } ;
 
 HELP: vocab-roots
diff --git a/core/vocabs/loader/loader-tests.factor b/core/vocabs/loader/loader-tests.factor
index b945126be4..5ba7f7ed88 100755
--- a/core/vocabs/loader/loader-tests.factor
+++ b/core/vocabs/loader/loader-tests.factor
@@ -55,7 +55,7 @@ IN: vocabs.loader.tests
     
     [ t ] [
         "resource:core/vocabs/loader/test/a/a.factor"
-        source-file source-file-definitions dup USE: prettyprint .
+        source-file definitions>> dup USE: prettyprint .
         "v-l-t-a-hello" "vocabs.loader.test.a" lookup dup .
         swap first key?
     ] unit-test
diff --git a/core/vocabs/vocabs-docs.factor b/core/vocabs/vocabs-docs.factor
index 0d55499620..328dce9b03 100755
--- a/core/vocabs/vocabs-docs.factor
+++ b/core/vocabs/vocabs-docs.factor
@@ -46,19 +46,19 @@ HELP: vocab
 { $class-description "Instances represent vocabularies." } ;
 
 HELP: vocab-name
-{ $values { "vocab" "a vocabulary specifier" } { "name" string } }
+{ $values { "vocab-spec" "a vocabulary specifier" } { "name" string } }
 { $description "Outputs the name of a vocabulary." } ;
 
 HELP: vocab-words
-{ $values { "vocab" "a vocabulary specifier" } { "words" "an assoc mapping strings to words" } }
+{ $values { "vocab-spec" "a vocabulary specifier" } { "words" "an assoc mapping strings to words" } }
 { $description "Outputs the words defined in a vocabulary." } ;
 
 HELP: vocab-source-loaded?
-{ $values { "vocab" "a vocabulary specifier" } { "source-loaded?" "a boolean" } }
+{ $values { "vocab-spec" "a vocabulary specifier" } { "?" "a boolean" } }
 { $description "Outputs if the source for this vocubulary has been loaded." } ;
 
 HELP: vocab-docs-loaded?
-{ $values { "vocab" "a vocabulary specifier" } { "docs-loaded?" "a boolean" } }
+{ $values { "vocab-spec" "a vocabulary specifier" } { "?" "a boolean" } }
 { $description "Outputs if the documentation for this vocubulary has been loaded." } ;
 
 HELP: words
diff --git a/extra/24-game/24-game-docs.factor b/extra/24-game/24-game-docs.factor
index 996d0a1240..fb1f5c057b 100644
--- a/extra/24-game/24-game-docs.factor
+++ b/extra/24-game/24-game-docs.factor
@@ -35,8 +35,8 @@ HELP: 24-able ( -- vector )
 }
 { $examples
     { $example
-        "USING: 24-game prettyprint ;"
-        "24-able 24-able? ."
+        "USING: 24-game kernel sequences prettyprint ;"
+        "24-able length 4 = ."
         "t"
     }
     { $notes { $link 24-able? } " is used in " { $link 24-able } "." }
diff --git a/extra/animations/animations.factor b/extra/animations/animations.factor
index 803536a51c..8ac4abe1fa 100644
--- a/extra/animations/animations.factor
+++ b/extra/animations/animations.factor
@@ -11,7 +11,7 @@ SYMBOL: sleep-period
 ! : my-progress ( -- progress ) millis 
 : progress ( -- progress ) millis last-loop get - reset-progress ;
 : progress-peek ( -- progress ) millis last-loop get - ;
-: set-end ( duration -- end-time ) dt>milliseconds millis + ;
+: set-end ( duration -- end-time ) duration>milliseconds millis + ;
 : loop ( quot end -- ) dup millis > [ [ dup call ] dip loop ] [ 2drop ] if ; inline
 : animate ( quot duration -- ) reset-progress set-end loop ; inline
 : sample ( revs quot -- avg ) reset-progress dupd times progress swap / ; inline
\ No newline at end of file
diff --git a/extra/asn1/asn1.factor b/extra/asn1/asn1.factor
index 3c4aea028b..df5d11be75 100644
--- a/extra/asn1/asn1.factor
+++ b/extra/asn1/asn1.factor
@@ -184,7 +184,7 @@ TUPLE: tag value ;
     tagnum get (>>value) ;
 
 M: string >ber ( str -- byte-array )
-    tagnum get tag-value 1array "C" pack-native swap dup
+    tagnum get value>> 1array "C" pack-native swap dup
     length >ber-length-encoding swapd append swap
     >byte-array append ;
 
diff --git a/extra/benchmark/binary-trees/binary-trees.factor b/extra/benchmark/binary-trees/binary-trees.factor
index bd3d460961..f562072f28 100644
--- a/extra/benchmark/binary-trees/binary-trees.factor
+++ b/extra/benchmark/binary-trees/binary-trees.factor
@@ -14,7 +14,7 @@ C: <tree-node> tree-node
         [ >r 2 *     r> bottom-up-tree ] 2tri
     ] [
         drop f f
-    ] if <tree-node> ;
+    ] if <tree-node> ; inline recursive
 
 GENERIC: item-check ( node -- n )
 
@@ -28,7 +28,7 @@ M: f item-check drop 0 ;
 : stretch-tree ( max-depth -- )
     1 + 0 over bottom-up-tree item-check
     [ "stretch tree of depth " write pprint ]
-    [ "\t check: " write . ] bi* ;
+    [ "\t check: " write . ] bi* ; inline
 
 :: long-lived-tree ( max-depth -- )
     0 max-depth bottom-up-tree
@@ -46,10 +46,10 @@ M: f item-check drop 0 ;
     ] each
 
     "long lived tree of depth " write max-depth pprint
-    "\t check: " write item-check . ;
+    "\t check: " write item-check . ; inline
 
 : binary-trees ( n -- )
-    min-depth 2 + max [ stretch-tree ] [ long-lived-tree ] bi ;
+    min-depth 2 + max [ stretch-tree ] [ long-lived-tree ] bi ; inline
 
 : binary-trees-main ( -- )
     16 binary-trees ;
diff --git a/extra/benchmark/dawes/dawes.factor b/extra/benchmark/dawes/dawes.factor
new file mode 100644
index 0000000000..7cff06d1bc
--- /dev/null
+++ b/extra/benchmark/dawes/dawes.factor
@@ -0,0 +1,21 @@
+USING: sequences alien.c-types math hints kernel byte-arrays ;
+IN: benchmark.dawes
+
+! Phil Dawes's performance problem
+
+: int-length ( byte-array -- n ) length "int" heap-size /i ; inline
+
+: count-ones ( byte-array -- n )
+    0 swap [ int-length ] keep [
+        int-nth 1 = [ 1 + ] when
+    ] curry each-integer ;
+
+HINTS: count-ones byte-array ;
+
+: make-byte-array ( -- byte-array )
+    120000 [ 255 bitand ] map >c-int-array ;
+
+: dawes-benchmark ( -- )
+    make-byte-array 200 swap [ count-ones ] curry replicate drop ;
+
+MAIN: dawes-benchmark
diff --git a/extra/benchmark/euler150/euler150.factor b/extra/benchmark/euler150/euler150.factor
new file mode 100644
index 0000000000..448c8575f9
--- /dev/null
+++ b/extra/benchmark/euler150/euler150.factor
@@ -0,0 +1,7 @@
+IN: benchmark.euler150
+USING: kernel project-euler.150 ;
+
+: euler150-benchmark ( -- )
+    euler150 -271248680 assert= ;
+
+MAIN: euler150-benchmark
diff --git a/extra/benchmark/euler186/euler186.factor b/extra/benchmark/euler186/euler186.factor
new file mode 100644
index 0000000000..681ca0e269
--- /dev/null
+++ b/extra/benchmark/euler186/euler186.factor
@@ -0,0 +1,7 @@
+IN: benchmark.euler186
+USING: kernel project-euler.186 ;
+
+: euler186-benchmark ( -- )
+    euler186 2325629 assert= ;
+
+MAIN: euler186-benchmark
diff --git a/extra/benchmark/mandel/colors/colors.factor b/extra/benchmark/mandel/colors/colors.factor
new file mode 100644
index 0000000000..848fbae01e
--- /dev/null
+++ b/extra/benchmark/mandel/colors/colors.factor
@@ -0,0 +1,19 @@
+USING: math math.order kernel arrays byte-arrays sequences
+colors.hsv benchmark.mandel.params ;
+IN: benchmark.mandel.colors
+
+: scale 255 * >fixnum ; inline
+
+: scale-rgb ( r g b -- n ) [ scale ] tri@ 3byte-array ;
+
+: sat 0.85 ; inline
+: val 0.85 ; inline
+
+: <color-map> ( nb-cols -- map )
+    dup [
+        360 * swap 1+ / sat val
+        3array hsv>rgb first3 scale-rgb
+    ] with map ;
+
+: color-map ( -- map )
+    nb-iter max-color min <color-map> ; foldable
diff --git a/extra/benchmark/mandel/mandel.factor b/extra/benchmark/mandel/mandel.factor
index 2685ff28b7..a40b123ed3 100755
--- a/extra/benchmark/mandel/mandel.factor
+++ b/extra/benchmark/mandel/mandel.factor
@@ -1,69 +1,45 @@
-USING: arrays io kernel math math.order namespaces sequences
-       byte-arrays byte-vectors math.functions math.parser io.files
-       colors.hsv io.encodings.binary ;
-
+USING: arrays io kernel math math.functions math.order
+math.parser sequences locals byte-arrays byte-vectors io.files
+io.encodings.binary benchmark.mandel.params
+benchmark.mandel.colors ;
 IN: benchmark.mandel
 
-: max-color 360   ; inline
-: zoom-fact 0.8   ; inline
-: width     640   ; inline
-: height    480   ; inline
-: nb-iter   40    ; inline
-: center    -0.65 ; inline
-
-: scale 255 * >fixnum ; inline
-
-: scale-rgb ( r g b -- n ) [ scale ] tri@ 3array ;
-
-: sat 0.85 ; inline
-: val 0.85 ; inline
-
-: <color-map> ( nb-cols -- map )
-    dup [
-        360 * swap 1+ / sat val
-        3array hsv>rgb first3 scale-rgb
-    ] with map ;
-
 : iter ( c z nb-iter -- x )
-    over absq 4.0 >= over zero? or
-    [ 2nip ] [ 1- >r sq dupd + r> iter ] if ; inline recursive
-
-SYMBOL: cols
+    dup 0 <= [ 2nip ] [
+        over absq 4.0 >= [ 2nip ] [
+            >r sq dupd + r> 1- iter
+        ] if
+    ] if ; inline recursive
 
 : x-inc width  200000 zoom-fact * / ; inline
 : y-inc height 150000 zoom-fact * / ; inline
 
 : c ( i j -- c )
-    >r
-    x-inc * center real-part x-inc width 2 / * - + >float
-    r>
-    y-inc * center imaginary-part y-inc height 2 / * - + >float
+    [ x-inc * center real-part x-inc width 2 / * - + >float ]
+    [ y-inc * center imaginary-part y-inc height 2 / * - + >float ] bi*
     rect> ; inline
 
-: render ( -- )
+:: render ( accum -- )
     height [
         width swap [
-            c 0 nb-iter iter dup zero? [
-                drop "\0\0\0"
-            ] [
-                cols get [ length mod ] keep nth
-            ] if %
+            c C{ 0.0 0.0 } nb-iter iter dup zero?
+            [ drop B{ 0 0 0 } ] [ color-map [ length mod ] keep nth ] if
+            accum push-all
         ] curry each
-    ] each ;
+    ] each ; inline
 
-: ppm-header ( w h -- )
-    "P6\n" % swap # " " % # "\n255\n" % ;
+:: ppm-header ( accum -- )
+    "P6\n" accum push-all
+    width number>string accum push-all
+    " " accum push-all
+    height number>string accum push-all
+    "\n255\n" accum push-all ; inline
 
-: buf-size ( -- n ) width height * 3 * 100 + ;
+: buf-size ( -- n ) width height * 3 * 100 + ; inline
 
 : mandel ( -- data )
-    [
-        buf-size <byte-vector> building set
-        width height ppm-header
-        nb-iter max-color min <color-map> cols set
-        render
-        building get >byte-array
-    ] with-scope ;
+    buf-size <byte-vector>
+    [ ppm-header ] [ render ] [ B{ } like ] tri ;
 
 : mandel-main ( -- )
     mandel "mandel.ppm" temp-file binary set-file-contents ;
diff --git a/extra/benchmark/mandel/params/params.factor b/extra/benchmark/mandel/params/params.factor
new file mode 100644
index 0000000000..3fcfe1d3ef
--- /dev/null
+++ b/extra/benchmark/mandel/params/params.factor
@@ -0,0 +1,8 @@
+IN: benchmark.mandel.params
+
+: max-color 360   ; inline
+: zoom-fact 0.8   ; inline
+: width     640   ; inline
+: height    480   ; inline
+: nb-iter   40    ; inline
+: center    -0.65 ; inline
diff --git a/extra/benchmark/typecheck2/typecheck2.factor b/extra/benchmark/typecheck2/typecheck2.factor
index f408389e69..2571eda412 100644
--- a/extra/benchmark/typecheck2/typecheck2.factor
+++ b/extra/benchmark/typecheck2/typecheck2.factor
@@ -3,7 +3,7 @@ IN: benchmark.typecheck2
 
 TUPLE: hello n ;
 
-: hello-n* ( obj -- value ) dup tuple? [ 3 slot ] [ 3 throw ] if ;
+: hello-n* ( obj -- value ) dup tuple? [ 2 slot ] [ 3 throw ] if ;
 
 : foo ( obj -- obj n ) 0 100000000 [ over hello-n* + ] times ;
 
diff --git a/extra/benchmark/typecheck3/typecheck3.factor b/extra/benchmark/typecheck3/typecheck3.factor
index b15d81df56..c4887c03c4 100644
--- a/extra/benchmark/typecheck3/typecheck3.factor
+++ b/extra/benchmark/typecheck3/typecheck3.factor
@@ -3,7 +3,7 @@ IN: benchmark.typecheck3
 
 TUPLE: hello n ;
 
-: hello-n* ( obj -- val ) dup tag 2 eq? [ 3 slot ] [ 3 throw ] if ;
+: hello-n* ( obj -- val ) dup tag 2 eq? [ 2 slot ] [ 3 throw ] if ;
 
 : foo ( obj -- obj n ) 0 100000000 [ over hello-n* + ] times ;
 
diff --git a/extra/benchmark/typecheck4/typecheck4.factor b/extra/benchmark/typecheck4/typecheck4.factor
index a2595810be..c881864304 100644
--- a/extra/benchmark/typecheck4/typecheck4.factor
+++ b/extra/benchmark/typecheck4/typecheck4.factor
@@ -3,7 +3,7 @@ IN: benchmark.typecheck4
 
 TUPLE: hello n ;
 
-: hello-n* ( obj -- val ) 3 slot ;
+: hello-n* ( obj -- val ) 2 slot ;
 
 : foo ( obj -- obj n ) 0 100000000 [ over hello-n* + ] times ;
 
diff --git a/extra/benchmark/ui-panes/ui-panes.factor b/extra/benchmark/ui-panes/ui-panes.factor
new file mode 100644
index 0000000000..6fdbdaecf6
--- /dev/null
+++ b/extra/benchmark/ui-panes/ui-panes.factor
@@ -0,0 +1,7 @@
+USING: ui.gadgets.panes prettyprint io sequences ;
+IN: benchmark.ui-panes
+
+: ui-pane-benchmark ( -- )
+    <pane> <pane-stream> [ 10000 [ . ] each ] with-output-stream* ;
+
+MAIN: ui-pane-benchmark
diff --git a/extra/boids/ui/ui.factor b/extra/boids/ui/ui.factor
index cd73c67a71..ddb25ccd8d 100755
--- a/extra/boids/ui/ui.factor
+++ b/extra/boids/ui/ui.factor
@@ -121,25 +121,25 @@ VARS: population-label cohesion-label alignment-label separation-label ;
     
       "1 - Randomize" [ drop randomize ] button* add-gadget
     
-      <pile> 1 over set-pack-fill
+      <pile> 1 >>fill
         population-label> add-gadget
         "3 - Add 10" [ drop add-10-boids ] button* add-gadget
         "2 - Sub 10" [ drop sub-10-boids ] button* add-gadget
       add-gadget
     
-      <pile> 1 over set-pack-fill
+      <pile> 1 >>fill
         cohesion-label> add-gadget
         "q - +0.1" [ drop inc-cohesion-weight ] button* add-gadget
         "a - -0.1" [ drop dec-cohesion-weight ] button* add-gadget
       add-gadget
 
-      <pile> 1 over set-pack-fill
+      <pile> 1 >>fill
         alignment-label> add-gadget
         "w - +0.1" [ drop inc-alignment-weight ] button* add-gadget
         "s - -0.1" [ drop dec-alignment-weight ] button* add-gadget
       add-gadget
 
-      <pile> 1 over set-pack-fill
+      <pile> 1 >>fill
         separation-label> add-gadget
         "e - +0.1" [ drop inc-separation-weight ] button* add-gadget
         "d - -0.1" [ drop dec-separation-weight ] button* add-gadget
diff --git a/unmaintained/bunny/authors.txt b/extra/bunny/authors.txt
similarity index 100%
rename from unmaintained/bunny/authors.txt
rename to extra/bunny/authors.txt
diff --git a/unmaintained/bunny/bun_zipper.ply b/extra/bunny/bun_zipper.ply
similarity index 100%
rename from unmaintained/bunny/bun_zipper.ply
rename to extra/bunny/bun_zipper.ply
diff --git a/unmaintained/bunny/bunny.factor b/extra/bunny/bunny.factor
similarity index 100%
rename from unmaintained/bunny/bunny.factor
rename to extra/bunny/bunny.factor
diff --git a/unmaintained/bunny/cel-shaded/cel-shaded.factor b/extra/bunny/cel-shaded/cel-shaded.factor
similarity index 100%
rename from unmaintained/bunny/cel-shaded/cel-shaded.factor
rename to extra/bunny/cel-shaded/cel-shaded.factor
diff --git a/unmaintained/bunny/deploy.factor b/extra/bunny/deploy.factor
similarity index 100%
rename from unmaintained/bunny/deploy.factor
rename to extra/bunny/deploy.factor
diff --git a/unmaintained/bunny/fixed-pipeline/fixed-pipeline.factor b/extra/bunny/fixed-pipeline/fixed-pipeline.factor
similarity index 100%
rename from unmaintained/bunny/fixed-pipeline/fixed-pipeline.factor
rename to extra/bunny/fixed-pipeline/fixed-pipeline.factor
diff --git a/unmaintained/bunny/model/model.factor b/extra/bunny/model/model.factor
similarity index 98%
rename from unmaintained/bunny/model/model.factor
rename to extra/bunny/model/model.factor
index 376cd3feae..32312aed89 100755
--- a/unmaintained/bunny/model/model.factor
+++ b/extra/bunny/model/model.factor
@@ -79,7 +79,7 @@ GENERIC: bunny-geom ( geom -- )
 GENERIC: draw-bunny ( geom draw -- )
 
 M: bunny-dlist bunny-geom
-    bunny-dlist-list glCallList ;
+    list>> glCallList ;
 
 M: bunny-buffers bunny-geom
     dup [ array>> ] [ element-array>> ] bi [
diff --git a/unmaintained/bunny/outlined/outlined.factor b/extra/bunny/outlined/outlined.factor
similarity index 97%
rename from unmaintained/bunny/outlined/outlined.factor
rename to extra/bunny/outlined/outlined.factor
index bf757c4fb3..cd67b8b33e 100755
--- a/unmaintained/bunny/outlined/outlined.factor
+++ b/extra/bunny/outlined/outlined.factor
@@ -139,11 +139,7 @@ TUPLE: bunny-outlined
 
 : <bunny-outlined> ( gadget -- draw )
     outlining-supported? [
-        pass1-program pass2-program {
-            (>>gadget)
-            (>>pass1-program)
-            (>>pass2-program)
-        } bunny-outlined construct
+        pass1-program pass2-program f f f f f bunny-outlined boa
     ] [ drop f ] if ;
 
 : (framebuffer-texture) ( dim iformat xformat -- texture )
diff --git a/unmaintained/bunny/summary.txt b/extra/bunny/summary.txt
similarity index 100%
rename from unmaintained/bunny/summary.txt
rename to extra/bunny/summary.txt
diff --git a/unmaintained/bunny/tags.txt b/extra/bunny/tags.txt
similarity index 100%
rename from unmaintained/bunny/tags.txt
rename to extra/bunny/tags.txt
diff --git a/extra/cfdg/cfdg.factor b/extra/cfdg/cfdg.factor
index 114ebf5445..434ecd59f5 100644
--- a/extra/cfdg/cfdg.factor
+++ b/extra/cfdg/cfdg.factor
@@ -5,8 +5,9 @@ USING: kernel alien.c-types combinators namespaces arrays
        opengl.gl opengl.glu opengl ui ui.gadgets.slate
        vars colors self self.slots
        random-weighted colors.hsv cfdg.gl accessors
-       ui.gadgets.handler ui.gestures assocs ui.gadgets macros ;
-
+       ui.gadgets.handler ui.gestures assocs ui.gadgets macros
+       qualified ;
+QUALIFIED: syntax
 IN: cfdg
 
 ! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
@@ -158,7 +159,7 @@ MACRO: rule ( seq -- quot ) [rule] ;
 
 VAR: background
 
-: set-initial-background ( -- ) T{ hsva f 0 0 1 1 } clone >self ;
+: set-initial-background ( -- ) T{ hsva syntax:f 0 0 1 1 } clone >self ;
 
 : set-background ( -- )
   set-initial-background
@@ -173,7 +174,7 @@ VAR: viewport ! { left width bottom height }
 
 VAR: start-shape
 
-: set-initial-color ( -- ) T{ hsva f 0 0 0 1 } clone >self ;
+: set-initial-color ( -- ) T{ hsva syntax:f 0 0 0 1 } clone >self ;
 
 ! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
@@ -244,8 +245,8 @@ SYMBOL: the-slate
     C[ dlist get [ dlist get 1 glDeleteLists ] when ] >>ungraft
   <handler>
     H{ } clone
-      T{ key-down f f "ENTER" } C[ drop rebuild ] swap pick set-at
-      T{ button-down }          C[ drop rebuild ] swap pick set-at
+      T{ key-down syntax:f syntax:f "ENTER" } C[ drop rebuild ] swap pick set-at
+      T{ button-down } C[ drop rebuild ] swap pick set-at
     >>table ;
 
 ! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
diff --git a/extra/classes/tuple/lib/authors.txt b/extra/classes/tuple/lib/authors.txt
deleted file mode 100644
index 7c1b2f2279..0000000000
--- a/extra/classes/tuple/lib/authors.txt
+++ /dev/null
@@ -1 +0,0 @@
-Doug Coleman
diff --git a/extra/classes/tuple/lib/lib-docs.factor b/extra/classes/tuple/lib/lib-docs.factor
deleted file mode 100644
index 0c4c11e46f..0000000000
--- a/extra/classes/tuple/lib/lib-docs.factor
+++ /dev/null
@@ -1,29 +0,0 @@
-USING: help.syntax help.markup kernel prettyprint sequences ;
-IN: classes.tuple.lib
-
-HELP: >tuple<
-{ $values { "class" "a tuple class" } }
-{ $description "Explodes the tuple so that tuple slots are on the stack in the order listed in the tuple." }
-{ $example
-    "USING: kernel prettyprint classes.tuple.lib ;"
-    "IN: scratchpad"
-    "TUPLE: foo a b c ;"
-    "1 2 3 \\ foo boa \\ foo >tuple< .s"
-    "1\n2\n3"
-}
-{ $notes "Words using " { $snippet ">tuple<" } " may be compiled." }
-{ $see-also >tuple*< } ;
-
-HELP: >tuple*<
-{ $values { "class" "a tuple class" } }
-{ $description "Explodes the tuple so that tuple slots ending with '*' are on the stack in the order listed in the tuple." }
-{ $example
-    "USING: kernel prettyprint classes.tuple.lib ;"
-    "IN: scratchpad"
-    "TUPLE: foo a bb* ccc dddd* ;"
-    "1 2 3 4 \\ foo boa \\ foo >tuple*< .s"
-    "2\n4"
-}
-{ $notes "Words using " { $snippet ">tuple*<" } " may be compiled." }
-{ $see-also >tuple< } ;
-
diff --git a/extra/classes/tuple/lib/lib-tests.factor b/extra/classes/tuple/lib/lib-tests.factor
deleted file mode 100644
index 7f7f24ab56..0000000000
--- a/extra/classes/tuple/lib/lib-tests.factor
+++ /dev/null
@@ -1,8 +0,0 @@
-USING: kernel tools.test classes.tuple.lib ;
-IN: classes.tuple.lib.tests
-
-TUPLE: foo a b* c d* e f* ;
-
-[ 1 2 3 4 5 6 ] [ 1 2 3 4 5 6 \ foo boa \ foo >tuple< ] unit-test
-[ 2 4 6 ] [ 1 2 3 4 5 6 \ foo boa \ foo >tuple*< ] unit-test
-
diff --git a/extra/classes/tuple/lib/lib.factor b/extra/classes/tuple/lib/lib.factor
deleted file mode 100755
index a234ce0d41..0000000000
--- a/extra/classes/tuple/lib/lib.factor
+++ /dev/null
@@ -1,18 +0,0 @@
-! Copyright (C) 2007 Doug Coleman.
-! See http://factorcode.org/license.txt for BSD license.
-USING: kernel macros sequences slots words classes.tuple
-quotations combinators accessors ;
-IN: classes.tuple.lib
-
-: reader-slots ( seq -- quot )
-    [ reader>> 1quotation ] map [ cleave ] curry ;
-
-MACRO: >tuple< ( class -- )
-    all-slots rest-slice reader-slots ;
-
-MACRO: >tuple*< ( class -- )
-    all-slots
-    [ slot-spec-name "*" tail? ] filter
-    reader-slots ;
-
-
diff --git a/extra/color-picker/color-picker.factor b/extra/color-picker/color-picker.factor
index 5400a12f89..4a0c148145 100755
--- a/extra/color-picker/color-picker.factor
+++ b/extra/color-picker/color-picker.factor
@@ -10,7 +10,7 @@ IN: color-picker
 ! Simple example demonstrating the use of models.
 
 : <color-slider> ( model -- gadget )
-    <x-slider> 1 over set-slider-line ;
+    <x-slider> 1 >>line ;
 
 TUPLE: color-preview < gadget ;
 
@@ -20,7 +20,7 @@ TUPLE: color-preview < gadget ;
       { 100 100 } >>dim ;
 
 M: color-preview model-changed
-    swap model-value over set-gadget-interior relayout-1 ;
+    swap value>> >>interior relayout-1 ;
 
 : <color-model> ( model -- model )
     [ [ 256 /f ] map 1 suffix first4 rgba boa <solid> ] <filter> ;
diff --git a/extra/db/authors.txt b/extra/db/authors.txt
deleted file mode 100644
index 7c1b2f2279..0000000000
--- a/extra/db/authors.txt
+++ /dev/null
@@ -1 +0,0 @@
-Doug Coleman
diff --git a/extra/db/postgresql/authors.txt b/extra/db/postgresql/authors.txt
deleted file mode 100644
index 7c1b2f2279..0000000000
--- a/extra/db/postgresql/authors.txt
+++ /dev/null
@@ -1 +0,0 @@
-Doug Coleman
diff --git a/extra/faq/faq.factor b/extra/faq/faq.factor
index 47d3727703..525cef68ed 100644
--- a/extra/faq/faq.factor
+++ b/extra/faq/faq.factor
@@ -18,15 +18,15 @@ C: <q/a> q/a
 : li>q/a ( li -- q/a )
     [ "br" tag-named*? not ] filter
     [ "strong" tag-named*? ] find-after
-    >r tag-children r> <q/a> ;
+    >r children>> r> <q/a> ;
 
 : q/a>li ( q/a -- li )
     [ question>> "strong" build-tag* f "br" build-tag* 2array ] keep
     answer>> append "li" build-tag* ;
 
 : xml>q/a ( xml -- q/a )
-    [ "question" tag-named tag-children ] keep
-    "answer" tag-named tag-children <q/a> ;
+    [ "question" tag-named children>> ] keep
+    "answer" tag-named children>> <q/a> ;
 
 : q/a>xml ( q/a -- xml )
     [ question>> "question" build-tag* ] keep
@@ -39,7 +39,7 @@ C: <question-list> question-list
 
 : xml>question-list ( list -- question-list )
     [ "title" swap at ] keep
-    tag-children [ tag? ] filter [ xml>q/a ] map
+    children>> [ tag? ] filter [ xml>q/a ] map
     <question-list> ;
 
 : question-list>xml ( question-list -- list )
diff --git a/extra/fjsc/fjsc.factor b/extra/fjsc/fjsc.factor
index e12092603a..ac3b447f1c 100755
--- a/extra/fjsc/fjsc.factor
+++ b/extra/fjsc/fjsc.factor
@@ -336,7 +336,7 @@ M: wrapper (parse-factor-quotation) ( object -- ast )
 GENERIC: fjsc-parse ( object -- ast )
 
 M: string fjsc-parse ( object -- ast )
-  'expression' parse parse-result-ast ;
+  'expression' parse ast>> ;
 
 M: quotation fjsc-parse ( object -- ast )
   [
diff --git a/extra/furnace/furnace.factor b/extra/furnace/furnace.factor
index 45aa55f050..fadd398882 100644
--- a/extra/furnace/furnace.factor
+++ b/extra/furnace/furnace.factor
@@ -176,7 +176,7 @@ CHLOE: a
                     [ link-attrs ]
                     [ "method" optional-attr "post" or =method ]
                     [ "action" required-attr resolve-base-path =action ]
-                    [ tag-attrs non-chloe-attrs-only print-attrs ]
+                    [ attrs>> non-chloe-attrs-only print-attrs ]
                 } cleave
             form>
         ]
@@ -196,13 +196,13 @@ STRING: button-tag-markup
 ;
 
 : add-tag-attrs ( attrs tag -- )
-    tag-attrs swap update ;
+    attrs>> swap update ;
 
 CHLOE: button
-    button-tag-markup string>xml delegate
+    button-tag-markup string>xml body>>
     {
-        [ [ tag-attrs chloe-attrs-only ] dip add-tag-attrs ]
-        [ [ tag-attrs non-chloe-attrs-only ] dip "button" tag-named add-tag-attrs ]
-        [ [ children>string 1array ] dip "button" tag-named set-tag-children ]
+        [ [ attrs>> chloe-attrs-only ] dip add-tag-attrs ]
+        [ [ attrs>> non-chloe-attrs-only ] dip "button" tag-named add-tag-attrs ]
+        [ [ children>string 1array ] dip "button" tag-named (>>children) ]
         [ nip ]
     } 2cleave process-chloe-tag ;
diff --git a/extra/game-input/backend/backend.factor b/extra/game-input/backend/backend.factor
index cfba0a52f5..df61179da7 100644
--- a/extra/game-input/backend/backend.factor
+++ b/extra/game-input/backend/backend.factor
@@ -2,12 +2,14 @@ USING: eval multiline system combinators ;
 IN: game-input.backend
 
 STRING: set-backend-for-macosx
-USING: namespaces game-input.backend.iokit game-input ;
+USING: namespaces parser game-input.backend.iokit ;
+<< "game-input" (use+) >>
 iokit-game-input-backend game-input-backend set-global
 ;
 
 STRING: set-backend-for-windows
-USING: namespaces game-input.backend.dinput game-input ;
+USING: namespaces parser game-input.backend.dinput ;
+<< "game-input" (use+) >>
 dinput-game-input-backend game-input-backend set-global
 ;
 
diff --git a/extra/game-input/backend/dinput/dinput.factor b/extra/game-input/backend/dinput/dinput.factor
index 73c9f511a1..116faf60cd 100755
--- a/extra/game-input/backend/dinput/dinput.factor
+++ b/extra/game-input/backend/dinput/dinput.factor
@@ -1,10 +1,11 @@
-USING: windows.dinput windows.dinput.constants game-input
+USING: windows.dinput windows.dinput.constants parser
 symbols alien.c-types windows.ole32 namespaces assocs kernel
 arrays vectors windows.kernel32 windows.com windows.dinput
 shuffle windows.user32 windows.messages sequences combinators
 math.geometry.rect ui.windows accessors math windows alien
 alien.strings io.encodings.utf16 continuations byte-arrays
 locals game-input.backend.dinput.keys-array ;
+<< "game-input" (use+) >>
 IN: game-input.backend.dinput
 
 SINGLETON: dinput-game-input-backend
diff --git a/extra/game-input/backend/iokit/iokit.factor b/extra/game-input/backend/iokit/iokit.factor
index dcdfa6d192..4a7d251425 100755
--- a/extra/game-input/backend/iokit/iokit.factor
+++ b/extra/game-input/backend/iokit/iokit.factor
@@ -1,9 +1,10 @@
 USING: cocoa cocoa.plists core-foundation iokit iokit.hid
 kernel cocoa.enumeration destructors math.parser cocoa.application 
-sequences locals combinators.short-circuit game-input threads
+sequences locals combinators.short-circuit threads
 symbols namespaces assocs vectors arrays combinators
 core-foundation.run-loop accessors sequences.private
-alien.c-types math ;
+alien.c-types math parser ;
+<< "game-input" (use+) >>
 IN: game-input.backend.iokit
 
 SINGLETON: iokit-game-input-backend
diff --git a/extra/game-input/game-input.factor b/extra/game-input/game-input.factor
index 208c8476fc..18ec04df1f 100755
--- a/extra/game-input/game-input.factor
+++ b/extra/game-input/game-input.factor
@@ -28,7 +28,6 @@ M: f (reset-game-input) ;
 PRIVATE>
 
 : open-game-input ( -- )
-    load-game-input-backend
     game-input-opened? [
         (open-game-input) 
         game-input-opened on
@@ -76,3 +75,6 @@ M: keyboard-state clone
     call-next-method dup keys>> clone >>keys ;
 
 HOOK: read-keyboard game-input-backend ( -- keyboard-state )
+
+load-game-input-backend
+
diff --git a/extra/gesture-logger/gesture-logger.factor b/extra/gesture-logger/gesture-logger.factor
index b990de03fc..61dc8cf77e 100644
--- a/extra/gesture-logger/gesture-logger.factor
+++ b/extra/gesture-logger/gesture-logger.factor
@@ -19,7 +19,7 @@ M: gesture-logger handle-gesture
     t ;
 
 M: gesture-logger user-input*
-    gesture-logger-stream [
+    stream>> [
         "User input: " write print
     ] with-output-stream* t ;
 
diff --git a/extra/html/streams/streams-tests.factor b/extra/html/streams/streams-tests.factor
index 948c998e13..b5707c158f 100644
--- a/extra/html/streams/streams-tests.factor
+++ b/extra/html/streams/streams-tests.factor
@@ -1,8 +1,6 @@
-
-USING: html.streams html.streams.private
-       io io.streams.string io.styles kernel
-       namespaces tools.test xml.writer sbufs sequences inspector colors ;
-
+USING: html.streams html.streams.private accessors io
+io.streams.string io.styles kernel namespaces tools.test
+xml.writer sbufs sequences inspector colors ;
 IN: html.streams.tests
 
 : make-html-string
@@ -33,7 +31,7 @@ IN: html.streams.tests
 TUPLE: funky town ;
 
 M: funky browser-link-href
-    "http://www.funky-town.com/" swap funky-town append ;
+    "http://www.funky-town.com/" swap town>> append ;
 
 [ "<a href='http://www.funky-town.com/austin'>&lt;</a>" ] [
     [
diff --git a/extra/html/templates/chloe/chloe.factor b/extra/html/templates/chloe/chloe.factor
index 67a7dc2045..afbd82fed4 100644
--- a/extra/html/templates/chloe/chloe.factor
+++ b/extra/html/templates/chloe/chloe.factor
@@ -22,10 +22,10 @@ C: <chloe> chloe
 DEFER: process-template
 
 : chloe-attrs-only ( assoc -- assoc' )
-    [ drop name-url chloe-ns = ] assoc-filter ;
+    [ drop url>> chloe-ns = ] assoc-filter ;
 
 : non-chloe-attrs-only ( assoc -- assoc' )
-    [ drop name-url chloe-ns = not ] assoc-filter ;
+    [ drop url>> chloe-ns = not ] assoc-filter ;
 
 : chloe-tag? ( tag -- ? )
     dup xml? [ body>> ] when
@@ -148,10 +148,10 @@ CHLOE-TUPLE: code
             process-template
         ] [
             {
-                [ xml-prolog write-prolog ]
-                [ xml-before write-chunk  ]
+                [ prolog>> write-prolog ]
+                [ before>> write-chunk  ]
                 [ process-template        ]
-                [ xml-after write-chunk   ]
+                [ after>> write-chunk   ]
             } cleave
         ] if
     ] with-scope ;
diff --git a/extra/http/http.factor b/extra/http/http.factor
index 70848ed9f6..2a5a19036f 100755
--- a/extra/http/http.factor
+++ b/extra/http/http.factor
@@ -106,7 +106,7 @@ TUPLE: cookie name value version comment path domain expires max-age http-only s
         [
             {
                 { [ dup timestamp? ] [ timestamp>cookie-string ] }
-                { [ dup duration? ] [ dt>seconds number>string ] }
+                { [ dup duration? ] [ duration>seconds number>string ] }
                 { [ dup real? ] [ number>string ] }
                 [ ]
             } cond
diff --git a/extra/inverse/inverse-tests.factor b/extra/inverse/inverse-tests.factor
index 3206636ea9..d106b1068a 100644
--- a/extra/inverse/inverse-tests.factor
+++ b/extra/inverse/inverse-tests.factor
@@ -32,7 +32,7 @@ C: <foo> foo
 : f>c ( *fahrenheit -- *celsius )
     32 - 1.8 / ;
 
-[ { 212 32 } ] [ { 100 0 } [ [ f>c ] map ] undo ] unit-test
+[ { 212.0 32.0 } ] [ { 100 0 } [ [ f>c ] map ] undo ] unit-test
 [ { t t f } ] [ { t f 1 } [ [ >boolean ] matches? ] map ] unit-test
 [ { t f } ] [ { { 1 2 3 } 4 } [ [ >array ] matches? ] map ] unit-test
 [ 9 9 ] [ 3 [ 1/2 ^ ] undo 3 [ sqrt ] undo ] unit-test
diff --git a/extra/inverse/inverse.factor b/extra/inverse/inverse.factor
index 2340442d5b..c7925b94be 100755
--- a/extra/inverse/inverse.factor
+++ b/extra/inverse/inverse.factor
@@ -207,8 +207,8 @@ DEFER: _
     "predicate" word-prop [ dupd call assure ] curry ;
 
 : slot-readers ( class -- quot )
-    all-slots rest ! tail gets rid of delegate
-    [ reader>> 1quotation [ keep ] curry ] map concat
+    all-slots
+    [ name>> reader-word 1quotation [ keep ] curry ] map concat
     [ ] like [ drop ] compose ;
 
 : ?wrapped ( object -- wrapped )
diff --git a/extra/irc/messages/messages.factor b/extra/irc/messages/messages.factor
index 201e8de9e7..d3eca92f15 100755
--- a/extra/irc/messages/messages.factor
+++ b/extra/irc/messages/messages.factor
@@ -127,4 +127,4 @@ M: sender-in-prefix irc-message-sender ( sender-in-prefix -- sender )
     } case
     [ [ tuple-slots ] [ parameters>> ] bi append ] dip
     [ all-slots over [ length ] bi@ min head >quotation ] keep
-    '[ @ , boa nip ] call ;
+    '[ @ , boa ] call ;
diff --git a/extra/joystick-demo/deploy.factor b/extra/joystick-demo/deploy.factor
new file mode 100644
index 0000000000..8843ae66f3
--- /dev/null
+++ b/extra/joystick-demo/deploy.factor
@@ -0,0 +1,15 @@
+USING: tools.deploy.config ;
+H{
+    { deploy-name "joystick-demo" }
+    { deploy-io 2 }
+    { deploy-word-defs? f }
+    { deploy-c-types? t }
+    { deploy-random? t }
+    { deploy-word-props? f }
+    { deploy-reflection 1 }
+    { deploy-threads? t }
+    { deploy-math? t }
+    { "stop-after-last-window?" t }
+    { deploy-ui? t }
+    { deploy-compiler? t }
+}
diff --git a/extra/json/reader/reader-tests.factor b/extra/json/reader/reader-tests.factor
index 4b7bd56f01..995ae0e0b8 100644
--- a/extra/json/reader/reader-tests.factor
+++ b/extra/json/reader/reader-tests.factor
@@ -11,9 +11,9 @@ IN: json.reader.tests
 { 102.0 } [ "102.0" json> ] unit-test
 { 102.5 } [ "102.5" json> ] unit-test
 { 102.5 } [ "102.50" json> ] unit-test
-{ -10250 } [ "-102.5e2" json> ] unit-test
-{ -10250 } [ "-102.5E+2" json> ] unit-test
-{ 10.25 } [ "1025e-2" json> ] unit-test
+{ -10250.0 } [ "-102.5e2" json> ] unit-test
+{ -10250.0 } [ "-102.5E+2" json> ] unit-test
+{ 10+1/4 } [ "1025e-2" json> ] unit-test
 { 0.125 } [ "0.125" json> ] unit-test
 { -0.125 } [ "-0.125" json> ] unit-test
 
diff --git a/extra/lcd/lcd.factor b/extra/lcd/lcd.factor
index d1646a4089..8123576f5e 100755
--- a/extra/lcd/lcd.factor
+++ b/extra/lcd/lcd.factor
@@ -26,7 +26,7 @@ IN: lcd
 : <time-display> ( timestamp -- gadget )
     [ hh:mm:ss lcd ] <filter> <label-control>
     "99:99:99" lcd over set-label-string
-    monospace-font over set-label-font ;
+    monospace-font >>font ;
 
 : time-window ( -- )
     [ time get <time-display> "Time" open-window ] with-ui ;
diff --git a/extra/lists/lazy/lazy.factor b/extra/lists/lazy/lazy.factor
index 8a1e73928c..5854e37702 100644
--- a/extra/lists/lazy/lazy.factor
+++ b/extra/lists/lazy/lazy.factor
@@ -356,7 +356,7 @@ M: lazy-io car ( lazy-io -- car )
         nip
     ] [
         drop dup stream>> over quot>> call
-        swap dupd set-lazy-io-car
+        >>car
     ] if ;
 
 M: lazy-io cdr ( lazy-io -- cdr )
diff --git a/extra/math/blas/cblas/tags.txt b/extra/math/blas/cblas/tags.txt
index 241ec1ecda..5118958180 100644
--- a/extra/math/blas/cblas/tags.txt
+++ b/extra/math/blas/cblas/tags.txt
@@ -1,2 +1,3 @@
 math
 bindings
+unportable
diff --git a/extra/math/blas/matrices/tags.txt b/extra/math/blas/matrices/tags.txt
index 241ec1ecda..5118958180 100644
--- a/extra/math/blas/matrices/tags.txt
+++ b/extra/math/blas/matrices/tags.txt
@@ -1,2 +1,3 @@
 math
 bindings
+unportable
diff --git a/extra/math/blas/syntax/tags.txt b/extra/math/blas/syntax/tags.txt
index ede10ab61b..6a932d96d2 100644
--- a/extra/math/blas/syntax/tags.txt
+++ b/extra/math/blas/syntax/tags.txt
@@ -1 +1,2 @@
 math
+unportable
diff --git a/extra/math/blas/vectors/tags.txt b/extra/math/blas/vectors/tags.txt
index ede10ab61b..6a932d96d2 100644
--- a/extra/math/blas/vectors/tags.txt
+++ b/extra/math/blas/vectors/tags.txt
@@ -1 +1,2 @@
 math
+unportable
diff --git a/extra/math/derivatives/derivatives-docs.factor b/extra/math/derivatives/derivatives-docs.factor
index 8e561f38ae..bbb793fe92 100644
--- a/extra/math/derivatives/derivatives-docs.factor
+++ b/extra/math/derivatives/derivatives-docs.factor
@@ -71,8 +71,8 @@ HELP: derivative-func
 { $examples
     { $example
         "USING: kernel math.derivatives math.functions math.trig prettyprint ;"
-        "60 deg>rad [ sin ] derivative-func call ."
-        "0.5000000000000173"
+        "60 deg>rad [ sin ] derivative-func call 0.5 .001 ~ ."
+        "t"
     }
     { $notes
         "Without a heavy algebraic system, derivatives must be "
diff --git a/extra/math/polynomials/polynomials-tests.factor b/extra/math/polynomials/polynomials-tests.factor
index 73215f9167..cccf24fbff 100644
--- a/extra/math/polynomials/polynomials-tests.factor
+++ b/extra/math/polynomials/polynomials-tests.factor
@@ -22,7 +22,7 @@ USING: kernel math math.polynomials tools.test ;
 [ V{ 1 0 1 } V{ 0 0 0 } ] [ { 1 1 1 1 } { 1 1 } p/mod ] unit-test
 [ V{ 1 0 1 } V{ 0 0 0 } ] [ { 1 1 1 1 } { 1 1 0 0 0 0 0 0 } p/mod ] unit-test
 [ V{ 1 0 1 } V{ 0 0 0 } ] [ { 1 1 1 1 0 0 0 0 } { 1 1 0 0 } p/mod ] unit-test
-[ V{ 5.0 } V{ 0.0 } ] [ { 10.0 } { 2.0 } p/mod ] unit-test
+[ V{ 5.0 } V{ 0 } ] [ { 10.0 } { 2.0 } p/mod ] unit-test
 [ V{ 15/16 } V{ 0 } ] [ { 3/4 } { 4/5 } p/mod ] unit-test
 [ t ] [ { 0 1 } { 0 1 0 } p= ] unit-test
 [ f ] [ { 0 0 1 } { 0 1 0 } p= ] unit-test
diff --git a/extra/math/quaternions/quaternions-tests.factor b/extra/math/quaternions/quaternions-tests.factor
index b30a1bc271..a6d255e421 100644
--- a/extra/math/quaternions/quaternions-tests.factor
+++ b/extra/math/quaternions/quaternions-tests.factor
@@ -2,11 +2,11 @@ IN: math.quaternions.tests
 USING: tools.test math.quaternions kernel math.vectors
 math.constants ;
 
-[ 1 ] [ qi norm ] unit-test
-[ 1 ] [ qj norm ] unit-test
-[ 1 ] [ qk norm ] unit-test
-[ 1 ] [ q1 norm ] unit-test
-[ 0 ] [ q0 norm ] unit-test
+[ 1.0 ] [ qi norm ] unit-test
+[ 1.0 ] [ qj norm ] unit-test
+[ 1.0 ] [ qk norm ] unit-test
+[ 1.0 ] [ q1 norm ] unit-test
+[ 0.0 ] [ q0 norm ] unit-test
 [ t ] [ qi qj q* qk = ] unit-test
 [ t ] [ qj qk q* qi = ] unit-test
 [ t ] [ qk qi q* qj = ] unit-test
diff --git a/extra/math/statistics/statistics-tests.factor b/extra/math/statistics/statistics-tests.factor
index 0884e1aed2..b6ff421956 100644
--- a/extra/math/statistics/statistics-tests.factor
+++ b/extra/math/statistics/statistics-tests.factor
@@ -5,7 +5,7 @@ IN: math.statistics.tests
 [ 3/2 ] [ { 1 2 } mean ] unit-test
 [ 0 ] [ { 0 0 0 } geometric-mean ] unit-test
 [ t ] [ { 2 2 2 2 } geometric-mean 2.0 .0001 ~ ] unit-test
-[ 1 ] [ { 1 1 1 } geometric-mean ] unit-test
+[ 1.0 ] [ { 1 1 1 } geometric-mean ] unit-test
 [ 1/3 ] [ { 1 1 1 } harmonic-mean ] unit-test
 
 [ 0 ] [ { 1 } range ] unit-test
@@ -14,12 +14,11 @@ IN: math.statistics.tests
 [ 5/2 ] [ { 1 2 3 4 } median ] unit-test
 
 [ 1 ] [ { 1 2 3 } var ] unit-test
-[ 1 ] [ { 1 2 3 } std ] unit-test
+[ 1.0 ] [ { 1 2 3 } std ] unit-test
 [ t ] [ { 1 2 3 4 } ste 0.6454972243679028 - .0001 < ] unit-test
 
 [ t ] [ { 23.2 33.4 22.5 66.3 44.5 } std 18.1906 - .0001 < ] unit-test
 
 [ 0 ] [ { 1 } var ] unit-test
-[ 0 ] [ { 1 } std ] unit-test
-[ 0 ] [ { 1 } ste ] unit-test
-
+[ 0.0 ] [ { 1 } std ] unit-test
+[ 0.0 ] [ { 1 } ste ] unit-test
diff --git a/extra/nehe/4/4.factor b/extra/nehe/4/4.factor
index 429e6d9d9c..0bbd4d593f 100644
--- a/extra/nehe/4/4.factor
+++ b/extra/nehe/4/4.factor
@@ -31,7 +31,7 @@ M: nehe4-gadget draw-gadget* ( gadget -- )
   GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT bitor glClear
   glLoadIdentity
   -1.5 0.0 -6.0 glTranslatef
-  dup nehe4-gadget-rtri 0.0 1.0 0.0 glRotatef
+  dup rtri>> 0.0 1.0 0.0 glRotatef
 
   GL_TRIANGLES [
     1.0 0.0 0.0 glColor3f
@@ -45,7 +45,7 @@ M: nehe4-gadget draw-gadget* ( gadget -- )
   glLoadIdentity
 
   1.5 0.0 -6.0 glTranslatef
-  dup nehe4-gadget-rquad 1.0 0.0 0.0 glRotatef
+  dup rquad>> 1.0 0.0 0.0 glRotatef
   0.5 0.5 1.0 glColor3f
   GL_QUADS [
     -1.0 1.0 0.0 glVertex3f
diff --git a/extra/nehe/5/5.factor b/extra/nehe/5/5.factor
index ebdfcd5367..1a416c9d95 100755
--- a/extra/nehe/5/5.factor
+++ b/extra/nehe/5/5.factor
@@ -30,7 +30,7 @@ M: nehe5-gadget draw-gadget* ( gadget -- )
   GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT bitor glClear
   glLoadIdentity
   -1.5 0.0 -6.0 glTranslatef
-  dup nehe5-gadget-rtri 0.0 1.0 0.0 glRotatef
+  dup rtri>> 0.0 1.0 0.0 glRotatef
 
   GL_TRIANGLES [
     1.0 0.0 0.0 glColor3f
@@ -65,7 +65,7 @@ M: nehe5-gadget draw-gadget* ( gadget -- )
   glLoadIdentity
 
   1.5 0.0 -7.0 glTranslatef
-  dup nehe5-gadget-rquad 1.0 0.0 0.0 glRotatef
+  dup rquad>> 1.0 0.0 0.0 glRotatef
   GL_QUADS [
     0.0 1.0 0.0 glColor3f
     1.0 1.0 -1.0 glVertex3f
diff --git a/extra/obj/examples/todo/todo.factor b/extra/obj/examples/todo/todo.factor
new file mode 100644
index 0000000000..3d545479e9
--- /dev/null
+++ b/extra/obj/examples/todo/todo.factor
@@ -0,0 +1,83 @@
+
+USING: kernel sequences sets combinators.cleave
+       obj obj.view obj.util obj.print ;
+
+IN: obj.examples.todo
+
+SYM: person types adjoin
+SYM: todo   types adjoin
+
+SYM: owners properties adjoin
+SYM: eta    properties adjoin
+SYM: notes  properties adjoin
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+SYM: slava { type person } define-object
+SYM: doug  { type person } define-object
+SYM: ed    { type person } define-object
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+SYM: compiler-bugs
+  {
+    type todo
+    owners { slava }
+    notes  {
+             "Investitage FEP on Terrorist"
+             "Problem with cutler in VirtualBox?"
+           }
+  }
+define-object
+
+SYM: remove-old-accessors-from-core
+  {
+    type todo
+    owners { slava }
+  }
+define-object
+
+SYM: move-db-and-web-framework-to-basis
+  {
+   type todo
+   owners { slava }
+  }
+define-object
+
+SYM: remove-old-accessors-from-basis
+  {
+    type todo
+    owners { doug ed }
+  }
+define-object
+
+SYM: blas-on-bsd
+  {
+    type todo
+    owners { slava doug }
+  }
+define-object
+
+SYM: multi-methods-backend
+  {
+    type todo
+    owners { slava }
+  }
+define-object
+
+SYM: update-core-for-multi-methods { type todo owners { slava } } define-object
+SYM: update-basis-for-multi-methods { type todo } define-object
+SYM: update-extra-for-multi-methods { type todo } define-object
+
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: todo-list ( -- )
+  objects [ type -> todo = ] filter
+    [ { [ self -> ] [ owners -> ] [ eta -> ] } 1arr ]
+  map
+  { "ITEM" "OWNERS" "ETA" } prefix
+  print-table ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
diff --git a/extra/obj/print/print.factor b/extra/obj/print/print.factor
index 066f24cb6a..000e161387 100644
--- a/extra/obj/print/print.factor
+++ b/extra/obj/print/print.factor
@@ -8,8 +8,19 @@ IN: obj.print
 
 : write-wrapped ( string -- ) H{ { wrap-margin 500 } } [ write ] with-nesting ;
 
+! : print-elt ( val -- )
+!   {
+!     { [ string? ] [ write-wrapped ] }
+!     { [ array?  ] [ [ . ] each    ] }
+!     { [ drop t  ] [ . ] }
+!   }
+!   1cond ;
+
+USING: accessors vocabs help.markup ;
+
 : print-elt ( val -- )
   {
+    { [ vocab?  ] [ [ name>> ] [ ] bi write-object ] }
     { [ string? ] [ write-wrapped ] }
     { [ array?  ] [ [ . ] each    ] }
     { [ drop t  ] [ . ] }
diff --git a/extra/obj/view/view.factor b/extra/obj/view/view.factor
index 6b3249f057..cf5ca33745 100644
--- a/extra/obj/view/view.factor
+++ b/extra/obj/view/view.factor
@@ -40,7 +40,13 @@ PREDICATE: obj-list < word \ objects = ;
 
 M: obj-list article-title ( objects -- title ) drop "Objects" ;
 
+! M: obj-list article-content ( objects -- title )
+!    execute
+!    [ [ type -> ] [ ] bi 2array ] map
+!    { $tab , } bake ;
+
 M: obj-list article-content ( objects -- title )
-   execute
+   drop
+   objects
    [ [ type -> ] [ ] bi 2array ] map
    { $tab , } bake ;
\ No newline at end of file
diff --git a/extra/parser-combinators/parser-combinators.factor b/extra/parser-combinators/parser-combinators.factor
index a05c140b86..da723bae9d 100755
--- a/extra/parser-combinators/parser-combinators.factor
+++ b/extra/parser-combinators/parser-combinators.factor
@@ -59,7 +59,7 @@ C: <token-parser> token-parser
 : case-insensitive-token ( string -- parser ) t <token-parser> ;
 
 M: token-parser parse ( input parser -- list )
-    dup token-parser-string swap token-parser-ignore-case?
+    [ string>> ] [ ignore-case?>> ] bi
     >r tuck r> ?string-head
     [ <parse-results> ] [ 2drop nil ] if ;
 
@@ -76,7 +76,7 @@ M: satisfy-parser parse ( input parser -- list )
     over empty? [
         2drop nil
     ] [
-        satisfy-parser-quot >r unclip-slice dup r> call
+        quot>> >r unclip-slice dup r> call
         [ swap <parse-results> ] [ 2drop nil ] if
     ] if ;
 
@@ -101,7 +101,7 @@ C: succeed succeed-parser ( result -- parser )
 M: succeed-parser parse ( input parser -- list )
     #! A parser that always returns 'result' as a
     #! successful parse with no input consumed.
-    succeed-parser-result swap <parse-results> ;
+    result>> swap <parse-results> ;
 
 TUPLE: fail-parser ;
 
@@ -118,7 +118,7 @@ TUPLE: ensure-parser test ;
     ensure-parser boa ;
 
 M: ensure-parser parse ( input parser -- list )
-    2dup ensure-parser-test parse nil?
+    2dup test>> parse nil?
     [ 2drop nil ] [ drop t swap <parse-results> ] if ;
 
 TUPLE: ensure-not-parser test ;
@@ -127,7 +127,7 @@ TUPLE: ensure-not-parser test ;
     ensure-not-parser boa ;
 
 M: ensure-not-parser parse ( input parser -- list )
-    2dup ensure-not-parser-test parse nil?
+    2dup test>> parse nil?
     [ drop t swap <parse-results> ] [ 2drop nil ] if ;
 
 TUPLE: and-parser parsers ;
@@ -157,7 +157,7 @@ M: and-parser parse ( input parser -- list )
     #! two parsers. First parser1 is applied to the
     #! input then parser2 is applied to the rest of
     #! the input strings from the first parser.
-    and-parser-parsers unclip swapd parse
+    parsers>> unclip swapd parse
     [ [ and-parser-parse ] reduce ] 2curry promise ;
 
 TUPLE: or-parser parsers ;
@@ -172,7 +172,7 @@ M: or-parser parse ( input parser1 -- list )
     #! Return the combined list resulting from the parses
     #! of parser1 and parser2 being applied to the same
     #! input. This implements the choice parsing operator.
-    or-parser-parsers 0 swap seq>list
+    parsers>> 0 swap seq>list
     [ parse ] lazy-map-with lconcat ;
 
 : left-trim-slice ( string -- string )
@@ -191,7 +191,7 @@ C: sp sp-parser ( p1 -- parser )
 M: sp-parser parse ( input parser -- list )
     #! Skip all leading whitespace from the input then call
     #! the parser on the remaining input.
-    >r left-trim-slice r> sp-parser-p1 parse ;
+    >r left-trim-slice r> p1>> parse ;
 
 TUPLE: just-parser p1 ;
 
@@ -202,7 +202,7 @@ M: just-parser parse ( input parser -- result )
     #! from the results anything where the remaining
     #! input to be parsed is not empty. So ensures a
     #! fully parsed input string.
-    just-parser-p1 parse [ parse-result-unparsed empty? ] lfilter ;
+    p1>> parse [ unparsed>> empty? ] lfilter ;
 
 TUPLE: apply-parser p1 quot ;
 
@@ -214,10 +214,10 @@ M: apply-parser parse ( input parser -- result )
     #! The result of that quotation then becomes the new parse result.
     #! This allows modification of parse tree results (like
     #! converting strings to integers, etc).
-    [ apply-parser-p1 ] keep apply-parser-quot
+    [ p1>> ] [ quot>> ] bi
     -rot parse [
-        [ parse-result-parsed swap call ] keep
-        parse-result-unparsed <parse-result>
+        [ parsed>> swap call ] keep
+        unparsed>> <parse-result>
     ] lazy-map-with ;
 
 TUPLE: some-parser p1 ;
@@ -229,7 +229,7 @@ M: some-parser parse ( input parser -- result )
     #! the parse is complete (the remaining input is empty),
     #! picks the first solution and only returns the parse
     #! tree since the remaining input is empty.
-    some-parser-p1 just parse-1 ;
+    p1>> just parse-1 ;
 
 : <& ( parser1 parser2 -- parser )
     #! Same as <&> except discard the results of the second parser.
@@ -272,7 +272,7 @@ LAZY: only-first ( parser -- parser )
 M: only-first-parser parse ( input parser -- list )
     #! Transform a parser into a parser that only yields
     #! the first possibility.
-    only-first-parser-p1 parse 1 swap ltake ;
+    p1>> parse 1 swap ltake ;
 
 LAZY: <!*> ( parser -- parser )
     #! Like <*> but only return one possible result
diff --git a/extra/peg/ebnf/ebnf-tests.factor b/extra/peg/ebnf/ebnf-tests.factor
index 47f19920c7..a6d3cf0b21 100644
--- a/extra/peg/ebnf/ebnf-tests.factor
+++ b/extra/peg/ebnf/ebnf-tests.factor
@@ -105,11 +105,11 @@ IN: peg.ebnf.tests
 ] unit-test
 
 { "foo" } [
-  "foo" 'non-terminal' parse ebnf-non-terminal-symbol
+  "foo" 'non-terminal' parse symbol>>
 ] unit-test
 
 { "foo" } [
-  "foo]" 'non-terminal' parse ebnf-non-terminal-symbol
+  "foo]" 'non-terminal' parse symbol>>
 ] unit-test
 
 { V{ "a" "b" } } [
diff --git a/extra/processing/gadget/gadget.factor b/extra/processing/gadget/gadget.factor
index c1a4c77703..0b3bb6dc01 100644
--- a/extra/processing/gadget/gadget.factor
+++ b/extra/processing/gadget/gadget.factor
@@ -32,7 +32,7 @@ M: processing-gadget handle-gesture ( gesture gadget -- ? )
      {
        [ dup key-down? ]
        [
-         key-down-sym key-value set
+         sym>> key-value set
          key-pressed-value on
          key-down>> dup [ call ] [ drop ] if
          t
@@ -49,7 +49,7 @@ M: processing-gadget handle-gesture ( gesture gadget -- ? )
      {
        [ dup button-down? ]
        [
-         button-down-# button-value set
+         #>> button-value set
          mouse-pressed-value on
          button-down>> dup [ call ] [ drop ] if
          t
@@ -66,4 +66,4 @@ M: processing-gadget handle-gesture ( gesture gadget -- ? )
      }
      { [ t ] [ 2drop t ] }
    }
-   cond ;
\ No newline at end of file
+   cond ;
diff --git a/extra/project-euler/059/059.factor b/extra/project-euler/059/059.factor
index 63a8e3e2c4..7cc6df3525 100644
--- a/extra/project-euler/059/059.factor
+++ b/extra/project-euler/059/059.factor
@@ -2,7 +2,7 @@
 ! See http://factorcode.org/license.txt for BSD license.
 USING: arrays ascii assocs hashtables io.encodings.ascii io.files kernel math
     math.parser namespaces sequences sequences.lib sequences.private sorting
-    splitting grouping strings sets ;
+    splitting grouping strings sets accessors ;
 IN: project-euler.059
 
 ! http://projecteuler.net/index.php?section=problems&id=59
@@ -60,9 +60,9 @@ TUPLE: rollover seq n ;
 
 C: <rollover> rollover
 
-M: rollover length rollover-n ;
+M: rollover length n>> ;
 
-M: rollover nth-unsafe rollover-seq [ length mod ] keep nth-unsafe ;
+M: rollover nth-unsafe seq>> [ length mod ] keep nth-unsafe ;
 
 INSTANCE: rollover immutable-sequence
 
diff --git a/extra/regexp/regexp.factor b/extra/regexp/regexp.factor
index 4920d481b1..cd2d0790ab 100755
--- a/extra/regexp/regexp.factor
+++ b/extra/regexp/regexp.factor
@@ -323,8 +323,8 @@ TUPLE: regexp source parser ignore-case? ;
 
 M: regexp pprint*
     [
-        dup regexp-source
+        dup source>>
         dup find-regexp-syntax swap % swap % %
-        dup regexp-ignore-case? [ "i" % ] when
+        dup ignore-case?>> [ "i" % ] when
     ] "" make
     swap present-text ;
diff --git a/extra/sequences/repeating/repeating.factor b/extra/sequences/repeating/repeating.factor
index 92b0925907..77fddd5510 100644
--- a/extra/sequences/repeating/repeating.factor
+++ b/extra/sequences/repeating/repeating.factor
@@ -11,7 +11,7 @@ TUPLE: repeating circular len ;
 : repeated ( seq length -- new-seq )
     dupd <repeating> swap like ;
 
-M: repeating length repeating-len ;
+M: repeating length len>> ;
 M: repeating set-length (>>len) ;
 
 M: repeating virtual@ ( n seq -- n' seq' ) circular>> ;
diff --git a/extra/slides/slides.factor b/extra/slides/slides.factor
index 05aa6779f5..a3031a7557 100755
--- a/extra/slides/slides.factor
+++ b/extra/slides/slides.factor
@@ -61,7 +61,7 @@ IN: slides
 
 : page-theme ( gadget -- )
     T{ gradient f { T{ rgba f 0.8 0.8 1.0 1.0 } T{ rgba f 0.8 1.0 1.0 1.0 } } }
-    swap set-gadget-interior ;
+    >>interior drop ;
 
 : <page> ( list -- gadget )
     [
@@ -82,8 +82,8 @@ TUPLE: slides < book ;
     [ <page> ] map 0 <model> slides new-book ;
 
 : change-page ( book n -- )
-    over control-value + over gadget-children length rem
-    swap gadget-model set-model ;
+    over control-value + over children>> length rem
+    swap model>> set-model ;
 
 : next-page ( book -- ) 1 change-page ;
 
diff --git a/extra/spheres/deploy.factor b/extra/spheres/deploy.factor
new file mode 100644
index 0000000000..0eeef1e3b7
--- /dev/null
+++ b/extra/spheres/deploy.factor
@@ -0,0 +1,15 @@
+USING: tools.deploy.config ;
+H{
+    { deploy-reflection 1 }
+    { deploy-random? t }
+    { deploy-word-defs? f }
+    { deploy-word-props? f }
+    { deploy-name "Spheres" }
+    { deploy-compiler? t }
+    { deploy-math? t }
+    { deploy-io 1 }
+    { deploy-threads? t }
+    { "stop-after-last-window?" t }
+    { deploy-ui? t }
+    { deploy-c-types? f }
+}
diff --git a/extra/springies/ui/ui.factor b/extra/springies/ui/ui.factor
index 75d3087fe5..423a68cf0d 100644
--- a/extra/springies/ui/ui.factor
+++ b/extra/springies/ui/ui.factor
@@ -10,7 +10,7 @@ IN: springies.ui
 : draw-node ( node -- ) pos>> { -5 -5 } v+ dup { 10 10 } v+ gl-rect ;
 
 : draw-spring ( spring -- )
-  [ spring-node-a pos>> ] [ spring-node-b pos>> ] bi gl-line ;
+  [ node-a>> pos>> ] [ node-b>> pos>> ] bi gl-line ;
 
 : draw-nodes ( -- ) nodes> [ draw-node ] each ;
 
@@ -52,16 +52,14 @@ DEFER: maybe-loop
 
 : springies-window* ( -- )
 
-  C[ display ] <slate> >slate
-    { 800 600 }                                      slate> set-slate-pdim
-    C[ { 500 500 } >world-size loop on [ run ] in-thread ]
-      slate> set-slate-graft
-    C[ loop off ]                                    slate> set-slate-ungraft
-
-  slate> "Springies" open-window ;
+  C[ display ] <slate>
+    { 800 600 } >>pdim
+    C[ { 500 500 } >world-size loop on [ run ] in-thread ] >>graft
+    C[ loop off ] >>ungraft
+  [ >slate ] [ "Springies" open-window ] bi ;
 
 : springies-window ( -- ) [ [ springies-window* ] with-scope ] with-ui ;
 
 ! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
-: go* ( quot -- ) '[ [ springies-window* 1000 sleep @ ] with-scope ] with-ui ;
\ No newline at end of file
+: go* ( quot -- ) '[ [ springies-window* 1000 sleep @ ] with-scope ] with-ui ;
diff --git a/extra/tuple-syntax/tuple-syntax-tests.factor b/extra/tuple-syntax/tuple-syntax-tests.factor
index 2eb9d8bb12..452672ea2a 100755
--- a/extra/tuple-syntax/tuple-syntax-tests.factor
+++ b/extra/tuple-syntax/tuple-syntax-tests.factor
@@ -4,5 +4,5 @@ IN: tuple-syntax.tests
 TUPLE: foo bar baz ;
 
 [ T{ foo } ] [ TUPLE{ foo } ] unit-test
-[ T{ foo 1 { 2 3 } { 4 { 5 } } } ]
-[ TUPLE{ foo bar: { 2 3 } delegate: 1 baz: { 4 { 5 } } } ] unit-test
+[ T{ foo f { 2 3 } { 4 { 5 } } } ]
+[ TUPLE{ foo bar: { 2 3 } baz: { 4 { 5 } } } ] unit-test
diff --git a/extra/x/widgets/wm/workspace/workspace.factor b/extra/x/widgets/wm/workspace/workspace.factor
index 104021706f..c11ad7e04d 100644
--- a/extra/x/widgets/wm/workspace/workspace.factor
+++ b/extra/x/widgets/wm/workspace/workspace.factor
@@ -1,5 +1,6 @@
 
-USING: kernel namespaces namespaces.lib math sequences vars mortar slot-accessors x ;
+USING: kernel namespaces namespaces.lib math sequences vars mortar
+accessors slot-accessors x ;
 
 IN: x.widgets.wm.workspace
 
@@ -23,9 +24,9 @@ dpy get $default-root <- children [ <- mapped? ] filter ;
 ! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 : switch-to-workspace ( n -- )
-mapped-windows current-workspace> workspaces> nth set-workspace-windows
+mapped-windows current-workspace> workspaces> nth (>>windows)
 mapped-windows [ <- unmap drop ] each
-dup workspaces> nth workspace-windows [ <- map drop ] each
+dup workspaces> nth windows>> [ <- map drop ] each
 current-workspace set* ;
 
 ! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
diff --git a/extra/xmode/marker/marker.factor b/extra/xmode/marker/marker.factor
index 707449a23f..f11ac6b5b2 100755
--- a/extra/xmode/marker/marker.factor
+++ b/extra/xmode/marker/marker.factor
@@ -63,10 +63,8 @@ M: f text-matches?
 
 M: string-matcher text-matches?
     [
-        dup string-matcher-string
-        swap string-matcher-ignore-case?
-        string-head?
-    ] keep string-matcher-string length and ;
+        [ string>> ] [ ignore-case?>> ] bi string-head?
+    ] keep string>> length and ;
 
 M: regexp text-matches?
     >r >string r> match-head ;
@@ -177,17 +175,17 @@ M: mark-following-rule handle-rule-start
     ?end-rule
     mark-token add-remaining-token
     tuck rule-match-token* next-token,
-    f context get set-line-context-end
-    context get set-line-context-in-rule ;
+    f context get (>>end)
+    context get (>>in-rule) ;
 
 M: mark-following-rule handle-rule-end
     nip rule-match-token* prev-token,
-    f context get set-line-context-in-rule ;
+    f context get (>>in-rule) ;
 
 M: mark-previous-rule handle-rule-start
     ?end-rule
     mark-token
-    dup rule-body-token prev-token,
+    dup body-token>> prev-token,
     rule-match-token* next-token, ;
 
 : do-escaped ( -- )
diff --git a/extra/xmode/rules/rules.factor b/extra/xmode/rules/rules.factor
index 4ab45d7539..e3c0c65db0 100755
--- a/extra/xmode/rules/rules.factor
+++ b/extra/xmode/rules/rules.factor
@@ -97,7 +97,7 @@ GENERIC: text-hash-char ( text -- ch )
 
 M: f text-hash-char ;
 
-M: string-matcher text-hash-char string-matcher-string first ;
+M: string-matcher text-hash-char string>> first ;
 
 M: regexp text-hash-char drop f ;
 
diff --git a/unfinished/vocab-browser/vocab-browser.factor b/unfinished/vocab-browser/vocab-browser.factor
new file mode 100644
index 0000000000..c5203a4894
--- /dev/null
+++ b/unfinished/vocab-browser/vocab-browser.factor
@@ -0,0 +1,271 @@
+
+USING: kernel words accessors
+       classes
+       classes.builtin
+       classes.tuple
+       classes.predicate
+       vocabs
+       arrays
+       sequences sorting
+       io help.markup
+       effects
+       generic
+       prettyprint
+       prettyprint.sections
+       prettyprint.backend
+       combinators.cleave
+       obj.print ;
+
+IN: vocab-browser
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: pprint-class ( class -- )
+  [
+    \ TUPLE: pprint-word dup pprint-word
+    dup superclass tuple eq?
+    [ "<" text dup superclass pprint-word ] unless
+    <block "slots" word-prop [ pprint-slot ] each
+    block> pprint-;
+  ]
+  with-pprint nl ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: word-effect-as-string ( word -- string )
+  stack-effect dup
+    [ effect>string ]
+    [ drop "" ]
+  if ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: print-vocabulary-summary ( vocabulary -- )
+
+  dup vocab words [ builtin-class? ] filter natural-sort
+  dup empty?
+    [ drop ]
+    [
+      "Builtin Classes" $heading nl
+      print-seq
+    ]
+  if
+
+  dup vocab words [ tuple-class? ] filter natural-sort
+  dup empty?
+    [ drop ]
+    [
+      "Tuple Classes" $heading nl
+      [
+        { [ ] [ superclass ] [ "slots" word-prop [ name>> ] map " " join ] }
+        1arr
+      ]
+      map
+      { "CLASS" "PARENT" "SLOTS" } prefix
+      print-table
+    ]
+  if
+
+  dup vocab words [ predicate-class? ] filter natural-sort
+  dup empty?
+    [ drop ]
+    [
+      "Predicate Classes" $heading nl
+      [ pprint-class ] each
+    ]
+  if
+  
+
+  dup vocab words [ generic? ] filter natural-sort
+  dup empty?
+    [ drop ]
+    [
+      "Generic words" $heading nl
+      [ [ ] [ stack-effect effect>string ] bi 2array ] map
+      print-table
+    ]
+  if
+
+  "Words" $heading nl
+  dup vocab words
+    [ predicate-class? not ] filter
+    [ builtin-class?   not ] filter
+    [ tuple-class?     not ] filter
+    [ generic?         not ] filter
+    [ word?                ] filter
+    natural-sort
+    [ [ ] [ word-effect-as-string ] bi 2array ] map
+  print-table
+
+  drop ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+USING: vocabs.loader tools.vocabs.browser ;
+
+: $vocab-summary ( seq -- )
+  first
+  dup vocab
+    [
+      dup print-vocabulary-summary
+      dup describe-help
+      ! dup describe-uses
+      ! dup describe-usage
+    ]
+  when
+  dup find-vocab-root
+    [
+      dup describe-summary
+      dup describe-tags
+      dup describe-authors
+      ! dup describe-files
+    ]
+  when
+  ! dup describe-children
+  drop ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+USING: assocs ui.tools.browser ui.operations io.styles ;
+
+! IN: tools.vocabs.browser
+
+! : $describe-vocab ( element -- ) $vocab-summary ;
+
+USING: tools.vocabs ;
+
+: print-vocabs ( -- )
+  vocabs
+    [ { [ vocab ] [ vocab-summary ] } 1arr ]
+  map
+  print-table ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+! : $all-vocabs ( seq -- ) drop print-vocabs ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+USING: help.syntax help.topics ;
+
+! ARTICLE: "vocab-index" "Vocabulary Index" { $all-vocabs } ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+M: vocab-spec article-content ( vocab-spec -- content )
+   { $vocab-summary } swap name>> suffix ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: loaded-and-unloaded-vocabs ( -- seq )
+  "" all-child-vocabs values concat [ name>> ] map ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+! ARTICLE: "loaded-vocabs-index" "Loaded Vocabularies" { $loaded-vocabs } ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+USING: debugger ;
+
+TUPLE: load-this-vocab name ;
+
+! : do-load-vocab ( ltv -- )
+!   dup name>> require
+!   name>> vocab com-follow ;
+
+: do-load-vocab ( ltv -- )
+  [
+    dup name>> require
+    name>> vocab com-follow
+  ]
+  curry
+  try ;
+
+[ load-this-vocab? ] \ do-load-vocab { { +primary+ t } } define-operation
+
+M: load-this-vocab pprint* ( obj -- )
+   [ name>> "*" append ] [ ] bi write-object ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: vocab-or-loader ( name -- obj )
+  dup vocab
+    [ vocab ]
+    [ load-this-vocab boa ]
+  if ;
+
+: vocab-summary-text ( vocab-name -- text )
+  dup vocab-summary-path vocab-file-contents
+  dup empty?
+    [ drop "" ]
+    [ first   ]
+  if ;
+
+! : vocab-table-entry ( vocab-name -- seq )
+!   { [ vocab-or-loader ] [ vocab-summary ] } 1arr ;
+
+: vocab-table-entry ( vocab-name -- seq )
+  { [ vocab-or-loader ] [ vocab-summary-text ] } 1arr ;
+
+: print-these-vocabs ( seq -- ) [ vocab-table-entry ] map print-table ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+! : vocab-list ( -- seq ) "" all-child-vocabs values concat [ name>> ] map ;
+
+: all-vocab-names ( -- seq )
+  all-vocabs values concat [ name>> ] map natural-sort ;
+
+: loaded-vocab-names ( -- seq ) all-vocab-names [ vocab ] filter ;
+
+: unloaded-vocab-names ( -- seq ) all-vocab-names [ vocab not ] filter ;
+
+: root->names ( root -- seq ) all-vocabs at [ name>> ] map natural-sort ;
+
+: vocab-names-core  ( -- seq ) "resource:core"  root->names ;
+: vocab-names-basis ( -- seq ) "resource:basis" root->names ;
+: vocab-names-extra ( -- seq ) "resource:extra" root->names ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+: $all-vocabs      ( seq -- ) drop all-vocab-names      print-these-vocabs ;
+: $loaded-vocabs   ( seq -- ) drop loaded-vocab-names   print-these-vocabs ;
+: $unloaded-vocabs ( seq -- ) drop unloaded-vocab-names print-these-vocabs ;
+
+: $vocabs-core     ( seq -- ) drop vocab-names-core     print-these-vocabs ;
+: $vocabs-basis    ( seq -- ) drop vocab-names-basis    print-these-vocabs ;
+: $vocabs-extra    ( seq -- ) drop vocab-names-extra    print-these-vocabs ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+! { "" }
+
+! all-child-vocabs values concat [ name>> ] map
+
+! : vocab-tree ( vocab -- seq )
+!   dup
+!   all-child-vocabs values concat [ name>> ] map prune
+!   [ vocab-tree ]
+!   map
+!   concat
+!   swap prefix
+!   [ vocab-source-path ] filter ;
+
+! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+ARTICLE: "vocab-index-all"      "All Vocabularies"      { $all-vocabs    } ;
+ARTICLE: "vocab-index-loaded"   "Loaded Vocabularies"   { $loaded-vocabs } ;
+ARTICLE: "vocab-index-unloaded" "Unloaded Vocabularies" { $loaded-vocabs } ;
+
+ARTICLE: "vocab-index-core"      "Core Vocabularies"    { $vocabs-core   } ;
+ARTICLE: "vocab-index-basis"     "Basis Vocabularies"   { $vocabs-basis  } ;
+ARTICLE: "vocab-index-extra"     "Extra Vocabularies"   { $vocabs-extra  } ;
+
+ARTICLE: "vocab-indices" "Vocabulary Indices"
+  { $subsection "vocab-index-core"     }
+  { $subsection "vocab-index-basis"    }
+  { $subsection "vocab-index-extra"    }
+  { $subsection "vocab-index-all"      }
+  { $subsection "vocab-index-loaded"   }
+  { $subsection "vocab-index-unloaded" } ;
\ No newline at end of file
diff --git a/extra/cpu/8080/8080-docs.factor b/unmaintained/cpu/8080/8080-docs.factor
similarity index 100%
rename from extra/cpu/8080/8080-docs.factor
rename to unmaintained/cpu/8080/8080-docs.factor
diff --git a/extra/cpu/8080/8080.factor b/unmaintained/cpu/8080/8080.factor
similarity index 100%
rename from extra/cpu/8080/8080.factor
rename to unmaintained/cpu/8080/8080.factor
diff --git a/extra/cpu/8080/authors.txt b/unmaintained/cpu/8080/authors.txt
similarity index 100%
rename from extra/cpu/8080/authors.txt
rename to unmaintained/cpu/8080/authors.txt
diff --git a/extra/cpu/8080/emulator/authors.txt b/unmaintained/cpu/8080/emulator/authors.txt
similarity index 100%
rename from extra/cpu/8080/emulator/authors.txt
rename to unmaintained/cpu/8080/emulator/authors.txt
diff --git a/extra/cpu/8080/emulator/emulator-docs.factor b/unmaintained/cpu/8080/emulator/emulator-docs.factor
similarity index 100%
rename from extra/cpu/8080/emulator/emulator-docs.factor
rename to unmaintained/cpu/8080/emulator/emulator-docs.factor
diff --git a/extra/cpu/8080/emulator/emulator.factor b/unmaintained/cpu/8080/emulator/emulator.factor
similarity index 100%
rename from extra/cpu/8080/emulator/emulator.factor
rename to unmaintained/cpu/8080/emulator/emulator.factor
diff --git a/extra/cpu/8080/emulator/summary.txt b/unmaintained/cpu/8080/emulator/summary.txt
similarity index 100%
rename from extra/cpu/8080/emulator/summary.txt
rename to unmaintained/cpu/8080/emulator/summary.txt
diff --git a/extra/cpu/8080/emulator/tags.txt b/unmaintained/cpu/8080/emulator/tags.txt
similarity index 100%
rename from extra/cpu/8080/emulator/tags.txt
rename to unmaintained/cpu/8080/emulator/tags.txt
diff --git a/extra/cpu/8080/summary.txt b/unmaintained/cpu/8080/summary.txt
similarity index 100%
rename from extra/cpu/8080/summary.txt
rename to unmaintained/cpu/8080/summary.txt
diff --git a/extra/cpu/8080/tags.txt b/unmaintained/cpu/8080/tags.txt
similarity index 100%
rename from extra/cpu/8080/tags.txt
rename to unmaintained/cpu/8080/tags.txt
diff --git a/extra/cpu/8080/test/test.factor b/unmaintained/cpu/8080/test/test.factor
similarity index 100%
rename from extra/cpu/8080/test/test.factor
rename to unmaintained/cpu/8080/test/test.factor
diff --git a/vm/types.c b/vm/types.c
index 59581ecee5..3097ee73f8 100755
--- a/vm/types.c
+++ b/vm/types.c
@@ -345,11 +345,8 @@ DEFINE_PRIMITIVE(tuple_boa)
 	F_TUPLE *tuple = allot_tuple(layout);
 	UNREGISTER_UNTAGGED(layout);
 
-	/* set delegate slot */
-	put(AREF(tuple,0),F);
-
 	F_FIXNUM i;
-	for(i = size - 1; i >= 1; i--)
+	for(i = size - 1; i >= 0; i--)
 		put(AREF(tuple,i),dpop());
 
 	dpush(tag_tuple(tuple));