diff --git a/docs/index.rst b/docs/index.rst
index 442932f..8a0641c 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -3,11 +3,7 @@ Flask-Babel
 
 .. module:: flask_babel
 
-Flask-Babel is an extension to `Flask`_ that adds i18n and l10n support to
-any Flask application with the help of `babel`_, `pytz`_ and
-`speaklater`_.  It has builtin support for date formatting with timezone
-support as well as a very simple and friendly interface to :mod:`gettext`
-translations.
+Easy integration of `Flask`_ and `babel`_.
 
 Installation
 ------------
@@ -35,9 +31,9 @@ object after configuring the application::
     babel = Babel(app)
 
 To disable jinja support, include ``configure_jinja=False`` in the Babel 
-constructor call.  The babel object itself can be used to configure the babel support
-further.  Babel has the following configuration values that can be used to
-change some internal defaults:
+constructor call.  The babel object itself can be used to configure the babel
+support further.  Babel has the following configuration values that can be used
+to change some internal defaults:
 
 =============================== =============================================
 `BABEL_DEFAULT_LOCALE`          The default locale to use if no locale
@@ -72,7 +68,7 @@ Example selector functions::
     from flask import g, request
 
     @babel.localeselector
-    def get_locale():
+    def get_user_locale():
         # if a user is logged in, use the locale from the user settings
         user = getattr(g, 'user', None)
         if user is not None:
@@ -83,7 +79,7 @@ Example selector functions::
         return request.accept_languages.best_match(['de', 'fr', 'en'])
 
     @babel.timezoneselector
-    def get_timezone():
+    def get_user_timezone():
         user = getattr(g, 'user', None)
         if user is not None:
             return user.timezone
@@ -91,122 +87,6 @@ Example selector functions::
 The example above assumes that the current user is stored on the
 :data:`flask.g` object.
 
-Jinja Filters
--------------
-
-Several commonly used formatters are added as jinja template filters after
-calling `init_app().` For dates and times, these are:
-
-- `<datetime>|datetimeformat` -> `format_datetime`
-- `<date>|dateformat` -> `format_date`
-- `<time>|timeformat` -> `format_time`
-- `<timedelta>|timedeltaformat` -> `format_timedelta`
-
-And for numbers, these are:
-
-- `<number>|numberformat` -> `format_number`
-- `<number>|decimalformat` -> `format_decimal`
-- `<number>|currencyformat` -> `format_currency`
-- `<number>|percentformat` -> `format_percent`
-- `<number>|scientificformat` -> `format_scientific`
-
-Formatting Dates
-----------------
-
-To format dates you can use the :func:`format_datetime`,
-:func:`format_date`, :func:`format_time` and :func:`format_timedelta`
-functions.  They all accept a :class:`datetime.datetime` (or
-:class:`datetime.date`, :class:`datetime.time` and
-:class:`datetime.timedelta`) object as first parameter and then optionally
-a format string.  The application should use naive datetime objects
-internally that use UTC as timezone.  On formatting it will automatically
-convert into the user's timezone in case it differs from UTC.
-
-To play with the date formatting from the console, you can use the
-:meth:`~flask.Flask.test_request_context` method:
-
->>> app.test_request_context().push()
-
-Here some examples:
-
->>> from flask_babel import format_datetime
->>> from datetime import datetime
->>> format_datetime(datetime(1987, 3, 5, 17, 12))
-u'Mar 5, 1987 5:12:00 PM'
->>> format_datetime(datetime(1987, 3, 5, 17, 12), 'full')
-u'Thursday, March 5, 1987 5:12:00 PM World (GMT) Time'
->>> format_datetime(datetime(1987, 3, 5, 17, 12), 'short')
-u'3/5/87 5:12 PM'
->>> format_datetime(datetime(1987, 3, 5, 17, 12), 'dd mm yyy')
-u'05 12 1987'
->>> format_datetime(datetime(1987, 3, 5, 17, 12), 'dd mm yyyy')
-u'05 12 1987'
-
-And again with a different language:
-
->>> app.config['BABEL_DEFAULT_LOCALE'] = 'de'
->>> from flask_babel import refresh; refresh()
->>> format_datetime(datetime(1987, 3, 5, 17, 12), 'EEEE, d. MMMM yyyy H:mm')
-u'Donnerstag, 5. M\xe4rz 1987 17:12'
-
-For more format examples head over to the `babel`_ documentation.
-
-Formatting Numbers
-------------------
-
-To format numbers you can use the :func:`format_number`,
-:func:`format_decimal`, :func:`format_currency`, :func:`format_percent` and :func:`format_scientific`
-functions.
-
-To play with the date formatting from the console, you can use the
-:meth:`~flask.Flask.test_request_context` method:
-
->>> app.test_request_context().push()
-
-Here are some examples:
-
->>> from flask_babel import format_number
->>> format_number(1099)
-'1,099'
-
->>> from flask_babel import format_decimal
->>> format_decimal(1.2346)
-u'1.235'
-
->>> from flask_babel import format_currency
->>> format_currency(1099.98, 'USD')
-'$1,099.98'
-
->>> from flask_babel import format_percent
->>> format_percent(0.34)
-'34%'
-
->>> from flask_babel import format_scientific
->>> format_scientific(10000)
-'1E4'
-
-And again with a different language:
-
->>> app.config['BABEL_DEFAULT_LOCALE'] = 'de'
->>> from flask_babel import refresh; refresh()
-
->>> format_number(1099)
-'1.099'
-
->>> format_decimal(1.2346)
-'1,235'
-
->>> format_currency(1099.98, 'USD')
-'1.099,98\xa0$'
-
->>> format_percent(0.34)
-'34\xa0%'
-
->>> format_scientific(10000)
-'1E4'
-
-For more format examples head over to the `babel`_ documentation.
-
 Using Translations
 ------------------
 
