### Install Extension Template

Source: https://quarto.org/docs/extensions/formats.llms

Use this command to install an extension along with its template files from a GitHub repository. The template provides a starting point for users.

```bash
quarto use template <gh-organization>/<extension>
```

--------------------------------

### Shiny Setup Code in Quarto

Source: https://quarto.org/docs/dashboards/interactivity/shiny-r.llms

Initializes the Shiny application environment and loads necessary libraries. The `context: setup` option ensures this code runs once when the application starts.

```r
#| context: setup
library(ggplot2)
dataset <- diamonds

```

--------------------------------

### Dashboard YAML and Setup

Source: https://quarto.org/docs/dashboards/interactivity/shiny-python/index.llms

Defines the dashboard format, enables Shiny server, and performs initial data loading and setup using `context: setup`.

```python
---
title: "Palmer Penguins"
author: "Cobblepot Analytics"
format: dashboard
server: shiny # <1>
---

```{{python}} # <2>
#| context: setup
import seaborn as sns
from shiny import reactive
from shiny.express import render, ui
penguins = sns.load_dataset("penguins")
``` # <2>
```

--------------------------------

### Specify Setup Context for Packages and Data

Source: https://quarto.org/docs/dashboards/interactivity/shiny-python/execution.llms

Use `context: setup` to designate code that loads required packages and data. This code runs during document rendering and once at Shiny application startup, improving performance for long-running setup tasks.

```python
#| context: setup
import seaborn as sns
penguins = sns.load_dataset("penguins")
```

--------------------------------

### Example Binder URL

Source: https://quarto.org/docs/projects/binder.llms

An example URL to launch a Binder environment for a specific GitHub repository, configured to open RStudio.

```url
https://mybinder.org/v2/gh/cwickham/binder-example/HEAD?urlpath=rstudio

```

--------------------------------

### Interactive Tool Installation

Source: https://quarto.org/docs/cli/install.llms

Run this command without arguments to be interactively prompted to choose which tool to install.

```bash
quarto install
```

--------------------------------

### Install Reveal.js Extension

Source: https://quarto.org/docs/extensions/revealjs.llms

Install a Reveal.js extension from a GitHub repository using the 'quarto add' command.

```bash
quarto add quarto-ext/attribution
```

--------------------------------

### Install Extension from Local File

Source: https://quarto.org/docs/cli/add.llms

Installs an extension packaged as a zip file from a local path. Replace `<path-to-zip>` with the actual file path.

```bash
quarto add <path-to-zip>
```

--------------------------------

### Install Shiny and Shinywidgets

Source: https://quarto.org/docs/dashboards/interactivity/shiny-python/index.llms

Install or upgrade the necessary Shiny packages for Quarto integration.

```bash
pip install --upgrade shiny shinywidgets
```

--------------------------------

### Install a Global Dependency

Source: https://quarto.org/docs/cli/install.llms

Use this command to install a specified global dependency. You can install multiple dependencies at once.

```bash
quarto install [target...]
```

--------------------------------

### Check Quarto Installation

Source: https://quarto.org/docs/cli/check.llms

Verifies the core Quarto installation. Use this to ensure Quarto itself is set up correctly.

```bash
quarto check install
```

--------------------------------

### Install Extension from URL

Source: https://quarto.org/docs/cli/add.llms

Installs an extension from a remote URL. Replace `<url>` with the direct link to the extension package.

```bash
quarto add <url>
```

--------------------------------

### Install and Initialize renv

Source: https://quarto.org/docs/projects/virtual-environments.llms

Installs the renv package from CRAN and initializes a new renv environment for the project.

```r
install.packages("renv")
renv::init()
```

--------------------------------

### Navigate and Start JupyterLab

Source: https://quarto.org/docs/manuscripts/authoring/jupyterlab.llms

Navigate into the cloned manuscript tutorial directory and start JupyterLab using Python 3. This command is used after cloning the template repository.

```bash
cd manuscript-tutorial
python3 -m jupyter lab
```

--------------------------------

