diff --git a/doc/source/_static/banner.jpg b/doc/source/_static/banner.jpg
new file mode 100644
index 00000000..99ce626e
Binary files /dev/null and b/doc/source/_static/banner.jpg differ
diff --git a/doc/source/_static/default.css b/doc/source/_static/default.css
new file mode 100644
index 00000000..abf84f1c
--- /dev/null
+++ b/doc/source/_static/default.css
@@ -0,0 +1,18 @@
+@import url("classic.css");
+
+div .toctree-wrapper { column-count: 2; }
+
+div .toctree-wrapper > ul { margin: 0; }
+
+ul .toctree-l1 { 
+    margin: 0;
+    -webkit-column-break-inside: avoid;
+    page-break-inside: avoid;
+    break-inside: avoid-column;
+}
+
+div.body {
+    min-width: 450px;
+    max-width: 100%;
+}
+
diff --git a/doc/source/acb_dirichlet.rst b/doc/source/acb_dirichlet.rst
index 62baa2fe..b01549d6 100644
--- a/doc/source/acb_dirichlet.rst
+++ b/doc/source/acb_dirichlet.rst
@@ -1,6 +1,6 @@
 .. _acb-dirichlet:
 
-**acb_dirichlet.h** -- Dirichlet L-functions, zeta functions, and related functions
+**acb_dirichlet.h** -- Dirichlet L-functions, Riemann zeta and related functions
 ===================================================================================
 
 *Warning: the interfaces in this module are experimental and may change
diff --git a/doc/source/acb_modular.rst b/doc/source/acb_modular.rst
index 39fba35e..61b73148 100644
--- a/doc/source/acb_modular.rst
+++ b/doc/source/acb_modular.rst
@@ -440,7 +440,7 @@ To avoid confusion, we only write `q^k` when `k` is an integer.
     each respective output variable. The *notransform* version does not
     move `\tau` to the fundamental domain or reduce `z` during the computation.
 
-The Dedekind eta function
+Dedekind eta function
 -------------------------------------------------------------------------------
 
 .. function:: void acb_modular_addseq_eta(slong * exponents, slong * aindex, slong * bindex, slong num)
diff --git a/doc/source/conf.py b/doc/source/conf.py
index a918a719..f127d72a 100644
--- a/doc/source/conf.py
+++ b/doc/source/conf.py
@@ -104,12 +104,26 @@ pygments_style = 'sphinx'
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 html_theme = 'default'
-#html_theme = 'pyramid'
+
+html_context = {
+    'css_files': ['_static/default.css'],
+}
 
 # Theme options are theme-specific and customize the look and feel of a theme
 # further.  For a list of options available for each theme, see the
 # documentation.
-html_theme_options = {'sidebarwidth' : 300}
+html_theme_options = {
+    'sidebarwidth' : 280,
+    'collapsiblesidebar': True,
+    'bodyfont': "'arial', sans-serif",
+    'headfont': "'arial', sans-serif",
+    'sidebarbtncolor': '#666',
+    'sidebarbgcolor': '#444',
+    'sidebarlinkcolor': '#ddd',
+    'relbarbgcolor': '#333',
+    'footerbgcolor': '#333',
+    'headbgcolor': '#fff',
+}
 
 # Add any paths that contain custom themes here, relative to this directory.
 #html_theme_path = []
@@ -123,7 +137,7 @@ html_theme_options = {'sidebarwidth' : 300}
 
 # The name of an image file (relative to this directory) to place at the top
 # of the sidebar.
-html_logo = "_static/arbwhite.png"
+#html_logo = "_static/arbwhite.png"
 
 # The name of an image file (within the static path) to use as favicon of the
 # docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
diff --git a/doc/source/index.rst b/doc/source/index.rst
index fec2d67f..9864a0f7 100644
--- a/doc/source/index.rst
+++ b/doc/source/index.rst
@@ -1,4 +1,4 @@
-Arb - a C library for arbitrary-precision interval arithmetic
+Arb - a C library for arbitrary-precision ball arithmetic
 =============================================================
 
 .. only:: latex
@@ -7,11 +7,14 @@ Arb - a C library for arbitrary-precision interval arithmetic
     ::::::::::::
 
     Welcome to Arb's documentation!
-    Arb is a C library for arbitrary-precision interval arithmetic,
-    using a midpoint-radius representation ("ball arithmetic").
-    It supports real and complex numbers, polynomials, power series,
-    matrices, and evaluation of many transcendental functions.
-    All operations are done with automatic, rigorous error bounds.
+    Arb is a C library for rigorous real and complex arithmetic with arbitrary precision.
+    Arb tracks numerical errors automatically using
+    *ball arithmetic*, a form of interval arithmetic based on a midpoint-radius
+    representation.
+    On top of this, Arb provides a wide range of mathematical functionality, including polynomials,
+    power series, matrices, integration, root-finding, and transcendental functions.
+    Arb is designed with efficiency as a primary goal, and is usually competitive with or faster
+    than other arbitrary-precision packages.
     The code is thread-safe, portable, and extensively tested.
 
     Arb is free software distributed under the
@@ -32,21 +35,25 @@ Arb - a C library for arbitrary-precision interval arithmetic
 
     This documentation is available in HTML format at http://arblib.org and in
     PDF format at http://arblib.org/arb.pdf.
-    The version of the documentation you are currently reading was updated
+    This edition of the documentation was updated
     |today| and describes Arb |version|.
     Documentation for :ref:`specific release versions <history>`
     is also available in PDF format.
 
 .. only:: html
 
