In this blog post, we'll take a look at some of the new features released with Livebook 0.8.1. Let's dive in!

The new file input

One of the goals of Livebook is to enable you to build interactive notebooks. That means offering various input elements that allow users to input data into the notebook.

This new version comes with two new inputs, one of them is the file input. You can use it to allow the user of your notebook to upload a file that the notebook will process.

There are many scenarios where this can be useful, for example, data exploration. Let's see how the new input can be used to explore data in a CSV file.

The new audio input

Another new input available in this release is the audio input.

It provides two options for uploading audio data: recording using a microphone or uploading an audio file.

Let's see an example of this new input in action.

Support for capturing images from the camera in the image input

The image input was first introduced in Livebook 0.8.0. With this new release, it has been improved to include the ability to take a picture using the computer's camera, in addition to uploading an image file.

Let's see how it works.

This feature was contributed by Cocoa Xu. 

Option to run the Setup cell without cache

A new option has been added to run the setup cell without cache. This can be useful when you want to force the dependencies of your notebook to be installed again from scratch.

While this was previously possible through the :force option of Mix.install/2:

Mix.install(
    [
        {:kino, "~> 0.8.1"}
    ],
    force: true
)

With this new release, it's now as simple as clicking a button:

Loading LB_ environment variables as Livebook secrets

Secrets management is a feature that was added in Livebook 0.7. It allows you to securely handle sensitive data, such as passwords and API keys.

Before this release, the UI was the only way to add secrets to Livebook. But now, there's another way.

You can provision Livebook Secrets through environment variables on the machine running your Livebook instance. Just create environment variables starting with LB_, such as LB_API_KEY or LB_DATABASE_PASSWORD, and Livebook will load them as Secrets.

This can be especially useful when running Livebook on platforms like Fly.io and Hugging Face. This means you can set up secrets on their panels, and they will directly appear in Livebook.

Let's see how that works for running Livebook via Docker.

Docker images with CUDA libraries

Last but not least, we also started to distribute Livebook via Docker images with CUDA libraries installed.

CUDA is a parallel computing platform and API that allows software to take advantage of the power of GPUs. This is particularly useful in technical fields where parallel programming can be applied, such as Machine Learning (ML).

Now running Stable Diffusion on your GPU directly from Livebook is even easier!

Try it!

To play with the new features, all you need to do is:

• Install the new Livebook version
• Import the notebook containing a demo of the new features by clicking on the badge below

Happy hacking!

Livebook 0.8 was launched a few weeks ago, and the highlight of that release was the new Neural Network Smart cell. But there are many other exciting updates included as well.

In this blog post, we will showcase ten of the most noteworthy features released with Livebook 0.8.

New mechanism for tracking how cells depend on each other

A known pain point of computational notebooks is reproducibility. But Livebook already solved that by enabling truly reproducible workflows. This was accomplished by the fact that the Livebook execution model is fully sequential, and there is no global mutable state.

Still, there was a downside with that fully sequential model. Whenever a cell was evaluated, all subsequent cells were marked as stale and required reevaluation. That happened regardless of whether those cells depended on the evaluated cell.

Not anymore!

This new release now tracks how cells depend on each other and only marks subsequent cells as stale if necessary. Let's see how that works.

Let's say you have four code cells like that:

Look how cell 4 depends on cell 1 and cell 2, but doesn't depend on cell 3. And notice how cell 4 simulates a computation that takes some time to finish.

Before Livebook 0.8, if you changed cell 3, cell 4 would become stale, even though cell 4 didn't depend on cell 3. And you'd need to reevaluate it:

With Livebook 0.8, when you change cell 3, Livebook knows that although cell 4 is subsequent to cell 3, it doesn't depend on it, so it doesn't mark cell 4 as stale anymore:

No more need to waste time waiting for unnecessary cell reevaluation!

Automatic execution of doctests

One cool feature of Elixir is Doctests. It helps you ensure that your documentation is up to date with your code.

This new release integrates Doctests natively into Livebook.

Now, whenever you evaluate a cell that contains a module definition with doctests, Livebook will automatically run those doctests for you and will show you the output:

We're planning to streamline that workflow even more in future releases.

Render math in on-hover documentation

Elixir has an amazing developer experience when it comes to documentation. And Livebook aims to leverage that.

Before this new release, Livebook already supported seeing the documentation of a module or function when you hover over it:

Now, the on-hover documentation also supports those fancy math documentation of yours (based on KaTeX)