@@ -240,6 +120,41 @@ To use such a lazy string, use the :func:`lazy_gettext` function::
 So how does Flask-Babel find the translations?  Well first you have to
 create some.  Here is how you do it:
 
+Dates, Times, and Numbers
+-------------------------
+Babel provides many utilities for dealing with dates, times, and numbers
+beyond what the built-in Python `gettext`_ module supports. You can easily
+use these with Flask-Babel::
+
+    from datetime import datetime
+    from babel.numbers import format_decimal
+    from babel.dates import format_datetime
+    from flask_babel import get_locale, get_timezone
+
+    @app.route('/currency')
+    def currency():
+        return format_currency(1000.99, 'CAD', locale=get_locale())
+
+    @app.route('/date')
+    def date():
+        return format_datetime(
+            datetime.utcnow(),
+            'H:mm zzzz',
+            tzinfo=get_timezone(),
+            locale=get_locale()
+        )
+
+All of the formatting methods in babel.numbers and .dates take a `locale`
+parameter, which we populate with our Flask-Babel `get_locale()`.
+
+.. note::
+
+   Prior to version 3.0.0, every Babel `format_*` method was duplicated in
+   Flask-Babel, which was needless duplication and meant that Flask-Babel
+   was always out of date with changes in Babel. Instead, we just provide
+   the glue and you (the user) just import directly from babel. This is the
+   same approach that other integrations such as Flask-WTF started using.
+
 Translating Applications
 ------------------------
 
@@ -334,34 +249,6 @@ Context Functions
 
 .. autofunction:: get_timezone
 