-        .. image:: _static/arbtext.png
+        .. image:: _static/banner.jpg
+            :align: center
 
     Welcome to Arb's documentation!
-    Arb is a C library for arbitrary-precision interval arithmetic,
-    using a midpoint-radius representation ("ball arithmetic").
-    It supports real and complex numbers, polynomials, power series,
-    matrices, and evaluation of many transcendental functions.
-    All operations are done with automatic, rigorous error bounds.
+    Arb is a C library for rigorous real and complex arithmetic with arbitrary precision.
+    Arb tracks numerical errors automatically using
+    *ball arithmetic*, a form of interval arithmetic based on a midpoint-radius
+    representation.
+    On top of this, Arb provides a wide range of mathematical functionality, including polynomials,
+    power series, matrices, integration, root-finding, and many transcendental functions.
+    Arb is designed with efficiency as a primary goal, and is usually competitive with or faster
+    than other arbitrary-precision packages.
     The code is thread-safe, portable, and extensively tested.
 
     Arb is free software distributed under the
@@ -67,7 +74,7 @@ Arb - a C library for arbitrary-precision interval arithmetic
 
     This documentation is available in HTML format at http://arblib.org and in
     PDF format at http://arblib.org/arb.pdf.
-    The version of the documentation you are currently reading was updated
+    This edition of the documentation was updated
     |today| and describes Arb |version|.
     Documentation for :ref:`specific release versions <history>`
     is also available in PDF format.
@@ -82,13 +89,23 @@ General information
    setup.rst
    using.rst
    issues.rst
+   credits.rst
+
+Example programs
+::::::::::::::::::::
+
+.. toctree::
+   :maxdepth: 2
+
    examples.rst
 
 Floating-point numbers
 ::::::::::::::::::::::::::::::::::::
 
-The radius and midpoint of a ball are represented using two specialized
-floating-point types.
+Arb uses two custom floating-point types in its implementation of ball
+arithmetic. The radius of a ball is represented using the type *mag_t* which is
+unsigned and has a fixed precision. The midpoint is represented using the
+type *arf_t* which has arbitrary precision.
 
 .. toctree::
    :maxdepth: 2
@@ -101,7 +118,7 @@ Real and complex numbers
 
 Real numbers (*arb_t*) are represented as midpoint-radius intervals,
 also known as balls. Complex numbers (*acb_t*) are represented in rectangular
-form, with balls for the real and imaginary parts.
+form, with *arb_t* balls for the real and imaginary parts.
 
 .. toctree::
    :maxdepth: 2
@@ -121,6 +138,10 @@ on polynomials, without introducing a separate power series type.
 
    arb_poly.rst
    acb_poly.rst
+
+.. toctree::
+   :maxdepth: 2
+
    arb_fmpz_poly.rst
 
 Transforms
@@ -143,7 +164,7 @@ Rudimentary linear algebra is supported.
    arb_mat.rst
    acb_mat.rst
 
-Higher mathematical functions
+Special functions
 ::::::::::::::::::::::::::::::::::::
 
 These modules implement mathematical functions with complexity
@@ -206,14 +227,9 @@ lengthy to reproduce in the documentation for each module.
    hypergeometric.rst
    agm.rst
 
-History, credits and references
+Version history
 :::::::::::::::::::::::::::::::::
 
-.. toctree::
-   :maxdepth: 2
-
-   credits.rst
-
 .. toctree::
    :maxdepth: 1
 
diff --git a/doc/source/issues.rst b/doc/source/issues.rst
index 82c28922..66126199 100644
--- a/doc/source/issues.rst
+++ b/doc/source/issues.rst
@@ -71,6 +71,8 @@ internal representation of numbers (using limb arrays).
 Arb uses the following FLINT types for exact (integral and rational)
 arbitrary-size values. For details, refer to the FLINT documentation.
 
+.. type:: fmpz
+
 .. type:: fmpz_t
 
     The FLINT multi-precision integer type uses an inline representation for small
@@ -80,6 +82,10 @@ arbitrary-size values. For details, refer to the FLINT documentation.
     The *fmpz_t* type is functionally identical to the GMP *mpz_t*
     type, but faster for small values.
 
+    An :type:`fmpz_t` is defined as an array of length one of type
+    :type:`fmpz` (which is just an alias for :type:`slong`),
+    permitting an :type:`fmpz_t` to be passed by reference.
+
 .. type:: fmpq_t
 
     FLINT multi-precision rational number.
@@ -236,7 +242,7 @@ Use of hardware floating-point arithmetic
 Arb uses hardware floating-point arithmetic (the ``double`` type in C) in two
 different ways.
 
-Firstly, ``double`` arithmetic as well as transcendental ``libm`` functions
+First, ``double`` arithmetic as well as transcendental ``libm`` functions
 (such as ``exp``, ``log``) are used to select parameters heuristically
 in various algorithms. Such heuristic use of approximate arithmetic does not
 affect correctness: when any error bounds depend on the parameters, the error
@@ -245,7 +251,7 @@ in the floating-point arithmetic on a particular machine could cause an
 algorithm to become inefficient due to inefficient parameters being
 selected.
 
-Secondly, ``double`` arithmetic is used internally for some rigorous error bound
+Second, ``double`` arithmetic is used internally for some rigorous error bound
 calculations. To guarantee correctness, we make the following assumptions.
 With the stated exceptions, these should hold on all commonly used platforms.