View and delete secrets in the sidebar

Livebook 0.7 introduced secret management. A solution to help you manage sensitive data used by your notebooks, like passwords and API keys.

With this new release, you can also view and delete those secrets in the notebook sidebar:

Support for image input

Livebook enables you to add a variety of user inputs to your notebooks, making them interactive and parametrizable.

This new release comes with a new input that allows the user of your notebook to upload images:

Visualization of nested data as a tree view

Inspecting a nested data structure can be hard when it gets big. For example, when you want to check the result of an HTTP API call.

With Kino 0.8 that accompanies the Livebook release, you can now visualize and inspect nested data in a tree view, so it gets easier to understand it:

This was a community contribution by Stefan Chrobot. He started the project during Spawnfest and won 2nd place overall. Shout out to him!

Neural Network Smart cell

We discussed that new feature in detail in a previous post. But it's so cool that we thought it was worth mentioning it again here.

That new Smart cell allows you to run various machine learning models directly in Livebook with just a few clicks. Here's an example of a text classification model:

Slack Message Smart cell

Let's say you want to send a notification to your Slack after your notebook completes some automation.

With the new Slack Smart cell, that's dead easy:

Geocoding in Map Smart cell

The Map Smart cell got even better. Now besides accepting data as latitude and longitude, you can also use the names of countries, states, cities, counties, and streets.

Let's see how that works:

More options to configure charts with the Chart Smart Cell

We added new options to help you customize your charts even more.

You can now toggle the bin config to discretize numeric values into a set of bins. This is useful for creating histograms, for example. Here's how it works:

Another new option is the color scheme. You can now choose your chart's color from a set of named color palettes. Here's how it works:

Last but not least, let's check the new scale config. You can use it to change the scale type of your chart, for example, from a linear to a log scale. Let's see how it works:

Try it!

To play with the new features, all you need to do is:

• Install the new Livebook version
• Import a notebook containing a demo of the new features by clicking on the badge below

Happy hacking!

Livebook v0.7 is out! This is a major release coming with significant features in the following areas:

• secret management
• visual representations of the running system (supervision trees, inter-process messaging, and more)
• an interactive user interface to visualize and edit Elixir pipelines

Let’s take a look at each of those.

We also created a video showing each one of those features:

Secret management

We know that putting sensitive data in your code, like passwords and API keys, is a security risk. With this new v0.7 release, Livebook has an integrated way to help you deal with that. We’re calling it Secrets. Let’s see an example.

Let’s say you’re writing a notebook that consumes data from an API that requires authentication:

api_username = "postman"
api_password = "password"

Req.get!("https://postman-echo.com/basic-auth", auth: {api_username, api_password})

This piece of code is hardcoding API username and password, but you want to avoid that. You can do that by creating two Livebook secrets, one for the API username and one for the API password:

Now, you can refactor your code to get the username and password values from those secrets by using System.fetch_env!/1:

api_username = System.fetch_env!("LB_API_USERNAME")
api_password = System.fetch_env!("LB_API_PASSWORD")

Req.get!("https://postman-echo.com/basic-auth", auth: {api_username, api_password})

Notice that Livebook adds an LB_ namespace to the environment variable name.

Let’s say you share with a co-worker that notebook that is using Livebook Secrets. If that person doesn’t have those secrets configured in their Livebook instance yet, when they run the notebook, Livebook will automatically ask them to create the required secrets! No more hidden secrets (pun intended 🤭). Here’s what it looks like:

The new Secrets feature is also already integrated with Database Connection Smart cells. When you’re creating a connection to PostgreSQL or Amazon Athena, Livebook will give you the option to use a Secret for the database password:

With Livebook Enterprise, you will be able to share secrets within your team and company. This allows notebooks to be safely versioned and distributed, even if they contain credentials or other restricted information.

Visual representations of the running system

One interesting aspect of coding is that it can feel like we’re “building castles in the air.” We can build something with our thoughts materialized by code, which is amazing!

But, because of the intangible nature of code, sometimes it can be hard to reason about it. When reading a piece of code, you’re simultaneously building a representation of how it works inside your mind. What if you could get some help with visualizing that?

That’s when the idea of “a picture is worth a thousand words” comes in handy.

Imagine someone who’s learning Elixir. The person is learning message passing between processes, and they are analyzing the following example:

parent = self()

child =
  spawn(fn ->
        receive do
            :ping -> send(parent, :pong)
        end
    end)