### Use a Quarto Starter Template

Source: https://quarto.org/docs/extensions/starter-templates.llms

Instantiate a starter template from a GitHub repository into the current or a new directory.

```bash
quarto use template cooltools/cool-project
```

--------------------------------

### Install Python Packages in Virtual Environment

Source: https://quarto.org/docs/tools/rstudio.llms

Use the RStudio Terminal to install Python packages into a project's activated virtual environment. This example installs the 'scikit-learn' package.

```bash
python3 -m pip install scikit-learn

```

--------------------------------

### Serve Document via Command Line

Source: https://quarto.org/docs/interactive/shiny/running.llms

Run a Quarto document from the command line using the `quarto serve` command. This starts a local server for the document.

```bash
quarto serve document.qmd
```

--------------------------------

### Example Quarto Project Directory Structure

Source: https://quarto.org/docs/publishing/confluence.llms

Organize your `.qmd` or `.ipynb` documents within a project directory for publishing.

```text
_quarto.yml
index.qmd
team.qmd
projects/
  planning.qmd
  retrospectives.qmd
```

--------------------------------

### Multi-Block Example for Documentation

Source: https://quarto.org/docs/output-formats/html-code.llms

Demonstrates how to include multiple code blocks and markdown content within a single documentation example by enclosing the entire structure in four backticks.

```markdown
````
---
title: "My document"
---

Some markdown content.

```{{python}}
1 + 1
```

Some additional markdown content.
````
```

--------------------------------

### Setup Cell for One-Time Code Execution

Source: https://quarto.org/docs/dashboards/interactivity/shiny-python/index.llms

Use `#| context: setup` to run code only once when the Shiny process starts. This is ideal for importing packages and loading data to avoid redundant computations for each user. Variables defined here are accessible in other cells.

```python
#| context: setup
import seaborn as sns
from shiny import reactive
from shiny.express import render, ui
penguins = sns.load_dataset("penguins")
```

--------------------------------

### Fully render all website/book formats then preview

Source: https://quarto.org/docs/cli/preview.llms

Ensure all formats of a website or book are fully rendered before starting the preview. This is useful for verifying the complete output.

```bash
quarto preview --render all
```

--------------------------------

### Integrate Revise.jl for Live Code Updates

Source: https://quarto.org/docs/computations/julia.llms

Import Revise.jl at the start of a notebook to enable automatic updates of function definitions. Ensure Revise.jl is installed in the notebook's project environment.

```julia
using Revise
```

--------------------------------

### Get Julia Engine Status

Source: https://quarto.org/docs/computations/julia.llms

Prints information about the currently running server and worker processes. Shows details like start time, runner version, environment, PIDs, ports, Julia version, timeouts, and active workers with their paths and run statuses.

```bash
$ quarto call engine julia status
QuartoNotebookRunner server status:
  started at: 9:44:31 (47 seconds ago)
  runner version: 0.15.0
  environment: /Users/username/Library/Caches/quarto/julia/
  pid: 42008
  port: 8000
  julia version: 1.11.4
  timeout: 5 minutes
  workers active: 1
    worker 1:
      path: /Users/username/notebook.qmd
      run started: 9:44:38 (40 seconds ago)
      run finished: -
      timeout: 5 minutes
      pid: 42026
      exe: `julia`
      exeflags: ["--color=yes"]
      env: ["JULIA_PROJECT=@."]
```

--------------------------------

### Basic Project Configuration

Source: https://quarto.org/docs/reference/projects/options.llms

Defines the project type and output directory. Use this for standard project setups.

```yaml
project:
  type: default
  output-dir: _output
```

--------------------------------

### Install Quarto Extension from GitHub

Source: https://quarto.org/docs/extensions/shortcodes.llms

Commands to install a Quarto extension from a GitHub repository. Supports installing the latest version or a specific branch/tag.

```bash
# install the current HEAD of the extension
quarto add cooltools/shorty

# install a branch or tagged release of the extension
quarto add cooltools/shorty@v1.2
quarto add cooltools/shorty@bugfix-22
```

