diff --git a/FieldTrip.cabal b/FieldTrip.cabal
--- a/FieldTrip.cabal
+++ b/FieldTrip.cabal
@@ -1,5 +1,5 @@
 Name:                FieldTrip
-Version:             0.2
+Version:             0.2.1
 Synopsis: 	     Functional 3D
 Category:            graphics
 Description:
@@ -21,7 +21,7 @@
 build-type:	     Simple
 Hs-Source-Dirs:      src
 Extensions:          
-Build-Depends:       base, old-time, OpenGL, GLUT, TypeCompose, MemoTrie, vector-space >= 0.4.1, graphicsFormats
+Build-Depends:       base, old-time, OpenGL, GLUT, TypeCompose, MemoTrie, vector-space >= 0.5, graphicsFormats
 Exposed-Modules:     
 		     Graphics.FieldTrip
 		     Graphics.FieldTrip.Misc
diff --git a/Makefile b/Makefile
--- a/Makefile
+++ b/Makefile
@@ -1,3 +1,3 @@
 # For special configuration, especially for docs.  Otherwise see README.
 
-include ../my-cabal-make.inc
+include ../cho-cabal-make.inc
diff --git a/announce b/announce
new file mode 100644
--- /dev/null
+++ b/announce
@@ -0,0 +1,13 @@
+FieldTrip [1] is a library for functional 3D graphics.  It is intended for building static, animated, and interactive 3D geometry, efficient enough for real-time synthesis and display.  Since FieldTrip is functional, one describes what models are, not how to render them (being rather than doing).
+
+Surfaces are described as functions from 2D space to 3D space.  As such, they are intrinsically curved rather than faceted.  Surface rendering tessellates adaptively, caching tessellations in an efficient, infinite data structure (from the MemoTrie library) for reuse.  Surface normals are computed automatically and exactly, using the derivative tools in the vector-space library.
+
+For animation or interaction, FieldTrip can be used with the Reactive [2] library for functional reactive programming (and possibly other animation frameworks).  By design, FieldTrip is completely orthogonal to any formulation or implementation of FRP.  The reactive-fieldtrip [3] library links Reactive and FieldTrip.
+
+FieldTrip now has a mailing list [4] and a feature/bug tracker [5].
+
+[1] http://haskell.org/haskellwiki/FieldTrip
+[2] http://haskell.org/haskellwiki/reactive
+[3] http://haskell.org/haskellwiki/reactive-fieldtrip
+[4] http://www.haskell.org/mailman/listinfo/FieldTrip
+[5] http://trac.haskell.org/FieldTrip
diff --git a/src/Graphics/FieldTrip/Color.hs b/src/Graphics/FieldTrip/Color.hs
--- a/src/Graphics/FieldTrip/Color.hs
+++ b/src/Graphics/FieldTrip/Color.hs
@@ -1,5 +1,6 @@
 {-# LANGUAGE FlexibleInstances, MultiParamTypeClasses
-           , UndecidableInstances, TypeSynonymInstances
+           , TypeFamilies, TypeSynonymInstances, FlexibleContexts
+           , UndecidableInstances
   #-}
 {-# OPTIONS_GHC -Wall -fno-warn-orphans #-}  -- Color4
 
@@ -105,12 +106,13 @@
   negateV (Color4 r g b a)
         = Color4 (negateV r) (negateV g) (negateV b) (negateV a)
 
-instance VectorSpace u s => VectorSpace (Color4 u) s where
+instance VectorSpace u => VectorSpace (Color4 u) where
+  type Scalar (Color4 u) = Scalar u
   s *^ (Color4 r g b a)
         = Color4 (s*^r) (s*^g) (s*^b) (s*^a)
 
-instance (InnerSpace r s, VectorSpace s s')
-    => InnerSpace (Color4 r) s where
+instance (InnerSpace r, AdditiveGroup (Scalar r))
+    => InnerSpace (Color4 r) where
   Color4 r g b a <.> Color4 r' g' b' a' =
     r<.>r' ^+^ g<.>g' ^+^ b<.>b' ^+^ a<.>a'
 
diff --git a/src/Graphics/FieldTrip/Geometry3.hs b/src/Graphics/FieldTrip/Geometry3.hs
--- a/src/Graphics/FieldTrip/Geometry3.hs
+++ b/src/Graphics/FieldTrip/Geometry3.hs
@@ -282,7 +282,8 @@
 
 -- | Parametric surface with texture
 -- surfG' :: Surf (Vector2 R :> R) -> ImageC -> Geometry3
-surfG' :: ( Floating s, InnerSpace s s, HasBasis s s, HasTrie (Basis s), Basis s ~ ()
+surfG' :: ( Floating s, InnerSpace s, Scalar s ~ s
+          , HasBasis s, HasTrie (Basis s), Basis s ~ ()
           , VertexComponent s, NormalComponent s, Color c) =>
           Surf (Vector2 s :> s) -> ((s, s) -> c) -> Geometry3
 surfG' surf img = rendererG $ \ (GC err _ _) -> rsurf err
@@ -294,7 +295,8 @@
 
 -- type VNC s = VC (VN3 s) (Color4 s)
 
-vsurf' :: (InnerSpace s s, Floating s, HasBasis s s, HasTrie (Basis s), Basis s ~ ()) =>
+vsurf' :: ( InnerSpace s, Floating s, Scalar s ~ s
+          , HasBasis s, HasTrie (Basis s), Basis s ~ ()) =>
           Surf (Vector2 s :> s) -> ((s,s) -> c) -> Vector2 s -> VC (VN3 s) c
 vsurf' surf img = liftA2 VC (vsurf surf) (img . coords2)
  where
@@ -336,8 +338,8 @@
 -- type SurfPt s = Two s :> Three s
 type SurfPt s = Vector2 s :> Vector3 s
 
-vsurf :: ( InnerSpace s s, Floating s
-         , HasBasis s s, HasTrie (Basis s), Basis s ~ ()) =>
+vsurf :: ( InnerSpace s, Floating s, Scalar s ~ s
+         , HasBasis s, HasTrie (Basis s), Basis s ~ ()) =>
          Surf (Vector2 s :> s) -> (Vector2 s -> VN3 s)
 vsurf surf = toVN3 . vector3D . surf . unvector2D . idD
 
@@ -347,8 +349,9 @@
 -- vec3 . surf . unvec2 . dId :: R2 -> R2 :> R3
 -- toVN3 . vec3 . surf . unvec2 . dId :: R2 -> VN3
 
-toVN3 :: (Floating s, InnerSpace s s, HasBasis s s, HasTrie (Basis s)
-         , HasNormal (SurfPt s), InnerSpace (SurfPt s) (Vector2 s :> s)
+toVN3 :: ( Floating s, InnerSpace s, Scalar s ~ s
+         , HasBasis s, HasTrie (Basis s)
+         , HasNormal (SurfPt s), InnerSpace (SurfPt s)
          ) =>
          SurfPt s -> VN3 s
 
diff --git a/src/Graphics/FieldTrip/ParamSurf.hs b/src/Graphics/FieldTrip/ParamSurf.hs
--- a/src/Graphics/FieldTrip/ParamSurf.hs
+++ b/src/Graphics/FieldTrip/ParamSurf.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE Rank2Types, TypeOperators, FlexibleContexts #-}
+{-# LANGUAGE Rank2Types, TypeOperators, FlexibleContexts, TypeFamilies #-}
 {-# OPTIONS_GHC -Wall #-}
 ----------------------------------------------------------------------
 -- |
@@ -60,7 +60,7 @@
 semiCircle = circle . (/ 2)
 
 -- | Torus, given radius of sweep circle and cross section
-torus :: (Floating s, VectorSpace s s) => s -> s -> Surf s
+torus :: (Floating s, VectorSpace s, Scalar s ~ s) => s -> s -> Surf s
 -- torus sr cr = revolve (\ s -> (sr,0) ^+^ cr *^ circle s)
 torus sr cr = revolve (const (sr,0) ^+^ cr *^ circle)
 
@@ -91,13 +91,13 @@
 sphere3 = profile semiCircle circle
 
 -- | Frustrum, given base & cap radii and height.
-frustrum :: (Floating s, VectorSpace s s) => s -> s -> s -> Surf s
+frustrum :: (Floating s, VectorSpace s, Scalar s ~ s) => s -> s -> s -> Surf s
 frustrum baseR topR h = profile circle rad
  where
    rad t = (lerp baseR topR (t + 1/2), h*t)
 
 -- | Unit cylinder.  Unit height and radii
-ucylinder :: (Floating s, VectorSpace s s) => Surf s
+ucylinder :: (Floating s, VectorSpace s) => Surf s
 ucylinder = profile circle (const 1)
 
 
@@ -108,7 +108,7 @@
 
 -- Sweep a basis curve by a sweep curve.  Warning: does not reorient the
 -- basis curve as cross-section.  TODO: Frenet frame.
-sweep :: VectorSpace s s' => Curve3 s -> Curve3 s -> Surf s
+sweep :: VectorSpace s => Curve3 s -> Curve3 s -> Surf s
 sweep = cartF (^+^)
 
 
@@ -116,10 +116,10 @@
 eggcrateH :: Floating s => HeightField s
 eggcrateH = cartF (*) cosU sinU
 
-revolveH :: (Floating s, InnerSpace s s) => Warp1 s -> HeightField s
+revolveH :: (Floating s, InnerSpace s, Scalar s ~ s) => Warp1 s -> HeightField s
 revolveH = (. magnitude)
 
-rippleH :: (Floating s, InnerSpace s s) => HeightField s
+rippleH :: (Floating s, InnerSpace s, Scalar s ~ s) => HeightField s
 rippleH = revolveH sinU
 
 -- | Simple ripply pond shape
@@ -129,14 +129,14 @@
 
 -- | Apply a displacement map at a value
 
-displaceV :: (InnerSpace v s, Floating s, HasNormal v) =>
-             v -> s -> v
+displaceV :: (InnerSpace v, s ~ Scalar v, Floating s, HasNormal v) =>
+             v -> Scalar v -> v
 displaceV v s = v ^+^ s *^ normal v
 
 -- | Apply a displacement map to a function (e.g., 'Curve2' or 'Surf') or
 -- other container.
-displace :: (InnerSpace v s, Floating s, HasNormal v, Applicative f) =>
-            f v -> f s -> f v
+displace :: (InnerSpace v, Scalar v ~ s, Floating s, HasNormal v, Applicative f) =>
+            f v -> f (Scalar v) -> f v
 displace = liftA2 displaceV
 
 
diff --git a/src/Graphics/FieldTrip/Point2.hs b/src/Graphics/FieldTrip/Point2.hs
--- a/src/Graphics/FieldTrip/Point2.hs
+++ b/src/Graphics/FieldTrip/Point2.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, UndecidableInstances #-}
+{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, TypeFamilies #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}  -- Vertex2
 ----------------------------------------------------------------------
 -- |
@@ -29,7 +29,7 @@
 type Point2 = Vertex2
 
 -- | Construct a 2D point in rectangular coordinates.
-point2 :: s -> s -> Vertex2 s
+point2 :: s -> s -> Point2 s
 point2 = Vertex2
 
 origin2 :: Num s => Point2 s
@@ -42,7 +42,8 @@
 
 -- UndecidableInstances because "the Coverage Condition fails" below
 
-instance VectorSpace u s => AffineSpace (Vertex2 u) (Vector2 u) s where
+instance VectorSpace u => AffineSpace (Vertex2 u) where
+  type AVector (Vertex2 u) = Vector2 u
   Vertex2 u v .-. Vertex2 u' v' = Vector2 (u ^-^ u') (v ^-^ v')
   Vertex2 u v .+^ Vector2 dx dy = Vertex2 (u ^+^ dx) (v ^+^ dy)
 
@@ -57,5 +58,5 @@
 point2Polar = (fmap.fmap) vToP vector2Polar
 
 -- | Polar coordinates of a point.  See also 'point2Polar'.
-point2PolarCoords :: (InnerSpace s s, Floating s) => Point2 s -> (s,s)
+point2PolarCoords :: (InnerSpace s, s ~ Scalar s, Floating s) => Point2 s -> (s,s)
 point2PolarCoords = vector2PolarCoords . pToV
diff --git a/src/Graphics/FieldTrip/Point3.hs b/src/Graphics/FieldTrip/Point3.hs
--- a/src/Graphics/FieldTrip/Point3.hs
+++ b/src/Graphics/FieldTrip/Point3.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, UndecidableInstances #-}
+{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, TypeFamilies #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}  -- Vertex3
 ----------------------------------------------------------------------
 -- |
@@ -29,7 +29,7 @@
 type Point3 = Vertex3
 
 -- | Construct a 3D point in rectangular coordinates.
-point3 :: s -> s -> s -> Vertex3 s
+point3 :: s -> s -> s -> Point3 s
 point3 = Vertex3
 
 origin3 :: Num s => Point3 s
@@ -42,7 +42,8 @@
 
 -- UndecidableInstances because "the Coverage Condition fails" below
 
-instance VectorSpace u s => AffineSpace (Vertex3 u) (Vector3 u) s where
+instance VectorSpace u => AffineSpace (Vertex3 u) where
+  type AVector (Vertex3 u) = Vector3 u
   Vertex3 u v w .-. Vertex3 u' v' w' = Vector3 (u ^-^ u') (v ^-^ v') (w ^-^ w')
   Vertex3 u v w .+^ Vector3 dx dv dw = Vertex3 (u ^+^ dx) (v ^+^ dv) (w ^+^ dw)
 
@@ -57,5 +58,6 @@
 point3Spherical = (fmap.fmap.fmap) vToP vector3Spherical
 
 -- | Spherical coordinates of a point.  See also 'point3Spherical'.
-point3SphericalCoords :: (InnerSpace s s, Floating s) => Point3 s -> (s,s,s)
+point3SphericalCoords :: (InnerSpace s, Floating s, s ~ Scalar s)
+                      => Point3 s -> (s,s,s)
 point3SphericalCoords = vector3SphericalCoords . pToV
diff --git a/src/Graphics/FieldTrip/Transform.hs b/src/Graphics/FieldTrip/Transform.hs
--- a/src/Graphics/FieldTrip/Transform.hs
+++ b/src/Graphics/FieldTrip/Transform.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances #-}
 {-# OPTIONS_GHC -Wall #-}
 ----------------------------------------------------------------------
 -- |
diff --git a/src/Graphics/FieldTrip/Vector2.hs b/src/Graphics/FieldTrip/Vector2.hs
--- a/src/Graphics/FieldTrip/Vector2.hs
+++ b/src/Graphics/FieldTrip/Vector2.hs
@@ -18,7 +18,8 @@
 
 module Graphics.FieldTrip.Vector2 
   (
-   Vector2(..), vector2x, vector2y
+   Vector2(..), vector2
+  , vector2x, vector2y
   , xVector2, yVector2
   , vector2Polar
   , vector2PolarCoords
@@ -35,6 +36,10 @@
 import Data.Derivative
 import Data.Cross
 
+-- | Construct a 3D vector in rectangular coordinates.
+vector2 :: s -> s -> Vector2 s
+vector2 = Vector2
+
 -- | The unit vector in the positive X direction.
 xVector2 :: Num s => Vector2 s
 xVector2 = Vector2 1 0
@@ -52,7 +57,8 @@
 vector2Polar rho theta = Vector2 (rho * cos theta) (rho * sin theta)
 
 -- | Polar coordinates of a vector.  See also 'vector2Polar'.
-vector2PolarCoords :: (InnerSpace s s, Floating s) => Vector2 s -> (s,s)
+vector2PolarCoords :: (InnerSpace s, Floating s, Scalar s ~ s)
+                   => Vector2 s -> (s,s)
 vector2PolarCoords v@(Vector2 x y) = (rho, theta)
  where
    rho   = magnitude v
@@ -71,22 +77,23 @@
 -- TODO: is UndecidableInstances still necessary?
 
 instance AdditiveGroup u => AdditiveGroup (Vector2 u) where
-  zeroV                         = Vector2 zeroV zeroV
-  Vector2 u v ^+^ Vector2 u' v' = Vector2 (u^+^u') (v^+^v')
-  negateV (Vector2 u v)         = Vector2 (negateV u) (negateV v)
+  zeroV                          = Vector2 zeroV zeroV
+  Vector2 u v ^+^ Vector2 u' v'  = Vector2 (u^+^u') (v^+^v')
+  negateV (Vector2 u v)          = Vector2 (negateV u) (negateV v)
 
-instance (VectorSpace u s) => VectorSpace (Vector2 u) s where
-  s *^ Vector2 u v            = Vector2 (s*^u) (s*^v)
+instance (VectorSpace u) => VectorSpace (Vector2 u) where
+  type Scalar (Vector2 u)        = Scalar u
+  s *^ Vector2 u v               = Vector2 (s*^u) (s*^v)
 
-instance (InnerSpace u s, AdditiveGroup s)
-    => InnerSpace (Vector2 u) s where
-  Vector2 u v <.> Vector2 u' v' = u<.>u' ^+^ v<.>v'
+instance (InnerSpace u, AdditiveGroup (Scalar u))
+    => InnerSpace (Vector2 u) where
+  Vector2 u v <.> Vector2 u' v'  = u<.>u' ^+^ v<.>v'
 
-instance HasBasis u s => HasBasis (Vector2 u) s where
-  type Basis (Vector2 u) = Basis (u,u)
-  basisValue             = toV2 . basisValue
-  decompose              = decompose  . fromV2
-  decompose'             = decompose' . fromV2
+instance HasBasis u => HasBasis (Vector2 u) where
+  type Basis (Vector2 u)         = Basis (u,u)
+  basisValue                     = toV2 . basisValue
+  decompose                      = decompose  . fromV2
+  decompose'                     = decompose' . fromV2
 
 toV2 :: (u,u) -> Vector2 u
 toV2 (u,v) = Vector2 u v
@@ -110,10 +117,10 @@
 
 
 
-vector2D :: (HasBasis a s, HasTrie (Basis a), VectorSpace s s) =>
+vector2D :: (HasBasis a, HasTrie (Basis a), VectorSpace s) =>
             Two (a :> s) -> a :> (Vector2 s)
 vector2D (u,v) = liftD2 Vector2 u v
 
-unvector2D :: (HasBasis a s, HasTrie (Basis a), VectorSpace s s) =>
+unvector2D :: (HasBasis a, HasTrie (Basis a), VectorSpace s) =>
               a :> (Vector2 s) -> Two (a :> s)
 unvector2D d = (vector2x <$>> d, vector2y <$>> d)
diff --git a/src/Graphics/FieldTrip/Vector3.hs b/src/Graphics/FieldTrip/Vector3.hs
--- a/src/Graphics/FieldTrip/Vector3.hs
+++ b/src/Graphics/FieldTrip/Vector3.hs
@@ -18,7 +18,7 @@
 
 module Graphics.FieldTrip.Vector3 
   (
-   Vector3(..)
+   Vector3(..), vector3
   , xVector3, yVector3, zVector3
   , vector3x, vector3y, vector3z
   , vector3Spherical
@@ -40,6 +40,12 @@
 
 -- type V3 = Vector3 Double
 
+
+-- | Construct a 3D vector in rectangular coordinates.
+vector3 :: s -> s -> s -> Vector3 s
+vector3 = Vector3
+
+
 -- | The unit vector in the positive X direction.
 xVector3 :: Num s => Vector3 s
 xVector3 = Vector3 1 0 0
@@ -71,7 +77,8 @@
    sinTheta = sin theta; sinPhi = sin phi 
 
 -- | Spherical coordinates of a vector.  See also 'vector2Spherical'.
-vector3SphericalCoords :: (InnerSpace s s, Floating s) => Vector3 s -> (s,s,s)
+vector3SphericalCoords :: (InnerSpace s, Floating s, Scalar s ~ s)
+                        => Vector3 s -> (s,s,s)
 vector3SphericalCoords v@(Vector3 x y z) = (rho, theta, phi)
  where
    rho   = magnitude v
@@ -93,14 +100,15 @@
                           = Vector3 (u^+^u') (v^+^v') (w^+^w')
   negateV (Vector3 u v w) = Vector3 (negateV u) (negateV v) (negateV w)
 
-instance VectorSpace u s => VectorSpace (Vector3 u) s where
-  s *^ Vector3 u v w    = Vector3 (s*^u) (s*^v) (s*^w)
+instance VectorSpace u => VectorSpace (Vector3 u) where
+  type Scalar (Vector3 u) = Scalar u
+  s *^ Vector3 u v w      = Vector3 (s*^u) (s*^v) (s*^w)
 
-instance (InnerSpace u s, AdditiveGroup s)
-    => InnerSpace (Vector3 u) s where
+instance (InnerSpace u, AdditiveGroup (Scalar u))
+    => InnerSpace (Vector3 u) where
   Vector3 u v w <.> Vector3 u' v' w' = u<.>u' ^+^ v<.>v' ^+^ w<.>w'
 
-instance HasBasis u s => HasBasis (Vector3 u) s where
+instance HasBasis u => HasBasis (Vector3 u) where
   type Basis (Vector3 u) = Basis (u,u,u)
   basisValue             = toV3 . basisValue
   decompose              = decompose  . fromV3
@@ -112,8 +120,8 @@
 fromV3 :: Vector3 u -> (u,u,u)
 fromV3 (Vector3 u v w) = (u,v,w)
 
-instance ( Num s, VectorSpace s s
-         , HasBasis s s, HasTrie (Basis s), Basis s ~ () )
+instance ( Num s, VectorSpace s
+         , HasBasis s, HasTrie (Basis s), Basis s ~ () )
          => HasNormal (Vector2 s :> Vector3 s) where
   normalVec v = d (Left ()) `cross3` d (Right ())
    where
@@ -170,10 +178,10 @@
 instance HasNormal (Three (Vector2 Double :> Double)) where
   normalVec = unvector3D . normalVec . vector3D
 
-vector3D :: (VectorSpace s s, HasTrie (Basis a)) =>
+vector3D :: (VectorSpace s, HasTrie (Basis a)) =>
             Three (a :> s) -> a :> (Vector3 s)
 vector3D (u,v,w) = liftD3 Vector3 u v w
 
-unvector3D :: (VectorSpace s s, HasTrie (Basis a)) =>
+unvector3D :: (VectorSpace s, HasTrie (Basis a)) =>
               a :> (Vector3 s) -> Three (a :> s)
 unvector3D d = (vector3x <$>> d, vector3y <$>> d, vector3z <$>> d)
diff --git a/wikipage.tw b/wikipage.tw
new file mode 100644
--- /dev/null
+++ b/wikipage.tw
@@ -0,0 +1,41 @@
+[[Category:Graphics]]	 
+[[Category:Packages]]
+
+== Abstract ==
+
+'''FieldTrip''' is a library for functional 3D graphics, intended for building static, animated, and interactive 3D geometry, efficient enough for real-time synthesis and display.
+Our first renderer uses OpenGL, with the usual visual limitations.
+Since FieldTrip is functional, it is about ''being'' rather than ''doing''.
+One describes what models are, not how to render them.
+
+Besides this wiki page, here are more ways to find out about and get involved with FieldTrip:
+* Join the [http://www.haskell.org/mailman/listinfo/FieldTrip FieldTrip mailing list].
+* Peruse [http://code.haskell.org/FieldTrip/doc/html/ the library documentation].
+* Install [http://hackage.haskell.org/cgi-bin/hackage-scripts/package/FieldTrip from Hackage].
+* Download the code repository: '''<tt>darcs get http://code.haskell.org/FieldTrip</tt>'''.  Patches welcome.
+* Report bugs and request features on [http://trac.haskell.org/fieldtrip/ the tracker].
+* Examine the [[FieldTrip/Versions| version history]].
+
+
+== Basic types ==
+
+The basic purpose of the core FieldTrip library is to allow a user build 3D geometry, from individual simple shapes to full 3D scenes.  The principal types are as follows.
+
+; <hask>Geometry3</hask>
+: 3D geometry.  These values can be spatially transformed in space (affinely: scale, rotate, translate) and combined (union).
+
+; <hask>Surf a = (a,a) -> (a,a,a)</hask>
+: Parametric surfaces, i.e., mappings from 2D to 3D.  Normals are constructed automatically and exactly via derivatives, thanks to the [[vector-space]] library.  These normals are used for shading.  For simplicity and composability, ''surfaces are curved'', not faceted.  Surface ''rendering'' tessellates adaptively, caching tessellations in an efficient, infinite data structure for reuse.  The mechanism for choosing tessellation is a very primitive placeholder.  FieldTrip provides some basic shapes of surfaces (spheres, torus, cubes, etc) and many functions for manipulating surfaces,  colors, etc.
+
+; <hask>Geometry2</hask>
+: 2D geometry.  There's a function (<hask>flatG</hask>) to embed 2D into 3D.
+
+; <hask>Image o = (R,R) -> o</hask>
+: A primitive placeholder for functional imagery in the spirit of [http://conal.net/Pan Pan].  The intention is to use this type or something like it for texture mapping.  Much design and implementation work to be done.
+
+== FieldTrip meets Reactive ==
+
+FieldTrip contains no support for animation, because we intend it to be used with the [[Reactive]] functional reactive programming ([[FRP]]) library (and possibly other animation frameworks).
+By design, FieldTrip is completely orthogonal to any formulation or implementation of FRP.
+
+The [[reactive-fieldtrip]] project connects [[Reactive]] and FieldTrip.