diff --git a/.gitignore b/.gitignore
index 241e57a..e27c7d8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,3 +5,4 @@ content/jupyter/images
content/overview/images
content/export/images
content/web/images
+.DS_Store
\ No newline at end of file
diff --git a/authoring/jupyter-notebooks.md b/authoring/jupyter-notebooks.md
index 1586cc5..515e6af 100644
--- a/authoring/jupyter-notebooks.md
+++ b/authoring/jupyter-notebooks.md
@@ -1,8 +1,161 @@
---
-title: Writing a Scientific Paper using Jupyter
+title: Write a Scientific Paper using Jupyter
short_title: Write using Jupyter
---
-:::{important} More Coming Soon! 🚧
-We are actively working on the documentation. Please check back soon or send us an email asking about this page: [support@curvenote.com](mailto:support@curvenote.com)
-:::
+# Write a Scientific Paper using Jupyter
+
+## Quick Start
+Create scientific papers directly from Jupyter notebooks with integrated code, outputs, and narrative text
+
+Jupyter notebooks provide a powerful way to write scientific papers that combine code, analysis, visualizations, and narrative text in a single document. Curvenote enhances this workflow by adding version control, collaboration, and publishing capabilities.
+
+## Before You Start
+
+Make sure you have:
+- Jupyter Lab or Jupyter Notebook installed
+- A Curvenote project set up
+- Your research data and analysis ready
+- A clear structure for your paper
+
+## 1. Set Up Your Jupyter Environment
+
+Start with a well-organized Jupyter notebook:
+
+1. **Create a new notebook** in Jupyter Lab or Jupyter Notebook
+2. **Organize your notebook** with clear sections:
+ - Introduction and background
+ - Methods and data
+ - Analysis and results
+ - Discussion and conclusions
+3. **Use markdown cells** for narrative text between code cells
+4. **Execute all cells** to ensure outputs are generated
+
+## 2. Structure Your Paper
+
+Organize your notebook to follow scientific paper conventions:
+
+### Introduction Section
+- **Background and context** in markdown cells
+- **Literature review** with citations
+- **Research questions** and objectives
+- **Hypotheses** to be tested
+
+### Methods Section
+- **Data collection** procedures
+- **Code for data preprocessing**
+- **Analysis methods** with clear comments
+- **Statistical approaches** used
+
+### Results Section
+- **Code for analysis** with outputs
+- **Figures and visualizations**
+- **Statistical results** and tables
+- **Key findings** in markdown
+
+### Discussion Section
+- **Interpretation** of results
+- **Comparison** with previous work
+- **Limitations** and future work
+- **Conclusions** and implications
+
+## 3. Add Rich Content
+
+Enhance your paper with various content types:
+
+### Code and Analysis
+```python
+# Example analysis code
+import pandas as pd
+import matplotlib.pyplot as plt
+
+# Load and process data
+data = pd.read_csv('experiment_data.csv')
+results = analyze_data(data)
+
+# Create visualization
+plt.figure(figsize=(10, 6))
+plt.plot(results['x'], results['y'])
+plt.title('Experimental Results')
+plt.show()
+```
+
+### Narrative Text
+Use markdown cells for:
+- **Explanations** of methods and results
+- **Citations** and references
+- **Context** and background information
+- **Discussion** of implications
+
+### Interactive Elements
+- **Interactive plots** (Plotly, Bokeh)
+- **Data tables** with sorting/filtering
+- **Embedded widgets** for exploration
+- **Dynamic visualizations**
+
+## 4. Link to Curvenote
+
+Connect your Jupyter notebook to Curvenote:
+
+1. **Upload your notebook** to your Curvenote project
+2. **Link to local file** for version control
+3. **Sync changes** automatically
+4. **Collaborate** with co-authors
+
+## 5. Format for Publication
+
+Prepare your notebook for publication:
+
+1. **Review all outputs** are properly displayed
+2. **Check markdown formatting** is correct
+3. **Verify citations** are properly formatted
+4. **Test interactive elements** work as expected
+5. **Export to various formats** (PDF, HTML, etc.)
+
+## 6. Collaborate and Review
+
+Work with co-authors effectively:
+
+1. **Share your project** with collaborators
+2. **Use comments** for feedback and discussion
+3. **Track changes** with version control
+4. **Review and revise** collaboratively
+5. **Finalize** for submission
+
+## Best Practices
+
+### Code Organization
+- **Clear variable names** and comments
+- **Modular functions** for reusability
+- **Error handling** for robustness
+- **Documentation** for complex algorithms
+
+### Writing Style
+- **Clear, concise language** in markdown cells
+- **Proper scientific tone** and terminology
+- **Logical flow** between sections
+- **Consistent formatting** throughout
+
+### Data Management
+- **Reproducible code** with fixed random seeds
+- **Data versioning** and backup
+- **Clear data sources** and citations
+- **Open data** when possible
+
+## Next Steps
+
+- [Add Interactive Outputs →](../editor/interactive-outputs.md)
+- [Link Data and Code →](../editor/add-and-link-notebooks.md)
+- [Publish & Share Your Article →](../getting-started/publish-article.md)
+
+---
+
+💡 **Tip:** Jupyter notebooks in Curvenote maintain full interactivity when published, allowing readers to explore your analysis, run code, and interact with visualizations directly in the browser.
+
+⚡ **Important:
+Reproducible Research Best Practices**
+
+- Always include all necessary code and data
+- Use version control for your notebooks
+- Document your environment and dependencies
+- Test that your notebook runs from start to finish
diff --git a/cli/authentication.md b/cli/authentication.md
index 4a9858e..d63452e 100644
--- a/cli/authentication.md
+++ b/cli/authentication.md
@@ -1,89 +1,72 @@
---
title: Authentication
+short_title: Authentication
---
-Most translation and export functionality is local and **does not** require you to be logged into Curvenote. Additionally, the API for any public content on Curvenote does not require you to be authenticated. However, if you want to sync content from your _private_ Curvenote projects to a local folder, modify any online projects, or deploy a website you will need to be authenticated.
+**Goal:**
+Sign in to the Curvenote CLI using an API token so you can work with private projects, sync content, and publish.
-The Curvenote CLI works on an API token that can be generated from your personal settings on [curvenote.com](https://curvenote.com).
+## When You Need to Authenticate
+- Accessing **private projects** from Curvenote
+- Modifying or syncing content online
+- Publishing content to a site
+- Running CI/CD or automation scripts
-## Creating an API Token
+Most translation/export of **public content** does not require authentication.
-API Tokens allow you to access your Curvenote content programmatically.
+## 1. Generate an API Token
+1. Sign in to [Curvenote](https://curvenote.com/).
+2. Go to **Personal Settings** → **API Access** or [click here](https://curvenote.com/profile?settings=true&tab=profile-api).
+3. Click **Generate New Token**.
+4. Copy the token — you won’t be able to see it again.
-🛠️ You can create an API token by clicking [here](https://curvenote.com/profile?settings=true&tab=profile-api) if you are signed in or navigating to your **Personal Settings**, which are available under your avatar in the top right.
-
-```{figure} images/settings-api-token.png
-:name: FdFCmj6QcJ
-:align: center
-:width: 70%
-
-Access the API Token by navigating to your **Personal Settings** by clicking on your avatar in the top right.
+## 2. Store the Token Locally
+Run:
+```bash
+curvenote token set
```
+Paste the API token when prompted.
-🛠️ Click on the **Generate New Token**, and give you token a description that you can recognize lated if you need to revoke it. You will be shown a screen that allows you to copy the API token for the next step.
+## 3. Store the Token as an Environment Variable
-```{figure} images/settings-api-copy-token.png
-:name: rm1dO7qLHx
-:align: center
-:width: 70%
+Useful for CI/CD or servers:
-Ensure that you copy your token for the next step. You will not be able to access this token again.
+```bash
+export CURVENOTE_TOKEN="API_TOKEN"
```
+The environment variable takes priority over stored tokens.
-🛠️ Copy the API Token. You will not be able to see this token again, so be sure to copy it!
+## 4. Switch Accounts
-## Sign In to Curvenote using the CLI
+If you have multiple accounts:
-🛠️ Sign into the Curvenote CLI using the command:
-
-```python
-curvenote token set
+```bash
+curvenote token select
```
-You will be asked for an API Token which you copied from your API Access settings in Curvenote (see above). The command will store a local config file that has your API token to be used for future calls to the library.
-
-### Validate you are signed in
-
-🛠️ You can validate that you are signed in using the command:
-
-```shell
+## 5. Check Authentication Status
+```bash
curvenote auth list
```
+Shows your current account or indicates if not authenticated.
-This will print your username and email or tell you that you are not authenticated.
-This command will also list any other accounts that you can login as.
-
-### Changing Profiles
-
-If you have multiple Curvenote accounts, for example, as a bot for a submission system, you can switch profiles using:
-
-```shell
-curvenote token select
+## 6. Sign Out
+```bash
+curvenote token delete
```
-This will bring up a prompt to select which account you should use for the Curvenote API.
-
-### Authenticating on a Server
-
-You can also override the config path by having a `CURVENOTE_TOKEN` in your environment, this is helpful when using the Curvenote CLI from a continuous integration system or on a server.
-
-```shell
-export CURVENOTE_TOKEN="API_TOKEN"
+Removes the stored token. If using an environment variable, unset it:
+```bash
+unset CURVENOTE_TOKEN
```
-:::{warning} `CURVENOTE_TOKEN` environment variable takes priority
-If the environment variable is present, it will have precedence over any token you have set previously.
-The CLI will notify you through a log message about which token is being used.
-:::
-
-Alternatively, you can use the `curvenote token set $ENV_VAR` to set the token programmatically; we recommend not to paste your token into the command line directly as that will create an entry in your terminal history.
-
-## Sign Out of Curvenote
-
-To sign out of the Curvenote CLI, you can call:
-
-```shell
-curvenote token delete
-```
+💡 **Tips:**
+- You only need to authenticate if working with private projects or publishing to a site.
+- Store the API token in an environment variable (`CURVENOTE_TOKEN`) for CI/CD.
+- Use `curvenote token select` to switch between accounts.
-This will remove the local config file with the API token in it. Note, if you have signed into the CLI using the environment variable, you can unset that using `unset CURVENOTE_TOKEN`. To confirm that you are logged out you can run the command `curvenote auth list` as before, and it should inform you that you are not authenticated.
+## Related Guides
+- [Install & Authenticate CLI (Tutorial)](install-cli.md)
+- [Push, Submit, and Publish Content](push-submit-publish.md)
+- [Set Up a Site for Publishing](setup-site.md)
+- [Continuous Integration with Curvenote CLI](ci-cli.md)
diff --git a/editor/add-and-link-notebooks.md b/editor/add-and-link-notebooks.md
index 989f869..e8ddf3d 100644
--- a/editor/add-and-link-notebooks.md
+++ b/editor/add-and-link-notebooks.md
@@ -1,25 +1,76 @@
---
title: Add & Link Notebooks
+short_title: Add & Link Notebooks
---
+# Add & Link Notebooks
+
+## Quick Start
+Upload Jupyter notebooks to your Curvenote project and link them to local files for version control and collaboration
+
Notebooks can be created in Jupyter then uploaded to a Curvenote project via the web app. You should always add pre-executed, saved notebooks to Curvenote so that outputs appear and are available for use. Notebooks that already exist on Curvenote can also be imported and linked to a local `.ipynb` file.
-## Upload a Notebook - Curvenote
+## Before You Start
-You can upload a Jupyter notebook to a Curvenote **project**. To upload an existing notebook:
+Make sure you have:
+- A Curvenote project open
+- A Jupyter notebook (`.ipynb` file) ready to upload
+- The notebook is saved with executed outputs (if you want to display results)
-- In the project navigation panel
- - Click the **Upload ☁️⬆️** icon
-- Click to browse or drag and drop an `.ipynb` file from your computer
- - Click **DONE**
+## 1. Upload a Notebook to Curvenote
-```{danger}
-The upload process for notebooks on Curvenote should only be used if you do not intend to run the notebook! The local copy of your notebook will not be linked to Curvenote (it does not contain the necessary metadata for versioning). If you need to run this notebook you will have to manually link your local copy. Learn more [Add & Link Notebooks](./add-and-link-notebooks.md).
+To upload an existing Jupyter notebook to your project:
-```
+1. **Open your project** in the Curvenote web app
+2. **In the project navigation panel:**
+ - Click the **Upload ☁️⬆️** icon
+3. **Add your notebook:**
+ - Click to browse and select your `.ipynb` file
+ - Or drag and drop the file from your computer
+4. **Click "DONE"** to complete the upload
-```{figure} images/m59m7JQmWVyPjlASj9v3-UGpUYCC2QlQIhNSTYmEh-v1.mp4
+```{figure} images/m59m7JQmWVyPjlASj9h3-UGpUYCC2QlQIhNSTYmEh-v1.mp4
:name: tdrOpSRldZ
:align: center
:width: 100%
```
+
+## 2. Link Local Notebooks (Recommended)
+
+For notebooks you plan to continue working on, it's better to link your local copy:
+
+1. **Upload the notebook** to Curvenote first (following steps above)
+2. **In your local project folder:**
+ - Place your `.ipynb` file in the appropriate directory
+ - The file should be in the same location relative to your project structure
+3. **Curvenote will automatically detect** the local file and link it
+4. **Future changes** to your local notebook will sync with Curvenote
+
+## 3. Use Notebooks in Your Articles
+
+Once uploaded, you can:
+
+- **Display notebook outputs** as figures in your articles
+- **Reference specific cells** from your notebooks
+- **Create interactive elements** that readers can explore
+- **Version control** your notebooks alongside your articles
+
+
+⚡ **Important:
+Upload vs. Link Workflow**
+
+- **Upload only**: Use this if you don't plan to run the notebook again
+- **Link local file**: Use this if you need to continue working on the notebook
+
+The upload process does not create a link to your local file, so you'll need to manually link it if you want to continue editing.
+
+
+## Next Steps
+
+- [Add Figures, Images, and Media →](./figures-and-images.md)
+- [Create Interactive Outputs →](./interactive-outputs.md)
+- [Work with Jupyter Notebooks →](../authoring/jupyter-notebooks.md)
+
+---
+
+💡 **Tip:** Always save your notebooks with executed outputs before uploading to Curvenote. This ensures that figures, charts, and other results are visible in your articles.
diff --git a/editor/citations.md b/editor/citations.md
index e75bab9..b20e3ae 100644
--- a/editor/citations.md
+++ b/editor/citations.md
@@ -1,131 +1,135 @@
---
-title: Citations
+title: Add Citations and References
+short_title: Citations
---
-You can easily add citations to your Curvenote articles and have quick access to them while you are typing. There are currently two ways to add references:
+# Add Citations and References
-1. **From a DOI**\: Simply search the document or article DOI, and add it to your article with one-click!
-2. **From a BibTex file**\: Export from your reference manager (e.g. Zotero, Mendeley, etc.) as a BibTex file, and drag and drop into Curvenote. If you want easy access to a reference manager, without downloading anything we recommend .
+## Quick Start
+Add citations to your Curvenote articles using DOIs or BibTeX files with automatic formatting and reference management
-Once your citations have been added to your project, you can easily access them through the `/cite` command, and can click on the citation to see all the details - and you can click on it to navigate to the web article or document. For example, try clicking on this citation {cite:p}`Cockett2015SimPEG`.
+You can easily add citations to your Curvenote articles and have quick access to them while you are typing. Citations can be added from DOIs or imported from BibTeX files, and they're automatically formatted according to your chosen style.
-## Video Demo 📺
-
-```{iframe} https://www.loom.com/embed/646329caf1e74c39bd6abb3835717ce0
-:label: YtpswdIs9H
-:align: center
-:width: 80%
-```
-
-```{list-table} Example of rendered citations, try clicking on any of the citations!
-:header-rows: 1
-:name: jBqbQidSUR
-
-* -
-
- - Parenthetical citation
-
- - Narrative citation
+## Before You Start
-* - 1 author
+Make sure you have:
+- An article open in Curvenote
+- DOIs for papers you want to cite, or
+- A BibTeX file exported from your reference manager
+- Your citation library set up in your project
- - {cite:p}`heinen_compensation_2014`
-
- - {cite:t}`heinen_compensation_2014`
-
-* - 2 authors
-
- - {cite:p}`Bartkowski2018Leverage`
-
- - {cite:t}`Bartkowski2018Leverage`
+## Video Demo 📺
-* - 3 or more authors
+[Watch the video tutorial](https://www.loom.com/embed/646329caf1e74c39bd6abb3835717ce0)
- - {cite:p}`winter_effects_2018`
+## 1. Add Citations from DOIs
- - {cite:t}`winter_effects_2018`
+A digital object identifier (DOI) is a unique string that permanently identifies an article or document on the web.
-* - Group author
+### Find the DOI
+1. **Locate the DOI** on the article or document you want to cite
+2. **Copy it to your clipboard**
+3. **Note**: If you can't find the DOI, use the 'Search Metadata' option on [crossref.org](https://crossref.org)
- - {cite:p}`EuropeanCommission2020`
+### Add the Citation
+1. **Place your cursor** where you want to add the citation
+2. **Type `/cite`** to access the citation menu
+3. **Navigate to "ADD DOI"**
+4. **Enter the DOI** in the search bar
+5. **Click "SEARCH"**
+6. **Select "CREATE CITATION"** if the correct article appears
- - {cite:t}`EuropeanCommission2020`
-```
+## 2. Import Citations from BibTeX Files
-## Adding citations through DOIs
+BibTeX files (`.bib`) are commonly used with LaTeX and can be exported from most reference managers like Zotero, Mendeley, or EndNote.
-A digital object identifier (DOI) is a unique string that’s used to permanently identify an article or document on the web. If you are citing a paper, it will have a searchable DOI you can add to your Curvenote citation library.
+### Export from Reference Manager
+1. **Open your reference manager** (Zotero, Mendeley, etc.)
+2. **Select the references** you want to import
+3. **Export as BibTeX** (`.bib` format)
+4. **Save the file** to your computer
-To add a DOI:
+### Import to Curvenote
+1. **Drag and drop** the `.bib` file into your Curvenote project
+2. **Or use the upload button** in your project
+3. **All references** will be added to your citation library
+4. **Citation keys** will be automatically generated
-- Locate the DOI on the article or document you want to cite, and copy it to your clipboard
+[Watch video: Importing citations from BibTeX file](images/MshxlXndaLsk3WbJ0ZGy-RaR3QGIKD1ek3VXMAX31-v3.mp4)
-```{note}
-The DOI is usually included with the article content. However, if you cannot find the DOI you can use the ‘Search Metadata’ option on [crossref.org.](crossref.org.)
+## 3. Insert Citations in Your Text
-```
+Once citations are in your library, you can easily insert them:
-- Place your cursor in the area you want to add the citation
-- Access the citation menu by using the `/cite` command
-- Navigate to **ADD DOI**
-- Enter the DOI in the search bar
-- Select **SEARCH**
-- If the appropriate article or document is shown, select **CREATE CITATION**
+### Single Citation
+1. **Place your cursor** where you want the citation
+2. **Type `/cite`** or `[[cite:`
+3. **Search for the reference** you want to cite
+4. **Select the citation** from the dropdown
+5. **The citation** will be inserted automatically
-```{figure} images/MshxlXndaLsk3WbJ0ZGy-tZmadZXYnXoMbmz0nAwm-v2.mp4
-:name: 17800507
-:align: center
-:width: 70%
-```
+### Multiple Citations
+1. **Place your cursor** where you want the citations
+2. **Type `/reference`** to access the references menu
+3. **Use the search** to find references
+4. **Check the boxes** for citations you want to add
+5. **Click "INSERT CITATIONS"**
-Your citation will now be added to your citation library for that project, and can be inserted into your articles without having to re-add the DOI.
+
-## Adding citations from BibTex files
+## 4. Format and Arrange Citations
-The bibtex (`*.bib`) file format is a storage format for citations, it is commonly used with $\LaTeX$, and can be exported from most reference managers.
+### Citation Styles
+Citations are automatically formatted according to your chosen style:
+- **Parenthetical citations**: `{cite:p}` for (Author, Year)
+- **Narrative citations**: `{cite:t}` for Author (Year)
-```{figure} images/MshxlXndaLsk3WbJ0ZGy-RaR3QGIKD1ek3VXMAX31-v3.mp4
-:name: adaa6acf
-:align: center
-:width: 70%
+### Group Citations
+1. **Select a citation** in your text
+2. **Click the `[]` button** in the toolbar to add brackets
+3. **Drag citations** into and out of citation groups
+4. **Rearrange citations** within groups as needed
-Import your references from a `*.bib` file, and easily update your references if you need to!
-```
-### Updating Citations
+## 5. Update and Manage Citations
-If you need to update your citation (e.g. fixing an author name, or adding a date), just re-export the bibtex from your reference manager, ensuring that the citation key for the reference is the same. Then just re-upload, the bibtex and all of the included reference will be updated💥.
+### Update Existing Citations
+1. **Re-export your BibTeX** from your reference manager
+2. **Ensure citation keys** remain the same
+3. **Re-upload the BibTeX file**
+4. **All references** will be updated automatically
-In Curvenote, the references are stored as a `Reference` block, when you upload through a bibtex file it is given a unique `name` that is derived from the citation key you provide. The block `name` (used in the URL and must be unique for a project) is prefixed with `ref-` and is lowercased. This means the bibtex references are like `Cockett2015-Elsevier` becomes `ref-cockett2015-elsevier`. You can also use these keys to quickly look up a citation through the `[[cite:` command or the reference search panel.
+### Citation Keys
+- **Format**: `ref-citationkey` (lowercase)
+- **Example**: `Cockett2015-Elsevier` becomes `ref-cockett2015-elsevier`
+- **Use for**: Quick lookup with `[[cite:` command
-## Inserting multiple citations
+## Citation Examples
-To add multiple citations:
+| Citation Type | Parenthetical Citation | Narrative Citation |
+|---------------|------------------------|-------------------|
+| 1 author | (Heinen, 2014) | Heinen (2014) |
+| 2 authors | (Bartkowski & Smith, 2018) | Bartkowski and Smith (2018) |
+| 3 or more authors | (Winter et al., 2018) | Winter et al. (2018) |
+| Group author | (European Commission, 2020) | European Commission (2020) |
-- Place your cursor in the area you want to add the citation
-- Access the references menu by using the `/reference` command
-- Filter using the **Search**, and use the checkboxes to select the citation you would like to add
-- Select **INSERT CITATIONS**
-The citations will now be added!
-```{figure} images/MshxlXndaLsk3WbJ0ZGy-V58UiaFTTyA5qx1tti7D-v1.png
-:name: bb7026ea
-:align: center
-:width: 60%
-```
+## Next Steps
-## Rearranging Citations
+- [Add Figures, Images, and Media →](./figures-and-images.md)
+- [Create Internal References →](./internal-references.md)
+- [Export to PDF/LaTeX →](./export-latex.md)
-By default when citations are added through the `[[cite:` command, they are added as individual citations, these can be wrapped in brackets using the `[]` icon in the toolbar when the citation is selected. You can also drag citations into and out of citation-groups. In latex, these correspond to `\citep{}` and render slightly differently than if you use your own brackets.
+---
-```{figure} images/MshxlXndaLsk3WbJ0ZGy-jTbSRxmzUrpQhHBo3ZuF-v3.mp4
-:name: a25010aa
-:align: center
-:width: 70%
+💡 **Tip:** Citations in Curvenote are clickable and will take you directly to the source article or document when clicked.
-Use the `[]` button to toggle the brackets around the citation. You can drag citations into different groups, or rearrange them in order.
-```
+⚡ **Important:
+Citation Management**
-Note that if you add the citation through the `/reference` command, then multiple citations will be added to a single group in one go.
+- Keep your BibTeX file updated in your reference manager
+- Use consistent citation keys across your project
+- Regularly sync your references to avoid conflicts
+- Test your citations before finalizing your document
diff --git a/editor/figures-and-images.md b/editor/figures-and-images.md
index 9c9f767..387df5e 100644
--- a/editor/figures-and-images.md
+++ b/editor/figures-and-images.md
@@ -1,128 +1,137 @@
---
-title: Figures & Images
+title: Add Figures, Images, and Media
+short_title: Add Figures & Images
---
-Images and GIFs can be added into articles by dragging them into a content block, or using the editing menu. Once added, images can be resized, and have numbered captions, which allow you to reference the figures in other parts of your document.
+# Add Figures, Images, and Media
+
+## Quick Start
+Add images, GIFs, and other media to your articles with proper formatting, captions, and internal references
+
+## Before You Start
+
+Make sure you have:
+- An article open in Curvenote
+- Images, GIFs, or other media files ready to add
+- Content in Draft Mode (click **EDIT** at the top of the page)
## Video Demo 📺
-```{iframe} https://www.loom.com/embed/6aa98f41d6f540cea5b759a1b9b0690f
-:label: GlzGgRNG6h
-:align: center
-:width: 90%
-```
+[Watch the video tutorial](https://www.loom.com/embed/6aa98f41d6f540cea5b759a1b9b0690f)
+
+## 1. Add Images and GIFs
+
+You can add static images (JPEG, TIFF, PNG) and GIFs using several methods:
-## Add Image or GIF
+### Method 1: Drag and Drop
+- **Drag and drop** images from your computer directly into a content block
+- A line will appear as you drag, and your images will appear below that line once dropped
-Static image formats (JPEG, TIFF, PNG, etc.) and GIFs are all supported and treated the same throughout Curvenote. To add an image or GIF you can either drag and drop from your computer or copy paste from your clipboard. Images and GIFs must be added to an existing content block when they are first added to Curvenote. After they have been added, they can be copied out via their oxa link and pasted as their own block within an article or notebook.
+### Method 2: Copy and Paste
+- **Paste** images directly from your clipboard into a content block
+- Images will automatically upload and appear in your content
-To add an image/GIF to an existing content block:
+### Method 3: Command Menu
+- Open the **command menu** by typing `/`
+- Search for `image`
+- Drag and drop your images into the box or click to browse and select files
-- You must be in Draft Mode for the page and block.
- - To enter Draft Mode for the page click **EDIT** at the top of the page.
- - To enter Draft Mode for the block, double click within the block or select the block and hit `enter`.
-- You can use any of the following to add one or multiple images/GIFs
- - **Drag and drop** images/GIFs from your computer directly into your block
- - A line will appear as you drag, and once you drop your images will appear below that line
- - **Paste** images/GIFs directly into your block
- - Open the **command menu** `/` and search for `image` then
- - Drag and drop your images/GIFs into the box
- - Click within the box to browse and select your files
- - Open the **insert menu** in the editing toolbar and select **Image** then
- - Drag and drop your images/GIFs into the box
- - Click within the box to browse and select your files
-- The transparency may pulse while the images/GIFs uploads.
+### Method 4: Insert Menu
+- Open the **insert menu** in the editing toolbar
+- Select **Image**
+- Drag and drop your images into the box or click to browse and select files
-To display an image/GIF as its own block:
+
-- You must be in Draft Mode for the page.
- - To enter Draft Mode for the page click **EDIT** at the top of the page.
-- Select the block above where you want to add your image/GIF.
- - You may need to hit `esc` until the entire block is selected or click directly on the block selection tab (it will be a slightly darker blue).
-- Paste your image/GIF.
-- A new block will appear below that is just your image/GIF.
+## 2. Create Standalone Image Blocks
-```{figure} images/Z1isOjJQGvM22q5fhunb-N5l1Q6oYXvf6h3LU4dRz-v1.png
-:name: uqtMbuXPbG
-:align: center
-:width: 70%
-```
+To display an image as its own block (separate from text):
-## Formatting
+1. **Enter Draft Mode** for the page (click **EDIT** at the top)
+2. **Select the block** above where you want to add your image
+ - You may need to hit `esc` until the entire block is selected
+ - Or click directly on the block selection tab (darker blue area)
+3. **Paste your image** - a new block will appear below with just your image
-Once your image, GIF, video or IFrame has uploaded, you’ll see a toolbar which will allow you to format your content. You’ll be able to adjust the alignment, change the width, or delete it.
+## 3. Format Your Images
-```{figure} images/Z1isOjJQGvM22q5fhunb-Dp770ojYtbrTmXDe2Gy0-v1.png
-:name: CYtDPoRVUr
-:align: center
-:width: 70%
-```
+Once uploaded, you'll see a formatting toolbar that allows you to:
-## Image and GIF Settings
+- **Adjust alignment** (left, center, right)
+- **Change width** (percentage of page width)
+- **Delete** the image if needed
-Images and GIFs are a special type of blocks in Curvenote. As shown above they can be displayed on their own within an article or notebook. They also have their own settings and versioning. Both can be used as a Figure with numbering, captions, and internal referencing within your content.
+
-### Versioning
+## 4. Create Figures with Captions and Numbering
-No matter if your image/GIF is displayed as its own block or within another block, it is versioned independently. New versions are created when you replace the image or update the image caption. When the image/GIF is selected, you can access the previous versions and choose to use them as you would a block, in the Block Details Panel.
+Images and GIFs can be formatted as **Figures** with automatic numbering and captions:
-Replacing an image/GIF will create a new version of the image/GIF block. To replace a block (not delete it):
+1. **Select the image** you want to format as a figure
+2. **In the formatting toolbar:**
+ - Click the lines symbol for **Show/Hide Caption**
+ - When caption is shown, click the number icon for **Toggle Numbering**
-- Select the image/GIF you want to replace.
-- Drag and drop or paste a new image onto the previous.
+Figures are automatically numbered by their location on the page, starting at 1.
-To use a different version of an image/GIF:
+
-- Select the image/GIF.
-- Expand the **Block Details Panel** on the right of the page.
-- Select a version you want to use.
- - A preview of that version will appear in place of the current image/GIF.
-- Click **USE VERSION**.
+## 5. Reference Figures in Your Text
-```{figure} images/Z1isOjJQGvM22q5fhunb-XSFXHCb26Y6uqqkIhsXz-v1.png
-:name: PJnQP46ZMR
-:align: center
-:width: 70%
-```
+You can reference figures by their numbers using internal references:
-### Settings
+### Method 1: Command Menu
+- Type `/link to figure` in your text
+- Select the figure you want to reference from the dropdown menu
-You can access and update the image/GIF block settings when the it is displayed either in a content block or on its own. The settings for an image/GIF block include the URL, title, description, image caption, and tags. The description for an image/GIF block is not displayed, as opposed to the image caption which can be displayed below the image/GIF and in the hover feature if the figure is referenced.
+### Method 2: Keyboard Shortcut
+- Type `[[fig:` in your text
+- Select the figure you want to reference from the dropdown menu
-To update the image/GIF settings:
+When readers click on the reference, a preview of the image and its caption is displayed.
-- Open Image Settings.
- - For and image/GIF inside a content block
- - Open the $\mathbf{\vdots}$ **Options** menu to the top-right of the image.
- - Select **Image Settings**.
- - For a stand-alone image/GIF block
- - Open the $\mathbf{\vdots}$ **Options** menu to the top-right of the block.
- - Select **Block Settings**.
-- Update the settings.
-- Click **UPDATE SETTINGS**.
+## 6. Manage Image Versions
-### Figures
+Images are versioned independently in Curvenote. New versions are created when you:
+- Replace the image
+- Update the image caption
-Image and GIFs can be formatted as Figures within your content on Curvenote. This means that they can be numbered, have captions displayed, and referenced throughout your text.
+### Replace an Image
+1. **Select the image** you want to replace
+2. **Drag and drop or paste** a new image onto the previous one
+3. A new version will be created automatically
-To toggle the caption and or numbering for an image/GIF:
+### Use a Previous Version
+1. **Select the image**
+2. **Expand the Block Details Panel** on the right of the page
+3. **Select a version** you want to use
+ - A preview will appear in place of the current image
+4. **Click "USE VERSION"**
-- Select the image.
-- In the formatting toolbar that appears:
- - Select the lines symbol for the **Show/Hide Caption** option.
- - When the caption is shown, you can then enable numbering by selecting the number icon for the **Toggle Numbering** option.
+
-Figures can be referenced by their numbers within the text using either the command menu or keyboard shortcuts. To reference a figure use one of the following two commands, then select the figure you want to reference from the drop down menu. When you click on the reference a preview of the image and its caption is displayed. Learn about internal references [Internal References](./internal-references.md)
+## 7. Update Image Settings
-`/link to figure` `[[fig:`
+You can access and update image settings including URL, title, description, caption, and tags:
-```{figure} images/Z1isOjJQGvM22q5fhunb-sIdK5tPBxpH5QPoljim3-v1.png
-:name: w1vNkL56vc
-:align: center
-:width: 50%
-```
+### For Images in Content Blocks
+1. Open the **⋮ Options menu** to the top-right of the image
+2. Select **"Image Settings"**
+3. Update the settings as needed
+4. Click **"UPDATE SETTINGS"**
-```{note}
-The numbering is ordered by location of the image/GIF on the page. All numbering will start at 1 at the beginning of the page. The numbering will automatically update with added or removed figures.
+### For Standalone Image Blocks
+1. Open the **⋮ Options menu** to the top-right of the block
+2. Select **"Block Settings"**
+3. Update the settings as needed
+4. Click **"UPDATE SETTINGS"**
+
+## Next Steps
+
+- [Create Internal References →](./internal-references.md)
+- [Add Interactive Outputs →](./interactive-outputs.md)
+- [Link Data and Code →](./add-and-link-notebooks.md)
+
+---
-```
+💡 **Tip:** Images and GIFs are treated as special blocks in Curvenote, meaning they can be reused across multiple articles and have their own versioning history.
diff --git a/editor/interactive-outputs.md b/editor/interactive-outputs.md
index 6a2bfaa..ca58805 100644
--- a/editor/interactive-outputs.md
+++ b/editor/interactive-outputs.md
@@ -1,19 +1,87 @@
---
-title: Interactive Outputs
+title: Add Interactive Outputs
+short_title: Interactive Outputs
---
-Curvenote is built to work hand in hand with Jupyter and allows you to directly use outputs from Jupyter as figures within your Curvenote articles. The versioning in Curvenote also allows for you to easily update your image in the article, rather than having to copy-and-paste a new static image each time you update your code. Curvenote also supports interactive Jupyter outputs, learn more [Interactive Outputs](./interactive-outputs-in-jupyter.md).
+# Add Interactive Outputs
-See [Jupyter](./jupyter-overview.md) documentation for more!
+## Quick Start
+Use Jupyter notebook outputs as interactive figures in your Curvenote articles with automatic versioning and updates
+
+Curvenote is built to work hand in hand with Jupyter and allows you to directly use outputs from Jupyter as figures within your Curvenote articles. The versioning in Curvenote also allows for you to easily update your image in the article, rather than having to copy-and-paste a new static image each time you update your code.
+
+## Before You Start
+
+Make sure you have:
+- A Jupyter notebook with outputs you want to use
+- The notebook linked to your Curvenote project
+- An article where you want to add the interactive outputs
## Video Demo 📺
-```{iframe} https://www.loom.com/embed/0c36c55d57644938825f5b7e05072f9f
-:label: DFsqOymUMf
-:align: center
-:width: 100%
-```
+[Watch the video tutorial](https://www.loom.com/embed/0c36c55d57644938825f5b7e05072f9f)
+
+## 1. Import Jupyter Outputs
+
+To use Jupyter outputs in your Curvenote articles:
+
+1. **Open your Jupyter notebook** in Curvenote
+2. **Select the output cell** you want to use (chart, plot, visualization, etc.)
+3. **Copy the output** using the copy button or keyboard shortcut
+4. **Paste into your article** where you want the output to appear
+
+The output will appear as a figure in your article and maintain its connection to the original notebook.
+
+## 2. Format Outputs as Figures
+
+Once imported, you can format Jupyter outputs as interactive figures:
+
+1. **Select the output** in your article
+2. **Use the formatting toolbar** that appears:
+ - Adjust size and location
+ - Add captions and numbering
+ - Set alignment and width
+3. **The output becomes a figure** that can be referenced throughout your text
+
+## 3. Reference Interactive Figures
+
+You can reference interactive figures the same way as regular figures:
+
+### Method 1: Command Menu
+- Type `/link to figure` in your text
+- Select the interactive figure from the dropdown menu
+
+### Method 2: Keyboard Shortcut
+- Type `[[fig:` in your text
+- Select the interactive figure from the dropdown menu
+
+## 4. Update Interactive Outputs
+
+When you update your Jupyter notebook:
+
+1. **Save your notebook** with the new outputs
+2. **The linked outputs in your article** will automatically update
+3. **No manual copying/pasting** required - Curvenote handles the versioning
+
+This ensures your articles always show the latest results from your analysis.
+
+## 5. Use Interactive Features
+
+Interactive Jupyter outputs can include:
+
+- **Interactive plots** (Plotly, Bokeh, etc.)
+- **Dynamic visualizations** that respond to user input
+- **Embedded widgets** and controls
+- **Live data displays** that update automatically
+
+## Next Steps
+
+- [Add Figures, Images, and Media →](./figures-and-images.md)
+- [Link Data and Code →](./add-and-link-notebooks.md)
+- [Write a Scientific Paper using Jupyter →](../authoring/jupyter-notebooks.md)
+
+---
-### Outputs as Figures
+💡 **Tip:** Interactive outputs maintain their full functionality when embedded in Curvenote articles, allowing readers to explore your data and visualizations directly within the document.
-Once you’ve imported your output cell into a Curvenote article, you can format the output as a figure. You can adjust the size and location, add a caption and numbering, and referencing the figure throughout your text. The formatting options are available in a toolbar that appears above or below the figure when you select the figure. Learn more about referencing figures [Internal References](./internal-references.md).
+See [Interactive Outputs in Jupyter](./interactive-outputs-in-jupyter.md) for advanced features and [Jupyter Overview](./jupyter-overview.md) for more information!
diff --git a/getting-started/create-a-site.md b/getting-started/create-a-site.md
new file mode 100644
index 0000000..f897d7f
--- /dev/null
+++ b/getting-started/create-a-site.md
@@ -0,0 +1,36 @@
+---
+title: Create a Site
+short_title: Create a Site
+---
+
+# Create a Site
+
+## Quick Start
+Set up your Curvenote site to publish and share your work online
+
+Creating a Curvenote site gives you a dedicated space to publish your research, lab work, or any scientific content. The process is simple and handled through our onboarding form.
+
+## Before you start
+
+- Curvenote account + CLI installed
+- Only Curvenote staff can create sites — you'll use our onboarding form
+
+## Request a site
+
+- Fill out the [Site Setup Request Form](https://forms.gle/Y8ppqCpPFKPH5GFr7)
+- Curvenote will set up:
+ - **Title & subdomain** (e.g., `my-lab.curve.space`)
+ - **Public or private** visibility
+ - **Initial landing content**
+- You'll receive a confirmation email once your site is live
+
+## Next steps after creation
+
+- Review your site's landing page
+- Follow the [Site Management →](../sites/index.md) guide to update content and handle submissions
+
+## Related guides
+
+- [Planning Your Site →](../site-design/planning.md)
+- [Publish & Share →](publish-article.md)
+- [Organize Content into Sections →](../authoring/organize-content.md)
diff --git a/getting-started/create-article-cli.md b/getting-started/create-article-cli.md
new file mode 100644
index 0000000..f46cdd0
--- /dev/null
+++ b/getting-started/create-article-cli.md
@@ -0,0 +1,68 @@
+---
+title: Write Your First Article
+short_title: Write Article
+---
+
+# Write Your First Article
+
+## Quick Start
+Create and edit your first article in Curvenote using the CLI
+
+Writing articles in Curvenote is straightforward and flexible. You can use Markdown, Jupyter notebooks, or other formats to create rich, interactive content.
+
+## Create a new article
+
+To create a new article, simply add a new Markdown file to your project's content/ directory using your preferred text editor or IDE.
+
+For example, create a file called `my-first-article.md`:
+```
+content/
+├── index.md
+└── my-first-article.md
+```
+
+Each article should start with YAML frontmatter containing at least a title field. For example:
+
+```yaml
+---
+title: My First Article
+date: 2025-08-15
+---
+```
+
+Once created, you can add the new article to your site navigation by editing `curvenote.yml` and linking to the file.
+
+💡 **Tip**: If your project is already linked to a Curvenote site, you can use `curvenote push` to sync changes for review or `curvenote submit` to send it to a collection.
+
+## Open and edit your article
+
+Open the new file in your preferred text editor (for example, VS Code, Sublime Text, or another editor you use).
+
+If you use Visual Studio Code, you can open the file directly from your terminal:
+```bash
+code content/my-first-article.md
+```
+
+You can write in **MyST Markdown** or use **Jupyter Notebooks**.
+
+## Preview locally
+
+See your changes instantly by running:
+
+```bash
+curvenote start
+```
+
+This opens a local preview of your site in your browser so you can check formatting, figures, and links.
+
+## Organize your articles
+
+For best practices on organizing content, see [Organize Articles and Sections](../authoring/organize-content.md)
+
+## Next steps
+
+- [Publish & Share →](./publish-article.md)
+- [Add Figures, Images, and Media →](../editor/figures-and-images.md)
+- [Link Data and Code →](../editor/add-and-link-notebooks.md)
+
+
diff --git a/getting-started/create-project.md b/getting-started/create-project.md
new file mode 100644
index 0000000..c09f419
--- /dev/null
+++ b/getting-started/create-project.md
@@ -0,0 +1,101 @@
+---
+title: Create Your First Project
+short_title: Create Project
+---
+
+# Create Your First Project
+
+## Quick Start
+Create and organize your first Curvenote project to start writing and publishing content
+
+A **project** is the container for everything you want to publish in Curvenote — including articles, figures, datasets, media, and the configuration that controls how they appear online.
+
+## What's a project in Curvenote?
+
+A project can be:
+- **A single article** — for example, a preprint, report, or tutorial
+- **A multi-article collection** — such as a lab website, conference proceedings, or journal issue
+- **A research output with multiple parts** — combining text, interactive figures, and linked data/code
+
+The `curvenote.yml` file defines the project's metadata, structure, and publishing settings, whether your project is just one file or a large collection.
+
+Projects typically include:
+
+- **Configuration file** (`curvenote.yml`) — **Required.** Defines site settings, article metadata, and publishing options
+- **Content files** — Any `.md`, `.ipynb`, or `.tex` files containing your articles, sections, and figures. These can be organized in any folder structure
+- **Supporting files** — Images, datasets, scripts, or other media used in your articles. These can be stored anywhere in the project
+
+There is no required folder naming convention; organize files and directories in the way that best suits your workflow.
+
+## Create a new project
+
+From your terminal:
+
+```bash
+curvenote init
+```
+
+When you run this command, you'll be prompted to choose how to initialize the project:
+
+### 1. Import from Curvenote
+Pulls content from the legacy web editor at curvenote.com.
+*Note: This workflow may be removed in future versions.*
+
+### 2. Use the content in this folder
+Treats the current folder as a Curvenote project using the existing files inside it.
+
+- This option is only available if the folder already contains content (e.g., `.md`, `.ipynb`, `.tex` files) and you are starting from that folder
+
+For new projects, we recommend starting in a folder where you've already added your initial article or content files.
+
+Then, run `curvenote init` from that folder to create the required curvenote.yml configuration file and begin organizing your content.
+
+## Navigate and explore
+
+Move into your new project folder:
+
+```bash
+cd my-first-project
+```
+
+Open `/index.md` in your editor — this is your first article. You can rename it, add more `.md` or `.myst.md`, `ipynb` or `.tex` files, and organize them in folders that make sense for your project.
+
+## Organize your content
+
+Best practices (adapt as needed for your workflow):
+
+- **One article per file** for clarity
+- Group related articles into folders (e.g., `/methods`, `/results`)
+- Store images and figures wherever is most convenient — for example, alongside the articles that reference them, or in a dedicated folder like `assets/` or `media/`
+- Use clear, short file names (avoid spaces)
+
+Example:
+```
+methods/
+├── data-collection.md
+└── analysis.md
+results/
+├── experiment-1.md
+└── experiment-2.md
+assets/
+├── shared-logo.png
+└── dataset.csv
+```
+
+## Check your setup
+
+You can preview your content locally by running:
+
+```bash
+curvenote start
+```
+
+This launches a local development server where you can see your project as it will appear online.
+
+## Next steps
+
+- [Write Your First Article →](create-article-cli.md)
+- [Publish & Share →](publish-article.md)
+- [Set Up a Site →](create-a-site.md)
+
+💡 **Tip:** You can connect your project to GitHub for version control. See [Submissions Using GitHub](submissions-using-github.md).
\ No newline at end of file
diff --git a/getting-started/install-cli.md b/getting-started/install-cli.md
new file mode 100644
index 0000000..fe42a71
--- /dev/null
+++ b/getting-started/install-cli.md
@@ -0,0 +1,71 @@
+---
+title: Install & Authenticate the Curvenote CLI
+short_title: Install CLI
+---
+
+# Install & Authenticate the Curvenote CLI
+
+## Quick Start
+Get the Curvenote CLI installed and authenticated in minutes
+
+The Curvenote CLI lets you create, manage, and publish content from your terminal. Follow these steps to get up and running quickly.
+
+## Before you start
+
+Make sure you have:
+
+**Node.js v18 or later** (comes with `npm`)
+- Check your version:
+ ```bash
+ node --version
+ ```
+- If needed, [download Node.js](https://nodejs.org/) or install via Conda:
+ ```bash
+ conda install -c conda-forge nodejs
+ ```
+
+## 1. Install the CLI
+
+Open your terminal and run:
+
+```bash
+npm install -g curvenote
+```
+
+Verify installation:
+```bash
+curvenote --version
+```
+
+You should see a version number. If you see an error, check your Node.js and `npm` setup.
+
+## 2. Authenticate with Curvenote
+
+You'll need an API token if working with private projects or publishing to a site.
+
+1. In your Curvenote Personal Settings, generate a new API token
+2. In your terminal, run:
+ ```bash
+ curvenote token set
+ ```
+3. Paste the API token when prompted
+
+For more options, see the full [Authentication Reference](../cli/authentication.md).
+
+## 3. Verify your setup
+
+Run:
+```bash
+curvenote token check
+```
+
+If it returns your username, your CLI is ready.
+
+## Next steps
+
+- [Create Your First Project →](create-project.md)
+- [Write Your First Article from the CLI →](create-article-cli.md)
+- [Set Up a Site for Publishing →](create-a-site.md)
+- [Publish & Share Content →](publish-article.md)
+
+💡 **Tip:** The Curvenote CLI is open source—[view it on GitHub](https://github.com/curvenote/curvenote).
diff --git a/getting-started/publish-article.md b/getting-started/publish-article.md
new file mode 100644
index 0000000..ef03612
--- /dev/null
+++ b/getting-started/publish-article.md
@@ -0,0 +1,63 @@
+---
+title: Publish & Share Your Article
+short_title: Publish & Share
+---
+
+# Publish & Share Your Article
+
+## What you'll learn
+How to publish your article and make it accessible online
+
+Publishing your article with Curvenote is simple and fast. Whether you want to share your research publicly or submit it for review, Curvenote makes it easy to get your content live on the web.
+
+## Before you publish
+
+Make sure your project is ready:
+
+- At least one article with content
+- A valid `curvenote.yml` configuration file
+- All required assets (figures, datasets, notebooks) included
+
+If you're not sure your site is configured, see [Set Up a Site](create-a-site.md)
+
+## Choose how to publish
+
+**Publish directly to the web (public)**
+
+This puts your project live on the `.curve.space` domain you set in `site.domains`:
+
+```bash
+curvenote deploy
+```
+
+**Submit to a site (for review or staged publishing)**
+
+Send your project to a site (e.g., a lab site or journal). Only site admins can make it public:
+
+```bash
+curvenote submit
+```
+
+If you have admin rights and want to publish from the CLI:
+
+```bash
+curvenote submission publish
+```
+
+## See the result
+
+- **Deploy:** The CLI will show your live `.curve.space` URL
+- **Submit:** Your submission appears in the site's admin area. If published, the site will provide the public URL
+
+## Update your content
+
+- **If you deployed:** Run `curvenote deploy` again to replace the live version
+- **If you submitted:** Run `curvenote submit ` to create a new submission version, then publish (via admin UI or `curvenote submission publish `)
+
+## Next steps
+
+- [Add Figures, Images, and Media →](../editor/figures-and-images.md)
+- [Link Data and Code →](../editor/add-and-link-notebooks.md)
+- [Export to PDF/Typst →](../editor/export-pdf.md)
+
+💡 **Tip:** Published content is "living" in Curvenote — you can make edits anytime, and your audience will always see the latest version.
diff --git a/getting-started/what-is-curvenote.md b/getting-started/what-is-curvenote.md
new file mode 100644
index 0000000..b205cc5
--- /dev/null
+++ b/getting-started/what-is-curvenote.md
@@ -0,0 +1,46 @@
+---
+title: What is Curvenote?
+short_title: What is Curvenote
+---
+
+# Get Started
+
+## Welcome
+Learn about Curvenote and how to get started
+
+Curvenote is a platform for **writing, organizing, and publishing scientific content**—built by researchers, for researchers. Add your text, datasets, and figures to create interactive, modular, and versioned scientific outputs that move beyond static PDFs.
+
+## What makes Curvenote different?
+
+Curvenote helps you move beyond static PDFs by enabling:
+
+- **Modular articles** with reusable blocks and components
+- **Versioned content** that tracks every change
+- **Web-first publishing** for better discoverability
+- **One-click exports** to Typst or PDF when needed
+
+## How it works
+
+Work in your browser or use the Curvenote CLI:
+
+- Write in **Markdown, Jupyter**, or the Curvenote editor
+- Organize content into **folders, articles, and blocks**
+- Connect to **GitHub** for version control and collaboration
+- Publish to the web with a single command
+- Export to Typst or PDF for review or submission
+
+## Built for research teams
+
+Curvenote supports collaborative research with:
+
+- Collaborative editing & version tracking
+- Reusable figures, text blocks, and citations
+- DOI minting & metadata management
+- Research integrity checks (iThenticate, Proofig)
+- Compliance with open science, funder, and institutional policies
+
+## Next steps
+
+- [Install the CLI →](install-cli.md)
+- [Set up your first publishing site →](create-a-site.md)
+- [Write and publish your first article →](create-article-cli.md)
\ No newline at end of file
diff --git a/myst.yml b/myst.yml
index 4b2d76a..bb94d90 100644
--- a/myst.yml
+++ b/myst.yml
@@ -42,27 +42,29 @@ project:
- file: solutions.md
- title: Getting Started
children:
- - file: start/index.md
- - title: Site design
+ - file: getting-started/what-is-curvenote.md
+ - file: getting-started/install-cli.md
+ - file: getting-started/create-project.md
+ - file: getting-started/create-article-cli.md
+ - file: getting-started/publish-article.md
+ - file: getting-started/create-a-site.md
+ - title: Design & Customize Your Site
children:
- - file: sites/index.md
- - file: sites/concepts.md
- - file: sites/create-a-site.md
- - file: sites/landing-pages.md
- - file: sites/navigation.md
- - file: sites/cards.md
- - file: sites/listings.md
- - file: sites/custom-domains.md
- - file: sites/curvenote-branding.md
- - file: sites/analytics.md
- - file: sites/custom-development.md
- - title: Preparing articles
+ - file: site-design/layout-and-theme.md
+ - file: site-design/planning.md
+ - file: site-design/custom-domains.md
+ - file: site-design/navigation.md
+ - title: Authoring Content
children:
- - file: authoring/myst-markdown.md
- - file: article-actions.md
- - file: authoring/submitting-your-work.md
- - file: tutorial-deploy-local.md
- - file: try-curvespace.md
+ - file: authoring/citations.md
+ - file: authoring/add-figures-media.md
+ - file: authoring/interactive-figures.md
+ - file: authoring/link-data-code.md
+ - file: authoring/organize-content.md
+ - file: authoring/reuse-blocks.md
+ - file: authoring/version-history.md
+ - file: authoring/writing-markdown-myst-jupyter.md
+
- title: Computational articles
children:
- file: computational-articles.md
diff --git a/sites/create-a-site.md b/sites/create-a-site.md
deleted file mode 100644
index cd40544..0000000
--- a/sites/create-a-site.md
+++ /dev/null
@@ -1,120 +0,0 @@
----
-title: How to Set Up a Publishing Site in Curvenote
-short_title: Create a Site
----
-
-:::{tip} Objective
-Get started creating a publishing destination for your articles, lab notebooks, or group collections.
-:::
-
-## Steps to Set Up a Site
-
-:::{important} Before you start
-Make sure you have:
-
-- A Curvenote account and access to the [Curvenote CLI](../cli/index.md)
-- Access to an existing site (or create one via the web admin interface)
-- A configured project (`curvenote.yml` file) if publishing from GitHub or locally
- :::
-
-### 1. Create a Site (via Web Admin)
-
-Creating a new site must currently be done through the web admin interface.
-
-- Choose a title and subdomain (e.g., `my-lab.curve.space`)
-- Set the site visibility (public or private)
-- Define the organization or group that owns the site
-
-_Coming Soon: CLI-based site creation is planned to make this easier for new users._
-
-### 2. Set a Landing Page or Featured Work
-
-Once the site exists, site administrators can set a "landing page" or featured work. This may be configured via:
-
-- The web admin interface (recommended)
-- CLI tools (if supported)
-
-The landing page gives visitors an entry point to your site’s most important content.
-
-### 3. Organize Your Content (Optional, CLI or Git-based Workflows)
-
-If you are managing content locally (e.g., in GitHub), organize your files into logical directories:
-
-- **Articles:** `articles/`
-- **Figures/Methods:** `components/`
-- **Landing page:** `index.md`
-
-For sites that accept community contributions or external submissions, this structure will be handled post-submission.
-
-### 4. Add Metadata and Content Types (Kinds)
-
-Ensure that each content file includes a frontmatter block with relevant metadata:
-
-```yaml
----
-title: 'An Advanced Microscopy Study'
-authors:
- - name: Dr. Lee
-kind: article
----
-```
-
-This metadata supports automated checks, collection assignment, and proper formatting.
-
-### 5. Submit Content to a Site and Collection
-
-Use the CLI to associate your content with a site and collection:
-
-```bash
-curvenote submit
-```
-
-You’ll be prompted to:
-
-- Select an existing site
-- Choose a collection (e.g., "Lab Articles")
-
-This prepares your content for publishing and notifies site administrators.
-
-### 6. Push Changes to the Server (Optional)
-
-To sync your draft content to the server for internal review:
-
-```bash
-curvenote push
-```
-
-This allows collaborators to preview your work, but does not make it publicly visible.
-
-### 7. Run Structural Checks (Optional)
-
-To verify your content is valid before publishing:
-
-```bash
-curvenote check
-```
-
-This will run structural and metadata checks and highlight any issues.
-
-> 💡 **Tip:** For more details on how to run a structural check, visit this page (link)
-
-### 8. Publish Content (Admin Action)
-
-Publishing makes submitted content live on the site:
-
-```bash
-curvenote submission publish
-```
-
-Only site admins can publish submitted content. Once published:
-
-- Content appears on the site
-- DOI, metadata, and links are activated
-
-## What Happens Next?
-
-Once published, you can:
-
-- Share links to your articles or site homepage
-- Make updates and re-publish (each update is versioned)
-- Embed content elsewhere (figures, notebooks, methods)
diff --git a/start/index.md b/start/index.md
deleted file mode 100644
index 6021bdf..0000000
--- a/start/index.md
+++ /dev/null
@@ -1,56 +0,0 @@
-# What is Curvenote?
-
-Curvenote is a platform for writing, organizing, and publishing scientific content—built by researchers, for researchers.
-
-It helps you move beyond static PDFs by enabling interactive, modular, and versioned scientific outputs. Whether you're drafting a preprint, creating a lab website, or sharing reproducible analyses, Curvenote provides the tools to publish with structure, transparency, and flexibility.
-
-## A new kind of scientific output
-
-Most research outputs today are frozen in time—locked into PDFs and detached from the data, code, or figures that created them. Curvenote enables a different approach:
-
-- Modular articles with reusable blocks and components
-- Versioned content that captures draft history and changes
-- Web-first publishing that prioritizes discoverability
-- Integrated exports to Typst and PDF when needed
-
-## Write once, publish anywhere
-
-Curvenote works in your browser or with the Curvenote CLI. You can:
-
-- Write in Markdown, Jupyter, or the Curvenote editor
-- Organize content into folders, articles, and blocks
-- Connect to GitHub for version control and collaboration
-- Publish to the web with a single command
-- Export to Typst or PDF for review or submission
-
-## Publishing is part of your workflow
-
-Publishing with Curvenote is fast and flexible. You can publish:
-
-- Single articles
-- Multi-article collections (like lab sites or documentation)
-- Research outputs with interactive figures, notebooks, and citations
-
-Everything you publish remains editable and updateable—no reformatting required.
-
-## Built for research teams
-
-Curvenote supports:
-
-- Collaborative editing and version tracking
-- Reusable figures, text blocks, and citations
-- DOI minting and metadata support
-- Automated research integrity checks (iThenticate, Proofig)
-- Compliance with open science, funder, and institutional policies
-
-## Why it matters
-
-Scientific knowledge should be open, versioned, and reusable. Curvenote is designed to support modern scientific communication by providing infrastructure for living research outputs.
-
-Whether you're preparing a funder report, publishing a preprint, or launching a public-facing project, Curvenote helps you move faster, stay organized, and share your work in ways that are meaningful to both humans and machines.
-
-## Next steps
-
-- [Install the CLI](../cli/index.md)
-- [Set up your first publishing site](../sites/index.md)
-- [Write and publish your first article](../authoring/index.md)