--------------------------------

### Install R Packages for Quarto

Source: https://quarto.org/docs/get-started/hello/positron.llms

Install the necessary R packages for working with Quarto documents. Ensure these packages are installed before proceeding with Quarto development.

```r
install.packages("rmarkdown")
install.packages("tidyverse")
install.packages("palmerpenguins")
```

--------------------------------

### Publish to Connect from CI using _publish.yml

Source: https://quarto.org/docs/publishing/rstudio-connect.llms

Set environment variables for Connect server address and API key, then use the `quarto publish connect` command. This assumes a `_publish.yml` file exists in the project.

```bash
export CONNECT_SERVER=https://connect.example.com/
export CONNECT_API_KEY=7C0947A852D8
quarto publish connect
```

--------------------------------

### Install R Markdown Package

Source: https://quarto.org/docs/computations/r.llms

Install the rmarkdown package to enable R code execution within Quarto documents. This also installs the knitr package.

```r
install.packages("rmarkdown")
```

--------------------------------

### Serve Project Preview with Custom Command

Source: https://quarto.org/docs/reference/projects/books.llms

Configure a custom command to serve the project preview, interpolating port and host, and setting environment variables.

```yaml
project:
  type: book
  preview:
    serve:
      cmd: "hugo serve --port {port} --bind {host} --navigateToChanged"
      env:
        HUGO_RELATIVEURLS: "true"
      ready: "Web Server is available at"
```

--------------------------------

### Quarto CLI Command to Install veraPDF

Source: https://quarto.org/docs/output-formats/pdf-basics.llms

Install the veraPDF tool for PDF/A and PDF/UA validation using the Quarto CLI. Ensure a compatible Java version is installed.

```bash
quarto install verapdf

```

--------------------------------

### Install rsvg-convert on Windows

Source: https://quarto.org/docs/prerelease/1.3/pdf.llms

Install rsvg-convert on Windows using Chocolatey.

```bash
choco install rsvg-convert
```

--------------------------------

### Preview PDF Output

Source: https://quarto.org/docs/computations/julia.llms

Sets up a live preview of the Quarto document as PDF. Changes are reflected automatically.

```bash
quarto preview document.qmd --to pdf
```

--------------------------------

### Serve with Project Profiles

Source: https://quarto.org/docs/cli/serve.llms

Serve a document using active project profiles for configuration.

```bash
quarto serve --profile production
```

--------------------------------

### Install TinyTeX

Source: https://quarto.org/docs/cli/install.llms

Installs the TinyTeX distribution, a lightweight LaTeX distribution for Quarto.

```bash
quarto install tinytex
```

--------------------------------

### Python Code Example

Source: https://quarto.org/docs/output-formats/ms-word.llms

An example of a Python code block that will be syntax highlighted.

```python
1 + 1

```

--------------------------------

### Example typst-gather.toml Configuration

Source: https://quarto.org/docs/advanced/typst/typst-gather.llms

A sample `typst-gather.toml` file demonstrating configuration options like `rootdir`, `destination`, and `discover`.

```toml
# typst-gather configuration
# Run: quarto call typst-gather

rootdir = "_extensions/myformat"
destination = "typst/packages"

discover = ["typst-template.typ", "typst-show.typ"]

# Preview packages are auto-discovered from imports.
# Uncomment to pin specific versions:
# [preview]
# marginalia = "0.3.1"
# cetz = "0.4.1"

# Local packages (@local namespace) must be configured manually.
# [local]
# my-pkg = "/path/to/my-pkg"
```

--------------------------------

### Configure Book Project Preview Settings

Source: https://quarto.org/docs/reference/projects/books.llms

Customize the behavior of `quarto preview` by setting the port, disabling the browser, and controlling input watching.

```yaml
project:
  type: book
  output-dir: _book
  preview:
    port: 4200
    browser: false
```

--------------------------------

### Install R Packages with renv

Source: https://quarto.org/docs/projects/virtual-environments.llms

Installs R packages from CRAN or GitHub using renv.

