diff --git a/etc/jupyter/jupyter_server_config.d/voila.json b/etc/jupyter/jupyter_server_config.d/voila.json
index ff38f42ff..7de60d1f5 100644
--- a/etc/jupyter/jupyter_server_config.d/voila.json
+++ b/etc/jupyter/jupyter_server_config.d/voila.json
@@ -1,7 +1,7 @@
 {
     "ServerApp": {
         "jpserver_extensions": {
-            "voila.server_extension": true
+            "voila": true
         }
     }
 }
diff --git a/setup.py b/setup.py
index 57f8e76e7..260080d00 100644
--- a/setup.py
+++ b/setup.py
@@ -273,7 +273,7 @@ def get_data_files():
     },
     'entry_points': {
         'console_scripts': [
-            'voila = voila.app:main'
+            'jupyter-voila = voila.app:main'
         ]
     },
     'install_requires': [
diff --git a/share/jupyter/voila/templates/default/nbconvert_templates/base.tpl b/share/jupyter/voila/templates/default/nbconvert_templates/base.tpl
index 300223792..b431e5ab4 100644
--- a/share/jupyter/voila/templates/default/nbconvert_templates/base.tpl
+++ b/share/jupyter/voila/templates/default/nbconvert_templates/base.tpl
@@ -14,7 +14,7 @@
 
 {%- block html_head_js -%}
 
-<script src="{{resources.base_url}}voila/static/jquery.min.js"></script>
+<script src="{{resources.base_url}}static/voila/jquery.min.js"></script>
 
 <script id="jupyter-config-data" type="application/json">
 {
@@ -34,15 +34,18 @@
 {% block footer %}
 {% block footer_js %}
 <script
-    src="{{resources.base_url}}voila/static/require.min.js"
+    src="{{resources.base_url}}static/voila/require.min.js"
     integrity="sha256-Ae2Vz/4ePdIu6ZyI/5ZGsYnb+m0JlOmKPjt6XZ9JJkA="
     crossorigin="anonymous">
 </script>
 <script>
-requirejs.config({ baseUrl: '{{resources.base_url}}voila/', waitSeconds: 30})
+requirejs.config({ 
+    baseUrl: '{{resources.base_url}}static/voila/', 
+    waitSeconds: 30
+})
 requirejs(
     [
-        "static/main",
+        "main",
     {% for ext in resources.nbextensions -%}
         "{{resources.base_url}}voila/nbextensions/{{ ext }}.js",
     {% endfor %}
diff --git a/share/jupyter/voila/templates/default/nbconvert_templates/voila.tpl b/share/jupyter/voila/templates/default/nbconvert_templates/voila.tpl
index ae0000861..5c4120d38 100644
--- a/share/jupyter/voila/templates/default/nbconvert_templates/voila.tpl
+++ b/share/jupyter/voila/templates/default/nbconvert_templates/voila.tpl
@@ -2,12 +2,12 @@
 {% from 'mathjax.tpl' import mathjax %}
 
 {%- block html_head_css -%}
-<link rel="stylesheet" type="text/css" href="{{resources.base_url}}voila/static/index.css"></link>
+<link rel="stylesheet" type="text/css" href="{{resources.base_url}}static/voila/index.css"></link>
 
 {% if resources.theme == 'dark' %}
-    <link rel="stylesheet" type="text/css" href="{{resources.base_url}}voila/static/theme-dark.css"></link>
+    <link rel="stylesheet" type="text/css" href="{{resources.base_url}}static/voila/theme-dark.css"></link>
 {% else %}
-    <link rel="stylesheet" type="text/css" href="{{resources.base_url}}voila/static/theme-light.css"></link>
+    <link rel="stylesheet" type="text/css" href="{{resources.base_url}}static/voila/theme-light.css"></link>
 {% endif %}
 
 {% for css in resources.inlining.css %}
diff --git a/share/jupyter/voila/templates/default/static/main.js b/share/jupyter/voila/templates/default/static/main.js
index 1b73e6355..4837f402e 100644
--- a/share/jupyter/voila/templates/default/static/main.js
+++ b/share/jupyter/voila/templates/default/static/main.js
@@ -7,7 +7,7 @@
 ****************************************************************************/
 
 // NOTE: this file is not transpiled, async/await is the only modern feature we use here
-require(['static/voila'], function(voila) {
+require(['voila'], function(voila) {
     // requirejs doesn't like to be passed an async function, so create one inside
     (async function() {
         var kernel = await voila.connectKernel()
diff --git a/voila/__init__.py b/voila/__init__.py
index 0ddf09761..d2039cdbe 100644
--- a/voila/__init__.py
+++ b/voila/__init__.py
@@ -7,8 +7,9 @@
 #############################################################################
 
 from ._version import __version__  # noqa
-from .server_extension import load_jupyter_server_extension  # noqa
+from .app import Voila  # noqa
 
+load_jupyter_server_extension = Voila.load_jupyter_server_extension
 
 def _jupyter_nbextension_paths():
     return [dict(
diff --git a/voila/app.py b/voila/app.py
index 3bbb9f43b..7a46bb580 100644
--- a/voila/app.py
+++ b/voila/app.py
@@ -41,7 +41,7 @@
 from jupyter_server.utils import url_path_join
 from jupyter_server.services.config import ConfigManager
 from jupyter_server.base.handlers import FileFindHandler
-
+from jupyter_server.extension.application import ExtensionApp
 from jupyter_core.paths import jupyter_config_path, jupyter_path
 
 from ipython_genutils.py3compat import getcwd
@@ -50,8 +50,6 @@
 from .handler import VoilaHandler
 from .treehandler import VoilaTreeHandler
 from ._version import __version__
-from .static_file_handler import MultiStaticFileHandler
-from .configuration import VoilaConfiguration
 
 ioloop.install()
 _kernel_id_regex = r"(?P<kernel_id>\w+-\w+-\w+-\w+-\w+)"
@@ -61,10 +59,12 @@ def _(x):
     return x
 
 
-class Voila(Application):
+class Voila(ExtensionApp):
     name = 'voila'
     version = __version__
     examples = 'voila example.ipynb --port 8888'
+    
+    extension_name = 'voila'
 
     flags = {
         'no-browser': ({'Voila': {'open_browser': False}}, _('Don\'t open the notebook in a browser after startup.'))
@@ -83,13 +83,7 @@ class Voila(Application):
         """
     )
     notebook_filename = Unicode()
-    port = Integer(
-        8866,
-        config=True,
-        help=_(
-            'Port of the voila server. Default 8866.'
-        )
-    )
+
     autoreload = Bool(
         False,
         config=True,
@@ -116,9 +110,19 @@ class Voila(Application):
         'server_url': 'Voila.server_url',
         'enable_nbextensions': 'VoilaConfiguration.enable_nbextensions'
     }
-    classes = [
-        VoilaConfiguration
-    ]
+
+    template = Unicode(
+        'default',
+        config=True,
+        allow_none=True,
+        help=(
+            'template name to be used by voila.'
+        )
+    )
+    theme = Unicode('light').tag(config=True)
+    strip_sources = Bool(True, help='Strip sources from rendered html').tag(config=True)
+    enable_nbextensions = Bool(False, config=True, help=('Set to True for Voila to load notebook extensions'))
+
     connection_dir_root = Unicode(
         config=True,
         help=_(
@@ -183,25 +187,6 @@ class Voila(Application):
         )
     )
 
-    ip = Unicode('localhost', config=True,
-                 help=_("The IP address the notebook server will listen on."))
-
-    open_browser = Bool(True, config=True,
-                        help=_("""Whether to open in a browser after starting.
-                        The specific browser used is platform dependent and
-                        determined by the python standard library `webbrowser`
-                        module, unless it is overridden using the --browser
-                        (NotebookApp.browser) configuration option.
-                        """))
-
-    browser = Unicode(u'', config=True,
-                      help="""Specify what command to use to invoke a web
-                      browser when opening the notebook. If not specified, the
-                      default browser will be determined by the `webbrowser`
-                      standard library module, which allows setting of the
-                      BROWSER environment variable to override it.
-                      """)
-
     webbrowser_open_new = Integer(2, config=True,
                                   help=_("""Specify Where to open the notebook on startup. This is the
                                   `new` argument passed to the standard library method `webbrowser.open`.
@@ -223,38 +208,6 @@ class Voila(Application):
                                  cannot be determined reliably by the Jupyter notebook server (proxified
                                  or containerized setups for example)."""))
 
-    @property
-    def display_url(self):
-        if self.custom_display_url:
-            url = self.custom_display_url
-            if not url.endswith('/'):
-                url += '/'
-        else:
-            if self.ip in ('', '0.0.0.0'):
-                ip = "%s" % socket.gethostname()
-            else:
-                ip = self.ip
-            url = self._url(ip)
-        # TODO: do we want to have the token?
-        # if self.token:
-        #     # Don't log full token if it came from config
-        #     token = self.token if self._token_generated else '...'
-        #     url = (url_concat(url, {'token': token})
-        #           + '\n or '
-        #           + url_concat(self._url('127.0.0.1'), {'token': token}))
-        return url
-
-    @property
-    def connection_url(self):
-        ip = self.ip if self.ip else 'localhost'
-        return self._url(ip)
-
-    def _url(self, ip):
-        # TODO: https / certfile
-        # proto = 'https' if self.certfile else 'http'
-        proto = 'http'
-        return "%s://%s:%i%s" % (proto, ip, self.port, self.base_url)
-
     config_file_paths = List(
         Unicode(),
         config=True,
@@ -263,28 +216,10 @@ def _url(self, ip):
         )
     )
 
-    tornado_settings = Dict(
-        {},
-        config=True,
-        help=_(
-            'Extra settings to apply to tornado application, e.g. headers, ssl, etc'
-        )
-    )
-
     @default('config_file_paths')
     def _config_file_paths_default(self):
         return [os.getcwd()] + jupyter_config_path()
 
-    @default('connection_dir_root')
-    def _default_connection_dir(self):
-        connection_dir = tempfile.gettempdir()
-        self.log.info('Using %s to store connection files' % connection_dir)
-        return connection_dir
-
-    @default('log_level')
-    def _default_log_level(self):
-        return logging.INFO
-
     # similar to NotebookApp, except no extra path
     @property
     def nbextensions_path(self):
@@ -306,199 +241,46 @@ def _default_root_dir(self):
         else:
             return getcwd()
 
-    def initialize(self, argv=None):
-        self.log.debug("Searching path %s for config files", self.config_file_paths)
-        # to make config_file_paths settable via cmd line, we first need to parse it
-        super(Voila, self).initialize(argv)
-        if len(self.extra_args) == 1:
-            arg = self.extra_args[0]
-            # I am not sure why we need to check if self.notebook_path is set, can we get rid of this?
-            if not self.notebook_path:
-                if os.path.isdir(arg):
-                    self.root_dir = arg
-                elif os.path.isfile(arg):
-                    self.notebook_path = arg
-                else:
-                    raise ValueError('argument is neither a file nor a directory: %r' % arg)
-        elif len(self.extra_args) != 0:
-            raise ValueError('provided more than 1 argument: %r' % self.extra_args)
-
-        # then we load the config
-        self.load_config_file('voila', path=self.config_file_paths)
-        # but that cli config has preference, so we overwrite with that
-        self.update_config(self.cli_config)
+
+    default_url = Unicode("/voila", config=True)
+
+    def initialize_templates(self):
         # common configuration options between the server extension and the application
-        self.voila_configuration = VoilaConfiguration(parent=self)
-        self.setup_template_dirs()
-        signal.signal(signal.SIGTERM, self._handle_signal_stop)
-
-    def setup_template_dirs(self):
-        if self.voila_configuration.template:
-            collect_template_paths(
-                self.nbconvert_template_paths,
-                self.static_paths,
-                self.template_paths,
-                self.voila_configuration.template)
-        self.log.debug('using template: %s', self.voila_configuration.template)
-        self.log.debug('nbconvert template paths:\n\t%s', '\n\t'.join(self.nbconvert_template_paths))
-        self.log.debug('template paths:\n\t%s', '\n\t'.join(self.template_paths))
-        self.log.debug('static paths:\n\t%s', '\n\t'.join(self.static_paths))
-        if self.notebook_path and not os.path.exists(self.notebook_path):
-            raise ValueError('Notebook not found: %s' % self.notebook_path)
-
-    def _handle_signal_stop(self, sig, frame):
-        self.log.info('Handle signal %s.' % sig)
-        self.ioloop.add_callback_from_signal(self.ioloop.stop)
-
-    def start(self):
-        self.connection_dir = tempfile.mkdtemp(
-            prefix='voila_',
-            dir=self.connection_dir_root
-        )
-        self.log.info('Storing connection files in %s.' % self.connection_dir)
-        self.log.info('Serving static files from %s.' % self.static_root)
-
-        self.kernel_manager = MappingKernelManager(
-            parent=self,
-            connection_dir=self.connection_dir,
-            allowed_message_types=[
-                'comm_msg',
-                'comm_info_request',
-                'kernel_info_request',
-                'shutdown_request'
-            ]
+        collect_template_paths(
+            self.nbconvert_template_paths,
+            self.static_paths,
+            self.template_paths,
+            self.template
         )
-
-        jenv_opt = {"autoescape": True}  # we might want extra options via cmd line like notebook server
+        jenv_opt = {"autoescape": True}
         env = jinja2.Environment(loader=jinja2.FileSystemLoader(self.template_paths), extensions=['jinja2.ext.i18n'], **jenv_opt)
+
         nbui = gettext.translation('nbui', localedir=os.path.join(ROOT, 'i18n'), fallback=True)
         env.install_gettext_translations(nbui, newstyle=False)
-        self.contents_manager = LargeFileManager(parent=self)
-
-        # we create a config manager that load both the serverconfig and nbconfig (classical notebook)
-        read_config_path = [os.path.join(p, 'serverconfig') for p in jupyter_config_path()]
-        read_config_path += [os.path.join(p, 'nbconfig') for p in jupyter_config_path()]
-        self.config_manager = ConfigManager(parent=self, read_config_path=read_config_path)
-
-        # default server_url to base_url
-        self.server_url = self.server_url or self.base_url
-
-        self.app = tornado.web.Application(
-            base_url=self.base_url,
-            server_url=self.server_url or self.base_url,
-            kernel_manager=self.kernel_manager,
-            allow_remote_access=True,
-            autoreload=self.autoreload,
+
+        template_settings = dict(
+            voila_template_paths=self.template_paths,
             voila_jinja2_env=env,
-            jinja2_env=env,
-            static_path='/',
-            server_root_dir='/',
-            contents_manager=self.contents_manager,
-            config_manager=self.config_manager
+            nbconvert_template_paths=self.nbconvert_template_paths
         )
-
-        self.app.settings.update(self.tornado_settings)
-
-        handlers = []
-
-        handlers.extend([
-            (url_path_join(self.server_url, r'/api/kernels/%s' % _kernel_id_regex), KernelHandler),
-            (url_path_join(self.server_url, r'/api/kernels/%s/channels' % _kernel_id_regex), ZMQChannelsHandler),
-            (
-                url_path_join(self.server_url, r'/voila/static/(.*)'),
-                MultiStaticFileHandler,
-                {
-                    'paths': self.static_paths,
-                    'default_filename': 'index.html'
-                }
-            )
-        ])
-
-        # Serving notebook extensions
-        if self.voila_configuration.enable_nbextensions:
-            handlers.append(
-                (
-                    url_path_join(self.server_url, r'/voila/nbextensions/(.*)'),
-                    FileFindHandler,
-                    {
-                        'path': self.nbextensions_path,
-                        'no_cache_paths': ['/'],  # don't cache anything in nbextensions
-                    },
-                )
-            )
-
-        if self.notebook_path:
-            handlers.append((
-                url_path_join(self.server_url, r'/'),
-                VoilaHandler,
-                {
-                    'notebook_path': os.path.relpath(self.notebook_path, self.root_dir),
-                    'nbconvert_template_paths': self.nbconvert_template_paths,
-                    'config': self.config,
-                    'voila_configuration': self.voila_configuration
-                }
-            ))
-        else:
-            self.log.debug('serving directory: %r', self.root_dir)
-            handlers.extend([
-                (self.server_url, VoilaTreeHandler),
-                (url_path_join(self.server_url, r'/voila/tree' + path_regex), VoilaTreeHandler),
-                (url_path_join(self.server_url, r'/voila/render' + notebook_path_regex), VoilaHandler,
-                    {
-                        'nbconvert_template_paths': self.nbconvert_template_paths,
-                        'config': self.config,
-                        'voila_configuration': self.voila_configuration
-                    }),
-            ])
-
-        self.app.add_handlers('.*$', handlers)
-        self.listen()
-
-    def stop(self):
-        shutil.rmtree(self.connection_dir)
-        self.kernel_manager.shutdown_all()
-
-    def listen(self):
-        self.app.listen(self.port)
-        self.log.info('Voila is running at:\n%s' % self.display_url)
-
-        if self.open_browser:
-            self.launch_browser()
-
-        self.ioloop = tornado.ioloop.IOLoop.current()
-        try:
-            self.ioloop.start()
-        except KeyboardInterrupt:
-            self.log.info('Stopping...')
-        finally:
-            self.stop()
-
-    def launch_browser(self):
-        try:
-            browser = webbrowser.get(self.browser or None)
-        except webbrowser.Error as e:
-            self.log.warning(_('No web browser found: %s.') % e)
-            browser = None
-
-        if not browser:
-            return
-
-        uri = self.base_url
-        fd, open_file = tempfile.mkstemp(suffix='.html')
-        # Write a temporary file to open in the browser
-        with io.open(fd, 'w', encoding='utf-8') as fh:
-            # TODO: do we want to have the token?
-            # if self.token:
-            #     url = url_concat(url, {'token': self.token})
-            url = url_path_join(self.connection_url, uri)
-
-            jinja2_env = self.app.settings['jinja2_env']
-            template = jinja2_env.get_template('browser-open.html')
-            fh.write(template.render(open_url=url))
-
-        def target():
-            return browser.open(urljoin('file:', pathname2url(open_file)), new=self.webbrowser_open_new)
-        threading.Thread(target=target).start()
-
+        self.settings.update(**template_settings)
+
+    def initialize_settings(self):
+        voila_configuration = dict(
+            template=self.template,
+            theme=self.theme,
+            strip_sources=self.strip_sources,
+            enable_nbextensions=self.enable_nbextensions,
+            notebook_path=self.notebook_path,
+        )
+        self.settings['voila_configuration'] = voila_configuration
+
+    def initialize_handlers(self):
+        handlers = [
+            ('/voila/render' + path_regex, VoilaHandler),
+            ('/voila', VoilaTreeHandler),
+            ('/voila/tree' + path_regex, VoilaTreeHandler),
+        ]
+        self.handlers.extend(handlers)
 
 main = Voila.launch_instance
diff --git a/voila/configuration.py b/voila/configuration.py
deleted file mode 100644
index 93d063abc..000000000
--- a/voila/configuration.py
+++ /dev/null
@@ -1,25 +0,0 @@
-#############################################################################
-# Copyright (c) 2018, Voila Contributors                                    #
-#                                                                           #
-# Distributed under the terms of the BSD 3-Clause License.                  #
-#                                                                           #
-# The full license is in the file LICENSE, distributed with this software.  #
-#############################################################################
-
-import traitlets.config
-from traitlets import Unicode, Bool
-
-
-class VoilaConfiguration(traitlets.config.Configurable):
-    """Common configuration options between the server extension and the application."""
-    template = Unicode(
-        'default',
-        config=True,
-        allow_none=True,
-        help=(
-            'template name to be used by voila.'
-        )
-    )
-    theme = Unicode('light').tag(config=True)
-    strip_sources = Bool(True, help='Strip sources from rendered html').tag(config=True)
-    enable_nbextensions = Bool(False, config=True, help=('Set to True for Voila to load notebook extensions'))
diff --git a/voila/handler.py b/voila/handler.py
index ba95ad43e..f71c67ebd 100644
--- a/voila/handler.py
+++ b/voila/handler.py
@@ -10,19 +10,31 @@
 
 import tornado.web
 
-from jupyter_server.base.handlers import JupyterHandler
+from jupyter_server.extension.handler import ExtensionHandler
 
 from .execute import executenb
 from .exporter import VoilaExporter
 
 
-class VoilaHandler(JupyterHandler):
+class VoilaHandler(ExtensionHandler):
+    extension_name = "voila"
+    
+    @property
+    def notebook_path(self):
+        return self.settings.get('notebook_path', [])
+
+    @property
+    def nbconvert_template_paths(self):
+        return self.settings.get('nbconvert_template_paths', [])
+
+    @property
+    def exporter_config(self):
+        return self.settings.get('config', None)
+
+    @property
+    def voila_configuration(self):
+        return self.settings['voila_configuration']
 
-    def initialize(self, **kwargs):
-        self.notebook_path = kwargs.pop('notebook_path', [])    # should it be []
-        self.nbconvert_template_paths = kwargs.pop('nbconvert_template_paths', [])
-        self.exporter_config = kwargs.pop('config', None)
-        self.voila_configuration = kwargs['voila_configuration']
 
     @tornado.web.authenticated
     @tornado.gen.coroutine
@@ -30,7 +42,7 @@ def get(self, path=None):
         # if the handler got a notebook_path argument, always serve that
         notebook_path = self.notebook_path or path
 
-        if self.voila_configuration.enable_nbextensions:
+        if self.voila_configuration['enable_nbextensions']:
             # generate a list of nbextensions that are enabled for the classical notebook
             # a template can use that to load classical notebook extensions, but does not have to
             notebook_config = self.config_manager.get('notebook')
@@ -62,7 +74,7 @@ def get(self, path=None):
             'kernel_id': kernel_id,
             'base_url': self.base_url,
             'nbextensions': nbextensions,
-            'theme': self.voila_configuration.theme
+            'theme': self.voila_configuration['theme']
         }
 
         exporter = VoilaExporter(
@@ -71,7 +83,7 @@ def get(self, path=None):
             contents_manager=self.contents_manager  # for the image inlining
         )
 
-        if self.voila_configuration.strip_sources:
+        if self.voila_configuration['strip_sources']:
             exporter.exclude_input = True
             exporter.exclude_output_prompt = True
             exporter.exclude_input_prompt = True
diff --git a/voila/server_extension.py b/voila/server_extension.py
deleted file mode 100644
index 589fe5724..000000000
--- a/voila/server_extension.py
+++ /dev/null
@@ -1,81 +0,0 @@
-#############################################################################
-# Copyright (c) 2018, Voila Contributors                                    #
-#                                                                           #
-# Distributed under the terms of the BSD 3-Clause License.                  #
-#                                                                           #
-# The full license is in the file LICENSE, distributed with this software.  #
-#############################################################################
-
-import os
-import gettext
-
-from jinja2 import Environment, FileSystemLoader
-
-from jupyter_server.utils import url_path_join
-from jupyter_server.base.handlers import path_regex
-from jupyter_server.base.handlers import FileFindHandler
-
-from .paths import ROOT, STATIC_ROOT, collect_template_paths, jupyter_path, notebook_path_regex
-from .handler import VoilaHandler
-from .treehandler import VoilaTreeHandler
-from .static_file_handler import MultiStaticFileHandler
-from .configuration import VoilaConfiguration
-
-
-def load_jupyter_server_extension(server_app):
-    web_app = server_app.web_app
-
-    nbconvert_template_paths = []
-    static_paths = [STATIC_ROOT]
-    template_paths = []
-
-    # common configuration options between the server extension and the application
-    voila_configuration = VoilaConfiguration(parent=server_app)
-    collect_template_paths(
-        nbconvert_template_paths,
-        static_paths,
-        template_paths,
-        voila_configuration.template
-    )
-
-    jenv_opt = {"autoescape": True}
-    env = Environment(loader=FileSystemLoader(template_paths), extensions=['jinja2.ext.i18n'], **jenv_opt)
-    web_app.settings['voila_jinja2_env'] = env
-
-    nbui = gettext.translation('nbui', localedir=os.path.join(ROOT, 'i18n'), fallback=True)
-    env.install_gettext_translations(nbui, newstyle=False)
-
-    host_pattern = '.*$'
-    base_url = url_path_join(web_app.settings['base_url'])
-
-    web_app.add_handlers(host_pattern, [
-        (url_path_join(base_url, '/voila/render' + notebook_path_regex), VoilaHandler, {
-            'config': server_app.config,
-            'nbconvert_template_paths': nbconvert_template_paths,
-            'voila_configuration': voila_configuration
-        }),
-        (url_path_join(base_url, '/voila'), VoilaTreeHandler),
-        (url_path_join(base_url, '/voila/tree' + path_regex), VoilaTreeHandler),
-        (url_path_join(base_url, '/voila/static/(.*)'), MultiStaticFileHandler, {'paths': static_paths}),
-    ])
-
-    # Serving notebook extensions
-    if voila_configuration.enable_nbextensions:
-        # First look into 'nbextensions_path' configuration key (classic notebook)
-        # and fall back to default path for nbextensions (jupyter server).
-        if 'nbextensions_path' in web_app.settings:
-            nbextensions_path = web_app.settings['nbextensions_path']
-        else:
-            nbextensions_path = jupyter_path('nbextensions')
-
-        web_app.add_handlers(host_pattern, [
-            # this handler serves the nbextensions similar to the classical notebook
-            (
-                url_path_join(base_url, r'/voila/nbextensions/(.*)'),
-                FileFindHandler,
-                {
-                    'path': nbextensions_path,
-                    'no_cache_paths': ['/'],  # don't cache anything in nbextensions
-                },
-            )
-        ])
diff --git a/voila/static_file_handler.py b/voila/static_file_handler.py
deleted file mode 100644
index 3a7eb393c..000000000
--- a/voila/static_file_handler.py
+++ /dev/null
@@ -1,39 +0,0 @@
-#############################################################################
-# Copyright (c) 2018, Voila Contributors                                    #
-#                                                                           #
-# Distributed under the terms of the BSD 3-Clause License.                  #
-#                                                                           #
-# The full license is in the file LICENSE, distributed with this software.  #
-#############################################################################
-
-import os
-
-import tornado.web
-
-
-class MultiStaticFileHandler(tornado.web.StaticFileHandler):
-    """A static file handler that 'merges' a list of directories
-
-    If initialized like this::
-
-        application = web.Application([
-            (r"/content/(.*)", web.MultiStaticFileHandler, {"paths": ["/var/1", "/var/2"]}),
-        ])
-
-    A file will be looked up in /var/1 first, then in /var/2.
-
-    """
-
-    def initialize(self, paths, default_filename=None):
-        self.roots = paths
-        super(MultiStaticFileHandler, self).initialize(path=paths[0], default_filename=default_filename)
-
-    def get_absolute_path(self, root, path):
-        # find the first absolute path that exists
-        self.root = self.roots[0]
-        for root in self.roots:
-            abspath = os.path.abspath(os.path.join(root, path))
-            if os.path.exists(abspath):
-                self.root = root  # make sure all the other methods in the base class know how to find the file
-                break
-        return abspath
diff --git a/voila/treehandler.py b/voila/treehandler.py
index ebcef52e0..170a4c4eb 100644
--- a/voila/treehandler.py
+++ b/voila/treehandler.py
@@ -8,11 +8,13 @@
 
 from tornado import web
 
-from jupyter_server.base.handlers import JupyterHandler
+from jupyter_server.extension.handler import ExtensionHandler
 from jupyter_server.utils import url_path_join, url_escape
 
 
-class VoilaTreeHandler(JupyterHandler):
+class VoilaTreeHandler(ExtensionHandler):
+    extension_name = "voila"
+
     def get_template(self, name):
         """Return the jinja template object for a given name"""
         return self.settings['voila_jinja2_env'].get_template(name)