![](\"https://img.announcekit.app/d175e7d24151611cf549a6edc8691f87?s=6e4d0933c7ea13764ca693096981787a\")
We're excited to share a batch of new features in Livebook Teams to help you manage access and keep your deployed apps organized.
Here's what's new.
Control access to your Livebook apps and servers using your existing Google Workspace groups.
Manage access right from Google Workspace. Add someone to a group, and they instantly get access to the right apps in Livebook Teams.
To get started, set up Google Workspace as your SSO provider in Livebook Teams, then map your Google groups to control access at the app server or app level.
Check the docs for setup instructions.
The new deployed apps page helps you stay organized as your collection of internal tools grows.
Organize apps into folders, search by name, and filter by folder. Quickly find the runbook or admin tool you need without scrolling through long lists.
Control who can access apps in each folder once you've organized them.
For example, give your ops team access to a \"production-runbooks\" folder, while your support team can use a \"support-tools\" folder.
Combine this with Google Workspace integration to map folders to Google groups for seamless access management.
Open notebooks directly from your private Git repository inside your Livebook app server.
This is great for template notebooks and runbooks you version in Git. Your team can browse and open them straight from the repository, no manual imports needed.
We now have full documentation on audit logs, showing how to track who ran what code and when.
Audit logs are essential for production. When someone runs a runbook that changes production data or system state, you'll have a clear record of who did it and when.
To start using these features, update to Livebook v0.18 or newer and configure them in your Teams organization settings.
", "url": "https://news.livebook.dev/new-in-livebook-teams-google-workspace-integration-app-folders-and-more-1y0y64", "title": "New in Livebook Teams: Google Workspace integration, App folders, and more", "summary": "We're excited to share a batch of new features in Livebook Teams to help you manage access and keep your deployed apps organized. Here's wha...", "date_modified": "2025-12-03T16:41:51.181Z", "tags": [ "releases" ] }, { "id": "396818", "content_html": "Livebook v0.14 is here with new features that make navigating your code easier than ever.
No more endless scrolling through a notebook to find module or function definitions — Livebook v0.14 has you covered.
When you define an Elixir module in a code cell, it will now be listed in the Outline panel in the sidebar.
The Outline panel, previously known as the Sections panel, now gives you a structured view of your code. It lists all the modules defined within each section of your notebook.
You can also use this panel to navigate to module definitions. Just click on a module's name on the Outline, and your notebook will automatically scroll to the position where it is defined.
Here's a video showing how it works:
Want to see how we built this? Here's the pull request.
Not only can you quickly navigate to the definition of a module, but you can also quickly go to the definition of a function.
To do that, hover over a module or function you defined in your notebook, hold Command ⌘ (for macOS) or Ctrl (for Windows/Linux), and click on the module or function call.
Here's a video showing how it works:
You can also access this feature through the link shown in the intellisense for a module or function call:
Want to see how we built this? Here are the pull requests: #2730, #2741.
We're dedicated to continually improving the Livebook developer experience, and these new features are another step in that journey.
Feel free to check out the v0.14 changelog to discover all the features and changes in this newest release.
Happy hacking!
", "url": "https://news.livebook.dev/code-navigation-with-go-to-definition-of-modules-and-functions-kuYrS", "title": "Code navigation with go to definition of modules and functions", "summary": "Learn how Livebook v0.14 improves code navigation with new features like module definitions in the Outline panel and go-to-definition for faster coding.", "date_modified": "2024-09-12T12:49:11.786Z", "tags": [ "releases" ] }, { "id": "391049", "content_html": "We are thrilled to announce the release of a new version of Livebook!
This version includes numerous new features and improvements. Today, we will highlight one of the most significant additions: Kino.Proxy.
By using Kino.Proxy, you can now expose API endpoints directly from your notebook or Livebook app.
Let's take a look at how it works.
Here's a simple \"hello world\" example:
Kino.Proxy.listen(fn conn ->\n Plug.Conn.send_resp(conn, 200, \"hello world!\")\nend)
The Kino.Proxy.listen/1 function makes Livebook expose API endpoints and will proxy requests to the handler function passed to it.
That handler function receives a Plug.Conn as an argument and should use the Plug API to send a response to the client.
Let's see a video with a simple example working:
You can also provide a module plug as an argument to Kino.Proxy.listen/1, like this:
defmodule MyPlug do\n def init([]), do: false\n\n def call(conn, _opts) do\n Plug.Conn.send_resp(conn, 200, \"hello world!\")\n end\nend\n\nKino.Proxy.listen(MyPlug)
Since our API handler is a plug, we can leverage other plugs. For example, here's how to use Plug.Router to handle multiple endpoints:
defmodule ApiRouter do\n use Plug.Router\n\n plug :match\n plug :dispatch\n\n get \"/hello\" do\n send_resp(conn, 200, \"hello from router\")\n end\n\n get \"/echo/:message\" do\n send_resp(conn, 200, String.upcase(message))\n end\n\n match _ do\n send_resp(conn, 404, \"oops, not found\")\n end\nend\n\nKino.Proxy.listen(ApiRouter)
This new feature enables an exciting new possibility: a Livebook app can now use Kino.Proxy to handle external HTTP requests, allowing code execution triggered by an external system.
Let’s see an example.
We built a Livebook app that tracks how many days we don't have a broken build in a GitHub repository:
Whenever a new build finishes in the configured Github Repo, GitHub sends a webhook to the Livebook app, which processes the request to update its state.
To handle webhooks inside the Livebook app, we could combine Plug.Router with Kino.listen/1 like this:
defmodule ApiRouter do\n use Plug.Router\n\n plug(:match)\n plug(Plug.Parsers, parsers: [:json], json_decoder: Jason)\n plug(:dispatch)\n\n post \"/webhook\" do\n process_webhook(conn.body_params)\n\n conn\n |> put_resp_content_type(\"application/json\")\n |> send_resp(200, ~s({\"message\": \"ok\"}))\n end\n\n match _ do\n conn\n |> put_resp_content_type(\"application/json\")\n |> send_resp(404, ~s({\"message\": \"not found\"}))\n end\n\n defp process_webhook(webhook_payload) do\n # Logic to do something with the webhook payload\n end\nend\n\nKino.Proxy.listen(ApiRouter)
Here's a quick video with a demo of that app:
Here's the source code for that Livebook app so you can understand how it works under the hood.
If you want to run the app by yourself, click here.
We believe that APIs with Kino.Proxy open Livebook to a new category of use cases.
For example, you can quickly build an API that receives a request from Zapier to automate internal processes.
We're looking forward to seeing what you will build it with!
One last thing: Livebook 0.13 has plenty more, and you can view all of them in our changelog.
We plan to share quicker demos of other Livebook 0.13 features on our X/Twitter, so feel free to follow us there.
Happy hacking!
", "url": "https://news.livebook.dev/livebook-0.13-expose-an-http-api-from-your-notebook-2wE6GY", "title": "Livebook 0.13: expose an HTTP API from your notebook", "summary": "Expose API endpoints directly from your Livebook notebooks with the new Kino.Proxy feature in Livebook 0.13. Learn how to handle external HTTP requests and integrate with other applications seamlessly.", "date_modified": "2024-07-05T12:19:57.960Z", "tags": [ "releases" ] }, { "id": "379726", "content_html": "We're thrilled to announce Tigris as the latest Livebook sponsor!
Tigris is a globally distributed S3-compatible object storage service that provides low latency anywhere in the world.
We've prepared a short demo showcasing the Tigris API through Livebook (of course 😉) to highlight its capabilities.
You'll find Tigris intuitive if you're familiar with other object storage services like AWS S3. Here's an example of saving an object to a Tigris bucket:
ExAws.S3.put_object(\"my_tigris_bucket_name\", \"cat.jpeg\", image)\n|> ExAws.request!()
Notice we're using an AWS S3 client. Thanks to Tigris's S3-API compatibility, transitioning your code requires minimal changes.
Let's say the object is uploaded to a public bucket; to retrieve it, it's just a simple HTTP GET:
![](\"https://img.announcekit.app/50bcd9d45263ba6aefd4bf876170152e?s=e972198a6951c1145dfd358bf675529f\")
![](\"https://img.announcekit.app/2bf4992ffa80fba9a69a0cd6db09deb4?s=b3cc05d646728d96618d42e5a036b487\")
![](\"https://img.announcekit.app/e43bc4053ce1f6e7d0c5eb44d3fb5518?s=6fc6651cc4fadd122e3b68f6584ed53b\")
![](\"https://img.announcekit.app/4739ab1cd41e7be1c12296253dc8e4c5?s=bc9530e54d3a08fa5cd6642ca536e852\")
![](\"https://img.announcekit.app/6e1782f6f6c4690f24f0717b622dc802?s=c792e2ee8c271999fc6f6e83a4c6e54b\")
![](\"https://img.announcekit.app/baa9d681e635dff05888abd0f96d38b3?s=ba24080f8ad3f29670230f70a0aeb188\")
![](\"https://img.announcekit.app/0ebc523813217eea4646c09d5c25077c?s=2716fd8a93bfdcbfc6399933b13f93eb\")
![](\"https://img.announcekit.app/fbe1ee696734e251cd2dacb37e5a62ee?s=9b1ef31409aac78661ac20c26ef524f2\")
object_url = \"https://fly.storage.tigris.dev/my_tigris_bucket_name/cat.jpeg\"\nReq.get!(object_url)Simple, right? Now for the real game-changer…
Imagine uploading a file from São Paulo (Brazil). The object is stored automatically in the nearest Tigris region, GRU (São Paulo).
When a user in Mumbai (India) requests the object, it's initially served from GRU. However, Tigris automatically caches the object in the region closest to the request's origin, significantly improving subsequent access times — all without extra configuration!
Here are some real numbers for that example:
| Request | Response | Response time (milliseconds) |
|---|---|---|
| gru (São Paulo) | gru (São Paulo) | 3.018 |
| bom (Mumbai) | gru (São Paulo) | 1207.364 |
| bom (Mumbai) | sin (Singapore) | 141.98 |
| bom (Mumbai) | sin (Singapore) | 134.972 |
| bos (Boston) | gru (São Paulo) | 1393.971 |
| bos (Boston) | iad (Washington, D.C.) | 29.399 |
| bos (Boston) | iad (Washington, D.C.) | 21.344 |
Tigris combines object storage with CDN capabilities. That means great UX for end-users and great DX for developers.
Let's look at a demo notebook that showcases this.
In our demo, we use Livebook's integration with MapLibre to plot the HTTP request and response locations on a map. We also log the response times in a table.
Additionally, we leveraged the Livebook Apps feature to visualize the notebook as an app.
Here's the result:
Tigris brings some cool innovations to the object storage space. For example, here's how you could use it as a global key-value store from Elixir.
If you want to try using Tigris with Elixir, they have official Elixir support.
", "url": "https://news.livebook.dev/welcoming-tigris-as-a-new-sponsor-of-livebook-1rsFQk", "title": "Welcoming Tigris as a new sponsor of Livebook!", "summary": "See how Tigris's S3-compatible storage and automatic caching enhance UX/DX, demonstrated via a Livebook demo.", "date_modified": "2024-03-26T13:12:12.000Z", "tags": [ "announcements" ] }, { "id": "355122", "content_html": "Welcome to the 5th day of Livebook Launch Week 2! 🎉
For those of us who found ourselves instinctively trying to use Vim or Emacs shortcuts in Livebook, only to realize that these weren’t supported, feeling frustrated. We hear you.
We’re excited to announce that now you can use Vim and Emacs key bindings while coding in Livebook.
Let’s see how it works.
Go to the settings page in Livebook and choose the “Key bindings” you prefer:
Once that’s done, you can use it in any Livebook cell with a code editor, like in a code cell or a markdown cell. Here’s an example using Vim keybindings:
From now on, you can bring your Vim/Emacs muscle memory to Livebook for a more pleasant and productive experience. Thanks to Kenichi Nakamura, who contributed that feature.
To start using that new feature, install the latest version of Livebook and have fun!
And if you want to discover everything that was added/changed in this release, here’s the changelog.
", "url": "https://news.livebook.dev/vim-and-emacs-key-bindings---launch-week-2---day-5-VfcA0", "title": "Vim and Emacs key bindings - Launch Week 2 - Day 5", "summary": "Vim and Emacs users can now use their favorite keybindings in Livebook. See our latest update for activation instructions.", "date_modified": "2023-10-13T13:40:11.000Z", "tags": [ "releases", "launch week" ] }, { "id": "354946", "content_html": "Welcome to the 4th day of Livebook Launch Week 2! 🎉
Today’s post is about our two new database integrations: Snowflake and SQL Server.
Together with those new ones, Livebook now comes with built-in integrations for seven databases and data warehouses:
Let’s see how the new integrations work.
The Snowflake integration is available through the Database Connection Smart cell. All you need to do is configure the Smart cell with your connection credentials, and you’ll be ready to start executing queries.
Let’s see how that works.
Under the hood, this is different from the other database integrations we already have. Livebook connects to Snowflake through ADBC (Arrow Database Connectivity), using the ADBC hex package, which contains ADBC bindings for Elixir.
The Arrow format is highly efficient, and it’s also integrated with Explorer, so now you can easily query a database and load the result into an Explorer dataframe.
Good news for those of us doing data analysis with Elixir and Livebook. 🎉
Connecting to SQL Server is also super simple. All you need to do is add a new Database Connection Smart cell, select SQL Server, and fill in your database credentials.
Here’s how it works.
This was a community contribution from Simon McConnell. Curious fact: the pull request contains less than 250 LOC! Cool, right?! 😎
To start playing with those new features, install the latest version of Livebook and have fun!
Welcome to the 3rd day of Livebook Launch Week 2! 🎉
Today, we’re excited to announce Livebook v0.11’s most prominent feature, file integration.
Although file integration may not sound exciting at first glance, bear with us; we have some elegant features to show.
Imagine code generation when you drag and drop a file based on the file type. Or quickly do a lazy reading of a multiple gigabyte parquet file stored in S3. That’s what we’re talking about! 😎
Watch the video where José Valim shows a demo of what this feature can do.
Throughout the last releases, we have been improving how Livebook helps to work with data.
Data comes from different sources. One common source is a database, which Livebook already has good support for. Another source is a file, either on your machine or on S3, which Livebook hasn’t natively integrated with yet.
Don’t get us wrong, you could already write some Elixir code in your notebook that reads a file from the file system or the web. But the Livebook UI had no understanding of it. And that’s what changed in this release.
The concept is simple. When you’re editing a notebook, you can add a file to it. All files are listed in the sidebar, so everyone using your notebook can quickly glance at your file dependencies. Once you do that, Livebook exposes an API for your notebook to read that file via the Kino.FS module.
But that’s not the only thing. Now that Livebook natively understands files, it can offer code suggestions based on the file type.
For example, when you drag and drop a CSV file to Livebook, it can generate code that creates an Explorer Dataframe from that data:
Or when you drag and drop a SQLite database file, Livebook can generate code that describes that database:
Or when you drag and drop an audio file, Livebook can generate code that uses a Machine Learning model to generate a transcription for you:
One thing you’ll notice in common with all those drag-and-drop examples is that Livebook doesn’t automatically execute the code. Instead, it emits the code and allows you to run it yourself.
This may look like a small detail, but it’s part of our vision for Livebook. We don’t want it to be a magic box that executes some task behind the scenes that you can’t know what it is. We want to enable you to introspect the code, learn from it, and customize it to your needs.
We took that approach with Smart cells. And that’s the approach we’re continuing to apply.
When you start adding files to your notebook, you’ll notice that there are two types of files: References and Attachments.
References are files that point to existing resources on your disk, a remote storage, or a URL. It’s like a symbolic link; Livebook doesn’t store the file, it just has a pointer to it.
Attachments are different. They are files stored in the files/ directory alongside your notebook source. So, a file attachment will be kept wherever you save your notebook.
So, if you’re storing a file in an S3-compatible cloud service, in a web server, or if you want to save it and version it alongside your notebook source, Livebook has you covered.
When you have a dataset with multiple gigabytes of data, you don’t want to load all of it at once to the memory. A common approach for that is lazy loading the data. And this new Livebook release supports that workflow as well.
For example, let’s say your dataset is stored as a Parquet file in S3. When you add that file to your notebook, Livebook will give the option to load that data into a dataframe lazily:
Not only that, but you can also lazily manipulate that data:
When needed, Livebook will download all the data, like when plotting a chart based on the data or when exporting it after some data wrangling:
All that means is now more than ever, you can use Livebook for work with multiple gigabytes of data without needing a machine with dozens of gigabytes of memory.
Ready to take the new Livebook for a spin?
Install the latest version, drop one of those files into a notebook, and see what happens!
When we announced Bumblebee, a collection of pre-trained models inspired by Hugging Face Transformers, the Whisper speech-to-text model quickly became one of the favorite and most used models within the Elixir community.
Thanks to advancements in the overall Numerical Elixir ecosystem, Livebook v0.11 includes a highly improved integration with Whisper, which we will detail in this article.
If you want to skip ahead and give it a try, install Livebook and start a new notebook. Then click “+ Smart cell” and choose “Neural Network task.” You will find Whisper as Speech-to-text under Audio.
There are three new features in our Whisper integration:
Of course, all of those features work together, providing a delightful experience as you can see below, where we transcribe on the fly one of Thinking Elixir episodes:
When you combine the features above with Nx’s ability to run neural networks distributed across multiple machines and GPUs, Elixir developers now have a first-class, state-of-the-art, speech-to-text model ready to run, enjoy, and scale.
Try for yourself!
Transcribe an audio file using our built-in Neural Network Task Smart cell. Maybe start with a small file to quickly see the result. Then you can try a bigger one.
Download the latest Livebook version and have fun!
Welcome to the second Livebook Launch Week! 🎉
If this is your first Launch Week with us, let us explain how this works. Starting today, each day of this week, we’ll announce a new feature of this release, Livebook v0.11.
Today, we’ll discuss our newest built-in Smart cell: Remote execution.
Livebook is a multi-purpose tool. And two of the most common use cases we’ve been seeing are debugging and internal tools.
A common requirement for both use cases is to write code that calls functions from a remote node, probably your main Elixir app in the production environment.
One way to do that is by connecting your notebook to the other node using the “Attached node” runtime:
That said, that approach has a limitation. When you use it, all of the code in your notebook will run in the context of that remote node. So, you can’t add Mix dependencies to your notebook, like VegaLite for charts or Kino for user interactions.
The other way we have to run remote functions is by using the default runtime (Elixir standalone) and using the erpc Erlang module, like this:
But, we noticed people have been using the “Attached node” by default when calling a function from a remote node, even when they need to add dependencies to their notebook. That’s a problem because although the “Attached node” setting is powerful for debugging, we believe that most of the time you need to interact with a remote node, you should use the erpc approach.
So, we decided to make the erpc approach a first-class citizen in Livebook. It’s now available as a new Smart cell that will streamline the process of calling functions from another node.
Here’s how the new Smart cell works:
As with any other Smart cell, one of the things it helps with is generating boilerplate code for you. There is no need to write the code that connects your notebook to a remote node over and over again.
But it goes beyond that.
The Smart cell can store the remote node’s cookie as a Livebook secret, so you don’t need to hardcode sensitive values inside your notebook. And with the upcoming Livebook Teams, it will be easy to share this secret with everyone on the team in a secure manner.
Last, this new Smart cell gives you autocompletion and docs preview of the modules defined in the remote node! Isn’t that awesome?! 🤯
We hope this feature will simplify the development of internal tools that need to communicate with existing nodes.
As an example, here’s a video showing how to use the new feature to connect a Livebook notebook to a Phoenix app, get some data from it, display a chart with those metrics, and share that as an interactive Livebook app:
All of the new features of this new release are already available today!
To start playing with them, install the latest version of Livebook and have fun!
We’re happy to announce that we’re sponsoring Spawnfest for the second time!
SpawnFest is an annual 48-hour online software development contest in which teams worldwide get one weekend to create the best BEAM-based applications they can.
We are collaborating with them again to create a bracket of the event dedicated to Livebook projects. Last year, most of the entries involved Kino and Smart Cells, but this year we are changing things up. Our Spawnfest bracket this year will focus on Livebook Apps.
Livebook Apps is a feature we launched earlier this year that enables you to turn your notebook into an interactive web application.
Since Livebook is a general-purpose tool, there aren’t many constraints on what you can build with Livebook Apps. So, it’s up to your imagination. But here are some examples to give you some inspiration.
Livebook comes with real-time collaboration out of the box. You can use that power in your Livebook apps as well.
Here’s a video showing how to build a chat app.
Livebook integrates with Hugging Face to bring you pre-trained models and helps you to use them with just a few clicks.
Here’s a video showing how to build an app that uses the Whisper machine learning model to transcribe audio messages in a chat.
Livebook integrates with Vegalite and Maplibre to make it super easy to build lots of different kinds of data visualization.
Here’s an example of an app that plots a chart with the number of stars a Github project got over time.
This app is deployed, so you can try it live. And here is the source code.
One month ago, we expanded Livebook Apps with a feature called Multi-Session Livebook Apps. We believe that this new feature is excellent for the automation of technical and business workflows.
You can think of it as a way to transform a script into a UI and share that with others by just sharing an URL.
Here’s a video showing how to build an app that gets data from Github’s API, generates a report, and sends it to a Slack channel.
Livebook Apps run inside a Livebook instance. So, you can run them in any Livebook installation, be it in the localhost or the cloud.
One of the easiest ways to install Livebook in the cloud is using Docker. Let’s see two examples of deploying a Livebook App this way.
First, make sure you have Fly’s command-line installed on your machine.
Now, clone the following template repo:
git clone https://github.com/hugobarauna/livebook-apps-on-fly-template.git my-livebook-apps\nAdd a file with the source code of your Liveobok App to the public-apps/ directory of your repository.
Then, follow Fly’s instructions to Deploy via Dockerfile.
After that, Livebook and your Livebook App will be running inside Fly.
Here’s a video showing how that works.
To deploy a Livebook App to Hugging Face, we’ll use Hugging Face Docker Spaces.
First, install Livebook on Hugging Face by following these instructions.
Second, add a file with the source code of your Liveobok App to the public-apps/ directory of your Space and make a commit.
After that, Hugging Face will rebuild your Space, and your Livebook app will be deployed.
Here’s a video showing how that works.
Participation in SpawnFest is 100% free of charge. To register, go to their website and follow the instructions.
We’re looking forward to seeing what you will build with Livebook Apps!
", "url": "https://news.livebook.dev/livebook-is-sponsoring-spawnfest-again-hskPC", "title": "Livebook is sponsoring SpawnFest again", "summary": "Join Spawnfest, the 48-hour BEAM-based app contest, build a Livebook App and have fun.", "date_modified": "2023-08-16T13:30:18.775Z", "tags": [ "announcements" ] }, { "id": "349382", "content_html": "Today we’re launching Livebook 0.10! 🎉
This major update brings many exciting features, with the spotlight being the introduction of multi-session Livebook apps.
We’ve also added a presentation view, initial Erlang support, Live Doctests, and dataframe file export. Let’s dive in and explore these new features.
Livebook 0.9 introduced Livebook apps. This is a way to turn your notebook into an interactive web application. Now, we’re expanding that further.
Initially, Livebook Apps was designed for long-running applications. Behind the scenes, only one instance of a Livebook app could run at any given moment. Since Livebook has built-in support for multiple users, all users accessing an app would be sharing the same instance of the app. We’re now calling that single-session Livebook apps.
This new version introduces multi-session Livebook Apps. What’s different is that when you join a multi-session application, you get a version of that app exclusively for you. Like single-session apps, multi-session apps can run for as long as they want, but most often, they will receive user input, execute several instructions, and then exit.
We believe they are an excellent fit for automating technical and business workflows. You can think of them as something similar to scripts, but instead of running in a terminal, they are interactive web applications accessed through the browser.
For example, instead of repeatedly being asked to run one-off scripts, you can package that script as a Livebook app and makes it accessible to other team members to run it, at any time, by themselves.
Let’s see how that works.
We noticed many people use Livebook for presentations. However, it can be frustrating to switch between Livebook and your slides. Also, showing the whole notebook can distract your audience. But there’s good news!
Franklin Rakotomalala contributed a Presentation view feature that hides the sidebar and focuses on the part of your notebook you want to present. Here’s how it works.
Shout out to Franklin!
You can now write Erlang code inside Livebook. Not only that, but you can combine it with Elixir in the same notebook. If you define a function or a variable inside one language, you can easily use it in the other.
Watch the video below for an example.
This was a community contribution by Benedikt Reinartz. Thanks to him, Livebook now supports multiple BEAM languages.
Starting from version 0.8, doctests are integrated with Livebook. This new version comes with exciting improvements in that area.
When you evaluate a cell with doctests, a traffic light-like status appears on the left of each doctest. This gives you a visual indication if it passed or not. Additionally, when the doctest fails, the failing result is directly inlined in the code editor.
Here’s how it works:
This is a step towards bringing Live Programming concepts into Livebook, the idea that for “programming to be more fluid, editing and debugging should occur concurrently as you write code.”
This one started with the code contribution of Jose Vargas and the research work of Szymon Kaliski.
When working on a data analysis task using Livebook, you might need to access the analysis result from another tool or share them with someone who prefers opening it in a spreadsheet.
Now, you can easily do that by exporting your dataframe to a CSV, NDJSON, or Parquet file. Here’s how it works:
To play with the new features, follow these steps:
And if you want to discover everything that changed in 0.10, here’s the changelog.
Happy hacking!
", "url": "https://news.livebook.dev/whats-new-in-livebook-0.10---introducing-multi-session-livebook-apps-3Dbpss", "title": "What's new in Livebook 0.10 - Introducing Multi-Session Livebook Apps", "summary": "This major update brings many exciting features, with the spotlight being the introduction of multi-session Livebook apps. We’ve also added a presentation view, initial Erlang support, Live Doctests, and dataframe file export.", "date_modified": "2023-07-14T12:36:24.000Z", "tags": [ "releases" ] }, { "id": "330836", "content_html": "Welcome to the fifth and last day of the first Livebook Launch Week!
Today we will talk about data wrangling with Livebook and the new data capabilities with this new release.
Watch the video where José Valim shows a demo of those new features.
You can also read an overview of the new features below.
Explorer is a project that brings series (one-dimensional data) and data frames (two-dimensional data) right into Elixir.
It is implemented on top of the Polars project, a highly performant dataframe Rust library. And it’s highly inspired by the dplyr project from R, which is quite expressive. We aim to bring ideas from both communities into Elixir to provide a powerful and elegant tool for data processing.
Let’s play with Explorer a little bit.
The first step of a data exploration project is to import the data. Let’s see how you can import a dataset into an Explorer data frame:
After importing the data, it’s usually a good idea to explore it a little bit. To do that, we’ll use a new feature from Livebook that helps us visualize an Explorer Dataframe as a table.
Kino is the library used by Livebook to render rich and interactive outputs directly from your Elixir code. Livebook has multiple built-in Kinos, but anyone can also build custom Kinos as a way to extend Livebook.
We built a new Kino called Kino Explorer for this release to improve the integration between Explorer and Livebook. Let’s see how we can use it to display an Explorer data frame as an interactive table:
In Livebook, a Smart cell is a UI-based cell that helps you to accomplish a specific task like creating a database connection, sending a message to a Slack channel, or running a Machine Learning model.
Livebook has various built-in Smart cells, and anyone can build a Smart cell to extend Livebook to their needs.
For this release, we built a new built-in Smart cell; the Data Transform one. Let’s see how we can use it for some data transformation.
Want to play with all of those new features?
First, ensure you’ve installed the latest version of Livebook.
Then, click the button below to run the notebook that José Valim built in the demo video:
If you have any comments or want to share what you’ve built using Livebook, you can tweet using the #LivebookLaunchWeek hashtag.
I hope you got as excited as we did with this new Livebook 0.9 release.
Besides that, we’re already working on much more exciting stuff we’re looking forward to sharing—for example, the upcoming Livebook Teams.
If you use or want to use Livebook at work with your colleagues, you can fill in our form to help us to inform Livebook Team’s roadmap and get updates about it.
Thank you very much for being with us these last five days. This is all for this first Livebook Launch Week!
Building Livebook and sharing what it’s capable of is a joy for us. We hope you can have fun with it too. 😄
Welcome to the fourth day of Livebook Launch Week! 🎉
Today we will build a Whisper chat app with Livebook and deploy it to Hugging Face.
In this chat app, users can communicate only by sending audio messages, which are then automatically converted to text by the Whisper Machine Learning model:
You can access the demo over the next few days on José Valim's Livebook instance on HuggingFace.
This demo covers a lot of cool features from Livebook, Nx, and Bumblebee, like:
Deploy Livebook notebooks as apps
On day 1 of our Launch Week, we saw how to deploy your notebook as an interactive web app. This time we’ll go further and deploy a Machine Learning-based app to Hugging Face.
Realtime and multiplayer apps
Livebook’s modern approach to code notebooks brings interactivity and collaboration. So, apps built with Livebook are also interactive and multiplayer by default! The Whisper chat app we’ll be an excellent example of that.
Concurrent Machine Learning
On day 2 of our Launch Week, we talked about the new Machine Learning models you can use with just a few clicks through Livebook’s Neural Network Smart Cell. In today’s video, you’ll see how to customize the code generated by the Smart cell and build an app on top of it.
We’ll add concurrency and batching to improve the app’s scalability and performance, allowing multiple users to submit audio messages simultaneously and efficiently process them using the Whisper model.
Want to run the Whisper chat app by yourself?
First, ensure you’ve installed the latest version of Livebok.
Then, click the button below to run the notebook yourself:
If you have any comments or want to share what you’ve built using Livebook, you can tweet using the #LivebookLaunchWeek hashtag.
Stay tuned for the final announcement of the Livebook Launch Week!
Welcome to the third day of Livebook Launch Week! 🎉
In today’s post, we’ll explore the new security features in Livebook 0.9, including the introduction of Hubs for centralized secret management and notebook stamping to enhance user experience while maintaining security.
We’ll also give you a sneak peek into the upcoming Livebook Teams product, designed to streamline the experience of using Livebook within a team.
Let’s dive in and discover how these features can improve your workflow and secure your notebooks!
Throughout the development of Livebook, one of the sources that informed our roadmap was a paper published in 2020 called “What’s Wrong with Computational Notebooks? Pain Points, Needs, and Design Opportunities”. The paper shows that computational notebook users face numerous pain points while using that kind of tool. One of those problems is security.
The paper defines that problem as follows:
Maintaining data confidentiality and access control is an ad hoc, manual process where errors can leak private client data
Here’s a quote about that problem by one of the people interviewed by the researchers:
We are missing a more private way of handling credentials. I don’t want client credentials be visible to others
To address that pain point, we added built-in secret management to Livebook since version 0.7.
Livebook’s built-in secret management allows your notebook to use sensitive data without hardcoding it. For example, imagine your notebook needs to use a password-protected API; this is how you’d save that password using Livebook Secrets from version 0.7:
As you create more and more notebooks and more secrets, you’ll eventually want to see all the secrets you created. But before Livebook 0.9, the only way to see all the secrets you configured was inside a notebook.
Now, we have a better way.
This new Livebook release introduces a concept we’re calling Hubs.
Every new Livebook installation comes with a default personal Hub. This is the place where Livebook will save your secrets and where you can manage all of them. Let’s see how it works.
But a Hub is not only a place to centralize your secrets. When you visit your personal Hub, you’ll notice another section called Stamping.
Before explaining this feature, let’s discuss why we created it.
Imagine the following scenario. You have a secret in your Livebook called “API_PASSWORD.” If you download a notebook from the internet, you don’t want that secret to be accessible by that notebook by default. That’s why you must explicitly share a Livebook secret with a notebook.
But what if you were opening a notebook you created and had already shared secrets with that notebook? Although you already trust that notebook, Livebook would still make you explicitly share secrets with it every single time you open it. Let’s watch a video that illustrates that UX problem:
Enters notebook stamping.
Livebook 0.9 automatically stamps your notebooks so you don’t need to share a secret more than once with a notebook you trust. The notebook stamp contains the list of the secret names you explicitly shared with the notebook, and it’s encrypted using your secret key saved in your personal Hub.
Let’s see a video of how that new feature improves the UX of Livebook Secrets.
We also use the notebook source itself to generate the stamp, so someone can’t get your stamp and go stamping other notebooks, pretending it’s yours.
Since the stamping uses the secret key saved in your personal Hub, if you’re using Livebook on multiple machines and want to share notebooks between them, you can configure them with the same secret key.
With this update to Livebook’s security capabilities, we aim to ensure users can enjoy a secure working environment without compromising on ease of use.
But there’s still one problem left. What if you’re working in a team and you want to share secrets among team members? You don’t want to share your personal secret key; it’s yours. Enters Livebook Teams.
Livebook Teams is a paid product we’re developing that will streamline the experience of using Livebook within a team.
Livebook Teams is not a different version of Livebook. Instead, it is a Hub that all of your team members and colleagues connect to in order to work together.
It will manage all the Livebook Secrets shared by your team and be responsible for stamping all the notebooks that belong to your group, so you can safely share secrets and notebooks among team members.
We have a lot of features planned for Livebook Teams, it’s not only about security and secret management. It will also enable your team to:
And there’s a lot more coming!
If using Livebook inside your company sounds interesting to you, please submit our form to help us to inform our roadmap and get updates about it.
We encourage you to go ahead and install Livebook’s latest version so you can have a better user experience while maintaining the security of your notebooks.
And if you have any comments or want to share what you’ve built using Livebook, you can tweet using the #LivebookLaunchWeek hashtag.
Stay tuned for the following announcement of the Livebook Launch Week!
Welcome to the second day of Livebook Launch Week! 🎉
Today we will discuss all the new Machine Learning capabilities in Elixir and Livebook. First, we will discuss some of the new Neural Network tasks in Livebook v0.9. Then we will show how easy it is to make an existing model run concurrently and then distributed across multiple machines and multiple GPUs.
Let’s get started!
This new Livebook release has many new Machine Learning models you can use with just a few clicks. But there is more exciting news about the Machine Learning story in the Elixir world.
Not only can you do Machine Learning with Elixir, but you can also do Distributed² Machine Learning!
But what does that “Distributed²” means?
It means that when executing a Machine Learning model with Elixir’s Nx, the distribution can happen on two dimensions:
This can lead to increased performance and better utilization of your hardware resources. And it only takes very few changes to your code.
Do you want to see an example? Watch this part of our video.
We are very excited about these features because we are starting to marry the benefits of Nx with the capabilities for building fault-tolerant and distributed software from the Erlang Virtual Machine. Case in point: adding distribution support to Nx took only 400 lines of code, including docs and tests!
Neural network tasks were initially added to Livebook version 0.8 with the idea of giving you the power to use modern Machine Learning models with just a few clicks.
This 0.9 release comes with more models. Here they are.
We encourage you to go ahead and install Livebook’s latest version to start playing with all of those Machine Learning models!
And if you have any comments or want to share what you’ve built using Livebook, you can tweet using the #LivebookLaunchWeek hashtag.
Stay tuned for the following announcement of the Livebook Launch Week!
Welcome to the first-ever Livebook Launch Week! 🎉
We’re kicking off this series of announcements to unveil the fantastic new features available in Livebook 0.9. Starting today, each day of this week, we’ll announce a new feature or something new you can do with this new Livebook release, version 0.9.
And today, we’re thrilled to announce the most prominent feature of this new release, the ability to run your notebook as an app.
Although Livebook is terrific for many use cases where you need to use it just by yourself, we always believed it could shine in contexts where multiple people are collaborating through it.
When Livebook was launched, it already came with real-time collaboration, allowing multiple people to edit a notebook simultaneously. This was already one step ahead of the traditional concept of a code notebook. But we thought it could go even further.
There are some scenarios where you want people to use your notebook but not necessarily edit it. In those scenarios, the person wants to run and interact with your notebook. That’s why we created and evolved Kino, a tool that enables you to build interactive notebooks.
Although Kino made your notebook interactive, it still felt like a notebook. The person could still see all the code cells mixed with the interactive widgets and the outputs. And this is not the best UX for sharing your notebook with people that need to use it but not edit it.
But now, we have a better way.
Now, you can deploy your notebook as an app! 🎉
This is a way to turn your Livebook notebook into a user-friendly application!
A deployed notebook is a web app that only shows the inputs and outputs of your notebook and is powered by your notebook code.
This allows you to share your notebook with a broader audience, making it more accessible to non-technical users or those unfamiliar with Livebook.
You can build internal apps, a demo of a Machine Learning model, or interactive automation tasks.
But in truth, we can’t imagine all the different ways you will use that, and we can’t wait to see what you will build with this new feature!
To get started, inside the Livebook’s Learn section, there’s a new notebook that will teach you how to write and deploy your first app: a chat application in only 15 lines of code!
This is for all of us who need to open a notebook multiple times per day or week and want to avoid repeatedly navigating the whole file directory structure to open that notebook every single time. Not anymore!
Now, you can star a notebook, and starred notebooks will show in your Livebook’s Home.
Shout out to ByeongUk Choi for adding that feature as a community contributor.
We revamped the “Opening a notebook” user flow.
Now all the ways of opening a notebook are centralized. And in that “Open notebook” page, we added a new section: “Recent notebooks.”
This section lists all the latest notebooks you’ve been working on, making it very easy to find recently used notebooks and quickly resume what you have been doing with Livebook since the last time you opened it.
Shout out to ByeongUk Choi for adding that feature as a community contributor.
Finding a specific section within your notebook can take more than a single mouse scroll when your notebook gets large.
The new “collapse sections” feature lets you toggle the visibility of the cells of sections so you can focus on particular parts of the notebook you’re working on.
Shout out to Jannik Becher for adding that feature as a community contributor.
We encourage you to go ahead and install Livebook’s latest version to build and deploy your first Livebook app!
And if you have any comments or want to share what you’ve built using Livebook, you can tweet using the #LivebookLaunchWeek hashtag.
Stay tuned for the following announcement of the Livebook Launch Week!
We are thrilled to announce the latest release of Livebook, version 0.9! 🎉
A lot of work went into bringing you a host of new features that will make your experience with Livebook even better and enable Livebook to be used in many different ways.
Over the coming weeks, we will be sharing more information about these exciting new additions.
Meanwhile, you are welcome to update to the latest and greatest.
Keep in mind we have moved our containers to GitHub, so if you are using Docker for installing Livebook, make sure to upgrade image references from \"livebook/livebook\" to \"ghcr.io/livebook-dev/livebook.\"
Stay tuned for more updates!
", "url": "https://news.livebook.dev/announcing-livebook-0.9-2tiuLC", "title": "Announcing Livebook 0.9", "summary": "We are thrilled to announce the latest release of Livebook, version 0.9! 🎉 A lot of work went into bringing you a host of new features that...", "date_modified": "2023-03-21T17:13:10.909Z", "tags": [ "releases" ] }, { "id": "324813", "content_html": "We are thrilled to introduce Livebook on Hugging Face Spaces! 🎉
Each Hugging Face Space environment offers up to 16GB of RAM and 2 CPU cores for free.
If you’re unfamiliar with Hugging Face (HF), it’s a platform for building, sharing, and collaborating on machine learning applications.
This is our second integration with Hugging Face; the first was through Bumblebee, which brings pre-trained neural network models from Hugging Face to the Elixir community.
We’ve been collaborating with HF to make using Livebook on Spaces a breeze. If you have a Hugging Face account, simply click the one-click deployment button below:
Alternatively, follow the step-by-step tutorial to install Livebook in a Hugging Face Space.
One of the great features of HF Spaces is its ease of upgrading to hardware with GPU accelerators. This is particularly useful for Machine Learning applications, which can be highly parallelized and computationally intensive.
Check out this video to see how easy it is to run Stable Diffusion with Livebook on top of a Hugging Face Space powered by a GPU:
Ready to give it a try for yourself? Start experimenting with Livebook on Hugging Face Spaces now.
", "url": "https://news.livebook.dev/livebook-inside-hugging-face-spaces-3LQaRi", "title": "Livebook inside Hugging Face Spaces", "summary": "This blog post announces the integration of Livebook and Hugging Face Spaces.", "date_modified": "2023-02-15T14:55:26.361Z", "tags": [ "announcements" ] }, { "id": "322859", "content_html": "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!
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.
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.
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.
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(\n [\n {:kino, \"~> 0.8.1\"}\n ],\n force: true\n)
With this new release, it's now as simple as clicking a button:
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.
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!
To play with the new features, all you need to do is:
Happy hacking!
", "url": "https://news.livebook.dev/what-s-new-in-livebook-0.8.1-NSbeg", "title": "What’s new in Livebook 0.8.1", "summary": "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 inputOne of the g...", "date_modified": "2023-01-30T17:15:44.823Z", "tags": [ "releases" ] }, { "id": "213737", "content_html": "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.
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!
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.
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)
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:
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:
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!
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:
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:
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:
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:
To play with the new features, all you need to do is:
Happy hacking!
", "url": "https://news.livebook.dev/whats-new-in-livebook-0.8-4gQiEE", "title": "What's new in Livebook 0.8", "summary": "This post showcases ten of the most noteworthy features released with Livebook 0.8.", "date_modified": "2023-01-12T12:56:55.793Z", "tags": [ "releases" ] } ] }![\"Run](\"https://img.announcekit.app/0759863cd5e0faec34915b102dd0f98a?s=fd1d7459682e7aef06b4b76180a07d66\")
![\"Run](\"https://img.announcekit.app/a505b3a5f38484368e6b7a1568421ae3?s=0fe72bb2a0618ea3cf1e7b865ea06b44\")
![\"Run](\"https://img.announcekit.app/e90c4908915427f8fdd0154bd0fe61c2?s=4dc7fcaeda7bbdeb33609886fc4178f9\")
![](\"https://img.announcekit.app/a47a0a71c771d7b96279f916bcd6e00c?s=280f9c675fb38d81d8923a4328242827\")
![](\"https://img.announcekit.app/74be2d683baf648265dc2728c3dbf6b0?s=7d1256a9394e6cc0ebfa9929d900bfb0\")
![](\"https://img.announcekit.app/f41dfd62fda79d547a385e0d13165255?s=56ddeb352a7e744178ff13e2eb6f56f0\")
![](\"https://img.announcekit.app/fb976982bc84358eda4bced5560562a3?s=4330957811a205f3df376df334d32bf1\")
![\"Run](\"https://img.announcekit.app/23401be6b9f3fe1d73307efa65dff4f0?s=a6372d9682bbb50d9caddc1f5a049e76\")
![](\"https://img.announcekit.app/628fc9d1f3a0305056929a66f48faca5?s=7eb02dbc6509b17173281eac98d98e18\")
![](\"https://img.announcekit.app/25661bfd6260b7661d40c063b56833de?s=d568beab422f28632f9b0b960870fc9d\")
![](\"https://img.announcekit.app/05074fe3f14d875b1464c1beabda828c?s=404e1e6fa02f8841d41f59b1de7a2c66\")
![](\"https://img.announcekit.app/1c0e64ba9eb59d46ae9de85d86fc1251?s=5bb29fab8d74a41c4b4d5e0fc11f746f\")
![](\"https://img.announcekit.app/3c815a751513b3b702f66a67f632d370?s=b2ecc3dbd3efc86b69c8d112b4769c74\")
![](\"https://img.announcekit.app/4010d33d33f7f3d5e4b6e5998c237308?s=4f8a71b5ec5ee1ccacf528f8ab58b658\")
![](\"https://img.announcekit.app/d27faa3ca14fbc19209395d654f70327?s=53b6ce3f808426cc6e41b511537f4ca9\")
![](\"https://img.announcekit.app/870a4e25f708ee106e0c41eea7550d2b?s=83ef779a11d70fe2d1ce10bd3d1e6c9b\")
![](\"https://img.announcekit.app/782700b43f509a6711f1472427b95521?s=626e81ceb8c1cfa953846e7f34eba421\")
![](\"https://img.announcekit.app/ead26eb1cc4a1ce2dbf871b82fa2ff3f?s=556f779213fe1fd00ac6029b87b910f8\")
![](\"https://img.announcekit.app/96e45adcb8547a7606af8d8389b33efa?s=098e232c4d59ae029fa7ebd835f301c1\")
![](\"https://img.announcekit.app/de8d4396bdadb78a80a9f2266d4d26b5?s=78a02941b2a32f23a6056cd4eb0dfa5d\")
![](\"https://img.announcekit.app/38153f13b4e32b0d7c61e5ffdb5a66c7?s=2dec7c7ed1278c57360a21bcd5f12747\")
![](\"https://img.announcekit.app/9048d7fb75793dbc3ec3645df476b7b1?s=ae690e5680d84990f720e5cea9da1c8e\")
![](\"https://img.announcekit.app/abf33ee570cbef793cedba5ce11c27be?s=fd59ecc2dd2d30c144a97d17385844a2\")
![\"Run](\"https://img.announcekit.app/a68ad7a0f934ac9d17878718f4917420?s=d8fde468ada46043629e3223b151b4a4\")