```r
install.packages("ggplot2")      # install from CRAN
renv::install("tidyverse/dplyr") # install from GitHub
```

--------------------------------

### Install librsvg on macOS

Source: https://quarto.org/docs/prerelease/1.3/pdf.llms

Use Homebrew to install librsvg on macOS for SVG to PDF conversion.

```bash
brew install librsvg
```

--------------------------------

### Install R Packages

Source: https://quarto.org/docs/get-started/computations/positron.llms

Install the 'rmarkdown' and 'tidyverse' packages required for R computations in Quarto.

```r
install.packages("rmarkdown")
install.packages("tidyverse")
```

--------------------------------

### Example Usage of Shortcode

Source: https://quarto.org/docs/extensions/shortcodes.llms

This QMD file demonstrates how to use the 'shorty' shortcode within a Quarto document. Rendering this file will display the output from the shortcode.

```markdown
---
title: "Shorty Example"
---

{{< shorty >}}
```

--------------------------------

### Create New Blog Project

Source: https://quarto.org/docs/websites/website-blog.llms

Use this command to generate the basic file structure for a new blog project in a specified directory.

```bash
quarto create project blog myblog
```

--------------------------------

### Install Chromium (Legacy)

Source: https://quarto.org/docs/cli/install.llms

Installs the Chromium browser, which may be used for legacy rendering purposes.

```bash
quarto install chromium
```

--------------------------------

### Initialize typst-gather Configuration File

Source: https://quarto.org/docs/advanced/typst/typst-gather.llms

Command to generate a starter `typst-gather.toml` configuration file for more control over package gathering.

```bash
quarto call typst-gather --init-config
```

--------------------------------

### Mermaid Flowchart Example

Source: https://quarto.org/docs/authoring/markdown-basics.llms

A direct example of a Mermaid flowchart syntax that can be embedded in Quarto documents.

```mermaid
flowchart LR
  A[Hard edge] --> B(Round edge)
  B --> C{Decision}
  C --> D[Result one]
  C --> E[Result two]
```

--------------------------------

### Preview Notebook with Quarto

Source: https://quarto.org/docs/tools/jupyter-lab.llms

Start a live preview of a Jupyter notebook. The notebook will be rendered, and a web browser will open with a live preview that updates automatically on save.

```bash
quarto preview notebook.ipynb
```

--------------------------------

### Custom Preview Server Configuration

Source: https://quarto.org/docs/reference/projects/websites.llms

Sets up a custom preview server command, environment variables, and a ready signal for external publishing systems.

```yaml
project:
  type: website
  preview:
    serve:
      cmd: "hugo serve --port {port} --bind {host} --navigateToChanged"
      env:
        HUGO_RELATIVEURLS: "true"
      ready: "Web Server is available at"
```

--------------------------------

### Serve and Open Browser

Source: https://quarto.org/docs/cli/serve.llms

Serve a document and automatically open a web browser to preview it.

```bash
quarto serve --browser
```

--------------------------------

### Install quarto-mode in Emacs

Source: https://quarto.org/docs/computations/r.llms

Install the quarto-mode package for Emacs to enable enhanced editing of Quarto documents.

```emacs
M-x package-refresh-contents
M-x package-install
  quarto-mode
```

--------------------------------

### Create Quarto Project with Type and Name

Source: https://quarto.org/docs/projects/quarto-projects.llms

Specify the project type and name directly as arguments to the create project command.

```bash
quarto create project <type> <name>
```

--------------------------------

### List installed Quarto extensions

Source: https://quarto.org/docs/cli/list.llms

Use this command to see all extensions that are currently installed in your Quarto environment.

```bash
quarto list extensions
```

--------------------------------

### Publish Project (Prompt for Provider)

Source: https://quarto.org/docs/cli/publish.llms

Use this command to publish a project when the provider is not explicitly specified. The system will prompt you to choose a provider.

```bash
quarto publish
```

--------------------------------

### Preview Quarto Website Locally

Source: https://quarto.org/docs/publishing/hugging-face.llms

