Starting point
- Mercury
- Your existing Jupyter notebook (.ipynb)
- Voila
- An existing Jupyter notebook (.ipynb)
Notebook app comparison · Reviewed August 2026
Mercury vs Voila: Turn Notebooks into Web Apps
Both preserve your notebook, and both work with existing ipywidgets. Mercury also gives you a reactive widget layer, ready-made themes, a home page for multiple notebooks, a login screen, and one-click cloud deployment.
Keep the Jupyter widgets you already have, or use Mercury widgets when you want downstream cells to rerun automatically without writing observe callbacks.
hello.ipynb · Mercury widgets
[1]
import mercury as mr[2]
name = mr.TextInput(label="What is your name?")[3]
mr.Markdown(f"## Hello {name.value}! 👋")hello.ipynb · ipywidgets work in both
[1]
import ipywidgets as widgets
from IPython.display import display, Markdown[2]
name_input = widgets.Text(
description="What is your name?"
)
output = widgets.Output()[3]
def on_change(change):
with output:
output.clear_output()
display(Markdown(
f"## Hello {change['new']}! 👋"
))[4]
name_input.observe(on_change, names="value")
display(name_input, output)The short answer
Choose Mercury when you want to keep your existing Jupyter widgets and add a more complete application layer around them.
- Run existing ipywidgets and compatible Jupyter widgets.
- Add reactive Mercury inputs without observe callbacks.
- Apply ready-made themes or configure the app style.
- Protect an app with login and deploy it to MLJAR Cloud.
Quick answer
Why Mercury is the more complete notebook app framework
Both preserve the .ipynb file and its Jupyter widgets. Mercury adds an optional reactive model, application styling, access options, and a managed deployment path.
Application shell
- Mercury
- Built-in layout, notebook settings, and multi-app home page
- Voila
- Notebook rendering with themes and customizable templates
Widget layer
- Mercury
- ipywidgets and compatible widgets, plus Mercury’s reactive widgets
- Voila
- Jupyter widgets, including ipywidgets and compatible libraries
Wiring interactivity
- Mercury
- Existing widget callbacks work; Mercury widgets can rerun downstream cells automatically
- Voila
- Define widget behavior in the notebook, often with observe callbacks
Code visibility
- Mercury
- Show code control in the app toolbar
- Voila
- strip_sources; input cells are hidden by default
Theming
- Mercury
- Ready-made themes plus configurable colors, typography, layout, and app chrome
- Voila
- Themes plus custom nbconvert and Jinja templates
Notebook directory
- Mercury
- Generated home page for multiple notebooks
- Voila
- Built-in tree page for a notebook directory
Access options
- Mercury
- Built-in shared-password login; private cloud apps available on paid plans
- Voila
- Authentication depends on the surrounding Jupyter deployment
License
- Mercury
- Apache-2.0
- Voila
- BSD-3-Clause
Deployment
- Mercury
- One-click MLJAR Cloud deployment with a free plan, or self-host with Docker
- Voila
- Self-host or use a general-purpose hosting platform
Best fit
- Mercury
- Existing widget notebooks or new reactive apps, with styling and managed deployment
- Voila
- Existing Jupyter-widget apps and deep template customization
Widget compatibility
Mercury gives you two ways to build
Run the Jupyter widgets already in your notebook, or use Mercury widgets when you want automatic downstream cell execution.
Existing notebook · Works in Mercury and Voilà
[1]
import ipywidgets as widgets
from IPython.display import display, Markdown[2]
name_input = widgets.Text(
description="What is your name?"
)
output = widgets.Output()[3]
def on_change(change):
with output:
output.clear_output()
display(Markdown(
f"## Hello {change['new']}! 👋"
))[4]
name_input.observe(on_change, names="value")
display(name_input, output)Mercury preserves this ipywidgets callback pattern just as Voilà does. No migration is required.
Optional simpler path · Mercury widgets
[1]
import mercury as mr[2]
name = mr.TextInput(label="What is your name?")[3]
mr.Markdown(f"## Hello {name.value}! 👋")Read .value normally; Mercury reruns the cells below the widget.
Mercury can serve the same Jupyter-widget notebooks as Voilà. Existing ipywidgets controls, .observe() callbacks, and compatible widget libraries continue to work, so moving an interactive notebook to Mercury does not require replacing its widget layer.
Mercury widgets are an additional path. With mr.TextInput, mr.Select, and the rest of Mercury’s widget library, you read .value and let Mercury rerun the downstream cells. You can choose the simpler reactive model for new interactions without giving up the Jupyter widgets already present in the notebook.
Code visibility
Both can hide implementation details. Mercury provides a Show code control in the toolbar. Voilà hides notebook input cells by default through strip_sources, and you can disable that setting when viewers should see the code.
Theming and templates
Mercury offers ready-made themes and a compact configuration for typography, colors, surfaces, widgets, navigation, and app details. Voilà still goes deeper for teams that want to maintain custom nbconvert or Jinja templates and control the rendered HTML directly.
Explore Voilà customizationMercury styles
A polished app without building a template
Start from a ready-made config.toml style and adjust the theme tokens for your product, report, or internal tool.
Minimal Light
A clean, neutral application theme for reports and everyday dashboards.
Editorial Serif
A warmer publication-style theme for research, reports, and narrative analysis.
Dark Ops
A high-contrast dark theme for operational dashboards and internal tools.
Built-in access protection
Put your notebook app behind a login
A dashboard for your team does not need to be public. Mercury can show a login page before anyone reaches the notebook app. For self-hosting, add one flag when the server starts:
mercury --pass=your-secret-here
This built-in option provides one shared password. Private MLJAR Cloud apps with individual access are available on paid plans.
Deployment
Publish to MLJAR Cloud with one click
Skip server setup, Docker configuration, and infrastructure management. MLJAR Studio can publish a Mercury notebook directly to MLJAR Cloud.
Start with one public app
The MLJAR Free plan includes one public Mercury web app. Create your notebook, click deploy, and share its URL without operating a server or entering a credit card.
Deploy a Mercury app for freeUpgrade when access must be private
Paid plans add private Mercury app capacity while preserving the same simple deployment flow. You can also self-host with Docker when your organization needs complete infrastructure control.
Compare publishing limitsVoilà has no dedicated managed deployment service. Its documentation covers general-purpose options such as Binder and Railway, so publishing usually involves more hosting setup than the MLJAR Cloud path.
Decision guide
Which one fits your project
Both tools take a finished notebook and serve it as a web app, and both render ipywidgets. The difference is how much you build yourself after that.
Choose Mercury if
- You want interactivity without observe callbacks—a widget change reruns the cells below it, so the notebook stays readable from top to bottom.
- You want the theme, sidebar, and code visibility controlled by a few settings instead of a maintained template.
- You need login protection and would rather not put JupyterHub or a reverse proxy in front of the app.
- You want to deploy without running a server yourself, including on a free plan.
- You want uploads and downloadable generated files as ready-made app widgets instead of building the file flow yourself.
- You are publishing several notebooks as one site with titles and descriptions rather than a file listing.
Choose Voilà if
- Your app leans on the wider Jupyter widget ecosystem—bqplot, ipyleaflet, ipympl, or ipysheet—and you want its reference renderer.
- Your callbacks are already written, and you need one widget to update one output instead of rerunning downstream cells.
- You want pixel-level layout control through nbconvert and Jinja templates, or a drag-arranged grid.
- You already run the infrastructure—JupyterHub, Kubernetes, or SSO at the proxy—and want the app served inside it.
- You prefer a focused renderer maintained in the Jupyter ecosystem.
If neither fits—because you need URL routing, multi-page state, or a custom frontend—you are probably looking for Dash, Panel, or a general web framework rather than a notebook renderer.
FAQ
Questions about Mercury and Voila
Can Mercury run a notebook that already uses ipywidgets?+
Yes. Mercury supports existing ipywidgets and compatible Jupyter widgets, including the callbacks already defined in the notebook. Mercury widgets are an additional option that can rerun downstream cells automatically; they do not replace or block ipywidgets.
Can I hide my code in both?+
Yes. Voilà hides notebook input cells by default with strip_sources, which can be disabled when source code should remain visible. Mercury provides a Show code control in the application toolbar.
Can I put a Mercury app behind a login screen?+
Yes. For a self-hosted app, start Mercury with the --pass option to show a shared-password login before the app opens. MLJAR Cloud also supports private Mercury apps on paid plans.
Is there a free managed hosting option for Voilà?+
Voilà has no dedicated managed cloud service. Binder can launch public repositories, but environments are temporary and builds can take time. MLJAR Cloud has a free plan that includes one public Mercury web app; paid plans add private app capacity.
What is Voici?+
Voici combines Voilà with JupyterLite to build static, browser-based notebook applications. The output can be hosted on GitHub Pages or another static web server, subject to the libraries and kernels supported in the browser.
Which is easier for someone new to notebooks?+
Mercury is usually easier for a first interactive app because you read a widget value and let downstream cells rerun. Voilà is especially natural when you already understand Jupyter widgets or already have an interactive ipywidgets notebook.
Publish a complete notebook app with Mercury
Keep your existing ipywidgets, add reactive inputs where useful, and publish with application styling, access control, and a clear deployment path.
pip install mercury