-Datetime Functions
-``````````````````
-
-.. autofunction:: to_user_timezone
-
-.. autofunction:: to_utc
-
-.. autofunction:: format_datetime
-
-.. autofunction:: format_date
-
-.. autofunction:: format_time
-
-.. autofunction:: format_timedelta
-
-Number Functions
-``````````````````
-
-.. autofunction:: format_number
-
-.. autofunction:: format_decimal
-
-.. autofunction:: format_currency
-
-.. autofunction:: format_percent
-
-.. autofunction:: format_scientific
-
 Gettext Functions
 `````````````````
 
@@ -389,3 +276,4 @@ Low-Level API
 .. _babel: http://babel.edgewall.org/
 .. _pytz: http://pytz.sourceforge.net/
 .. _speaklater: http://pypi.python.org/pypi/speaklater
+.. _gettext: https://docs.python.org/3/library/gettext.html
diff --git a/flask_babel/__init__.py b/flask_babel/__init__.py
index a64b0e6..9e30b56 100644
--- a/flask_babel/__init__.py
+++ b/flask_babel/__init__.py
@@ -1,60 +1,23 @@
-"""
-    flaskext.babel
-    ~~~~~~~~~~~~~~
-
-    Implements i18n/l10n support for Flask applications based on Babel.
-
-    :copyright: (c) 2013 by Armin Ronacher, Daniel Neuhäuser.
-    :license: BSD, see LICENSE for more details.
-"""
-from __future__ import absolute_import
 import os
 
-from datetime import datetime
 from contextlib import contextmanager
 from flask import current_app, request
 from flask.ctx import has_request_context
 from flask.helpers import locked_cached_property
-from babel import dates, numbers, support, Locale
-from pytz import timezone, UTC
-from werkzeug.datastructures import ImmutableDict
+from babel import support, Locale
+from pytz import timezone
 
 from flask_babel.speaklater import LazyString
 
 
 class Babel(object):
-    """Central controller class that can be used to configure how
-    Flask-Babel behaves.  Each application that wants to use Flask-Babel
-    has to create, or run :meth:`init_app` on, an instance of this class
-    after the configuration was initialized.
-    """
-
-    default_date_formats = ImmutableDict({
-        'time':             'medium',
-        'date':             'medium',
-        'datetime':         'medium',
-        'time.short':       None,
-        'time.medium':      None,
-        'time.full':        None,
-        'time.long':        None,
-        'date.short':       None,
-        'date.medium':      None,
-        'date.full':        None,
-        'date.long':        None,
-        'datetime.short':   None,
-        'datetime.medium':  None,
-        'datetime.full':    None,
-        'datetime.long':    None,
-    })
-
     def __init__(self, app=None, default_locale='en', default_timezone='UTC',
-                 default_domain='messages', date_formats=None,
-                 configure_jinja=True):
+                 default_domain='messages', configure_jinja=True):
         self._default_locale = default_locale
         self._default_timezone = default_timezone
         self._default_domain = default_domain
-        self._date_formats = date_formats
         self._configure_jinja = configure_jinja
+
         self.app = app
         self.locale_selector_func = None
         self.timezone_selector_func = None
@@ -67,43 +30,31 @@ def init_app(self, app):
         the constructor.
         """
         self.app = app
-        app.babel_instance = self
+
         if not hasattr(app, 'extensions'):
             app.extensions = {}
+
+        # Several extensions, such as Flask-WTF, check for this value before
+        # using get_locale. Don't remove or rename without thought.
         app.extensions['babel'] = self
 
-        app.config.setdefault('BABEL_DEFAULT_LOCALE', self._default_locale)
-        app.config.setdefault('BABEL_DEFAULT_TIMEZONE', self._default_timezone)
-        app.config.setdefault('BABEL_DOMAIN', self._default_domain)
-        if self._date_formats is None:
-            self._date_formats = self.default_date_formats.copy()
-
-        #: a mapping of Babel datetime format strings that can be modified
-        #: to change the defaults.  If you invoke :func:`format_datetime`
-        #: and do not provide any format string Flask-Babel will do the
-        #: following things:
-        #:
-        #: 1.   look up ``date_formats['datetime']``.  By default ``'medium'``
-        #:      is returned to enforce medium length datetime formats.
-        #: 2.   ``date_formats['datetime.medium'] (if ``'medium'`` was
-        #:      returned in step one) is looked up.  If the return value
-        #:      is anything but `None` this is used as new format string.
-        #:      otherwise the default for that language is used.
-        self.date_formats = self._date_formats
+        self._default_locale = Locale.parse(
+            app.config.get('BABEL_DEFAULT_LOCALE', self._default_locale)
+        )
+        self._default_timezone = timezone(
+            app.config.get('BABEL_DEFAULT_TIMEZONE', self._default_timezone)
+        )
+
+        self._default_domain = app.config.get(
+            'BABEL_DEFAULT_DOMAIN',
+            app.config.get(
+                # Legacy configuration key.
+                'BABEL_DOMAIN',
+                self._default_timezone
+            )
+        )
 
         if self._configure_jinja:
-            app.jinja_env.filters.update(
-                datetimeformat=format_datetime,
-                dateformat=format_date,
-                timeformat=format_time,
-                timedeltaformat=format_timedelta,
-
-                numberformat=format_number,
-                decimalformat=format_decimal,
-                currencyformat=format_currency,
-                percentformat=format_percent,
-                scientificformat=format_scientific,
-            )
             app.jinja_env.add_extension('jinja2.ext.i18n')
             app.jinja_env.install_gettext_callables(
                 lambda x: get_translations().ugettext(x),
@@ -161,27 +112,27 @@ def list_translations(self):
         return result
 
     @property
-    def default_locale(self):
+    def default_locale(self) -> Locale:
         """The default locale from the configuration as instance of a
         `babel.Locale` object.
         """
-        return Locale.parse(self.app.config['BABEL_DEFAULT_LOCALE'])
+        return self._default_locale
 
     @property
-    def default_timezone(self):
+    def default_timezone(self) -> timezone:
         """The default timezone from the configuration as instance of a
         `pytz.timezone` object.
         """
-        return timezone(self.app.config['BABEL_DEFAULT_TIMEZONE'])
+        return self._default_timezone
 
     @property
     def domain(self):
         """The message domain for the translations as a string.
         """
-        return self.app.config['BABEL_DOMAIN']
+        return self._default_domain
 
     @locked_cached_property
-    def domain_instance(self):
+    def domain_instance(self) -> 'Domain':
         """The message domain for the translations.
         """
         return Domain(domain=self.app.config['BABEL_DOMAIN'])
@@ -217,6 +168,7 @@ def get_locale():
     ctx = _get_current_context()
     if ctx is None:
         return None
+
     locale = getattr(ctx, 'babel_locale', None)
     if locale is None:
         babel = current_app.extensions['babel']
@@ -229,6 +181,7 @@ def get_locale():
             else:
                 locale = Locale.parse(rv)
         ctx.babel_locale = locale
+
     return locale
 
 
@@ -311,209 +264,12 @@ def force_locale(locale):
             setattr(ctx, key, value)
 
 
-def _get_format(key, format):
-    """A small helper for the datetime formatting functions.  Looks up
-    format defaults for different kinds.
-    """
-    babel = current_app.extensions['babel']
-    if format is None:
-        format = babel.date_formats[key]
-    if format in ('short', 'medium', 'full', 'long'):
-        rv = babel.date_formats['%s.%s' % (key, format)]
-        if rv is not None:
-            format = rv
-    return format
-
-
-def to_user_timezone(datetime):
-    """Convert a datetime object to the user's timezone.  This automatically
-    happens on all date formatting unless rebasing is disabled.  If you need
-    to convert a :class:`datetime.datetime` object at any time to the user's
-    timezone (as returned by :func:`get_timezone` this function can be used).
-    """
-    if datetime.tzinfo is None:
-        datetime = datetime.replace(tzinfo=UTC)
-    tzinfo = get_timezone()
-    return tzinfo.normalize(datetime.astimezone(tzinfo))
-
-
-def to_utc(datetime):
-    """Convert a datetime object to UTC and drop tzinfo.  This is the
-    opposite operation to :func:`to_user_timezone`.
-    """
-    if datetime.tzinfo is None:
-        datetime = get_timezone().localize(datetime)
-    return datetime.astimezone(UTC).replace(tzinfo=None)
-
-
-def format_datetime(datetime=None, format=None, rebase=True):
-    """Return a date formatted according to the given pattern.  If no
-    :class:`~datetime.datetime` object is passed, the current time is
-    assumed.  By default rebasing happens which causes the object to
-    be converted to the users's timezone (as returned by
-    :func:`to_user_timezone`).  This function formats both date and
-    time.
-
-    The format parameter can either be ``'short'``, ``'medium'``,
-    ``'long'`` or ``'full'`` (in which cause the language's default for
-    that setting is used, or the default from the :attr:`Babel.date_formats`
-    mapping is used) or a format string as documented by Babel.
-
-    This function is also available in the template context as filter
-    named `datetimeformat`.
-    """
-    format = _get_format('datetime', format)
-    return _date_format(dates.format_datetime, datetime, format, rebase)
-
-
-def format_date(date=None, format=None, rebase=True):
-    """Return a date formatted according to the given pattern.  If no
-    :class:`~datetime.datetime` or :class:`~datetime.date` object is passed,
-    the current time is assumed.  By default rebasing happens which causes
-    the object to be converted to the users's timezone (as returned by
-    :func:`to_user_timezone`).  This function only formats the date part
-    of a :class:`~datetime.datetime` object.
-
-    The format parameter can either be ``'short'``, ``'medium'``,
-    ``'long'`` or ``'full'`` (in which cause the language's default for
-    that setting is used, or the default from the :attr:`Babel.date_formats`
-    mapping is used) or a format string as documented by Babel.
-
-    This function is also available in the template context as filter
-    named `dateformat`.
-    """
-    if rebase and isinstance(date, datetime):
-        date = to_user_timezone(date)
-    format = _get_format('date', format)
-    return _date_format(dates.format_date, date, format, rebase)
-
-
-def format_time(time=None, format=None, rebase=True):
-    """Return a time formatted according to the given pattern.  If no
-    :class:`~datetime.datetime` object is passed, the current time is
-    assumed.  By default rebasing happens which causes the object to
-    be converted to the users's timezone (as returned by
-    :func:`to_user_timezone`).  This function formats both date and
-    time.
-
-    The format parameter can either be ``'short'``, ``'medium'``,
-    ``'long'`` or ``'full'`` (in which cause the language's default for
-    that setting is used, or the default from the :attr:`Babel.date_formats`
-    mapping is used) or a format string as documented by Babel.
-
-    This function is also available in the template context as filter
-    named `timeformat`.
-    """
-    format = _get_format('time', format)
-    return _date_format(dates.format_time, time, format, rebase)
-
-
-def format_timedelta(datetime_or_timedelta, granularity='second',
-                     add_direction=False, threshold=0.85):
-    """Format the elapsed time from the given date to now or the given
-    timedelta.
-
-    This function is also available in the template context as filter
-    named `timedeltaformat`.
-    """
-    if isinstance(datetime_or_timedelta, datetime):
-        datetime_or_timedelta = datetime.utcnow() - datetime_or_timedelta
-    return dates.format_timedelta(
-        datetime_or_timedelta,
-        granularity,
-        threshold=threshold,
-        add_direction=add_direction,
-        locale=get_locale()
-    )
-
-
-def _date_format(formatter, obj, format, rebase, **extra):
-    """Internal helper that formats the date."""
-    locale = get_locale()
-    extra = {}
-    if formatter is not dates.format_date and rebase:
-        extra['tzinfo'] = get_timezone()
-    return formatter(obj, format, locale=locale, **extra)
-
-
-def format_number(number):
-    """Return the given number formatted for the locale in request
-
-    :param number: the number to format
-    :return: the formatted number
-    :rtype: unicode
-    """
-    locale = get_locale()
-    return numbers.format_decimal(number, locale=locale)
-
-
-def format_decimal(number, format=None):
-    """Return the given decimal number formatted for the locale in request
-
-    :param number: the number to format
-    :param format: the format to use
-    :return: the formatted number
-    :rtype: unicode
-    """
-    locale = get_locale()
-    return numbers.format_decimal(number, format=format, locale=locale)
-
-
-def format_currency(number, currency, format=None, currency_digits=True,
-                    format_type='standard'):
-    """Return the given number formatted for the locale in request
-
-    :param number: the number to format
-    :param currency: the currency code
-    :param format: the format to use
-    :param currency_digits: use the currency’s number of decimal digits
-                            [default: True]
-    :param format_type: the currency format type to use
-                        [default: standard]
-    :return: the formatted number
-    :rtype: unicode
-    """
-    locale = get_locale()
-    return numbers.format_currency(
-        number,
-        currency,
-        format=format,
-        locale=locale,
-        currency_digits=currency_digits,
-        format_type=format_type
-    )
-
-
-def format_percent(number, format=None):
-    """Return formatted percent value for the locale in request
-
-    :param number: the number to format
-    :param format: the format to use
-    :return: the formatted percent number
-    :rtype: unicode
-    """
-    locale = get_locale()
-    return numbers.format_percent(number, format=format, locale=locale)
-
-
-def format_scientific(number, format=None):
-    """Return value formatted in scientific notation for the locale in request
-
-    :param number: the number to format
-    :param format: the format to use
-    :return: the formatted percent number
-    :rtype: unicode
-    """
-    locale = get_locale()
-    return numbers.format_scientific(number, format=format, locale=locale)
-
-
 class Domain(object):
-    """Localization domain. By default will use look for tranlations in Flask
-    application directory and "messages" domain - all message catalogs should
-    be called ``messages.mo``.
-    """
+    """Localization domain.
 
+    By default will look for translations in Flask application directory and
+    "messages" domain.
+    """
     def __init__(self, translation_directories=None, domain='messages'):
         if isinstance(translation_directories, str):
             translation_directories = [translation_directories]
@@ -543,20 +299,15 @@ def as_default(self):
 
         ctx.babel_domain = self
 
-    def get_translations_cache(self, ctx):
-        """Returns dictionary-like object for translation caching"""
-        return self.cache
-
     def get_translations(self):
         ctx = _get_current_context()
 
         if ctx is None:
             return support.NullTranslations()
 
-        cache = self.get_translations_cache(ctx)
         locale = get_locale()
         try:
-            return cache[str(locale), self.domain]
+            return self.cache[str(locale), self.domain]
         except KeyError:
             translations = support.Translations()
 
@@ -574,98 +325,9 @@ def get_translations(self):
                 if hasattr(catalog, 'plural'):
                     translations.plural = catalog.plural
 
-            cache[str(locale), self.domain] = translations
+            self.cache[str(locale), self.domain] = translations
             return translations
 
-    def gettext(self, string, **variables):
-        """Translates a string with the current locale and passes in the
-        given keyword arguments as mapping to a string formatting string.
-
-        ::
-
-            gettext(u'Hello World!')
-            gettext(u'Hello %(name)s!', name='World')
-        """
-        t = self.get_translations()
-        s = t.ugettext(string)
-        return s if not variables else s % variables
-
-    def ngettext(self, singular, plural, num, **variables):
-        """Translates a string with the current locale and passes in the
-        given keyword arguments as mapping to a string formatting string.
-        The `num` parameter is used to dispatch between singular and various
-        plural forms of the message.  It is available in the format string
-        as ``%(num)d`` or ``%(num)s``.  The source language should be
-        English or a similar language which only has one plural form.
-
-        ::
-
-            ngettext(u'%(num)d Apple', u'%(num)d Apples', num=len(apples))
-        """
-        variables.setdefault('num', num)
-        t = self.get_translations()
-        s = t.ungettext(singular, plural, num)
-        return s if not variables else s % variables
-
-    def pgettext(self, context, string, **variables):
-        """Like :func:`gettext` but with a context.
-
-        .. versionadded:: 0.7
-        """
-        t = self.get_translations()
-        s = t.upgettext(context, string)
-        return s if not variables else s % variables
-
-    def npgettext(self, context, singular, plural, num, **variables):
-        """Like :func:`ngettext` but with a context.
-
-        .. versionadded:: 0.7
-        """
-        variables.setdefault('num', num)
-        t = self.get_translations()
-        s = t.unpgettext(context, singular, plural, num)
-        return s if not variables else s % variables
-
-    def lazy_gettext(self, string, **variables):
-        """Like :func:`gettext` but the string returned is lazy which means
-        it will be translated when it is used as an actual string.
-
-        Example::
-
-            hello = lazy_gettext('Hello World')
-
-            @app.route('/')
-            def index():
-                return unicode(hello)
-        """
-        return LazyString(self.gettext, string, **variables)
-
-    def lazy_ngettext(self, singular, plural, num, **variables):
-        """Like :func:`ngettext` but the string returned is lazy which means
-        it will be translated when it is used as an actual string.
-
-        Example::
-
-            apples = lazy_ngettext(
-                '%(num)d Apple',
-                '%(num)d Apples',
-                num=len(apples)
-            )
-
-            @app.route('/')
-            def index():
-                return unicode(apples)
-        """
-        return LazyString(self.ngettext, singular, plural, num, **variables)
-
-    def lazy_pgettext(self, context, string, **variables):
-        """Like :func:`pgettext` but the string returned is lazy which means
-        it will be translated when it is used as an actual string.
-
-        .. versionadded:: 0.7
-        """
-        return LazyString(self.pgettext, context, string, **variables)
-
 
 def _get_current_context():
     if has_request_context():
@@ -691,7 +353,6 @@ def get_domain():
     return ctx.babel_domain
 
 
-# Create shortcuts for the default Flask domain
 def gettext(*args, **kwargs):
     return get_domain().gettext(*args, **kwargs)