Run this command from the root of your repository to preview changes to your Quarto website before publishing. Ensure you are in the correct directory.

```bash
quarto preview src
```

--------------------------------

### Preview Quarto Document as PDF

Source: https://quarto.org/docs/computations/python.llms

Starts a live preview of a Quarto document as PDF. This command is used when PDF output is desired for the preview.

```bash
# preview as pdf
quarto preview document.qmd --to pdf
```

--------------------------------

### Reproducible Example Request Template

Source: https://quarto.org/docs/triaging/index.llms

Use this template to request a small, self-contained, reproducible example from users to help diagnose and fix problems. It explains how to share Quarto documents or Git repositories and includes examples for both R and Python.

```markdown
Could you share a **small self-contained "working" (reproducible)** example to work with, _i.e._, a complete Quarto document or a Git repository? The goal is to make it as easy as possible for us to recreate your problem so that we can fix it: please help us help you! Thanks.

---

You can share a **self-contained "working" (reproducible)** Quarto document using the following syntax, _i.e._, using more backticks than you have in your document (usually four ` ```` `).
See <https://quarto.org/bug-reports.html#small-is-beautiful-aim-for-a-single-document-with-10-lines>.

If you have multiple files (and if it is **absolutely required** to have multiple files), please share as a Git repository.

<table>
<tr><th>R</th><th>Python</th></tr>
<tr><td>

````md
````qmd
---
title: "Reproducible Quarto Document"
format: html
engine: knitr
---

This is a reproducible Quarto document.

{{< lipsum 1 >}}

```{r}
x <- c(1, 2, 3, 4, 5)
y <- c(1, 4, 9, 16, 25)

plot(x, y)
```

![An image]({{< placeholder 600 400 >}}){#fig-placeholder}

{{< lipsum 1 >}}

The end after @fig-placeholder.
````
````

</td><td>

````md
````qmd
---
title: "Reproducible Quarto Document"
format: html
engine: jupyter
---

This is a reproducible Quarto document.

{{< lipsum 1 >}}

```{python}
import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]
y = [1, 4, 9, 16, 25]

plt.plot(x, y)
plt.show()
```

![An image]({{< placeholder 600 400 >}}){#fig-placeholder}

{{< lipsum 1 >}}

The end after @fig-placeholder.
````
````

</td></tr>
</table>

Additionally and if not already given, please share the output of `quarto check` within a code block (*i.e.*, using three backticks ` ```txt `), see <https://quarto.org/bug-reports.html#check>.
```

--------------------------------

### Example Quarto Scss Theme File

Source: https://quarto.org/docs/output-formats/html-themes-more.llms

A basic Scss theme file demonstrating the structure with functions, defaults, and rules.

```css
/*-- scss:functions --*/
@function colorToRGB ($color) {
  @return "rgb(" + red($color) + ", " + green($color) + ", " + blue($color)+ ")";
}

/*-- scss:defaults --*/
$h2-font-size:          1.6rem !default;
$headings-font-weight:  500 !default;

/*-- scss:rules --*/
h1, h2, h3, h4, h5, h6 {
  text-shadow: -1px -1px 0 rgba(0, 0, 0, .3);
}
```

--------------------------------

### Install Tidyverse Package

Source: https://quarto.org/docs/manuscripts/authoring/rstudio.llms

Install the 'tidyverse' package, which is required for running the R code that generates the earthquake plot.

```r
install.packages("tidyverse")
```

--------------------------------

### Example Extension File Structure

Source: https://quarto.org/docs/extensions/distributing.llms

Illustrates the typical directory and file layout for a Quarto extension, including the essential _extensions directory.

```text
README.md
LICENSE
example.qmd
_extensions/
  my-filter/
    _extension.yml
    my-filter.lua
