diff --git a/Doxyfile b/Doxyfile
index 920a6520a..ed270f7c2 100644
--- a/Doxyfile
+++ b/Doxyfile
@@ -5,7 +5,7 @@
 #---------------------------------------------------------------------------
 DOXYFILE_ENCODING      = UTF-8
 PROJECT_NAME           = Eigen
-PROJECT_NUMBER         = 2.0-alpha6
+PROJECT_NUMBER         = 2.0-alpha7
 OUTPUT_DIRECTORY       = ./
 CREATE_SUBDIRS         = NO
 OUTPUT_LANGUAGE        = English
diff --git a/Eigen/src/Core/Matrix.h b/Eigen/src/Core/Matrix.h
index 74806833b..d992e279a 100644
--- a/Eigen/src/Core/Matrix.h
+++ b/Eigen/src/Core/Matrix.h
@@ -373,8 +373,20 @@ class Matrix : public MatrixBase<Matrix<_Scalar, _Rows, _Cols, _MaxRows, _MaxCol
 };
 
 /** \defgroup matrixtypedefs Global matrix typedefs
-  * Eigen defines several typedef shortcuts for most common matrix types.
-  * Here is the explicit list.
+  *
+  * Eigen defines several typedef shortcuts for most common matrix and vector types.
+  *
+  * The general patterns are the following:
+  *
+  * \c MatrixSizeType where \c Size can be \c 2,\c 3,\c 4 for fixed size square matrices or \c X for dynamic size,
+  * and where \c Type can be \c i for integer, \c f for float, \c d for double, \c cf for complex float, \c cd
+  * for complex double.
+  *
+  * For example, \c Matrix3d is a fixed-size 3x3 matrix type of doubles, and \c MatrixXf is a dynamic-size matrix of floats.
+  *
+  * There are also \c VectorSizeType and \c RowVectorSizeType which are self-explanatory. For example, \c Vector4cf is
+  * a fixed-size vector of 4 complex floats.
+  *
   * \sa class Matrix
   */
 
diff --git a/Eigen/src/Geometry/AngleAxis.h b/Eigen/src/Geometry/AngleAxis.h
index 563735376..733f273d7 100644
--- a/Eigen/src/Geometry/AngleAxis.h
+++ b/Eigen/src/Geometry/AngleAxis.h
@@ -104,7 +104,7 @@ public:
   operator* (const Matrix3& a, const AngleAxis& b)
   { return a * b.toRotationMatrix(); }
 
-  /** \Returns the inverse rotation, i.e., an angle-axis with opposite rotation angle */
+  /** \returns the inverse rotation, i.e., an angle-axis with opposite rotation angle */
   AngleAxis inverse() const
   { return AngleAxis(-m_angle, m_axis); }
 
diff --git a/Eigen/src/Geometry/OrthoMethods.h b/Eigen/src/Geometry/OrthoMethods.h
index 57864afec..b826a96fb 100644
--- a/Eigen/src/Geometry/OrthoMethods.h
+++ b/Eigen/src/Geometry/OrthoMethods.h
@@ -93,7 +93,7 @@ struct ei_someOrthogonal_selector<Derived,2>
   { return VectorType(-ei_conj(src.y()), ei_conj(src.x())).normalized(); }
 };
 
-/** \Returns an orthogonal vector of \c *this
+/** \returns an orthogonal vector of \c *this
   *
   * The size of \c *this must be at least 2. If the size is exactly 2,
   * then the returned vector is a counter clock wise rotation of \c *this, \ie (-y,x).
diff --git a/Eigen/src/Geometry/Rotation.h b/Eigen/src/Geometry/Rotation.h
index f6c4fd4a1..47a10938e 100644
--- a/Eigen/src/Geometry/Rotation.h
+++ b/Eigen/src/Geometry/Rotation.h
@@ -138,10 +138,10 @@ public:
   /** Construct a 2D counter clock wise rotation from the angle \a a in radian. */
   inline Rotation2D(Scalar a) : m_angle(a) {}
 
