diff --git a/astro.config.mjs b/astro.config.mjs
index c078cd3..ee6a001 100644
--- a/astro.config.mjs
+++ b/astro.config.mjs
@@ -3,6 +3,9 @@ import { defineConfig } from "astro/config";
import tailwindcss from "@tailwindcss/vite";
export default defineConfig({
+ markdown: {
+ shikiConfig: { theme: "github-dark" },
+ },
vite: {
plugins: [tailwindcss()],
},
diff --git a/public/videos/blog/2022-08-24-livebook-spawnfest/explore-section.mp4 b/public/videos/blog/2022-08-24-livebook-spawnfest/explore-section.mp4
new file mode 100644
index 0000000..136b206
Binary files /dev/null and b/public/videos/blog/2022-08-24-livebook-spawnfest/explore-section.mp4 differ
diff --git a/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/create-secret.mp4 b/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/create-secret.mp4
new file mode 100644
index 0000000..f3167eb
Binary files /dev/null and b/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/create-secret.mp4 differ
diff --git a/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/database-connection-secret.mp4 b/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/database-connection-secret.mp4
new file mode 100644
index 0000000..fa60c7c
Binary files /dev/null and b/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/database-connection-secret.mp4 differ
diff --git a/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/dbg-image-pipeline.mp4 b/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/dbg-image-pipeline.mp4
new file mode 100644
index 0000000..5ed89df
Binary files /dev/null and b/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/dbg-image-pipeline.mp4 differ
diff --git a/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/dbg-pipeline.mp4 b/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/dbg-pipeline.mp4
new file mode 100644
index 0000000..1f3b48a
Binary files /dev/null and b/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/dbg-pipeline.mp4 differ
diff --git a/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/grid-layout.mp4 b/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/grid-layout.mp4
new file mode 100644
index 0000000..b16c045
Binary files /dev/null and b/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/grid-layout.mp4 differ
diff --git a/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/message-passing-visualization.mp4 b/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/message-passing-visualization.mp4
new file mode 100644
index 0000000..e87750d
Binary files /dev/null and b/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/message-passing-visualization.mp4 differ
diff --git a/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/shared-notebook-secret-prompt.mp4 b/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/shared-notebook-secret-prompt.mp4
new file mode 100644
index 0000000..fb382e3
Binary files /dev/null and b/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/shared-notebook-secret-prompt.mp4 differ
diff --git a/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/supervision-tree-output.mp4 b/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/supervision-tree-output.mp4
new file mode 100644
index 0000000..0caa097
Binary files /dev/null and b/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/supervision-tree-output.mp4 differ
diff --git a/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/tabs-layout.mp4 b/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/tabs-layout.mp4
new file mode 100644
index 0000000..acc022d
Binary files /dev/null and b/public/videos/blog/2022-10-11-whats-new-in-livebook-0-7/tabs-layout.mp4 differ
diff --git a/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/chart-cell-bin.mp4 b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/chart-cell-bin.mp4
new file mode 100644
index 0000000..530183b
Binary files /dev/null and b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/chart-cell-bin.mp4 differ
diff --git a/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/chart-cell-color-scheme.mp4 b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/chart-cell-color-scheme.mp4
new file mode 100644
index 0000000..1725152
Binary files /dev/null and b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/chart-cell-color-scheme.mp4 differ
diff --git a/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/chart-cell-scale.mp4 b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/chart-cell-scale.mp4
new file mode 100644
index 0000000..738c4f5
Binary files /dev/null and b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/chart-cell-scale.mp4 differ
diff --git a/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/doctests.mp4 b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/doctests.mp4
new file mode 100644
index 0000000..d195600
Binary files /dev/null and b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/doctests.mp4 differ
diff --git a/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/hover-docs-math.mp4 b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/hover-docs-math.mp4
new file mode 100644
index 0000000..4615986
Binary files /dev/null and b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/hover-docs-math.mp4 differ
diff --git a/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/hover-docs.mp4 b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/hover-docs.mp4
new file mode 100644
index 0000000..9e1947a
Binary files /dev/null and b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/hover-docs.mp4 differ
diff --git a/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/image-input.mp4 b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/image-input.mp4
new file mode 100644
index 0000000..6e2d7ba
Binary files /dev/null and b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/image-input.mp4 differ
diff --git a/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/map-cell-geocoding.mp4 b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/map-cell-geocoding.mp4
new file mode 100644
index 0000000..2a4d0f4
Binary files /dev/null and b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/map-cell-geocoding.mp4 differ
diff --git a/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/neural-network-cell.mp4 b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/neural-network-cell.mp4
new file mode 100644
index 0000000..718599f
Binary files /dev/null and b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/neural-network-cell.mp4 differ
diff --git a/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/secrets-sidebar.mp4 b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/secrets-sidebar.mp4
new file mode 100644
index 0000000..e0cbdc0
Binary files /dev/null and b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/secrets-sidebar.mp4 differ
diff --git a/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/slack-message-cell.mp4 b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/slack-message-cell.mp4
new file mode 100644
index 0000000..8c9b545
Binary files /dev/null and b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/slack-message-cell.mp4 differ
diff --git a/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/stale-cell-after.mp4 b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/stale-cell-after.mp4
new file mode 100644
index 0000000..060000f
Binary files /dev/null and b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/stale-cell-after.mp4 differ
diff --git a/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/stale-cell-before.mp4 b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/stale-cell-before.mp4
new file mode 100644
index 0000000..8209a74
Binary files /dev/null and b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/stale-cell-before.mp4 differ
diff --git a/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/tree-view.mp4 b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/tree-view.mp4
new file mode 100644
index 0000000..1d72f91
Binary files /dev/null and b/public/videos/blog/2023-01-12-whats-new-in-livebook-0-8/tree-view.mp4 differ
diff --git a/public/videos/blog/2023-01-30-whats-new-in-livebook-0-8-1/setup-cell-without-cache.mp4 b/public/videos/blog/2023-01-30-whats-new-in-livebook-0-8-1/setup-cell-without-cache.mp4
new file mode 100644
index 0000000..633db40
Binary files /dev/null and b/public/videos/blog/2023-01-30-whats-new-in-livebook-0-8-1/setup-cell-without-cache.mp4 differ
diff --git a/src/blog/2021/04-13-announcing-livebook.md b/src/blog/2021/04-13-announcing-livebook.md
new file mode 100644
index 0000000..23868c6
--- /dev/null
+++ b/src/blog/2021/04-13-announcing-livebook.md
@@ -0,0 +1,32 @@
+---
+title: "Announcing Livebook"
+description: "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."
+date: 2021-04-13
+tags: ["releases"]
+---
+
+We are glad to announce [Livebook](https://github.com/livebook-dev/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](https://github.com/elixir-nx/axon/), 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](https://github.com/phoenixframework/phoenix_live_view) 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](https://katex.org/).
+
+* 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.
diff --git a/src/blog/2022/01-24-v0-5-flowcharts-custom-widgets-intellisense-and-ui-improvements.md b/src/blog/2022/01-24-v0-5-flowcharts-custom-widgets-intellisense-and-ui-improvements.md
new file mode 100644
index 0000000..c4c367d
--- /dev/null
+++ b/src/blog/2022/01-24-v0-5-flowcharts-custom-widgets-intellisense-and-ui-improvements.md
@@ -0,0 +1,38 @@
+---
+title: "v0.5: Flowcharts, custom widgets, intellisense, and UI improvements"
+description: "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:"
+date: 2022-01-24
+tags: ["releases"]
+---
+
+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](https://mermaid-js.github.io/) 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](https://github.com/livebook-dev/livebook/releases/tag/v0.5.0) for the complete list of changes.
diff --git a/src/blog/2022/05-11-v0-6-automate-and-learn-with-smart-cells.md b/src/blog/2022/05-11-v0-6-automate-and-learn-with-smart-cells.md
new file mode 100644
index 0000000..bb75daa
--- /dev/null
+++ b/src/blog/2022/05-11-v0-6-automate-and-learn-with-smart-cells.md
@@ -0,0 +1,44 @@
+---
+title: "v0.6: Automate and learn with smart cells"
+description: "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:"
+date: 2022-05-11
+tags: ["releases"]
+---
+
+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](https://github.com/livebook-dev/livebook/releases/tag/v0.6.0) for the complete list of changes.
diff --git a/src/blog/2022/07-28-introducing-the-livebook-desktop-app.md b/src/blog/2022/07-28-introducing-the-livebook-desktop-app.md
new file mode 100644
index 0000000..5947a9f
--- /dev/null
+++ b/src/blog/2022/07-28-introducing-the-livebook-desktop-app.md
@@ -0,0 +1,26 @@
+---
+title: "Introducing the Livebook Desktop app 🎉"
+description: "We want Livebook to be accessible to as many people as possible. Before this release, installing Livebook on your machine could be considered easy, especially if you already had Elixir installed."
+date: 2022-07-28
+tags: ["announcements"]
+---
+
+We want Livebook to be accessible to as many people as possible. Before this release, installing Livebook on your machine could be considered easy, especially if you already had Elixir installed.
+
+But imagine someone who's not an Elixir developer. They had to either install Docker or Elixir before getting started with Livebook. And if they are in their first steps as developers, even using a terminal could be demanding.
+
+That's why we built [Livebook desktop](/#install). It's the simplest way to install Livebook on your machine.
+
+
+
+Livebook desktop doesn't require the person to have Elixir previously installed on their machine. And it works both on the Mac and Windows.
+
+We hope that the desktop app enables way more people to try Livebook.
+
+For example, let's say you want to help your friend to start learning Elixir. You can tell that person to download Livebook desktop and follow the built-in "Distributed portals with Elixir" notebook, a fast-paced introduction to Elixir.
+
+Or maybe for the data scientist that heard about Livebook and wants to try it. That person can download Livebook desktop and learn how to do data visualization in Livebook with the built-in "Plotting with VegaLite" and "Maps with MapLibre" notebooks.
+
+If you want to try the Livebook desktop app, it's just [one click away](/#install).
+
+We hope you enjoy it! 😊
diff --git a/src/blog/2022/08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook.md b/src/blog/2022/08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook.md
new file mode 100644
index 0000000..e1782b5
--- /dev/null
+++ b/src/blog/2022/08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook.md
@@ -0,0 +1,106 @@
+---
+title: "How to query and visualize data from Google BigQuery using Livebook"
+description: "Querying and visualizing data from a database is a common and recurring task. That's the kind of thing you don't want to repeat yourself, writing the same code repeatedly. That's where Livebook Smart cells come in. It helps you to automate any workflow you want."
+date: 2022-08-02
+tags: ["tutorials"]
+---
+
+Querying and visualizing data from a database is a common and recurring task. That's the kind of thing you don't want to repeat yourself, writing the same code repeatedly. That's where Livebook Smart cells come in. It helps you to automate any workflow you want.
+
+Livebook has built-in Smart cells that help you query and visualize data from multiple databases, like PostgreSQL, MySQL, Google BigQuery, AWS Athena, and SQLite.
+
+This article explains how to use Livevook Smart cells to query and visualize data from a Google BigQuery dataset.
+
+If you like video format, here's a video version of this article:
+
+
+
+
+
+You can also run this tutorial inside your Livebook instance:
+
+[](/run?url=https%3A%2F%2Fraw.githubusercontent.com%2Fhugobarauna%2Flivebook-notebooks%2Fmain%2Flivebook_google_big_query.livemd)
+
+## Connecting to Google BigQuery using the Database connection Smart cell
+
+Before connecting to a Google BigQuery dataset, you need to create a Google Cloud service account and a service account key. Follow [the steps in this guide](https://cloud.google.com/docs/authentication/getting-started) and download the generated service account key JSON file. That file contains the info needed to configure a connection to Google BigQuery.
+
+Now, create a new notebook. Then, let's create a Google BigQuery connection using a Database connection smart cell. Click the options "Smart > Database connection > Google BigQuery":
+
+
+
+Once you've done that, you'll see a Smart cell with input fields to configure your Google BigQuery connection:
+
+
+
+Configure your Google BigQuery connection by following the instructions inside the Smart cell:
+
+* Add your Google Cloud Project ID
+* Upload your JSON credentials file
+
+> **Pro tip:** if you have an authenticated [gcloud CLI](https://cloud.google.com/sdk/gcloud) in the machine running your Livebook instance, then Livebook will automatically pick up your Google Cloud credentials and use it for access. No need to upload the JSON file. 😉
+
+Now, click the "Evaluate" icon to run that Smart cell. Once you do that, the Smart cell will configure the connection and assign it to a variable called `conn`.
+
+## Querying Google BigQuery using the SQL Query smart cell
+
+Now, let's use your Google BigQuery connection to query a Google BigQuery public dataset.
+
+Add a new SQL Query smart cell by clicking the options "Smart > SQL Query":
+
+
+
+Once done, you can write and execute a SQL query inside that cell. Let's query a public Google BigQuery dataset.
+
+Copy the following query to the cell:
+
+```sql
+select t.year, t.country_name, t.midyear_population
+from bigquery-public-data.census_bureau_international.midyear_population as t
+where year < 2022
+order by year
+```
+
+And execute the cell. The Smart cell will execute the query and assign its result to a variable called `result`. It also will show you the result of the query in a table format, like this:
+
+
+
+## Visualizing data from Google BigQuery using the Chart smart cell
+
+Now we can visualize the result from that query using a Chart smart cell.
+
+Add a new Chart smart cell by clicking the option "Smart > Chart":
+
+
+
+Your newly created Chart smart cell will look something like this:
+
+
+
+Now, let's use that cell to visualize the results from our query.
+
+The query we wrote returned the population per year per country from the International Census Data, which is published as a Google BigQuery public dataset. We can use that data to visualize how the world population has been growing over the years.
+
+Use your Chart smart cell to configure:
+
+* the chart's title
+* the chart's width
+* the chart's type
+* the x-axis and its type
+* the y-axis, its type, and aggregate
+
+
+
+Once you've configured the cell, you can evaluate it, and it will build a chart for you. It will look something like this:
+
+
+
+That's it! Using Livebook Smart cells, you can connect to a Google BigQuery dataset, execute a SQL query and visualize the results with a chart. And since this is quite a common task, Smart cells enable you to do that without writing a single line of code!
+
+And, if you need more customization in any part of the process, easy peasy. You can easily convert a Smart cell to a code cell and edit the code generated for you. To do that, click in a Smart cell, and then click the "Convert to Code cell" icon:
+
+
+
+When you click the "Convert to Code cell" icon, it will transform your Smart cell into a Code cell. You'll be able to see the code that was running behind the Smart cell and edit it as you like:
+
+
diff --git a/src/blog/2022/08-24-livebook-spawnfest.md b/src/blog/2022/08-24-livebook-spawnfest.md
new file mode 100644
index 0000000..47a3882
--- /dev/null
+++ b/src/blog/2022/08-24-livebook-spawnfest.md
@@ -0,0 +1,57 @@
+---
+title: "Livebook + SpawnFest = ❤️ & 💻"
+description: "SpawnFest will have a specific category for Livebook-based projects this year, which Livebook is sponsoring."
+date: 2022-08-24
+tags: ["announcements"]
+---
+
+Good news, SpawnFest will have a specific category for Livebook-based projects this year!
+
+[SpawnFest](https://spawnfest.org/) is an annual 48-hour online software development contest in which teams from around the world get exactly one weekend to create the best BEAM-based applications they can.
+
+Over the years, we've seen many fantastic projects coming out of SpawnFest. We're excited to partner with them this year to bring that energy to the Livebook community. We're sponsoring a category for Livebook-based projects. The idea is to incentivize the community to develop more ideas on how to use Livebook while also supporting a community event.
+
+There are two kinds of projects you'll be able to build:
+
+* a Livebook notebook
+* a Livebook Smart Cell
+
+You could build all sorts of cool stuff using a Livebook notebook. Here are a few ideas for what to build with a Livebook notebook:
+
+* integrating and playing with APIs
+* data exploration and visualization
+* machine learning models
+* interactive data apps
+
+With [Smart Cells](/blog/v0-6-automate-and-learn-with-smart-cells), you can build a custom notebook cell that could be reused by your notebooks or other community members.
+
+If you want to see some examples of custom Smart Cells, here's a Smart Cell that [allows querying the GitHub GraphQL API](https://github.com/sdball/github_graphql_smartcell). And here's another one that [allows connecting to a remote node in an Elixir cluster](https://github.com/zoten/cluster_connect_smartcell) and optionally send a `:erpc` call.
+
+And if you'd like a few ideas of what to build using a Smart Cell, here are a few:
+
+* a Smart Cell that sends a message to Slack
+* a Smart Cell where you could fill in some input fields, and then it sends an HTTP request to some API
+* a Smart Cell that builds a connection to a database, service, or server
+
+## How to get started with Livebook
+
+If you haven't used Livebook yet, it's easier than ever to get started because of our new desktop app. You can [download and install it](/#install) in a couple of minutes.
+
+Once you have installed it, you can use the built-in notebooks to learn how to use Livebook. You can do that by opening Livebook and going to Explore section:
+
+
+
+
+
+In the Explore section, you'll find many notebooks that will help you to learn how to use Livebook. We currently have builtin notebooks about:
+
+* learning Elixir
+* how to use Livebook itself
+* how to create charts (using VegaLite)
+* how to plot maps using geospatial and tabular data (using MapLibre)
+* how to build interactive notebooks (using Kino)
+* how to build a custom Smart Cell
+
+This year SpawnFest will be on October 15th and 16th. [Visit the event's website](https://spawnfest.org/) to learn more about it and how to register.
+
+We're looking forward to seeing what you'll build using Livebook! =D
diff --git a/src/blog/2022/09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook.md b/src/blog/2022/09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook.md
new file mode 100644
index 0000000..6b519d5
--- /dev/null
+++ b/src/blog/2022/09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook.md
@@ -0,0 +1,113 @@
+---
+title: "How to query and visualize data from Amazon Athena using Livebook"
+description: "In this blog post, you'll learn how to use Livebook to connect to Amazon Athena, execute a SQL query against it, and visualize the data."
+date: 2022-09-28
+tags: ["tutorials"]
+---
+
+Livebook has built-in integrations with many data sources, including Amazon Athena.
+
+In this blog post, you'll learn how to use Livebook to connect to Amazon Athena, execute a SQL query against it, and visualize the data.
+
+You can also run this tutorial inside your Livebook instance by clicking the button below:
+
+[](/run?url=https%3A%2F%2Fgithub.com%2Fhugobarauna%2Flivebook-notebooks%2Fblob%2Fmain%2Famazon_athena_integration.livemd)
+
+## Connecting to Amazon Athena using the Database connection Smart cell
+
+To connect to Amazon Athena, you'll need the following info from your AWS account:
+
+* AWS access key ID
+* AWS secret access key
+* Athena database name
+* S3 bucket to write query results to
+
+Now, let's create an Amazon Athena connection using a Database connection Smart cell. Click the options "Smart > Database connection > Amazon Athena":
+
+
+
+Once you've done that, you'll see a Smart cell with input fields to configure your Amazon Athena connection:
+
+
+
+Fill in the following fields to configure your connection:
+
+* Add your AWS access key ID
+* Add your AWS secret access key
+* Add your Athena database name
+* Add your S3 bucket in the "Output Location" field
+
+Now, click the "Evaluate" icon to run that Smart cell. Once you've done that, the Smart cell will configure the connection and assign it to a variable called `conn`.
+
+## Querying Amazon Athena using the SQL Query Smart cell
+
+Before querying Athena, we need to have an Athena table to query from. So, let's create one.
+
+We'll create an Athena table based on a public dataset published on AWS Open Data. We'll use the [GHCN-Daily dataset](https://github.com/awslabs/open-data-docs/tree/main/docs/noaa/noaa-ghcn), which contains climate records measured by thousands of climate stations worldwide. Let's create an Athena table called `stations` with metadata about those climate stations.
+
+To do that, Add a new SQL Query Smart cell by clicking the options "Smart > SQL Query":
+
+
+
+Copy and paste the SQL code below to the SQL Query cell:
+
+```sql
+CREATE EXTERNAL TABLE IF NOT EXISTS default.stations (
+ station_id string,
+ latitude double,
+ longitude double,
+ elevation double,
+ name string)
+ROW FORMAT SERDE
+ 'org.apache.hadoop.hive.serde2.RegexSerDe'
+WITH SERDEPROPERTIES (
+ 'input.regex'='([^ ]*) *([^ ]*) *([^ ]*) *([^ ]*) *(.+)$')
+STORED AS INPUTFORMAT
+ 'org.apache.hadoop.mapred.TextInputFormat'
+OUTPUTFORMAT
+ 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
+LOCATION
+ 's3://livebook-blog/amazon-athena-integration'
+TBLPROPERTIES (
+ 'typeOfData'='file')
+```
+
+Now, click the "Evaluate" icon to run that Smart cell. Now we have an Athena table to query from.
+
+Add a new SQL Query Smart cell and copy and paste the following SQL query to it:
+
+```sql
+select * from default.stations order by station_id
+```
+
+Evaluate that cell. It will query your Athena table and assign the results to a `result2` variable. You'll see the result of that query in a tabular format like this:
+
+
+
+## Visualizing geographic coordinates data using the Map Smart cell
+
+Notice that the table we created has each climate station's latitude and longitude information. We can visualize that data with a map visualization using the Map Smart cell. Let's do that.
+
+Add a Map Smart cell by clicking the options "Smart > Map":
+
+
+
+Your Map Smart cell will look something like this:
+
+
+
+Use your Map Smart cell to configure:
+
+* the layer name
+* the data source
+* the coordinates format
+* the longitude field
+* the latitude field
+
+
+
+Once you've configured the Smart cell, you can evaluate it, and it will build a map for you. It will look something like this:
+
+
+
+That's it! Using Livebook Smart cells, you can connect to an Amazon Athena database, execute a SQL query against it and visualize the result.
diff --git a/src/blog/2022/10-11-whats-new-in-livebook-0-7.md b/src/blog/2022/10-11-whats-new-in-livebook-0-7.md
new file mode 100644
index 0000000..14cab93
--- /dev/null
+++ b/src/blog/2022/10-11-whats-new-in-livebook-0-7.md
@@ -0,0 +1,242 @@
+---
+title: "What's new in Livebook 0.7"
+description: "Livebook v0.7 is out! This is a major release coming with significant features in the following areas:"
+date: 2022-10-11
+tags: ["releases"]
+---
+
+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:
+
+```elixir
+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`:
+
+```elixir
+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:
+
+
+
+
+
+## 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:
+
+```elixir
+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](/blog/v0-5-flowcharts-custom-widgets-intellisense-and-ui-improvements), Livebook has a way to show visual widgets to the user, through its [Kino package](https://github.com/livebook-dev/kino). 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:
+
+
+
+
+
+This feature has been [contributed](https://github.com/livebook-dev/kino/pulls?q=is%3Apr+author%3Aakoutmos) by [Alex Koutmos](https://twitter.com/akoutmos), and it is a great example of how modern notebooks can benefit from an open-source community.
+
+## Interactive user interface to visualize and edit Elixir pipelines
+
+[Elixir 1.14](https://elixir-lang.org/blog/2022/09/01/elixir-v1-14-0-released/) 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
+"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](https://twitter.com/nakaji573) created a [cool example](https://qiita.com/RyoWakabayashi/items/7d9eff9df1041c705713) showing how that could be applied to a pipeline that is using Elixir to process an image using [Evision](https://github.com/cocoa-xu/evision):
+
+```elixir
+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](https://github.com/livebook-dev/livebook/blob/main/CHANGELOG.md#v070-2022-10-07)
+* [Kino’s changelog](https://github.com/livebook-dev/kino/blob/main/CHANGELOG.md#v070-2022-10-07)
+* [KinoDB’s changelog](https://github.com/livebook-dev/kino_db/blob/main/CHANGELOG.md#v020-2022-10-07)
+
+### 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:
+
+```elixir
+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:
+
+```elixir
+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("")
+ 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](https://github.com/livebook-dev/livebook#desktop-app) 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](/#install)
+2. Import [this notebook](https://github.com/hugobarauna/livebook-notebooks/blob/main/whats_new_in_livebook_v07.livemd) containing a demo of the new features
+
+[](/run?url=https%3A%2F%2Fgithub.com%2Fhugobarauna%2Flivebook-notebooks%2Fblob%2Fmain%2Fwhats_new_in_livebook_v07.livemd)
+
+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!
diff --git a/src/blog/2022/12-08-announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir.md b/src/blog/2022/12-08-announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir.md
new file mode 100644
index 0000000..bf230f6
--- /dev/null
+++ b/src/blog/2022/12-08-announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir.md
@@ -0,0 +1,94 @@
+---
+title: "Announcing Bumblebee: GPT2, Stable Diffusion, and more in Elixir"
+description: "We have implemented several models, from GPT2 to Stable Diffusion, in pure Elixir, and you can download training parameters for said models directly from Hugging Face. Run Machine Learning models in three clicks with Livebook."
+date: 2022-12-08
+tags: ["announcements"]
+---
+
+We are glad to announce a variety of Neural Networks models are now available to the Elixir community via [the Bumblebee project](https://github.com/elixir-nx/bumblebee).
+
+We have implemented several models, from GPT2 to Stable Diffusion, in pure Elixir, and you can download training parameters for said models directly from [Hugging Face](https://huggingface.co/).
+
+To run your first Machine Learning model in Elixir, all you need is three clicks, thanks to [our integration between Livebook and Bumblebee](https://github.com/livebook-dev/kino_bumblebee). You can also easily embed and run said models within existing Elixir projects.
+
+Watch the video by José Valim covering all of these topics and features:
+
+
+
+
+
+## Running Machine Learning models with Livebook
+
+Here are some examples of what it looks like to use [Livebook to run Machine Learning models](https://github.com/livebook-dev/kino_bumblebee):
+
+### Text to image
+
+
+
+### Image classification
+
+
+
+### Text classification
+
+
+
+### Text generation
+
+
+
+## Incorporating models into any Elixir project
+
+Thanks to the new [Nx.Serving](https://hexdocs.pm/nx/Nx.Serving.html) functionality, you should be able to incorporate those models into any existing project with little effort and run them at scale.
+
+You should be able to embed and serve these models as part of your existing Phoenix web applications, integrate them into data processing pipelines with Broadway, and deploy them alongside Nerves embedded systems - without needing 3rd-party dependencies.
+
+Here’s [an example](https://github.com/elixir-nx/bumblebee/blob/main/examples/phoenix/image_classification.exs) of using Bumblebee to run an image classification model inside a Phoenix app:
+
+
+
+
+
+## Integration with Hugging Face
+
+Bumblebee allows you to download and use trained models directly from Hugging Face. Let’s see [an example](https://github.com/elixir-nx/bumblebee/blob/main/notebooks/examples.livemd#text-generation) of how we can generate text continuation using the popular GPT-2 model:
+
+```elixir
+{:ok, gpt2} = Bumblebee.load_model({:hf, "gpt2"})
+{:ok, tokenizer} = Bumblebee.load_tokenizer({:hf, "gpt2"})
+
+serving = Bumblebee.Text.generation(gpt2, tokenizer, max_new_tokens: 10)
+
+text = "Yesterday, I was reading a book and"
+Nx.Serving.run(serving, text)
+
+#=> %{
+#=> results: [
+#=> %{
+#=> text: "Yesterday I was reading a book and I was thinking, 'What's going on?'"
+#=> }
+#=> ]
+#=> }
+```
+
+As you can see, we just load the model data and use a high-level function designed for the text generation task, that’s it!
+
+## Compiling to CPU/GPU
+
+All of our Neural Networks can be compiled to the CPU/GPU, thanks to projects such as [EXLA](https://github.com/elixir-nx/nx/tree/main/exla) (based on Google XLA) and [Torchx](https://github.com/elixir-nx/nx/tree/main/torchx) (based on Libtorch).
+
+## A massive milestone in our Numerical Elixir effort
+
+This release is a huge milestone in our Numerical Elixir effort, which started almost two years ago. These new features, in particular, are possible thanks to the enormous efforts of José Valim, Jonatan Kłosko, Sean Moriarity, and Paulo Valente. We are also thankful to Hugging Face for enabling collaborative Machine Learning across communities and tools, which played an essential role in bringing the Elixir ecosystem up to speed.
+
+Next, we plan to focus on training and transfer learning of Neural Networks in Elixir, allowing developers to augment and specialize pre-trained models according to the needs of their businesses and applications. We also hope to publish more on our progress in developing traditional Machine Learning algorithms.
+
+## Your turn
+
+If you want to give Bumblebee a try, you can:
+
+* Download [Livebook v0.8](/) and automatically generate “Neural Networks tasks” from the “+ Smart” cell menu inside your notebooks.
+* We have also written [single-file Phoenix applications](https://github.com/elixir-nx/bumblebee/tree/main/examples/phoenix) as examples of Bumblebee models inside Phoenix (+ LiveView) apps. Those should provide the necessary building blocks to integrate Bumblebee into your production app.
+* For a more hands-on approach, read some of our [notebooks](https://github.com/elixir-nx/bumblebee/tree/main/notebooks).
+
+If you want to help us build the Machine Learning ecosystem for Elixir, check out the projects above, and give them a try. There are many exciting areas, from compiler development to model building. For instance, pull requests that bring more models and architectures to Bumblebee are welcome. The future is concurrent, distributed, and fun!
diff --git a/src/blog/2023/01-12-whats-new-in-livebook-0-8.md b/src/blog/2023/01-12-whats-new-in-livebook-0-8.md
new file mode 100644
index 0000000..5805b45
--- /dev/null
+++ b/src/blog/2023/01-12-whats-new-in-livebook-0-8.md
@@ -0,0 +1,165 @@
+---
+title: "What's new in Livebook 0.8"
+description: "This post showcases ten of the most noteworthy features released with Livebook 0.8."
+date: 2023-01-12
+tags: ["releases"]
+---
+
+Livebook 0.8 [was launched a few weeks ago](/blog/announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir), 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](https://www.microsoft.com/en-us/research/publication/whats-wrong-with-computational-notebooks/) 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](https://elixir-lang.org/blog/2022/12/22/cheatsheets-and-8-other-features-in-exdoc-that-improve-the-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](https://katex.org/))
+
+
+
+
+
+## View and delete secrets in the sidebar
+
+Livebook 0.7 [introduced secret management](/blog/whats-new-in-livebook-0-7). 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](https://hexdocs.pm/kino/Kino.Input.html) 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](https://hexdocs.pm/kino/Kino.Input.html#image/2):
+
+
+
+
+
+## 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](https://github.com/livebook-dev/kino/pull/208) by [Stefan Chrobot](https://twitter.com/StefanChrobot). He started the project during [Spawnfest](https://spawnfest.org/) and won 2nd place overall. Shout out to him!
+
+## Neural Network Smart cell
+
+We discussed that new feature in detail [in a previous post](/blog/announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir). 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](/#install) the new Livebook version
+* Import a notebook containing a demo of the new features by clicking on the badge below
+
+[](/run?url=https%3A%2F%2Fgithub.com%2Fhugobarauna%2Flivebook-notebooks%2Fblob%2Fmain%2Fwhats_new_in_livebook_v08.livemd)
+
+Happy hacking!
diff --git a/src/blog/2023/01-30-whats-new-in-livebook-0-8-1.md b/src/blog/2023/01-30-whats-new-in-livebook-0-8-1.md
new file mode 100644
index 0000000..383f69c
--- /dev/null
+++ b/src/blog/2023/01-30-whats-new-in-livebook-0-8-1.md
@@ -0,0 +1,100 @@
+---
+title: "What’s new in Livebook 0.8.1"
+description: "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!"
+date: 2023-01-30
+tags: ["releases"]
+---
+
+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](https://hexdocs.pm/kino/Kino.Input.html) that allow users to input data into the notebook.
+
+This new version comes with two new inputs, one of them is the [file input](https://hexdocs.pm/kino/Kino.Input.html#file/2). 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](https://hexdocs.pm/kino/Kino.Input.html#audio/2).
+
+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](https://hexdocs.pm/kino/Kino.Input.html#image/2) 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](https://github.com/livebook-dev/livebook/pull/1595) by [Cocoa Xu](https://twitter.com/_uwu_cocoa).
+
+## 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`:
+
+```elixir
+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](/blog/whats-new-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](https://hub.docker.com/r/livebook/livebook/tags) with CUDA libraries installed.
+
+[CUDA](https://en.wikipedia.org/wiki/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](/blog/announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir) is even easier!
+
+## Try it!
+
+To play with the new features, all you need to do is:
+
+* [Install](/#install) the new Livebook version
+* Import the notebook containing a demo of the new features by clicking on the badge below
+
+[](/run?url=https%3A%2F%2Fgithub.com%2Fhugobarauna%2Flivebook-notebooks%2Fblob%2Fmain%2Fwhats_new_in_livebook_v0.8.1.livemd)
+
+Happy hacking!
diff --git a/src/blog/2023/02-15-livebook-inside-hugging-face-spaces.md b/src/blog/2023/02-15-livebook-inside-hugging-face-spaces.md
new file mode 100644
index 0000000..403bedd
--- /dev/null
+++ b/src/blog/2023/02-15-livebook-inside-hugging-face-spaces.md
@@ -0,0 +1,32 @@
+---
+title: "Livebook inside Hugging Face Spaces"
+description: "This blog post announces the integration of Livebook and Hugging Face Spaces."
+date: 2023-02-15
+tags: ["announcements"]
+---
+
+We are thrilled to introduce Livebook on Hugging Face Spaces! 🎉
+
+Each [Hugging Face Space environment](https://huggingface.co/docs/hub/spaces-overview#hardware-resources) 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](/integrations/hugging-face); [the first](/blog/announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir) 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:
+
+[](http://huggingface.co/new-space?template=livebook-dev/livebook)
+
+Alternatively, follow the step-by-step tutorial to [install Livebook in a Hugging Face Space](https://huggingface.co/docs/hub/spaces-sdks-docker-livebook).
+
+## Livebook with GPU acceleration on Hugging Face Spaces
+
+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.
diff --git a/src/blog/2023/03-21-announcing-livebook-0-9.md b/src/blog/2023/03-21-announcing-livebook-0-9.md
new file mode 100644
index 0000000..84d7c5f
--- /dev/null
+++ b/src/blog/2023/03-21-announcing-livebook-0-9.md
@@ -0,0 +1,18 @@
+---
+title: "Announcing Livebook 0.9"
+description: "We are thrilled to announce the latest release of Livebook, version 0.9! 🎉"
+date: 2023-03-21
+tags: ["releases"]
+---
+
+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](/#install).
+
+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](https://github.com/livebook-dev/livebook/tree/v0.9.0#docker) from "livebook/livebook" to "ghcr.io/livebook-dev/livebook."
+
+Stay tuned for more updates!
diff --git a/src/blog/2023/04-10-deploy-notebooks-as-apps-quality-of-life-upgrades-launch-week-1-day-1.md b/src/blog/2023/04-10-deploy-notebooks-as-apps-quality-of-life-upgrades-launch-week-1-day-1.md
new file mode 100644
index 0000000..f60449c
--- /dev/null
+++ b/src/blog/2023/04-10-deploy-notebooks-as-apps-quality-of-life-upgrades-launch-week-1-day-1.md
@@ -0,0 +1,103 @@
+---
+title: "Deploy notebooks as apps & quality-of-life upgrades - Launch Week 1 - Day 1"
+description: "Explore Livebook 0.9's new features: deploy notebooks as user-friendly apps, star & access recent notebooks, and collapse sections. Learn how to build and deploy your notebook as an app with Livebook."
+date: 2023-04-10
+tags: ["releases", "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.
+
+
+
+
+
+## Deploy Livebook notebooks as apps
+
+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!
+
+
+
+## Quality-of-life improvements
+
+### Star a notebook
+
+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](https://github.com/ByeongUkChoi) for [adding that feature](https://github.com/livebook-dev/livebook/pull/1639) as a community contributor.
+
+### Recent notebooks
+
+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](https://github.com/ByeongUkChoi) for [adding that feature](https://github.com/livebook-dev/livebook/pull/1639) as a community contributor.
+
+### Collapse sections
+
+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](https://github.com/jannikbecher) for [adding that feature](https://github.com/livebook-dev/livebook/pull/1772) as a community contributor.
+
+## What now?
+
+We encourage you to go ahead and [install Livebook’s latest version](/#install) 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](https://twitter.com/intent/tweet?text=I%27m%20loving%20the%20new%20Livebook%200.9!%20%23LivebookLaunchWeek) hashtag.
+
+Stay tuned for the following announcement of the Livebook Launch Week!
+
+## More Launch Week
+
+* [Day 2: Distributed² Machine Learning notebooks with Elixir and Livebook](/blog/distributed2-machine-learning-notebooks-with-elixir-and-livebook-launch-week-1-day-2)
+* [Day 3: Hubs and secret management](/blog/hubs-and-secret-management-launch-week-1-day-3)
+* [Day 4: Build and deploy a Whisper chat app to Hugging Face in 15 minutes](/blog/build-and-deploy-a-whisper-chat-app-to-hugging-face-in-15-minutes-launch-week-1-day-4)
+* [Day 5: Data wrangling in Elixir with Explorer, the power of Rust, the elegance of R](/blog/data-wrangling-in-elixir-with-explorer-the-power-of-rust-the-elegance-of-r-launch-week-1-day-5)
diff --git a/src/blog/2023/04-11-distributed2-machine-learning-notebooks-with-elixir-and-livebook-launch-week-1-day-2.md b/src/blog/2023/04-11-distributed2-machine-learning-notebooks-with-elixir-and-livebook-launch-week-1-day-2.md
new file mode 100644
index 0000000..9628311
--- /dev/null
+++ b/src/blog/2023/04-11-distributed2-machine-learning-notebooks-with-elixir-and-livebook-launch-week-1-day-2.md
@@ -0,0 +1,92 @@
+---
+title: "Distributed² Machine Learning notebooks with Elixir and Livebook - Launch Week 1 - Day 2"
+description: "Explore Livebook v0.9's enhanced Machine Learning features: new Neural Network tasks with the built-in Smart Cell, Distributed² Machine Learning in Elixir, and more."
+date: 2023-04-11
+tags: ["releases", "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!
+
+
+
+
+
+## Distributed² Machine Learning with Elixir
+
+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](https://hexdocs.pm/nx/Nx.Serving.html#module-stateful-process-workflow), the distribution can happen on two dimensions:
+
+* it can be distributed to multiple machines
+* inside each machine, it can be distributed to multiple GPUs
+
+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](https://youtu.be/MSMyRBJAoSs?t=232).
+
+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](https://github.com/elixir-nx/nx/pull/1090), including docs and tests!
+
+## New Machine Learning models available
+
+Neural network tasks were initially [added to Livebook version 0.8](/blog/announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir) 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.
+
+### Speech-to-text
+
+
+
+
+
+### Conversation
+
+
+
+
+
+### Question answering
+
+
+
+
+
+### Language detection
+
+
+
+
+
+### Zero-shot text classification
+
+
+
+
+
+### Punctuation
+
+
+
+
+
+## What now?
+
+We encourage you to go ahead and [install Livebook’s latest version](/#install) 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](https://twitter.com/intent/tweet?text=I%27m%20loving%20the%20new%20Livebook%200.9!%20%23LivebookLaunchWeek) hashtag.
+
+Stay tuned for the following announcement of the Livebook Launch Week!
+
+## More Launch Week
+
+* [Day 1: Deploy notebooks as apps & quality-of-life upgrades](/blog/deploy-notebooks-as-apps-quality-of-life-upgrades-launch-week-1-day-1)
+* [Day 3: Hubs and secret management](/blog/hubs-and-secret-management-launch-week-1-day-3)
+* [Day 4: Build and deploy a Whisper chat app to Hugging Face in 15 minutes](/blog/build-and-deploy-a-whisper-chat-app-to-hugging-face-in-15-minutes-launch-week-1-day-4)
+* [Day 5: Data wrangling in Elixir with Explorer, the power of Rust, the elegance of R](/blog/data-wrangling-in-elixir-with-explorer-the-power-of-rust-the-elegance-of-r-launch-week-1-day-5)
diff --git a/src/blog/2023/04-12-hubs-and-secret-management-launch-week-1-day-3.md b/src/blog/2023/04-12-hubs-and-secret-management-launch-week-1-day-3.md
new file mode 100644
index 0000000..e8ba85a
--- /dev/null
+++ b/src/blog/2023/04-12-hubs-and-secret-management-launch-week-1-day-3.md
@@ -0,0 +1,97 @@
+---
+title: "Hubs and secret management - Launch Week 1 - Day 3"
+description: "Discover Livebook 0.9's new security features, including Hubs for centralized secret management and notebook stamping."
+date: 2023-04-12
+tags: ["releases", "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.
+
+Let’s dive in and discover how these features can improve your workflow and secure your notebooks!
+
+
+
+
+
+## What’s wrong with computational notebooks?
+
+Throughout the development of Livebook, one of the sources that [informed our roadmap](https://github.com/livebook-dev/livebook/issues/1223) was a paper published in 2020 called [“What’s Wrong with Computational Notebooks? Pain Points, Needs, and Design Opportunities”](https://www.microsoft.com/en-us/research/publication/whats-wrong-with-computational-notebooks/). 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](/blog/whats-new-in-livebook-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.
+
+## Livebook Hubs
+
+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.
+
+
+
+## Notebook 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.
+
+## What now?
+
+We encourage you to go ahead and [install Livebook’s latest version](/#install) 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](https://twitter.com/intent/tweet?text=I%27m%20loving%20the%20new%20Livebook%200.9!%20%23LivebookLaunchWeek) hashtag.
+
+Stay tuned for the following announcement of the Livebook Launch Week!
+
+## More Launch Week
+
+* [Day 1: Deploy notebooks as apps & quality-of-life upgrades](/blog/deploy-notebooks-as-apps-quality-of-life-upgrades-launch-week-1-day-1)
+* [Day 2: Distributed² Machine Learning notebooks with Elixir and Livebook](/blog/distributed2-machine-learning-notebooks-with-elixir-and-livebook-launch-week-1-day-2)
+* [Day 4: Build and deploy a Whisper chat app to Hugging Face in 15 minutes](/blog/build-and-deploy-a-whisper-chat-app-to-hugging-face-in-15-minutes-launch-week-1-day-4)
+* [Day 5: Data wrangling in Elixir with Explorer, the power of Rust, the elegance of R](/blog/data-wrangling-in-elixir-with-explorer-the-power-of-rust-the-elegance-of-r-launch-week-1-day-5)
diff --git a/src/blog/2023/04-13-build-and-deploy-a-whisper-chat-app-to-hugging-face-in-15-minutes-launch-week-1-day-4.md b/src/blog/2023/04-13-build-and-deploy-a-whisper-chat-app-to-hugging-face-in-15-minutes-launch-week-1-day-4.md
new file mode 100644
index 0000000..87cea4c
--- /dev/null
+++ b/src/blog/2023/04-13-build-and-deploy-a-whisper-chat-app-to-hugging-face-in-15-minutes-launch-week-1-day-4.md
@@ -0,0 +1,55 @@
+---
+title: "Build and deploy a Whisper chat app to Hugging Face in 15 minutes - Launch Week 1 - Day 4"
+description: "Learn how to use Livebook to build a Machine Learning app and deploy it to Hugging Face in less than 15 minutes."
+date: 2023-04-13
+tags: ["releases", "launch week"]
+---
+
+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](https://huggingface.co/spaces/josevalim/livebook).
+
+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](/blog/deploy-notebooks-as-apps-quality-of-life-upgrades-launch-week-1-day-1), 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](/blog/distributed2-machine-learning-notebooks-with-elixir-and-livebook-launch-week-1-day-2), 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.
+
+## What now?
+
+Want to run the Whisper chat app by yourself?
+
+First, ensure you’ve [installed the latest version of Livebok](/#install).
+
+Then, click the button below to run the notebook yourself:
+
+[](/run?url=https%3A%2F%2Fgist.githubusercontent.com%2Fhugobarauna%2F7011f0b0d85a8ba520308e6b936cdfcf%2Fraw%2F8b5a968a90b55a461273ae9ce375f9525dee5ef6%2Fwhisper_chat.livemd)
+
+If you have any comments or want to share what you’ve built using Livebook, you can [tweet using the #LivebookLaunchWeek](https://twitter.com/intent/tweet?text=I%27m%20loving%20the%20new%20Livebook%200.9!%20%23LivebookLaunchWeek) hashtag.
+
+Stay tuned for the final announcement of the Livebook Launch Week!
+
+## More Launch Week
+
+* [Day 1: Deploy notebooks as apps & quality-of-life upgrades](/blog/deploy-notebooks-as-apps-quality-of-life-upgrades-launch-week-1-day-1)
+* [Day 2: Distributed² Machine Learning notebooks with Elixir and Livebook](/blog/distributed2-machine-learning-notebooks-with-elixir-and-livebook-launch-week-1-day-2)
+* [Day 3: Hubs and secret management](/blog/hubs-and-secret-management-launch-week-1-day-3)
+* [Day 5: Data wrangling in Elixir with Explorer, the power of Rust, the elegance of R](/blog/data-wrangling-in-elixir-with-explorer-the-power-of-rust-the-elegance-of-r-launch-week-1-day-5)
diff --git a/src/blog/2023/04-14-data-wrangling-in-elixir-with-explorer-the-power-of-rust-the-elegance-of-r-launch-week-1-day-5.md b/src/blog/2023/04-14-data-wrangling-in-elixir-with-explorer-the-power-of-rust-the-elegance-of-r-launch-week-1-day-5.md
new file mode 100644
index 0000000..c51b0d1
--- /dev/null
+++ b/src/blog/2023/04-14-data-wrangling-in-elixir-with-explorer-the-power-of-rust-the-elegance-of-r-launch-week-1-day-5.md
@@ -0,0 +1,81 @@
+---
+title: "Data wrangling in Elixir with Explorer, the power of Rust, the elegance of R - Launch Week 1 - Day 5"
+description: "This post introduces the new data features in Livebook 0.9: fast data exploration through integration with Explorer, interactive data tables, and data transformation using the new Data Transform Smart cell."
+date: 2023-04-14
+tags: ["releases", "launch week"]
+---
+
+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: series and dataframes for fast data exploration in Elixir
+
+[Explorer](https://github.com/elixir-nx/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](https://www.pola.rs/) project, a highly performant dataframe Rust library. And it’s highly inspired by the [dplyr](https://dplyr.tidyverse.org/) 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.
+
+## Visualizing an Explorer dataframe as an interactive table
+
+[Kino](https://hexdocs.pm/kino/Kino.html) 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](https://hexdocs.pm/kino/Kino.html#module-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:
+
+
+
+
+
+## Data transformation using the new Data Transform Smart cell
+
+In Livebook, a [Smart cell](https://hexdocs.pm/kino/Kino.SmartCell.html) is a UI-based cell that helps you to accomplish a specific task like [creating a database connection](/blog/how-to-query-and-visualize-data-from-google-bigquery-using-livebook), [sending a message to a Slack channel](https://github.com/livebook-dev/kino_slack), or [running a Machine Learning model](/blog/announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir).
+
+Livebook has various built-in Smart cells, and anyone can [build a Smart cell](https://hexdocs.pm/kino/Kino.SmartCell.html) 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.
+
+
+
+
+
+## What now?
+
+Want to play with all of those new features?
+
+First, ensure you’ve [installed the latest version of Livebook](/#install).
+
+Then, click the button below to run the notebook that José Valim built in the demo video:
+
+[](/run?url=https%3A%2F%2Fgist.githubusercontent.com%2Fhugobarauna%2Fcd509c9ea429c3e6a664b64e34a6c31c%2Fraw%2Fde7ef09070178792a1439a8c1ddcbce3da2c10ff%2Fdata_wrangling_with_explorer.livemd)
+
+If you have any comments or want to share what you’ve built using Livebook, you can [tweet using the #LivebookLaunchWeek](https://twitter.com/intent/tweet?text=I%27m%20loving%20the%20new%20Livebook%200.9!%20%23LivebookLaunchWeek) hashtag.
+
+I hope you got as excited as we did with this new Livebook 0.9 release.
+
+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. 😄
+
+## More Launch Week
+
+* [Day 1: Deploy notebooks as apps & quality-of-life upgrades](/blog/deploy-notebooks-as-apps-quality-of-life-upgrades-launch-week-1-day-1)
+* [Day 2: Distributed² Machine Learning notebooks with Elixir and Livebook](/blog/distributed2-machine-learning-notebooks-with-elixir-and-livebook-launch-week-1-day-2)
+* [Day 3: Hubs and secret management](/blog/hubs-and-secret-management-launch-week-1-day-3)
+* [Day 4: Build and deploy a Whisper chat app to Hugging Face in 15 minutes](/blog/build-and-deploy-a-whisper-chat-app-to-hugging-face-in-15-minutes-launch-week-1-day-4)
diff --git a/src/blog/2023/07-14-whats-new-in-livebook-0-10-introducing-multi-session-livebook-apps.md b/src/blog/2023/07-14-whats-new-in-livebook-0-10-introducing-multi-session-livebook-apps.md
new file mode 100644
index 0000000..85a6aba
--- /dev/null
+++ b/src/blog/2023/07-14-whats-new-in-livebook-0-10-introducing-multi-session-livebook-apps.md
@@ -0,0 +1,93 @@
+---
+title: "What's new in Livebook 0.10 - Introducing Multi-Session Livebook Apps"
+description: "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: 2023-07-14
+tags: ["releases"]
+---
+
+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.
+
+## Multi-Session Livebook Apps
+
+[Livebook 0.9 introduced Livebook apps](/blog/deploy-notebooks-as-apps-quality-of-life-upgrades-launch-week-1-day-1). 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.
+
+
+
+
+
+## Presentation View
+
+We noticed many people [use Livebook for presentations](https://www.youtube.com/watch?v=b9BQM40UzEs&t=564s). 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](https://github.com/aifrak) 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!
+
+## Initial Erlang Support
+
+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](https://github.com/filmor). Thanks to him, Livebook now supports multiple BEAM languages.
+
+## Live Doctests
+
+Starting from version 0.8, [doctests are integrated with Livebook](/blog/whats-new-in-livebook-0-8). 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](https://github.com/livebook-dev/livebook/issues/1351) into Livebook, [the idea](https://www.microsoft.com/en-us/research/publication/usable-live-programming/) 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](https://github.com/Sleepful) and the [research work of Szymon Kaliski](https://szymonkaliski.com/projects/live-coding-livebook/).
+
+## Dataframe File Export
+
+When working on a [data analysis task using Livebook](/blog/data-wrangling-in-elixir-with-explorer-the-power-of-rust-the-elegance-of-r-launch-week-1-day-5), 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:
+
+
+
+
+
+## Try it!
+
+To play with the new features, follow these steps:
+
+* [Install](/#install) the latest Livebook version
+* Import the demo notebook that showcases the new features by clicking the badge below
+
+[](/run?url=https%3A%2F%2Fgithub.com%2Fhugobarauna%2Flivebook-notebooks%2Fblob%2Fmain%2Fwhats_new_in_livebook_v0.10.livemd)
+
+And if you want to discover everything that changed in 0.10, here’s [the changelog](https://github.com/livebook-dev/livebook/blob/v0.10/CHANGELOG.md).
+
+Happy hacking!
diff --git a/src/blog/2023/08-16-livebook-is-sponsoring-spawnfest-again.md b/src/blog/2023/08-16-livebook-is-sponsoring-spawnfest-again.md
new file mode 100644
index 0000000..9fa0af1
--- /dev/null
+++ b/src/blog/2023/08-16-livebook-is-sponsoring-spawnfest-again.md
@@ -0,0 +1,112 @@
+---
+title: "Livebook is sponsoring SpawnFest again"
+description: "Join Spawnfest, the 48-hour BEAM-based app contest, build a Livebook App and have fun."
+date: 2023-08-16
+tags: ["announcements"]
+---
+
+We’re happy to announce that we’re sponsoring [Spawnfest](https://spawnfest.org/?ref=livebook) 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](/blog/deploy-notebooks-as-apps-quality-of-life-upgrades-launch-week-1-day-1) that enables you to turn your notebook into an interactive web application.
+
+## What you can build with Livebook Apps
+
+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.
+
+### A multi-user real-time app
+
+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.
+
+
+
+
+
+### A machine learning app
+
+Livebook [integrates with Hugging Face](/integrations/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.
+
+
+
+
+
+### A data visualization app
+
+Livebook [integrates with Vegalite](/integrations/vega-lite/) and [Maplibre](/integrations/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](https://hugobarauna-livebook.hf.space/apps/github-stars/76zaly3wjkfo67p5iqmxaicmum5a5ampdpsmywft). And here is the [source code](https://huggingface.co/spaces/hugobarauna/livebook/blob/main/public-apps/github_stars.livemd).
+
+### A workflow automation app
+
+One month ago, we expanded Livebook Apps with a feature called [Multi-Session Livebook Apps](/blog/whats-new-in-livebook-0-10-introducing-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.
+
+
+
+
+
+## How to deploy a Livebook App
+
+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.
+
+### How to deploy a Livebook App to [Fly.io](http://fly.io/)
+
+First, make sure you have [Fly’s command-line installed](https://fly.io/docs/hands-on/install-flyctl/) on your machine.
+
+Now, clone the following template repo:
+
+```sh
+git clone https://github.com/hugobarauna/livebook-apps-on-fly-template.git my-livebook-apps
+```
+
+Add 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](https://fly.io/docs/languages-and-frameworks/dockerfile/).
+
+After that, Livebook and your Livebook App will be running inside Fly.
+
+Here’s a video showing how that works.
+
+
+
+
+
+### How to deploy a Livebook App to Hugging Face
+
+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](https://huggingface.co/docs/hub/spaces-sdks-docker-livebook#your-first-livebook-space).
+
+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.
+
+
+
+
+
+## How to participate in Spawnfest
+
+Participation in SpawnFest is 100% free of charge. To register, [go to their website](https://spawnfest.org/) and follow the instructions.
+
+We’re looking forward to seeing what you will build with Livebook Apps!
diff --git a/src/blog/2023/10-09-remote-execution-smart-cell-launch-week-2-day-1.md b/src/blog/2023/10-09-remote-execution-smart-cell-launch-week-2-day-1.md
new file mode 100644
index 0000000..98d7f82
--- /dev/null
+++ b/src/blog/2023/10-09-remote-execution-smart-cell-launch-week-2-day-1.md
@@ -0,0 +1,73 @@
+---
+title: "Remote execution Smart cell - Launch Week 2 - Day 1"
+description: "Introducing Remote Execution Smart cell in Livebook v0.11. Run functions on remote nodes effortlessly."
+date: 2023-10-09
+tags: ["releases", "launch week"]
+---
+
+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.
+
+## Calling code from other nodes before the new Smart cell
+
+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.
+
+## Calling code from other nodes using the Remote execution Smart cell
+
+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.
+
+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:
+
+
+
+
+
+## What now?
+
+All of the new features of this new release are already available today!
+
+To start playing with them, [install the latest version](/#install) of Livebook and have fun!
+
+## More of Launch Week 2
+
+* [Day 2: Speech-to-text with Whisper: timestamping, streaming, and parallelism, oh-my!](/blog/speech-to-text-with-whisper-timestamping-streaming-and-parallelism-oh-my-launch-week-2-day-2)
+* [Day 3: Introducing File Integration](/blog/introducing-file-integration-launch-week-2-day-3)
+* [Day 4: Integration with SnowFlake and Microsoft SQL Server](/blog/integration-with-snowflake-and-microsoft-sql-server-launch-week-2-day-4)
+* [Day 5: Vim and Emacs key bindings](/blog/vim-and-emacs-key-bindings-launch-week-2-day-5)
diff --git a/src/blog/2023/10-10-speech-to-text-with-whisper-timestamping-streaming-and-parallelism-oh-my-launch-week-2-day-2.md b/src/blog/2023/10-10-speech-to-text-with-whisper-timestamping-streaming-and-parallelism-oh-my-launch-week-2-day-2.md
new file mode 100644
index 0000000..27f2a21
--- /dev/null
+++ b/src/blog/2023/10-10-speech-to-text-with-whisper-timestamping-streaming-and-parallelism-oh-my-launch-week-2-day-2.md
@@ -0,0 +1,47 @@
+---
+title: "Speech-to-text with Whisper: timestamping, streaming, and parallelism, oh-my! - Launch Week 2 - Day 2"
+description: "Explore the improved Whisper integration with Livebook v0.11. Features include real-time streaming, audio timestamping, and faster processing."
+date: 2023-10-10
+tags: ["releases", "launch week"]
+---
+
+When we [announced Bumblebee](/blog/announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir), 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](https://github.com/elixir-nx), 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](/#install) and start a new notebook. Then click “+ Smart cell” and choose “Neural Network task.” You will find Whisper as Speech-to-text under Audio.
+
+
+
+
+
+## New features
+
+There are three new features in our Whisper integration:
+
+1. Timestamping: we now include timestamps on audio segments.
+2. Streaming: our previous version of Whisper was limited to 30 seconds of audio, leaving it up to users to break their audio apart. This new version is capable of streaming both inputs and outputs. You can give arbitrarily long files to the model, which will be streamed as input, and the model will proceed to merge and stream transcriptions as they arrive.
+3. Parallelism: in addition to streaming, files with more than 30 seconds will be split and batched according to the Neural Network batch size. For example, with a batch size of 10, up to 5 minutes of audio can be processed in parallel. Thanks to this, we expect our models to perform inference an order of magnitude faster compared to Open AI’s implementation when transcribing larger files on the GPU.
+
+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](https://podcast.thinkingelixir.com/46):
+
+
+
+
+
+When you combine the features above with [Nx’s ability to run neural networks distributed across multiple machines and GPUs](/blog/distributed2-machine-learning-notebooks-with-elixir-and-livebook-launch-week-1-day-2), Elixir developers now have a first-class, state-of-the-art, speech-to-text model ready to run, enjoy, and scale.
+
+## What now?
+
+Try for yourself!
+
+Transcribe an audio file using our built-in Neural Network Task Smart cell. Maybe start with a [small file](https://github.com/hugobarauna/livebook-notebooks/blob/main/launch_week_2/live.m4a) to quickly see the result. Then you can try a [bigger one](https://podcast.thinkingelixir.com/46).
+
+[Download the latest Livebook version](/#install) and have fun!
+
+## More of Launch Week 2
+
+* [Day 1: Remote execution Smart cell](/blog/remote-execution-smart-cell-launch-week-2-day-1)
+* [Day 3: Introducing File Integration](/blog/introducing-file-integration-launch-week-2-day-3)
+* [Day 4: Integration with SnowFlake and Microsoft SQL Server](/blog/integration-with-snowflake-and-microsoft-sql-server-launch-week-2-day-4)
+* [Day 5: Vim and Emacs key bindings](/blog/vim-and-emacs-key-bindings-launch-week-2-day-5)
diff --git a/src/blog/2023/10-11-introducing-file-integration-launch-week-2-day-3.md b/src/blog/2023/10-11-introducing-file-integration-launch-week-2-day-3.md
new file mode 100644
index 0000000..c5fdb9d
--- /dev/null
+++ b/src/blog/2023/10-11-introducing-file-integration-launch-week-2-day-3.md
@@ -0,0 +1,109 @@
+---
+title: "Introducing File Integration - Launch Week 2 - Day 3"
+description: "Introducing Livebook v0.11 with file integration—drag and drop files for instant code generation, lazy read large datasets, and more. Explore now!"
+date: 2023-10-11
+tags: ["releases", "launch week"]
+---
+
+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.
+
+
+
+
+
+## Why?
+
+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](/integrations/?type=database). 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.
+
+## What’s the Livebook file integration?
+
+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](/blog/v0-6-automate-and-learn-with-smart-cells). And that’s the approach we’re continuing to apply.
+
+## File references and file attachments
+
+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.
+
+## Lazy data reading and manipulation
+
+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.
+
+## What now?
+
+Ready to take the new Livebook for a spin?
+
+[Install the latest version](/#install), drop [one of those files into](https://github.com/hugobarauna/livebook-notebooks/tree/main/launch_week_2) a notebook, and see what happens!
+
+## More of Launch Week 2
+
+* [Day 1: Remote execution Smart cell](/blog/remote-execution-smart-cell-launch-week-2-day-1)
+* [Day 2: Speech-to-text with Whisper: timestamping, streaming, and parallelism, oh-my!](/blog/speech-to-text-with-whisper-timestamping-streaming-and-parallelism-oh-my-launch-week-2-day-2)
+* [Day 4: Integration with SnowFlake and Microsoft SQL Server](/blog/integration-with-snowflake-and-microsoft-sql-server-launch-week-2-day-4)
+* [Day 5: Vim and Emacs key bindings](/blog/vim-and-emacs-key-bindings-launch-week-2-day-5)
diff --git a/src/blog/2023/10-12-integration-with-snowflake-and-microsoft-sql-server-launch-week-2-day-4.md b/src/blog/2023/10-12-integration-with-snowflake-and-microsoft-sql-server-launch-week-2-day-4.md
new file mode 100644
index 0000000..0010766
--- /dev/null
+++ b/src/blog/2023/10-12-integration-with-snowflake-and-microsoft-sql-server-launch-week-2-day-4.md
@@ -0,0 +1,61 @@
+---
+title: "Integration with Snowflake and Microsoft SQL Server - Launch Week 2 - Day 4"
+description: "Explore Livebook's new database integrations with Snowflake and Microsoft SQL Server. Learn how to connect and execute queries using the Database Connection and SQL Query Smart cells."
+date: 2023-10-12
+tags: ["releases", "launch week"]
+---
+
+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](/integrations/?type=database):
+
+* PostgreSQL
+* MySQL
+* SQL Server
+* SQLite
+* Google BigQuery
+* Amazon Athena
+* Snowflake
+
+Let’s see how the new integrations work.
+
+## Connecting to Snowflake
+
+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](https://github.com/elixir-explorer/adbc), 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](https://hexdocs.pm/explorer/Explorer.DataFrame.html#from_query/4).
+
+Good news for those of us doing data analysis with Elixir and Livebook. 🎉
+
+## Connecting to Microsoft SQL Server
+
+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](https://github.com/simonmcconnell). Curious fact: the [pull request](https://github.com/livebook-dev/kino_db/pull/65) contains less than 250 LOC! Cool, right?! 😎
+
+## What now?
+
+To start playing with those new features, [install the latest version of Livebook](/#install) and have fun!
+
+## More of Launch Week 2
+
+* [Day 1: Remote execution Smart cell](/blog/remote-execution-smart-cell-launch-week-2-day-1)
+* [Day 2: Speech-to-text with Whisper: timestamping, streaming, and parallelism, oh-my!](/blog/speech-to-text-with-whisper-timestamping-streaming-and-parallelism-oh-my-launch-week-2-day-2)
+* [Day 3: Introducing File Integration](/blog/introducing-file-integration-launch-week-2-day-3)
+* [Day 5: Vim and Emacs key bindings](/blog/vim-and-emacs-key-bindings-launch-week-2-day-5)
diff --git a/src/blog/2023/10-13-vim-and-emacs-key-bindings-launch-week-2-day-5.md b/src/blog/2023/10-13-vim-and-emacs-key-bindings-launch-week-2-day-5.md
new file mode 100644
index 0000000..0b6f6f9
--- /dev/null
+++ b/src/blog/2023/10-13-vim-and-emacs-key-bindings-launch-week-2-day-5.md
@@ -0,0 +1,43 @@
+---
+title: "Vim and Emacs key bindings - Launch Week 2 - Day 5"
+description: "Vim and Emacs users can now use their favorite keybindings in Livebook. See our latest update for activation instructions."
+date: 2023-10-13
+tags: ["releases", "launch week"]
+---
+
+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.
+
+## Using Vim or Emacs key bindings in Livebook
+
+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](https://github.com/kenichi), who [contributed that feature](https://github.com/livebook-dev/livebook/pull/2173).
+
+## What now?
+
+To start using that new feature, [install the latest version of Livebook](/#install) and have fun!
+
+## More of Launch Week 2
+
+* [Day 1: Remote execution Smart cell](/blog/remote-execution-smart-cell-launch-week-2-day-1)
+* [Day 2: Speech-to-text with Whisper: timestamping, streaming, and parallelism, oh-my!](/blog/speech-to-text-with-whisper-timestamping-streaming-and-parallelism-oh-my-launch-week-2-day-2)
+* [Day 3: Introducing File Integration](/blog/introducing-file-integration-launch-week-2-day-3)
+* [Day 4: Integration with SnowFlake and Microsoft SQL Server](/blog/integration-with-snowflake-and-microsoft-sql-server-launch-week-2-day-4)
+
+And if you want to discover everything that was added/changed in this release, here’s [the changelog](https://github.com/livebook-dev/livebook/blob/v0.11/CHANGELOG.md).
diff --git a/src/blog/2024/03-26-welcoming-tigris-as-a-new-sponsor-of-livebook.md b/src/blog/2024/03-26-welcoming-tigris-as-a-new-sponsor-of-livebook.md
new file mode 100644
index 0000000..00a5a14
--- /dev/null
+++ b/src/blog/2024/03-26-welcoming-tigris-as-a-new-sponsor-of-livebook.md
@@ -0,0 +1,70 @@
+---
+title: "Welcoming Tigris as a new sponsor of Livebook!"
+description: "See how Tigris's S3-compatible storage and automatic caching enhance UX/DX, demonstrated via a Livebook demo."
+date: 2024-03-26
+tags: ["announcements"]
+---
+
+We're thrilled to announce [Tigris](https://www.tigrisdata.com/) 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.
+
+## Quick intro to Tigris
+
+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:
+
+```elixir
+ExAws.S3.put_object("my_tigris_bucket_name", "cat.jpeg", image)
+|> 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:
+
+```elixir
+object_url = "https://fly.storage.tigris.dev/my_tigris_bucket_name/cat.jpeg"
+Req.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.
+
+## Demo
+
+In our demo, we use [Livebook's integration with MapLibre](/integrations/maplibre/) to plot the HTTP request and response locations on a map. We also log the response times in a [table](https://hexdocs.pm/kino/Kino.DataTable.html).
+
+Additionally, we leveraged the [Livebook Apps feature](/blog/deploy-notebooks-as-apps-quality-of-life-upgrades-launch-week-1-day-1) to visualize the notebook as an app.
+
+Here's the result:
+
+
+
+
+
+## Wrap-up
+
+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](https://fly.io/phoenix-files/what-if-s3-could-be-a-fast-globally-synced-key-value-database-that-s-tigris/?utm_source=thinkingelixir&utm_medium=shownotes).
+
+If you want to try using Tigris with Elixir, they have [official Elixir support](https://www.tigrisdata.com/docs/sdks/s3/aws-elixir-sdk/).
diff --git a/src/blog/2024/07-05-livebook-0-13-expose-an-http-api-from-your-notebook.md b/src/blog/2024/07-05-livebook-0-13-expose-an-http-api-from-your-notebook.md
new file mode 100644
index 0000000..0bec17f
--- /dev/null
+++ b/src/blog/2024/07-05-livebook-0-13-expose-an-http-api-from-your-notebook.md
@@ -0,0 +1,145 @@
+---
+title: "Livebook 0.13: expose an HTTP API from your notebook"
+description: "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: 2024-07-05
+tags: ["releases"]
+---
+
+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.
+
+## How to expose an API endpoint from your Livebook notebook
+
+Here's a simple "hello world" example:
+
+```elixir
+Kino.Proxy.listen(fn conn ->
+ Plug.Conn.send_resp(conn, 200, "hello world!")
+end)
+```
+
+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](https://hexdocs.pm/plug/readme.html) to send a response to the client.
+
+Let's see a video with a simple example working:
+
+
+
+
+
+## Leveraging Plug for APIs with Kino.Proxy
+
+You can also provide a module plug as an argument to `Kino.Proxy.listen/1`, like this:
+
+```elixir
+defmodule MyPlug do
+ def init([]), do: false
+
+ def call(conn, _opts) do
+ Plug.Conn.send_resp(conn, 200, "hello world!")
+ end
+end
+
+Kino.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:
+
+```elixir
+defmodule ApiRouter do
+ use Plug.Router
+
+ plug :match
+ plug :dispatch
+
+ get "/hello" do
+ send_resp(conn, 200, "hello from router")
+ end
+
+ get "/echo/:message" do
+ send_resp(conn, 200, String.upcase(message))
+ end
+
+ match _ do
+ send_resp(conn, 404, "oops, not found")
+ end
+end
+
+Kino.Proxy.listen(ApiRouter)
+```
+
+## Livebook apps + Kino.Proxy = handling requests from external apps
+
+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:
+
+```elixir
+defmodule ApiRouter do
+ use Plug.Router
+
+ plug(:match)
+ plug(Plug.Parsers, parsers: [:json], json_decoder: Jason)
+ plug(:dispatch)
+
+ post "/webhook" do
+ process_webhook(conn.body_params)
+
+ conn
+ |> put_resp_content_type("application/json")
+ |> send_resp(200, ~s({"message": "ok"}))
+ end
+
+ match _ do
+ conn
+ |> put_resp_content_type("application/json")
+ |> send_resp(404, ~s({"message": "not found"}))
+ end
+
+ defp process_webhook(webhook_payload) do
+ # Logic to do something with the webhook payload
+ end
+end
+
+Kino.Proxy.listen(ApiRouter)
+```
+
+Here's a quick video with a demo of that app:
+
+
+
+
+
+Here's the [source code for that Livebook app](https://github.com/hugobarauna/livebook-notebooks/blob/main/ci_green_streak.livemd) so you can understand how it works under the hood.
+
+If you want to run the app by yourself, [click here](/run/?url=https%3A%2F%2Fgithub.com%2Fhugobarauna%2Flivebook-notebooks%2Fblob%2Fmain%2Fci_green_streak.livemd).
+
+## Wrapping up
+
+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](https://github.com/livebook-dev/livebook/blob/v0.13/CHANGELOG.md).
+
+We plan to share quicker demos of other Livebook 0.13 features on [our X/Twitter, so feel free to follow us there](https://x.com/livebookdev).
+
+Happy hacking!
diff --git a/src/blog/2024/09-12-code-navigation-with-go-to-definition-of-modules-and-functions.md b/src/blog/2024/09-12-code-navigation-with-go-to-definition-of-modules-and-functions.md
new file mode 100644
index 0000000..6cb9fc1
--- /dev/null
+++ b/src/blog/2024/09-12-code-navigation-with-go-to-definition-of-modules-and-functions.md
@@ -0,0 +1,54 @@
+---
+title: "Code navigation with go to definition of modules and functions"
+description: "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: 2024-09-12
+tags: ["releases"]
+---
+
+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.
+
+## Module definitions in the Outline panel
+
+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](https://github.com/livebook-dev/livebook/pull/2760).
+
+## Go to definition of modules and functions
+
+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](https://github.com/livebook-dev/livebook/pull/2730), [#2741](https://github.com/livebook-dev/livebook/pull/2741).
+
+## Conclusion
+
+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](https://github.com/livebook-dev/livebook/blob/v0.14/CHANGELOG.md) to discover all the features and changes in this newest release.
+
+Happy hacking!
diff --git a/src/components/DefaultMenu.astro b/src/components/DefaultMenu.astro
index 082b7ab..6c81094 100644
--- a/src/components/DefaultMenu.astro
+++ b/src/components/DefaultMenu.astro
@@ -62,8 +62,11 @@ import { isPathActive } from "../lib/utils.js";
Docs
What’s new?
diff --git a/src/components/DefaultMobileMenu.astro b/src/components/DefaultMobileMenu.astro
index 6f7c5dc..9ef057a 100644
--- a/src/components/DefaultMobileMenu.astro
+++ b/src/components/DefaultMobileMenu.astro
@@ -29,8 +29,11 @@ import { isPathActive } from "../lib/utils.js";
Docs
What’s new?
diff --git a/src/content.config.ts b/src/content.config.ts
new file mode 100644
index 0000000..34c4323
--- /dev/null
+++ b/src/content.config.ts
@@ -0,0 +1,20 @@
+import { defineCollection, z } from "astro:content";
+import { glob } from "astro/loaders";
+
+const blog = defineCollection({
+ loader: glob({
+ base: "./src/blog",
+ pattern: "**/*.md",
+ // Posts live at {year}/{month}-{day}-{slug}.md, the id is the slug
+ generateId: ({ entry }) =>
+ entry.replace(/^\d{4}\/\d{2}-\d{2}-/, "").replace(/\.md$/, ""),
+ }),
+ schema: z.object({
+ title: z.string(),
+ description: z.string(),
+ date: z.date(),
+ tags: z.array(z.string()).default([]),
+ }),
+});
+
+export const collections = { blog };
diff --git a/src/images/blog/2022-01-24-v0-5-flowcharts-custom-widgets-intellisense-and-ui-improvements/kino-explore-guides.png b/src/images/blog/2022-01-24-v0-5-flowcharts-custom-widgets-intellisense-and-ui-improvements/kino-explore-guides.png
new file mode 100644
index 0000000..fbe9880
Binary files /dev/null and b/src/images/blog/2022-01-24-v0-5-flowcharts-custom-widgets-intellisense-and-ui-improvements/kino-explore-guides.png differ
diff --git a/src/images/blog/2022-01-24-v0-5-flowcharts-custom-widgets-intellisense-and-ui-improvements/mermaid-flowchart.png b/src/images/blog/2022-01-24-v0-5-flowcharts-custom-widgets-intellisense-and-ui-improvements/mermaid-flowchart.png
new file mode 100644
index 0000000..eb05687
Binary files /dev/null and b/src/images/blog/2022-01-24-v0-5-flowcharts-custom-widgets-intellisense-and-ui-improvements/mermaid-flowchart.png differ
diff --git a/src/images/blog/2022-05-11-v0-6-automate-and-learn-with-smart-cells/diagram-button.png b/src/images/blog/2022-05-11-v0-6-automate-and-learn-with-smart-cells/diagram-button.png
new file mode 100644
index 0000000..77fbab1
Binary files /dev/null and b/src/images/blog/2022-05-11-v0-6-automate-and-learn-with-smart-cells/diagram-button.png differ
diff --git a/src/images/blog/2022-05-11-v0-6-automate-and-learn-with-smart-cells/error-highlighting.png b/src/images/blog/2022-05-11-v0-6-automate-and-learn-with-smart-cells/error-highlighting.png
new file mode 100644
index 0000000..4d0ff90
Binary files /dev/null and b/src/images/blog/2022-05-11-v0-6-automate-and-learn-with-smart-cells/error-highlighting.png differ
diff --git a/src/images/blog/2022-05-11-v0-6-automate-and-learn-with-smart-cells/package-search.png b/src/images/blog/2022-05-11-v0-6-automate-and-learn-with-smart-cells/package-search.png
new file mode 100644
index 0000000..14c2c3c
Binary files /dev/null and b/src/images/blog/2022-05-11-v0-6-automate-and-learn-with-smart-cells/package-search.png differ
diff --git a/src/images/blog/2022-05-11-v0-6-automate-and-learn-with-smart-cells/smart-cells.png b/src/images/blog/2022-05-11-v0-6-automate-and-learn-with-smart-cells/smart-cells.png
new file mode 100644
index 0000000..9c40aef
Binary files /dev/null and b/src/images/blog/2022-05-11-v0-6-automate-and-learn-with-smart-cells/smart-cells.png differ
diff --git a/src/images/blog/2022-07-28-introducing-the-livebook-desktop-app/livebook-desktop.png b/src/images/blog/2022-07-28-introducing-the-livebook-desktop-app/livebook-desktop.png
new file mode 100644
index 0000000..ccc84de
Binary files /dev/null and b/src/images/blog/2022-07-28-introducing-the-livebook-desktop-app/livebook-desktop.png differ
diff --git a/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/add-chart-cell.png b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/add-chart-cell.png
new file mode 100644
index 0000000..49d4feb
Binary files /dev/null and b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/add-chart-cell.png differ
diff --git a/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/add-database-connection-cell.png b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/add-database-connection-cell.png
new file mode 100644
index 0000000..77d6bd2
Binary files /dev/null and b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/add-database-connection-cell.png differ
diff --git a/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/add-sql-query-cell.png b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/add-sql-query-cell.png
new file mode 100644
index 0000000..f4a012d
Binary files /dev/null and b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/add-sql-query-cell.png differ
diff --git a/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/chart-cell-configured.png b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/chart-cell-configured.png
new file mode 100644
index 0000000..bb65744
Binary files /dev/null and b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/chart-cell-configured.png differ
diff --git a/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/chart-cell.png b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/chart-cell.png
new file mode 100644
index 0000000..6c36428
Binary files /dev/null and b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/chart-cell.png differ
diff --git a/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/chart-result.png b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/chart-result.png
new file mode 100644
index 0000000..8db926d
Binary files /dev/null and b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/chart-result.png differ
diff --git a/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/convert-to-code-cell.png b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/convert-to-code-cell.png
new file mode 100644
index 0000000..a2d4511
Binary files /dev/null and b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/convert-to-code-cell.png differ
diff --git a/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/database-connection-cell.png b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/database-connection-cell.png
new file mode 100644
index 0000000..ae1f70d
Binary files /dev/null and b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/database-connection-cell.png differ
diff --git a/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/generated-code.png b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/generated-code.png
new file mode 100644
index 0000000..8251080
Binary files /dev/null and b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/generated-code.png differ
diff --git a/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/query-result-table.png b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/query-result-table.png
new file mode 100644
index 0000000..9a42d53
Binary files /dev/null and b/src/images/blog/2022-08-02-how-to-query-and-visualize-data-from-google-bigquery-using-livebook/query-result-table.png differ
diff --git a/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/add-database-connection-cell.png b/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/add-database-connection-cell.png
new file mode 100644
index 0000000..c1e9e6b
Binary files /dev/null and b/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/add-database-connection-cell.png differ
diff --git a/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/add-map-cell.png b/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/add-map-cell.png
new file mode 100644
index 0000000..fb24094
Binary files /dev/null and b/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/add-map-cell.png differ
diff --git a/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/add-sql-query-cell.png b/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/add-sql-query-cell.png
new file mode 100644
index 0000000..e901b79
Binary files /dev/null and b/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/add-sql-query-cell.png differ
diff --git a/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/database-connection-cell.png b/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/database-connection-cell.png
new file mode 100644
index 0000000..40d0c96
Binary files /dev/null and b/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/database-connection-cell.png differ
diff --git a/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/map-cell-configured.png b/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/map-cell-configured.png
new file mode 100644
index 0000000..b499909
Binary files /dev/null and b/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/map-cell-configured.png differ
diff --git a/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/map-cell.png b/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/map-cell.png
new file mode 100644
index 0000000..d8baa97
Binary files /dev/null and b/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/map-cell.png differ
diff --git a/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/map-result.png b/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/map-result.png
new file mode 100644
index 0000000..799c79a
Binary files /dev/null and b/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/map-result.png differ
diff --git a/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/query-result-table.png b/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/query-result-table.png
new file mode 100644
index 0000000..8231bc5
Binary files /dev/null and b/src/images/blog/2022-09-28-how-to-query-and-visualize-data-from-amazon-athena-using-livebook/query-result-table.png differ
diff --git a/src/images/blog/2022-10-11-whats-new-in-livebook-0-7/seq-trace-diagram.png b/src/images/blog/2022-10-11-whats-new-in-livebook-0-7/seq-trace-diagram.png
new file mode 100644
index 0000000..57838a6
Binary files /dev/null and b/src/images/blog/2022-10-11-whats-new-in-livebook-0-7/seq-trace-diagram.png differ
diff --git a/src/images/blog/2022-10-11-whats-new-in-livebook-0-7/supervision-tree.png b/src/images/blog/2022-10-11-whats-new-in-livebook-0-7/supervision-tree.png
new file mode 100644
index 0000000..2d650e5
Binary files /dev/null and b/src/images/blog/2022-10-11-whats-new-in-livebook-0-7/supervision-tree.png differ
diff --git a/src/images/blog/2022-12-08-announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir/image-classification.png b/src/images/blog/2022-12-08-announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir/image-classification.png
new file mode 100644
index 0000000..b56837e
Binary files /dev/null and b/src/images/blog/2022-12-08-announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir/image-classification.png differ
diff --git a/src/images/blog/2022-12-08-announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir/text-classification.png b/src/images/blog/2022-12-08-announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir/text-classification.png
new file mode 100644
index 0000000..7673816
Binary files /dev/null and b/src/images/blog/2022-12-08-announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir/text-classification.png differ
diff --git a/src/images/blog/2022-12-08-announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir/text-generation.png b/src/images/blog/2022-12-08-announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir/text-generation.png
new file mode 100644
index 0000000..bcbff52
Binary files /dev/null and b/src/images/blog/2022-12-08-announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir/text-generation.png differ
diff --git a/src/images/blog/2022-12-08-announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir/text-to-image.png b/src/images/blog/2022-12-08-announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir/text-to-image.png
new file mode 100644
index 0000000..5a27ee8
Binary files /dev/null and b/src/images/blog/2022-12-08-announcing-bumblebee-gpt2-stable-diffusion-and-more-in-elixir/text-to-image.png differ
diff --git a/src/images/blog/2023-01-12-whats-new-in-livebook-0-8/dependent-cells-example.png b/src/images/blog/2023-01-12-whats-new-in-livebook-0-8/dependent-cells-example.png
new file mode 100644
index 0000000..eb918c8
Binary files /dev/null and b/src/images/blog/2023-01-12-whats-new-in-livebook-0-8/dependent-cells-example.png differ
diff --git a/src/images/blog/2023-01-12-whats-new-in-livebook-0-8/run-in-livebook-badge.png b/src/images/blog/2023-01-12-whats-new-in-livebook-0-8/run-in-livebook-badge.png
new file mode 100644
index 0000000..0838e1d
Binary files /dev/null and b/src/images/blog/2023-01-12-whats-new-in-livebook-0-8/run-in-livebook-badge.png differ
diff --git a/src/images/blog/2023-01-30-whats-new-in-livebook-0-8-1/run-in-livebook-badge.png b/src/images/blog/2023-01-30-whats-new-in-livebook-0-8-1/run-in-livebook-badge.png
new file mode 100644
index 0000000..0838e1d
Binary files /dev/null and b/src/images/blog/2023-01-30-whats-new-in-livebook-0-8-1/run-in-livebook-badge.png differ
diff --git a/src/images/blog/2023-02-15-livebook-inside-hugging-face-spaces/deploy-to-spaces-button.png b/src/images/blog/2023-02-15-livebook-inside-hugging-face-spaces/deploy-to-spaces-button.png
new file mode 100644
index 0000000..8ceee5b
Binary files /dev/null and b/src/images/blog/2023-02-15-livebook-inside-hugging-face-spaces/deploy-to-spaces-button.png differ
diff --git a/src/images/blog/2023-04-10-deploy-notebooks-as-apps-quality-of-life-upgrades-launch-week-1-day-1/first-app-notebook.png b/src/images/blog/2023-04-10-deploy-notebooks-as-apps-quality-of-life-upgrades-launch-week-1-day-1/first-app-notebook.png
new file mode 100644
index 0000000..db009cb
Binary files /dev/null and b/src/images/blog/2023-04-10-deploy-notebooks-as-apps-quality-of-life-upgrades-launch-week-1-day-1/first-app-notebook.png differ
diff --git a/src/images/blog/2023-04-12-hubs-and-secret-management-launch-week-1-day-3/hub-stamping.png b/src/images/blog/2023-04-12-hubs-and-secret-management-launch-week-1-day-3/hub-stamping.png
new file mode 100644
index 0000000..70c6521
Binary files /dev/null and b/src/images/blog/2023-04-12-hubs-and-secret-management-launch-week-1-day-3/hub-stamping.png differ
diff --git a/src/images/blog/2023-04-13-build-and-deploy-a-whisper-chat-app-to-hugging-face-in-15-minutes-launch-week-1-day-4/run-in-livebook-badge.png b/src/images/blog/2023-04-13-build-and-deploy-a-whisper-chat-app-to-hugging-face-in-15-minutes-launch-week-1-day-4/run-in-livebook-badge.png
new file mode 100644
index 0000000..0838e1d
Binary files /dev/null and b/src/images/blog/2023-04-13-build-and-deploy-a-whisper-chat-app-to-hugging-face-in-15-minutes-launch-week-1-day-4/run-in-livebook-badge.png differ
diff --git a/src/images/blog/2023-04-14-data-wrangling-in-elixir-with-explorer-the-power-of-rust-the-elegance-of-r-launch-week-1-day-5/run-in-livebook-badge.png b/src/images/blog/2023-04-14-data-wrangling-in-elixir-with-explorer-the-power-of-rust-the-elegance-of-r-launch-week-1-day-5/run-in-livebook-badge.png
new file mode 100644
index 0000000..0838e1d
Binary files /dev/null and b/src/images/blog/2023-04-14-data-wrangling-in-elixir-with-explorer-the-power-of-rust-the-elegance-of-r-launch-week-1-day-5/run-in-livebook-badge.png differ
diff --git a/src/images/blog/2023-07-14-whats-new-in-livebook-0-10-introducing-multi-session-livebook-apps/run-in-livebook-badge.png b/src/images/blog/2023-07-14-whats-new-in-livebook-0-10-introducing-multi-session-livebook-apps/run-in-livebook-badge.png
new file mode 100644
index 0000000..160aef6
Binary files /dev/null and b/src/images/blog/2023-07-14-whats-new-in-livebook-0-10-introducing-multi-session-livebook-apps/run-in-livebook-badge.png differ
diff --git a/src/images/blog/2024-07-05-livebook-0-13-expose-an-http-api-from-your-notebook/build-tracker-app.png b/src/images/blog/2024-07-05-livebook-0-13-expose-an-http-api-from-your-notebook/build-tracker-app.png
new file mode 100644
index 0000000..ce50211
Binary files /dev/null and b/src/images/blog/2024-07-05-livebook-0-13-expose-an-http-api-from-your-notebook/build-tracker-app.png differ
diff --git a/src/images/blog/2024-07-05-livebook-0-13-expose-an-http-api-from-your-notebook/github-webhook-flow.png b/src/images/blog/2024-07-05-livebook-0-13-expose-an-http-api-from-your-notebook/github-webhook-flow.png
new file mode 100644
index 0000000..8523232
Binary files /dev/null and b/src/images/blog/2024-07-05-livebook-0-13-expose-an-http-api-from-your-notebook/github-webhook-flow.png differ
diff --git a/src/images/blog/2024-09-12-code-navigation-with-go-to-definition-of-modules-and-functions/intellisense-go-to-definition.png b/src/images/blog/2024-09-12-code-navigation-with-go-to-definition-of-modules-and-functions/intellisense-go-to-definition.png
new file mode 100644
index 0000000..ec548fd
Binary files /dev/null and b/src/images/blog/2024-09-12-code-navigation-with-go-to-definition-of-modules-and-functions/intellisense-go-to-definition.png differ
diff --git a/src/images/blog/2024-09-12-code-navigation-with-go-to-definition-of-modules-and-functions/outline-panel.png b/src/images/blog/2024-09-12-code-navigation-with-go-to-definition-of-modules-and-functions/outline-panel.png
new file mode 100644
index 0000000..7608b51
Binary files /dev/null and b/src/images/blog/2024-09-12-code-navigation-with-go-to-definition-of-modules-and-functions/outline-panel.png differ
diff --git a/src/layouts/Layout.astro b/src/layouts/Layout.astro
index c29b6cd..33d53c8 100644
--- a/src/layouts/Layout.astro
+++ b/src/layouts/Layout.astro
@@ -14,9 +14,13 @@ import DefaultMobileMenu from "../components/DefaultMobileMenu.astro";
export interface Props {
title: string;
+ description?: string;
}
-const { title } = Astro.props;
+const {
+ title,
+ description = "Automate code & data workflows with interactive notebooks",
+} = Astro.props;
---
@@ -26,10 +30,7 @@ const { title } = Astro.props;
-
+
{title} - Livebook.dev
@@ -182,30 +183,6 @@ const { title } = Astro.props;
-
-
-
-