solara 1.29.1__py2.py3-none-any.whl → 1.30.1__py2.py3-none-any.whl

solara/website/pages/{docs/content/00-introduction.md → documentation/getting_started/content/01-introduction.md}

@@ -1,3 +1,7 @@
+---
+title: A quick introduction to Solara
+description: Solara is an Open Source library that lets you use and build data-focused web apps (data apps) using reusable UI components. Here you'll learn the basics!
+---
 # Introduction
 
 
@@ -5,7 +9,7 @@
 
 Solara is an Open Source library that lets you use and build data-focused web apps (data apps) using reusable UI components. Your app will work in the Jupyter notebook and production-grade web frameworks (FastAPI, Starlette, Flask, ...).
 
-Solara uses proven technologies and mature standards. Grow from a one-off experiment in the Jupyter notebook to a dynamic data portal in production.  Built on top of [Reacton](/docs/understanding/reacton) to keep your code complexity under control and [IPywidgets](/docs/understanding/ipywidgets) to access a rich set of UI libraries without having to write Javascript or CSS.
+Solara uses proven technologies and mature standards. Grow from a one-off experiment in the Jupyter notebook to a dynamic data portal in production.  Built on top of [Reacton](/documentation/advanced/understanding/reacton) to keep your code complexity under control and [IPywidgets](/documentation/advanced/understanding/ipywidgets) to access a rich set of UI libraries without having to write Javascript or CSS.
 
 We care about developer experience. Solara will give your hot code reloading and type hints for faster development.
 
@@ -17,19 +21,19 @@ Many frameworks only solve a specific set of problems. Once you step outside of
 
 On the other extreme, you might be working with a library with no clear patterns that let you do anything. You may only be weeks away from a total code complexity nightmare, which slowly kills your project.
 
-At the same time, starting a new framework from scratch would be unwise. We prefer to build on top of solid, battle-tested libraries, such as [IPywidgets](/docs/understanding/ipywidgets).
+At the same time, starting a new framework from scratch would be unwise. We prefer to build on top of solid, battle-tested libraries, such as [IPywidgets](/documentation/advanced/understanding/ipywidgets).
 
 ## Why use Solara?
 
 Instead of inventing a new API with an unknown track record, we take a different approach. We look at the JavaScript world. React is a technology that has proven itself for many years. It has shown to be a good all-around model for building complex UIs.
 
-[Reacton](/docs/understanding/reacton) is the equivalent of ReactJS for Python (and IPywidgets). It allows us to use the same reusable components and hooks as in the ReactJS ecosystem. Using Reacton, we build web/data applications without suffering from complex code bases.
+[Reacton](/documentation/advanced/understanding/reacton) is the equivalent of ReactJS for Python (and IPywidgets). It allows us to use the same reusable components and hooks as in the ReactJS ecosystem. Using Reacton, we build web/data applications without suffering from complex code bases.
 
 Looking again at the JavaScript world, we see software such as NextJS is putting a framework around ReactJS. NextJS is more opinionated than ReactJS and adds more "batteries" such as routing.
 
 Solara plays a similar role as NextJS. It builds on top of Reacton but handles things like routing for you.
 
-But Solara is also different and is even more opinionated than NextJS. The reason for this is its focus on the data-heavy Python ecosystem. For this reason, it comes with many components and hooks that make building beautiful data apps easier (see our [API](/api)).
+But Solara is also different and is even more opinionated than NextJS. The reason for this is its focus on the data-heavy Python ecosystem. For this reason, it comes with many components and hooks that make building beautiful data apps easier (see our [Documentation](/documentation)).
 
 Solara is a clear, systematic, Python-based web framework using industry-trusted technology. Smooth developer experience and enforced code modularity will allow you to build a data app at any scale while maintaining simple code.
 
@@ -37,7 +41,7 @@ Solara is a clear, systematic, Python-based web framework using industry-trusted
 
 For your understanding, it might be good just to run an example.
 
-Follow the [installation instructions](/docs/installing) or do the TLDR:
+Follow the [installation instructions](/documentation/getting_started/installing) or do the TLDR:
 
     $ pip install solara
 
@@ -78,18 +82,18 @@ The browser should open http://127.0.0.1:8765
 Solara is actually two things.
 
 ### Solara server
-[Solara server](/docs/understanding/solara-server) renders ipywidgets in the browser in a very efficient manner and takes care of many other things
-such as [routing](/docs/understanding/routing) and [Static Site Generation](/docs/reference/static-site-generation).
+[Solara server](/documentation/advanced/understanding/solara-server) renders ipywidgets in the browser in a very efficient manner and takes care of many other things
+such as [routing](/documentation/advanced/understanding/routing) and [Static Site Generation](/documentation/getting_started/reference/static-site-generation).
 
 ### Solara UI
 