-  /** \Returns the rotation angle */
+  /** \returns the rotation angle */
   inline Scalar angle() const { return m_angle; }
 
-  /** \Returns a read-write reference to the rotation angle */
+  /** \returns a read-write reference to the rotation angle */
   inline Scalar& angle() { return m_angle; }
 
   /** Automatic convertion to a 2D rotation matrix.
@@ -149,7 +149,7 @@ public:
     */
   inline operator Matrix2() const { return toRotationMatrix(); }
 
-  /** \Returns the inverse rotation */
+  /** \returns the inverse rotation */
   inline Rotation2D inverse() const { return -m_angle; }
 
   /** Concatenates two rotations */
diff --git a/doc/QuickStartGuide.dox b/doc/QuickStartGuide.dox
index 6244f391e..2f1d7758b 100644
--- a/doc/QuickStartGuide.dox
+++ b/doc/QuickStartGuide.dox
@@ -4,17 +4,52 @@ namespace Eigen {
 
 <h1>Quick start guide</h1>
 
-<h2>Matrix creation and initialization</h2>
+<h2>Simple example with fixed-size matrices and vectors</h2>
+
+By fixed-size, we mean that the number of rows and columns are known at compile-time. In this case, Eigen avoids dynamic memory allocation and unroll loops. This is useful for very small sizes (typically up to 4x4).
+
+<table><tr><td>
+\include Tutorial_simple_example_fixed_size.cpp
+</td>
+<td>
+output:
+\include Tutorial_simple_example_fixed_size.out
+</td></tr></table>
+
+<h2>Simple example with dynamic-size matrices and vectors</h2>
+
+Dynamic-size means that the number of rows and columns are not known at compile-time. In this case, they are stored as runtime variables and the arrays are dynamically allocated.
+
+<table><tr><td>
+\include Tutorial_simple_example_dynamic_size.cpp
+</td>
+<td>
+output:
+\include Tutorial_simple_example_dynamic_size.out
+</td></tr></table>
+
+<h2>Matrix and vector types</h2>
+
+In Eigen, all kinds of dense matrices and vectors are represented by the template class Matrix. In most cases you can simply use one of the several convenient typedefs (\ref matrixtypedefs).
+
+The template class Matrix takes a number of template parameters, but for now it is enough to understand the 3 first ones (and the others can then be left unspecified):
+
+\code Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime> \endcode
+
+\li \c Scalar is the scalar type, i.e. the type of the coefficients. That is, if you want a vector of floats, choose \c float here.
+\li \c RowsAtCompileTime and \c ColsAtCompileTime are the number of rows and columns of the matrix as known at compile-time. 
+
+For example, \c Vector3d is a typedef for \code Matrix<double, 3, 1> \endcode.
+
+What if the matrix has dynamic-size i.e. the number of rows or cols isn't known at compile-time? Then use the special value Eigen::Dynamic. For example, \c VectorXd is a typedef for \code Matrix<double, Dynamic, 1> \endcode.
+
+<h2>Matrix and vector creation and initialization</h2>
 
-In Eigen all kind of dense matrices and vectors are represented by the template class Matrix.
-For instance \code Matrix<int,Dynamic,4> m(size,4);\endcode declares a matrix of 4 columns
-with a dynamic number of rows.
-However, in most cases you can simply use one of the several convenient typedefs (\ref matrixtypedefs).
 For instance \code Matrix3f m = Matrix3f::Identity(); \endcode creates a 3x3 fixed size matrix of float
 which is initialized to the identity matrix.
 Similarly \code MatrixXcd m = MatrixXcd::Zero(rows,cols); \endcode creates a rows x cols matrix
 of double precision complex which is initialized to zero. Here rows and cols do not have to be
-known at runtime. In "MatrixXcd", "X" stands for dynamic, "c" for complex, and "d" for double.
+known at compile-time. In "MatrixXcd", "X" stands for dynamic, "c" for complex, and "d" for double.
 
 You can also initialize a matrix with all coefficients equal to one:
 \code MatrixXi m = MatrixXi::Ones(rows,cols); \endcode