send(child, :ping)

receive do
    :pong -> :ponged!
end

Instead of making the person create a representation of how that code works only through text, we could show them a visual representation of it.

Since v0.5, Livebook has a way to show visual widgets to the user, through its Kino package. And with this v0.7 release, we have a new Kino widget to show a visual representation of message passing between Elixir processes.

All you need to do is wrap your code with Kino.Process.render_seq_trace/2:

Seeing a visual representation of code is not only applicable when you’re just getting started with Elixir. Imagine, for example, you need to code something that performs a job concurrently, and you discover Elixir’s Task.async_stream/3. You read its documentation and understand its API, but you also want to learn more about how it orchestrates multiple processes. You could use Livebook to visualize that:

Besides visualizing message passing, you can now use Livebook to visualize a supervision tree. You can do that by calling the Kino.Process.render_sup_tree/2 function with the supervisor’s PID:

Livebook will also automatically show you a supervision tree if your cell returns the PID of a supervisor:

Interactive user interface to visualize and edit Elixir pipelines

Elixir 1.14 came with a fantastic new feature for debugging called dbg. It can do many things, one of which is to help inspect a pipeline. So we thought, “how would dbg work inside Livebook?”

Maybe we could do some visualization of the pipeline, showing the result of each pipeline step, as the regular dbg does. But, since we’re already in a more visual environment, we went one step further. We built not only a visualization of an Elixir pipeline but also the ability to edit and interact with it!

Let’s say you run the following pipeline inside Livebook:

"Elixir is cool!"
|> String.trim_trailing("!")
|> String.split()
|> List.first()
|> dbg()

When you do that, Livebook will show a widget that you can use to:

• see the result of the pipeline
• enable/disable a pipeline step
• drag and drop a pipeline step to re-order the pipeline

Here’s what it looks like:

This can be very helpful if you’re trying to understand what each step of a pipeline is doing. Ryo Wakabayashi created a cool example showing how that could be applied to a pipeline that is using Elixir to process an image using Evision:

image_path
|> OpenCV.imread!()
|> OpenCV.blur!([9, 9])
|> OpenCV.warpAffine!(move, [512, 512])
|> OpenCV.warpAffine!(rotation, [512, 512])
|> OpenCV.rectangle!([50, 10], [125, 60], [255, 0, 0])
|> OpenCV.ellipse!([300, 300], [100, 200], 30, 0, 360, [255, 255, 0], thickness: 3)
|> Helper.show_image()
|> dbg()

Other notable features and improvements

Besides those three big features, this new version contains many other news. You can check our GitHub repo’s changelogs to see everything that comes with this new version.

• Livebook’s changelog
• Kino’s changelog
• KinoDB’s changelog

Organize your cell output with a tab or grid layout

You can now use Kino.Layout.tabs/1 to show the output of your cell in tabs. Here’s an example of how to do it:

data = [
    %{id: 1, name: "Elixir", website: "https://elixir-lang.org"},
    %{id: 2, name: "Erlang", website: "https://www.erlang.org"}
]

Kino.Layout.tabs(
    Table: Kino.DataTable.new(data),
    Raw: data
)

Here’s what it looks like:

You can also use Kino.Layout.grid/2 to show the output of your cell in a grid. Here’s an example of how to do it:

urls = [
  "https://images.unsplash.com/photo-1603203040743-24aced6793b4?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=580&h=580&q=80",
  "https://images.unsplash.com/photo-1578339850459-76b0ac239aa2?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=580&h=580&q=80",
  "https://images.unsplash.com/photo-1633479397973-4e69efa75df2?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=580&h=580&q=80",
  "https://images.unsplash.com/photo-1597838816882-4435b1977fbe?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=580&h=580&q=80",
  "https://images.unsplash.com/photo-1629778712393-4f316eee143e?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=580&h=580&q=80",
  "https://images.unsplash.com/photo-1638667168629-58c2516fbd22?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8&auto=format&fit=crop&w=580&h=580&q=80"
]

images =
    for {url, i} <- Enum.with_index(urls, 1) do
        image = Kino.Markdown.new("![](#{url})")
    label =  Kino.Markdown.new("**Image #{i}**")
        Kino.Layout.grid([image, label], boxed: true)
    end

Kino.Layout.grid(images, columns: 3)

Here’s what it looks like:

Universal desktop build for Mac and automated nightly builds

We made some improvements in the build process of Livebook Desktop.