-The UI part is built on top of [Reacton](/docs/understanding/reacton), which uses the existing IPyWidgets stack. It gives a consistent set
+The UI part is built on top of [Reacton](/documentation/advanced/understanding/reacton), which uses the existing IPyWidgets stack. It gives a consistent set
 of modern UI components with the Material Design look, as well as a set of routines to make application development of data heavy web apps
 easier.
 
 
 ### Overview
-If you use Jupyter, then you probably use the Jupyter notebook, Lab, or [Voila](/docs/understanding/voila) to get your widgets into the browser. You may not care about [Solara server](/docs/understanding/solara-server) and can focus on just the UI part.
+If you use Jupyter, then you probably use the Jupyter notebook, Lab, or [Voila](/documentation/advanced/understanding/voila) to get your widgets into the browser. You may not care about [Solara server](/documentation/advanced/understanding/solara-server) and can focus on just the UI part.
 
 If you don't use Jupyter, don't know what it is, or are an ML Ops, Dev Ops, or Sys Admin, you are probably more interested in the Solara server.
 
@@ -99,19 +103,19 @@ If you don't use Jupyter, don't know what it is, or are an ML Ops, Dev Ops, or S
 
 We recommend going through the documentation linearly following the arrows on the bottom, meaning you will go through:
 
- * [Installing](/docs/installing)
- * [Quick start](/docs/quickstart)
- * [Tutorials](/docs/tutorial)
+ * [Installing](/documentation/getting_started/installing)
+ * [Quick start](/documentation/getting_started)
+ * [Tutorials](/documentation/getting_started/tutorials)
 
-If you want to know more about specific parts, you can go through the [How-to section](/docs/howto) to learn more. Feel free to skip chapters, and go back to topics when you need to.
+If you want to know more about specific parts, you can go through the [How-to section](/documentation/advanced/howto) to learn more. Feel free to skip chapters, and go back to topics when you need to.
 
 
-If you want to know what components or hooks are available, or want to know more about a specific component, check out the [API](/api) which includes live code examples. Other reference documentation can be found at the [reference section](/docs/reference)
+If you want to know what components or hooks are available, or want to know more about a specific component, check out the [Documentation](/documentation) which includes live code examples. Other reference documentation can be found at the [reference section](/documentation/getting_started/reference)
 