```

--------------------------------

### Install TinyTeX with System PATH Update

Source: https://quarto.org/docs/output-formats/pdf-engine.llms

Installs TinyTeX and updates the system PATH to make it accessible to other applications.

```bash
quarto install tinytex --update-path
```

--------------------------------

### Setup Code Execution in Quarto

Source: https://quarto.org/docs/interactive/shiny/execution.llms

Execute code in both rendering and serving contexts. Use 'include: false' to prevent code, warnings, and output from appearing in the rendered document.

```r
#| context: setup
#| include: false

# load libraries
library(dplyr)

# load data
dataset <- import_data("data.csv")
dataset <- sample_n(dataset, 1000)

```

--------------------------------

### Install TinyTeX for PDF Generation

Source: https://quarto.org/docs/get-started/authoring/neovim.llms

Command to install TinyTeX, a lightweight LaTeX distribution required for PDF output.

```bash
quarto install tinytex

```

--------------------------------

### Install Shiny and Shinywidgets Packages

Source: https://quarto.org/docs/dashboards/interactivity/shiny-python/running.llms

Install or upgrade the necessary Shiny and shinywidgets Python packages to their latest versions.

```bash
pip install --upgrade shiny shinywidgets

```

--------------------------------

### Add Extension (Basic Usage)

Source: https://quarto.org/docs/cli/add.llms

Installs an extension to the current folder or project. Replace `<extension:string>` with the actual extension identifier.

```bash
quarto add <extension:string>
```

--------------------------------

### Create Manuscript Project from Command Line

Source: https://quarto.org/docs/manuscripts/components.llms

Initiate a new manuscript project with template content using the 'quarto create project manuscript' command.

```bash
quarto create project manuscript
```

--------------------------------

### WebTeX Math Conversion Example

Source: https://quarto.org/docs/output-formats/gfm.llms

An example of inline LaTeX math in markdown that will be converted by WebTeX into an image URL.

```markdown
$x + 1$
```

--------------------------------

### Create Format Extensions for PDF, DOCX, and Revealjs

Source: https://quarto.org/docs/extensions/formats.llms

Demonstrates how to create format extensions derived from other base formats like PDF, DOCX, and Revealjs.

```bash
quarto create extension format:pdf
quarto create extension format:docx
quarto create extension format:revealjs
```

--------------------------------

### BibTeX Entry Example

Source: https://quarto.org/docs/get-started/authoring/neovim.llms

This is an example of a BibTeX entry for a journal article, used for citing sources in Quarto documents.

```bibtex
@article{knuth1984,
  title={Literate programming},
  author={Knuth, Donald E.},
  journal={The Computer Journal},
  volume={27},
  number={2},
  pages={97--111},
  year={1984},
  publisher={British Computer Society}
}
```

--------------------------------

### Basic Serve Command

Source: https://quarto.org/docs/cli/serve.llms

Serve an interactive Shiny document. The document will be rendered before serving by default.

```bash
quarto serve dashboard.qmd
```

--------------------------------

### Example Markdown with Custom Language

Source: https://quarto.org/docs/extensions/engine.llms

An example of a code block using a custom language defined by an engine extension.

```markdown
```{my-language}
x = 42
```
```

--------------------------------

### Quarto CLI: Use a template from Github

Source: https://quarto.org/docs/cli/use.llms

Example of how to specify a GitHub organization and repository to use as a Quarto template.

```bash
quarto use template <gh-org>/<gh-repo>
```

--------------------------------

### Quarto Document Code Block Example

Source: https://quarto.org/docs/authoring/notebook-embed.llms

Example of a Quarto code block with a label, which can be used as an identifier for embedding.

```r
#| label: fig-size-scatter
ggplot(penguins, aes(body_mass_g, flipper_length_mm)) +
  geom_point(aes(color = species)) +
  scale_color_manual(values = colors) +
  theme_minimal()