First, we unified the Mac Intel and Mac Silicon download files into a single Mac Universal file. No need to ask yourself if you’re supposed to download the Intel or Silicon distribution. Pretty neat!

Second, we automated the build process of generating Livebok Desktop. We’re using that to do nightly builds of Livebook Desktop based on the main branch of our GitHub repo.

That means now you can use our nightly builds to download Livebook Desktop and play with the new features we’re still working on before we launch a new release. 😉

Try it!

To play with the new features all you need to do is:

1. Install the new Livebook version
2. Import this notebook containing a demo of the new features

Our team put a lot of effort into this new release, and we’re very excited about it! We hope you like it too.

Happy hacking!

Livebook v0.6 is out with a number of exciting features! Join us, as we go from a database connection to charting the data in a few simple steps:

Below is a quick overview of the biggest features in this new version.

Smart cells

Livebook v0.6 introduces a new type of cells to help you automate and master entire coding workflows! Smart cells are UI components for performing high-level tasks, such as charting your data:

We already have a couple Smart cells - including connection to PostgreSQL and MySQL - but the best part is that anyone can create new Smart cells and share with the community. We can't wait to automate workflows from HTTP requests to Machine Learning models!

Package search

The new version also brings a much more integrated dependency management, including the new package search and the setup cell:

Error highlighting

You will also find better error reporting! Spot typos and syntax errors right away with the new squiggly lines:

Streamlined diagrams

In the previous release we introduced support for Mermaid.js diagrams in Markdown cells. It's now even easier with the new Diagram button:

There's more

There are many other notable features, including "code zen" and persistent configuration. Check out the technical release notes for the complete list of changes.

Livebook v0.5 is out with a number of goodies! We have recorded a video showing how to use those features to build chat apps, multiplayer games, and more:

In case you can't watch it, here is a rundown of the biggest features.

Flowcharts with Mermaid.js

Many teams are using Livebook for documentation. v0.5 improves on this use case by allowing users to embed Mermaid.js diagrams and visualizations:

Define your Mermaid.js definitions inside ```mermaid blocks and you are good to go!

Custom widgets

You can now add your own widgets to Livebook, known as Kinos in Livebook terminology. Build chat apps, multiplayer games, interactive maps, and more! It doesn't matter what is your domain area, you can now make Livebook as powerful as you want.

We have revamped our Explore guides to include a complete course on Kino with several examples:

Other improvements

• You can now increase the editor font-size and pick a high-contrast theme. We also improved the contrast and accessibility in several places.
  
  
• The code editor now supports auto-completion of structs fields and shows additional metadata about functions, such as which version they were added and deprecation notices.

Check out the technical release notes for the complete list of changes.

We are glad to announce Livebook, an open source web application for writing interactive and collaborative code notebooks in Elixir and implemented with Phoenix LiveView. Livebook is an important step in our journey to enable the Erlang VM and its ecosystem to be suitable for numerical and scientific computing.

José Valim has recorded a screencast that highlights some Livebook features, which you can watch below. It also showcases the Axon library, for building Neural Networks in Elixir, as well as some improvements coming in Elixir v1.12:

Features

If you can’t yet watch the video, here is a summary of Livebook features:

• A deployable web app built with Phoenix LiveView where users can create, fork, and run multiple notebooks.
  
  
• Each notebook is made of multiple sections: each section is made of Markdown and Elixir cells. Code in Elixir cells can be evaluated on demand. Mathematical formulas are also supported via KaTeX.
  
  
• Persistence: notebooks can be persisted to disk through the .livemd format, which is a subset of Markdown. This means your notebooks can be saved for later, easily shared, and they also play well with version control.
  
  
• Sequential evaluation: code cells run in a specific order, guaranteeing future users of the same Livebook see the same output. If you re-execute a previous cell, following cells are marked as stale to make it clear they depend on outdated notebook state.
  
  
• Custom runtimes: when executing Elixir code, you can either start a fresh Elixir process, connect to an existing node, or run it inside an existing Elixir project, with access to all of its modules and dependencies. This means Livebook can be a great tool to provide live documentation for existing projects.
  
  
• Explicit dependencies: if your notebook has dependencies, they are explicitly listed and installed with the help of the Mix.install/2 command in Elixir v1.12+.
  
  
• Collaborative features allow multiple users to work on the same notebook at once. Collaboration works either in single-node or multi-node deployments - without a need for additional tooling.