-If you feel like you miss some basic understanding and want to give a bit deeper into the what and why feel free to explore the [Understanding section](/docs/understanding).
+If you feel like you miss some basic understanding and want to give a bit deeper into the what and why feel free to explore the [Understanding section](/documentation/advanced/understanding).
 
 
-[Our examples](/examples) may help you see how particular problems can be solved using Solara, or as inspiration. If you want to contribute an example, contact us on GitHub or directly open a [Pull Request](https://github.com/widgetti/solara/).
+[Our examples](/documentation/examples) may help you see how particular problems can be solved using Solara, or as inspiration. If you want to contribute an example, contact us on GitHub or directly open a [Pull Request](https://github.com/widgetti/solara/).
 
 
 ## Where can I hire an expert?

solara/website/pages/{docs → documentation/getting_started}/content/02-installing.md

@@ -1,3 +1,7 @@
+---
+title: Installing Solara
+description: Installation should be as easy as running pip install Solara. Read on for advanced setups.
+---
 # Installation
 
 ## Create a virtual environment
@@ -44,7 +48,7 @@ solara @ https://github.com/widgetti/solara/package/archive/master.tar.gz
 
 ```
 
-If you want to do development on Solara, read the [development documentation](/docs/development).
+If you want to do development on Solara, read the [development documentation](/documentation/advanced/development/setup).
 
 ## Air-gapped installation / Firewalled network
 

solara/website/pages/documentation/getting_started/content/04-tutorials/00-overview.md

@@ -0,0 +1,14 @@
+---
+title: Solara Tutorials
+description: A collection of tutorials for those learning to use Solara, each geared towards a users coming from particular backgrounds, such as data science, or
+    users coming from other frameworks like Streamlit.
+---
+# Tutorials
+
+Instead of having one tutorial, we have tutorials for different audiences.
+
+  * [Jupyter Dashboard](/documentation/getting_started/tutorials/jupyter-dashboard-part1): Learn to create a dashboard in the Jupyter notebook.
+  * [Data science](/documentation/getting_started/tutorials/data-science): In this tutorial, we will introduce Solara from the perspective of a data scientist or when you are thinking of using Solara for a data science app.
+  * [Web app](/documentation/getting_started/tutorials/web-app): You are not a data scientist, but you are interested in using Solara to create a web app using Pure Python.
+  * [IPywidgets user](/documentation/getting_started/tutorials/ipywidgets): If you are already using [ipywidgets](/documentation/advanced/understanding/ipywidgets) you will learn how to use the [Solara server](/documentation/advanced/understanding/solara-server) to render your regular ipywidget applications.
+  * [Streamlit](/documentation/getting_started/tutorials/streamlit): If you are an existing Streamlit user, this might appeal more to you.

solara/website/pages/{docs/content/04-tutorial → documentation/getting_started/content/04-tutorials}/20-web-app.md

@@ -1,3 +1,8 @@
+---
+title: Tutorial - Building web apps in python using Solara
+description: In this tutorial, you will learn how to use Solara to create a tiny web app using only Python. You can run these apps using either Solara server,
+    Jupyter lab / notebook, or whatever server infrastructure you prefer.
+---
 # Tutorial: Web app
 
 In this tutorial, you will learn how to use Solara to create a tiny web app using only Python.
@@ -5,7 +10,7 @@ In this tutorial, you will learn how to use Solara to create a tiny web app usin
 ## You should know
 This tutorial will assume you have successfully installed Solara.
 
-If not, please follow the [Installation guide](/docs/installing).
+If not, please follow the [Installation guide](/documentation/getting_started/installing).
 
 ## Generate a script file
 The simplest way to get started is to run the command
@@ -40,7 +45,7 @@ def Page():
 
 ## Run the script
 
-Using [Solara server](/docs/understanding/solara-server), we can now run our Python script using:
+Using [Solara server](/documentation/advanced/understanding/solara-server), we can now run our Python script using:
 
 ```bash
 $ solara run sol.py
@@ -50,7 +55,7 @@ Solara server is starting at http://localhost:8765
 If you open the URL in your browser ([or click here](http://localhost:8765)), you should see the same example as above.
 
 Solara will run your script once, and will look for the `Page` component. Solara expects this component to exist
-and be a [Reacton](/docs/understanding/reacton) component. (See the [IPywidget tutorial](/docs/tutorial/ipywidgets) to learn how to render a regular ipywidget).
+and be a [Reacton](/documentation/advanced/understanding/reacton) component. (See the [IPywidget tutorial](/documentation/getting_started/tutorials/ipywidgets) to learn how to render a regular ipywidget).
 
 Since your script is only run once, you could put in the main body of your script code that only needs to run once (e.g. loading data from disk)
 
@@ -68,7 +73,7 @@ Lets modify the script a little bit, possibly in this way:
 ```
 
 If we save the script, Solara will automatically reload your script and update
-your browser (we call this feature [hot reloading](/docs/reference/reloading)).
+your browser (we call this feature [hot reloading](/documentation/getting_started/reference/reloading)).
 
 Note that Solara will remember your state (e.g., the number of buttons clicked) when the app reloads.
 

solara/website/pages/{docs/content/04-tutorial → documentation/getting_started/content/04-tutorials}/30-ipywidgets.md

@@ -1,15 +1,19 @@
+---
+title: Tutorial - Building ipywidgets based apps
+description: Ipywidgets can be used together with Solara to build and quickly get to users your data apps or dashboards.
+---
 # Tutorial: IPywidgets
 
-If you are already using [ipywidgets](/docs/understanding/ipywidgets) in the notebook, possibly using [Voila](/docs/understanding/voila), you might be pleased to know that you
-can also use the [Solara server](/docs/understanding/solara-server) to render your regular ipywidget application.
+If you are already using [ipywidgets](/documentation/advanced/understanding/ipywidgets) in the notebook, possibly using [Voila](/documentation/advanced/understanding/voila), you might be pleased to know that you
+can also use the [Solara server](/documentation/advanced/understanding/solara-server) to render your regular ipywidget application.
 
-We recommend you learn how to write applications using [Reacton](/docs/understanding/reacton). However, if you have already written an application in
-pure [ipywidgets](/docs/understanding/ipywidgets), this approach will let you gradually move from pure ipywidgets to Reacton.
+We recommend you learn how to write applications using [Reacton](/documentation/advanced/understanding/reacton). However, if you have already written an application in
+pure [ipywidgets](/documentation/advanced/understanding/ipywidgets), this approach will let you gradually move from pure ipywidgets to Reacton.
 
 ## You should know
 This tutorial will assume you have successfully installed Solara.
 
-If not, please follow the [Installation guide](/docs/installing).
+If not, please follow the [Installation guide](/documentation/getting_started/installing).
 
 ## Your first ipywidget based Solara app
 
@@ -70,10 +74,10 @@ Try making the following code change (remove the first, add the last), and watch
 
 ## Using Solara components
 
-There are a lot of [valuable components in Solara](/api), but they are written as [Reacton/Solara components](/docs/understanding/reacton-basics), not
+There are a lot of [valuable components in Solara](/documentation/components), but they are written as [Reacton/Solara components](/documentation/advanced/understanding/reacton-basics), not
 classic ipywidgets.
 
-Use the [.widget(...)](/api/widget) method on a component to create a widget that can be used in your existing classic ipywidget application.
+Use the [.widget(...)](/documentation/api/utilities/widget) method on a component to create a widget that can be used in your existing classic ipywidget application.
 
 ```python
 
@@ -111,10 +115,10 @@ Note that we did not include the `:page` here, since solara will automatically l
 
 ## What you have learned
 
-  * [Solara server](/docs/understanding/solara-server) can render [ipywidgets](/docs/understanding/ipywidgets).
+  * [Solara server](/documentation/advanced/understanding/solara-server) can render [ipywidgets](/documentation/advanced/understanding/ipywidgets).
   * Running `$ solara run filename.py:variablename` tells Solara which script to execute and which variable name from the script to render.
   * The script is executed:
     * Once, when the solara server starts.
     * On each page request.
     * For each open browser page/tab, when the script is saved (hot reloading).
-  * Using the [.widget(...)](/api/widget) method we can start using Solara components in classic ipywidget app.
+  * Using the [.widget(...)](/documentation/api/utilities/widget) method we can start using Solara components in classic ipywidget app.

solara/website/pages/{docs/content/04-tutorial → documentation/getting_started/content/04-tutorials}/40-streamlit.md

@@ -1,3 +1,8 @@
+---
+title: Using Solara as a more scalable alternative to Streamlit
+description: If you are coming from Streamlit, it should be simple to adapt to using Solara, and take advantage of partial re-execution, state
+    management, and reusable components.
+---
 # Tutorial: Streamlit
 
 If you are coming from [Streamlit](https://streamlit.io/) you may be happy to know Solara does not re-execute your whole script. We execute components (starting with the `Page` component), and only need to re-execute what needs to.
@@ -18,8 +23,8 @@ st.markdown(f"{x} squared = {x_squared}")
 
 ## Translated to Solara
 
-We now translate this to the equivalent in Solara. The largest difference is we need to explicitly create (application) state using [`solara.reactive`](/api/reactive). By passing the
-reactive variable to the [SliderInt](/api/slider) via `value=x` we set up a two way binding between the component and the reactive variable. The generated text is passed down to the [Markdown](/api/markdown) component.
+We now translate this to the equivalent in Solara. The largest difference is we need to explicitly create (application) state using [`solara.reactive`](/documentation/api/utilities/reactive). By passing the
+reactive variable to the [SliderInt](/documentation/components/input/slider) via `value=x` we set up a two way binding between the component and the reactive variable. The generated text is passed down to the [Markdown](/documentation/components/output/markdown) component.
 
 
 ```solara
@@ -61,7 +66,7 @@ Again, slightly different for a different environment.
 
 ## Hot reloading
 
-If you are using [Solara server](/docs/understanding/solara-server), try editing `sol.py`, and watch the page reload automatically after you save your file. Notebook users can simply edit and re-run.
+If you are using [Solara server](/documentation/advanced/understanding/solara-server), try editing `sol.py`, and watch the page reload automatically after you save your file. Notebook users can simply edit and re-run.
 
 (*Note: Upgrade to solara 1.14.0 for a fix in hot reloading using `pip install "solara>=1.14.0"`*)
 
@@ -69,13 +74,13 @@ If you are using [Solara server](/docs/understanding/solara-server), try editing
 
 ### Execution model
 As the introduction says, Solara does not re-execute your whole script after user interactions.
-The main script is executed only once. With Solara you can use your main script to read large dataframes, or do some pre-calculations without the need for [caching](/docs/reference/caching).
+The main script is executed only once. With Solara you can use your main script to read large dataframes, or do some pre-calculations without the need for [caching](/documentation/getting_started/reference/caching).
 
-When a user navigates to a Solara server, the `Page` component (basically a function) will get executed. The `Page` component will call (lazily) new components like [solara.Markdown](/api/markdown) to build up the page. If state changes due to user input, Solara will trigger a cascade of re-excecutions of components which inputs or state changed, but never your whole script, nor every component.
+When a user navigates to a Solara server, the `Page` component (basically a function) will get executed. The `Page` component will call (lazily) new components like [solara.Markdown](/documentation/components/output/markdown) to build up the page. If state changes due to user input, Solara will trigger a cascade of re-excecutions of components which inputs or state changed, but never your whole script, nor every component.
 
 ### State
-With Solara (and [Reacton](/docs/understanding/reacton)) state does not live in a UI component (like a slider). Application state created with [`solara.reactive`](/api/reactive) lives on its own. Connecting the state to the UI component (in this case a slider) is a separate step, done via `value=x` in the above example. In general we recommend organising your components
-similarly as in the example: [First use_state and other hooks, then calculations, at last the UI components](/docs/understanding/anatomy).
+With Solara (and [Reacton](/documentation/advanced/understanding/reacton)) state does not live in a UI component (like a slider). Application state created with [`solara.reactive`](/documentation/api/utilities/reactive) lives on its own. Connecting the state to the UI component (in this case a slider) is a separate step, done via `value=x` in the above example. In general we recommend organising your components
+similarly as in the example: [First use_state and other hooks, then calculations, at last the UI components](/documentation/advanced/understanding/anatomy).
 
 For complex situations, it is important to separate the state and the UI. Especially when you need the state of a UI component as input of the UI component itself, you can get stuck with streamlit. In Solara this follows naturally.
 
@@ -83,8 +88,8 @@ For complex situations, it is important to separate the state and the UI. Especi
 ## Creating a reusable component
 
 
-A big advantage of Solara is that you can create reusable components. A single component can be seen as the equivalent of a single streamlit script. However, in that case, we need to modify our component to have its own state, rather than using global application state, for this you can use the [`use_reactive`](/api/use_reactive), or [`use_state`](/api/use_state) hook.
-Read more about state management in the [state management](/docs/fundamentals/state-management) section.
+A big advantage of Solara is that you can create reusable components. A single component can be seen as the equivalent of a single streamlit script. However, in that case, we need to modify our component to have its own state, rather than using global application state, for this you can use the [`use_reactive`](/documentation/api/hooks/use_reactive), or [`use_state`](/documentation/api/hooks/use_state) hook.
+Read more about state management in the [state management](/documentation/getting_started/fundamentals/state-management) section.
 
 ```solara
 import solara
@@ -129,8 +134,8 @@ Changing that "y" to "x" will lead to an error, however. If this is a problem in
 
 ### Long running function
 
-In Streamlit, it is normal for your main script to block execution. In Solara, the functions bodies of your components ([called render functions](/docs/understanding/anatomy)) should not block. Functions that block, or take a long time to execute, should be executed in a thread, such that rendering can continue. Using threads may sound scary, but using the
-[use_thread](/api/use_thread) hook will help a lot.
+In Streamlit, it is normal for your main script to block execution. In Solara, the functions bodies of your components ([called render functions](/documentation/advanced/understanding/anatomy)) should not block. Functions that block, or take a long time to execute, should be executed in a thread, such that rendering can continue. Using threads may sound scary, but using the
+[use_thread](/documentation/api/hooks/use_thread) hook will help a lot.
 
 ## What you have learned
 
@@ -138,4 +143,4 @@ In Streamlit, it is normal for your main script to block execution. In Solara, t
  * Solara will re-execute components instead, only what needs to.
  * State in Solara is separate from the UI components, unlike streamlit, where they are strongly linked.
  * State can be on the application level (global) for simplicity or on the component level (local) for creating reusable components.
- * Solara should not block the render loop. Long-running functions should be executed in a thread using [use_thread](/api/use_thread).
+ * Solara should not block the render loop. Long-running functions should be executed in a thread using [use_thread](/documentation/api/hooks/use_thread).

solara/website/pages/{docs/content/04-tutorial → documentation/getting_started/content/04-tutorials}/50-dash.md

@@ -1,3 +1,7 @@
+---
+title: Using Solara as an alternative to Dash
+description: If you are familiar with Dash, Solara should be easy to adapt to. In Solara the state is managed and stored on the server, and components are declaratively reusable.
+---
 # Tutorial: Dash users
 
 Dash is quite different from Solara. In Dash, state lives in your browser, and via callbacks your app will change from 1 state to another. In Solara, the state lives on the server, and also state transitions happen at the server.
@@ -36,7 +40,7 @@ This small app creates a dropdown (what we call Select in Solara), and some mark
 
 ## Translated to Solara
 
-In Solara, we need to explicitly create application state using [`solara.reactive`](/api/reactive). We wire this up with the [Select][/api/select] via `value=color` and pass the color value down to the [Markdown](/api/markdown) component.
+In Solara, we need to explicitly create application state using [`solara.reactive`](/documentation/api/utilities/reactive). We wire this up with the [Select][/documentation/components/input/select] via `value=color` and pass the color value down to the [Markdown](/documentation/components/output/markdown) component.
 
 ```solara
 import solara
@@ -50,7 +54,7 @@ def Page():
     solara.Markdown("## Hello World", style={"color": color.value})
 ```
 
-Since this component combines two components, we have to put them together in a [container](/docs/understanding/containers) component, here implicitly a [Column](/api/column).
+Since this component combines two components, we have to put them together in a [container](/documentation/advanced/understanding/containers) component, here implicitly a [Column](/documentation/components/layout/column).
 
 ## Making a re-usable component
 
@@ -115,7 +119,7 @@ if __name__ == "__main__":
 
 ### In Solara
 
-A big advantage of Solara is that components are reusable by default. However, we need to modify our component to have its own state, rather than using global application state. Creating local component state with [`use_reactive`](/api/use_reactive), or [`use_state`](/api/use_state) hook. Read more about state management in the [state management](/docs/fundamentals/state-management) section.
+A big advantage of Solara is that components are reusable by default. However, we need to modify our component to have its own state, rather than using global application state. Creating local component state with [`use_reactive`](/documentation/api/hooks/use_reactive), or [`use_state`](/documentation/api/hooks/use_state) hook. Read more about state management in the [state management](/documentation/getting_started/fundamentals/state-management) section.
 
 We will rename (from `Page` to `MarkdownWithColor`) the component, add local state, and put in the markdown text as an argument.
 

solara/website/pages/{docs/content/04-tutorial → documentation/getting_started/content/04-tutorials}/_data_science.ipynb

@@ -16,7 +16,7 @@
     "  * You have successfully installed Solara\n",
     "  * You know how to display a Solara component in a notebook or script\n",
     "\n",
-    "If not, please follow the [Quick start](/docs/quickstart).\n",
+    "If not, please follow the [Quick start](/documentation/getting_started).\n",
     "\n",
     "## Extra packages you need to install\n",
     "\n",
@@ -85,7 +85,7 @@
     "fig = px.scatter(df, \"sepal_length\", \"sepal_width\")\n",
     "```\n",
     "\n",
-    "To display this figure in a Solara component, we should return an element that can render the plotly figure. [FigurePlotly](/api/plotly) will do the job for us.\n",
+    "To display this figure in a Solara component, we should return an element that can render the plotly figure. [FigurePlotly](/documentation/components/viz/plotly) will do the job for us.\n",
     "\n",
     "Putting this together"
    ]
@@ -133,7 +133,7 @@
     "x_axis = solara.reactive(\"sepal_length\")\n",
     "```\n",
     "\n",
-    "This code creates a reactive variable. You can use this reactive variable in your component and pass it to a [`Select`]((/api/select)) component to control the selected column.\n",
+    "This code creates a reactive variable. You can use this reactive variable in your component and pass it to a [`Select`](/documentation/components/input/select) component to control the selected column.\n",
     "\n",
     "\n",
     "```python\n",
@@ -196,7 +196,7 @@
     "\n",
     "#### State\n",
     "\n",
-    "Understanding state management and how Solara re-renders component is crucial for understanding building larger applications. If you don't fully graps it now, that is ok. You should first get used to the pattern, and consider reading [About state management](/docs/fundamentals/state-management) later on to get a deeper understanding.\n",
+    "Understanding state management and how Solara re-renders component is crucial for understanding building larger applications. If you don't fully graps it now, that is ok. You should first get used to the pattern, and consider reading [About state management](/documentation/getting_started/fundamentals/state-management) later on to get a deeper understanding.\n",
     "\n"
    ]
   },
@@ -358,7 +358,7 @@
     "    return df.sort_values('distance')[1:n+1]\n",
     "```\n",
     "\n",
-    "We now only find the nearest neighbours if `click_data.value` is not None, and display the dataframe using the [`DataFrame`](/api/dataframe) component.\n"
+    "We now only find the nearest neighbours if `click_data.value` is not None, and display the dataframe using the [`DataFrame`](/documentation/components/data/dataframe) component.\n"
    ]
   },
   {

solara/website/pages/documentation/getting_started/content/05-fundamentals/00-overview.md

@@ -0,0 +1,11 @@
+---
+title: Fundamentals of Solara
+description: These articles dive deeper into the fundamental aspects of Soalra, like using components, hooks, and managing state.
+---
+# Fundamentals
+
+If you want to dive deeper into Solara, this section is for you. We will cover the following topics:
+
+  * [Components](/documentation/getting_started/fundamentals/components)
+  * Hooks (soon)
+  * [State management](/documentation/getting_started/fundamentals/state-management)

solara/website/pages/{docs/content/07-fundamentals → documentation/getting_started/content/05-fundamentals}/10-components.md

@@ -1,3 +1,8 @@
+---
+title: Introduction to Solara components
+description: In Solara, components are the building blocks of your web application. They allow you to create modular, reusable, and maintainable user interface elements
+    that can be combined to create a complete and interactive application.
+---
 <!-- TODO: column auto -->
 
 # Introduction to Components
@@ -19,9 +24,9 @@ In Solara, there are two main types of components: Widget Components and Functio
 
 Widget Components correspond to ipywidgets and are responsible for rendering visual elements in the browser, such as buttons, sliders, or performing layout tasks. These components are the foundation of your user interface and provide the essential building blocks for creating interactive applications.
 
-Solara mainly uses the [ipyvuetify library](/docs/understanding/ipyvuetify) for its widget components. It provides a set of high-level components that can be used to create rich, interactive user interfaces.
+Solara mainly uses the [ipyvuetify library](/documentation/advanced/understanding/ipyvuetify) for its widget components. It provides a set of high-level components that can be used to create rich, interactive user interfaces.
 
-See the [API docs](/docs/api) for a complete list of basic UI components.
+See the [components page](/documentation/components) for a complete list of basic UI components.
 
 ## Function Components
 

solara/website/pages/{docs/content/07-fundamentals → documentation/getting_started/content/05-fundamentals}/50-state-management.md

@@ -1,12 +1,17 @@
+---
+title: Introduction to state management in Solara
+description: State management is a crucial aspect of building data-focused web applications with Solara. By effectively managing state, you can create interactive
+    and responsive applications that react to changes in data and user input.
+---
 # Introduction
 
-State management is a crucial aspect of building data-focused web applications with Solara. By effectively managing state, you can create interactive and responsive applications that react to changes in data and user input. In Solara, there are two primary ways to define state: global application state using [`solara.reactive`](/api/reactive) and local component state using [`solara.use_state`](/api/use_state) or [`solara.use_reactive`](/api/use_reactive). This article will discuss these two approaches and provide examples of how to use them in your Solara applications.
+State management is a crucial aspect of building data-focused web applications with Solara. By effectively managing state, you can create interactive and responsive applications that react to changes in data and user input. In Solara, there are two primary ways to define state: global application state using [`solara.reactive`](/documentation/api/utilities/reactive) and local component state using [`solara.use_state`](/documentation/api/hooks/use_state) or [`solara.use_reactive`](/documentation/api/hooks/use_reactive). This article will discuss these two approaches and provide examples of how to use them in your Solara applications.
 
 ## Two main ways of defining state in Solara
 
 ### Global application state using solara.reactive
 
-Using [`solara.reactive`](/api/reactive) allows you to create global state variables that can be accessed and modified from any component within your application. This approach is useful when you need to manage state that is shared across multiple components or when you want to maintain consistency throughout your application.
+Using [`solara.reactive`](/documentation/api/utilities/reactive) allows you to create global state variables that can be accessed and modified from any component within your application. This approach is useful when you need to manage state that is shared across multiple components or when you want to maintain consistency throughout your application.
 
 Example:
 
@@ -30,7 +35,7 @@ In this case, the `SomeAppSpecificComponent` is not reusable in the sense that a
 
 ## Local component state using solara.use_state
 
-[`solara.use_state`](/api/use_state) is a hook that allows you to manage local state within a specific component. This approach is beneficial when you want to encapsulate state within a component, making it self-contained and modular. Local state management is suitable for situations where state changes only affect the component and do not need to be shared across the application.
+[`solara.use_state`](/documentation/api/hooks/use_state) is a hook that allows you to manage local state within a specific component. This approach is beneficial when you want to encapsulate state within a component, making it self-contained and modular. Local state management is suitable for situations where state changes only affect the component and do not need to be shared across the application.
 
 Example:
 ```solara

solara/website/pages/documentation/getting_started/content/06-reference/00-overview.md

@@ -0,0 +1,3 @@
+# Reference documentation
+
+Our reference documentation informs you about how certain parts in Solara work.

solara/website/pages/{docs/content/15-reference → documentation/getting_started/content/06-reference}/40-static_files.md

@@ -1,3 +1,7 @@
+---
+title: Using static files and resources in your Solara application
+description: When using Solara, you can host static files, like images, which will then be available at /static/public, in the ../public folder.
+---
 # Static files
 
 Files located on your local filesystem at the `../public` directory will be served by the Solara server at `/static/public`. A typical directory layout looks like this:

solara/website/pages/{docs/content/15-reference → documentation/getting_started/content/06-reference}/41-asset-files.md

@@ -1,3 +1,7 @@
+---
+title: Incorporating your assets, styles, and logos into your app
+description: Solara looks for overrides of certain style and asset files in the assets folder by default. You can use these to incorporate your branding into your dashboard or app.
+---
 # Assets files
 
 Asset files are special files with are loaded by Solara-server and thus have a special meaning, and come with defaults. Current supported assets files are:
@@ -29,4 +33,4 @@ All assets files are served under `/static/assets/<filename>`, but how the asset
 Putting the `assets` directory 1 level higher than the `pages` directory avoids name collision with pages.
 
 
-Although the `assets` directory can be used for serving arbitrary files, we recommend using the [static files](/docs/reference/static-files) directory instead, to avoid name collisions.
+Although the `assets` directory can be used for serving arbitrary files, we recommend using the [static files](/documentation/getting_started/reference/static-files) directory instead, to avoid name collisions.

solara/website/pages/{docs/content/15-reference → documentation/getting_started/content/06-reference}/60-static-site-generation.md

@@ -1,3 +1,7 @@
+---
+title: Generating a static site version of your app or dashboard
+description: Solara's static site generation (SSG) feature allows you to pre-render HTML for your app or dashboard, improving the user experience by providing quick page loads.
+---
 ## Static Site Generation
 ## Introduction
 Solara's static site generation (SSG) feature allows you to pre-render HTML for your website, improving the user experience by providing quick page loads. When a user requests a page, the pre-rendered HTML is served directly to the user. After the page is displayed, the Solara server will connect and take over rendering to make the page interactive.
@@ -29,7 +33,7 @@ Using the command
 $ solara ssg your.awesome.app
 ```
 
-Will run the solara server and use playwright to fetch all known pages and save them to the `../build` directory. Solara knows about your pages because of its [routing support](/docs/understanding/routing).
+Will run the solara server and use playwright to fetch all known pages and save them to the `../build` directory. Solara knows about your pages because of its [routing support](/documentation/advanced/understanding/routing).
 
 All HTML files in the `../build` will be used to pre-populate the HTML served to the user.
 

solara/website/pages/{docs/content/15-reference → documentation/getting_started/content/06-reference}/70-search.md

@@ -1,6 +1,10 @@
+---
+title: Incorporating search into your Solara application
+description: If you are using static site generation (SSG) in your Solara application, you can make use of our search feature for it too!
+---
 # Search
 
-Solara can provide search, if [SSG](/docs/reference/static-site-generation) is enabled. This allows you to add a search box to you website, which performs a full-text search to provide quick access to pages. The solara website itself uses the
+Solara can provide search, if [SSG](/documentation/getting_started/reference/static-site-generation) is enabled. This allows you to add a search box to you website, which performs a full-text search to provide quick access to pages. The solara website itself uses the
 search feature as well in the toolbar.
 
 ## Using Solara's Search feature.

solara/website/pages/{docs/content/15-reference → documentation/getting_started/content/06-reference}/80-reloading.md

@@ -1,3 +1,7 @@
+---
+title: Automatic reloading of source files when developing with Solara
+description: Solara automatically detects changes in certain source file types, and hot reloads your application when you save them.
+---
 # Reloading
 
 ## Reloading of Python files
@@ -13,18 +17,18 @@ When a `.vue` file is saved, the widgets get updated automatically, without need
 
 ## Reloading of .vue files
 
-The [Style component](/api/style) accepts a Path as argument, when that is used and the server is in development mode (the default), also
+The [Style component](/documentation/components/advanced/style) accepts a Path as argument, when that is used and the server is in development mode (the default), also
 CSS files will be hot reloaded.
 
 
 ## Restarting the server after changes to the solara packages
 
 
-You don't need to care about this feature if you only use solara, this is only relevant for development on solara itself, [see also development instructions](/docs/development).
+You don't need to care about this feature if you only use solara, this is only relevant for development on solara itself, [see also development instructions](/documentation/advanced/development/setup).
 
 If the `--auto-restart/-a` flag is passed to solara-server and any changes occur in the `solara` package (excluding `solara.webpage`), solara-server will restart. This speeds up development on `solara-server` for developers since you do not
 need to manually restart the server in the terminal.
 
 ## Disabling reloading
 
-In production mode (pass the `--production` argument to `solara run`) watching of files is disabled, and no reloading of files or vue templates will occur. If you run solara integrated in flask or uvicorn as laid out in [deployment documentation](https://solara.dev/docs/deploying/self-hosted)
+In production mode (pass the `--production` argument to `solara run`) watching of files is disabled, and no reloading of files or vue templates will occur. If you run solara integrated in flask or uvicorn as laid out in [deployment documentation](https://solara.dev/documentation/getting_started/deploying/self-hosted)

solara/website/pages/{docs/content/15-reference → documentation/getting_started/content/06-reference}/90-notebook-support.md

@@ -1,4 +1,7 @@
-
+---
+title: Using Solara within notebooks
+description: Solara can be used to generate an interactive app directly using your notebook file by running just one command.
+---
 # Notebook support
 
 We also support notebooks, simply assign to the `Page` variable in a code cell, save your notebook, and run `$ solara run myapp.ipynb`. If you widget or component is called differently, run like `$ solara run myapp.ipynb:myobject.nested_widget`.

solara/website/pages/{docs/content/15-reference → documentation/getting_started/content/06-reference}/95-caching.md

@@ -1,3 +1,8 @@
+---
+title: Caching resources for your solara application or dashboard
+description: Solara has a dict-like object at `solara.cache.storage` that can be used to store objects in under a key. So we can use this global
+    object as normal dict.
+---
 # Caching
 
 Solara has a dict-like object at `solara.cache.storage` that can be used to store objects in under a key. So we can use this global
@@ -11,7 +16,7 @@ assert "my-key" in solara.cache.storage
 
 Note that at any time later on, the key may be removed from this object, as a cache always has a limited capacity.
 
-The `solara.cache.storage` cache object is used by [memoize](/api/memoize), if no storage argument is passed to this decorator.
+The `solara.cache.storage` cache object is used by [memoize](/documentation/api/utilities/memoize), if no storage argument is passed to this decorator.
 
 ## Types of cache
 

solara/website/pages/documentation/getting_started/content/07-deploying/00-overview.md

@@ -0,0 +1,7 @@
+---
+title: Overview of how to deploy your Solara application or dashboard
+description: Solara apps can be easily either self hosted, or hosted on a variety of cloud platforms.
+---
+# Deploying a solara app
+
+A Solara app can be [self hosted](/documentation/getting_started/deploying/self-hosted) or [cloud hosted](/documentation/getting_started/deploying/cloud-hosted).