```

--------------------------------

### Publish Document (Prompt for Provider)

Source: https://quarto.org/docs/cli/publish.llms

Use this command to publish a specific document (e.g., a .qmd file) when the provider is not explicitly specified. The system will prompt you to choose a provider.

```bash
quarto publish document.qmd
```

--------------------------------

### Install Packages in Conda Environment

Source: https://quarto.org/docs/projects/virtual-environments.llms

Installs necessary packages like jupyter, pandas, and matplotlib into the active conda environment.

```bash
conda install jupyter
conda install pandas matplotlib 
```

--------------------------------

### Install R Packages

Source: https://quarto.org/docs/get-started/hello/rstudio.llms

Installs the 'tidyverse' and 'palmerpenguins' R packages, which are often required for data analysis and visualization in R.

```r
install.packages("tidyverse")
install.packages("palmerpenguins")
```

--------------------------------

### Render, Add, Commit, and Push Site

Source: https://quarto.org/docs/publishing/github-pages.llms

Render your Quarto site, stage the 'docs' directory, commit the changes, and push to your GitHub repository.

```bash
quarto render
git add docs
git commit -m "Publish site to docs/"
git push
```

--------------------------------

### Install Jupyter Cache Package

Source: https://quarto.org/docs/computations/julia.llms

Install the `jupyter-cache` package to enable caching of cell outputs for notebooks rendered by Quarto.

```bash
pip install jupyter-cache
```

--------------------------------

### Markdown Example with Keyboard Shortcuts

Source: https://quarto.org/docs/authoring/markdown-basics.llms

Demonstrates embedding keyboard shortcuts using the kbd shortcode within Markdown text.

```markdown
To print, press {{< kbd Shift-Ctrl-P >}}. To open an existing new project, press {{< kbd mac=Shift-Command-O win=Shift-Control-O linux=Shift-Ctrl-L >}}.
```

--------------------------------

### Preview Blog Project

Source: https://quarto.org/docs/websites/website-blog.llms

Renders the blog project and opens a live preview in your web browser. The preview automatically updates as you save changes to your project files.

```bash
quarto preview myblog
```

--------------------------------

### Embed YouTube Video with Start Time

Source: https://quarto.org/docs/authoring/videos.llms

Specify a start time in seconds for YouTube videos. This controls where playback begins.

```quarto
{{< video https://youtu.be/wo9vZccmqwc start="10" >}}
```

--------------------------------

### Date Format String Examples

Source: https://quarto.org/docs/reference/dates.llms

Illustrates various date format strings and their corresponding outputs for custom date formatting in Quarto.

```text
Format | Output
-- | --
`MMM D, YYYY` | Mar 7, 2005
`DD/MM/YYYY` | 07/03/2005
`[YYYYescape] YYYY-MM-DDTHH:mm:ssZ[Z]` | YYYYescape 2005-03-07T00:00:00-05:00Z
`YYYY-MM-DDTHH:mm:ssZ` | 2005-03-07T00:00:00-05:00
`dddd MMM D, YYYY` | Monday Mar 7, 2005
```

--------------------------------

### Preview Quarto Document as HTML

Source: https://quarto.org/docs/computations/python.llms

Starts a live preview of a Quarto document as HTML. This is useful for quickly iterating on document changes.

```bash
# preview as html
quarto preview document.qmd
```

--------------------------------

### Install Jupyter Package

Source: https://quarto.org/docs/computations/julia.llms

Install the necessary Jupyter package in a Python 3 environment to enable Quarto to execute Jupyter kernels.

```bash
pip install jupyter
```

--------------------------------

### Serve with Logging

Source: https://quarto.org/docs/cli/serve.llms

Serve a document and log output to a specified file with a given log level and format.

```bash
quarto serve --log /var/log/quarto.log --log-level debug --log-format json-stream
```

--------------------------------

### Install IJulia Package

Source: https://quarto.org/docs/computations/julia.llms

Install the IJulia package from within the Julia REPL. This is a prerequisite for using Julia execution kernels with Jupyter.

```julia
using Pkg
Pkg.add("IJulia")
using IJulia
notebook()
```

--------------------------------

### Render with Command Line Parameters

Source: https://quarto.org/docs/computations/parameters.llms

Pass parameters to `quarto render` using the `-P` flag for both .ipynb and .qmd files.

```bash
quarto render document.ipynb -P alpha:0.2 -P ratio:0.3
```