Rendering R scripts using Jupyter kernels

[tzakharko]

Description

I am attempting to use quarto render to render an R script using the Jypyter engine as described in the documentation. Some things don't work as expected, and before I open a bug report I'd like to make sure I am not setting things up wrong.

1. The Jupyter kernel for R is not detected automatically — when I run my quarto render script.R, the system attempts to launch the Python kernel and does not evaluate any code. I need to manually specify jupyter: ark or jupyter: ir in the metadata for it to work.

2. Some cell attributes don't seem to be doing anything. For example #| output: asis wraps the output in <pre> instead of interpreting it as markdown. Similarly, cells that produce figures don't seem to work properly. E.g. fig-width and friends don't work, and the code still shows up despite setting echo: false. Confusingly, quarto produces different HTML output when rendering a script and a notebook with otherwise identical contents.

Here is the sample script I was attempting to render:

# %% [markdown]
# ---
# title: A test
# author: A reporter
# jupyter: ark
# ---

# %%
#| echo: true
#| output: false
library(tidyverse)

# %%
#| echo: false
#| output: asis
knitr::kable(head(iris))

# %% [markdown]
# Some markdown

# %%
#| echo: false
#| fig-width: 4
#| fig-cap: A plot
ggplot(iris) + geom_point(aes(x = Sepal.Length, y = Sepal.Width, color = Species))

And here is a fragment of rendered output:

[mcanouil]

Did you try using a plain Quarto document instead?

Side note: library(tidyverse) is unnecessary in addition to not being small thing to install. Prefer making the two calls for ggplot2 and knitr.

[mcanouil]

Another thought.
Quarto assumes knitr as engine for R code.
Did you try setting the engine first instead of the kernel? engine: jupyter, this should trigger Quarto's kernel detection and it should use a compatible kernel if there is one.

[cscheid]

Thanks for the message -

You're hitting a number of relatively obscure code paths here (rendering .R scripts, using jupyter to render R, and using non-ipynb files to render jupyter notebooks). We should make sure this works, but I'm not too surprised something is going wrong.

I will defer a full answer to @jmcphers, but I think ark isn't quite ready for this sort of usage, so we should probably consider ir instead. Would you mind opening an issue, filling out the information we ask, and adding some additional information? specifically, the output of jupyter kernelspec list would be useful.

Edit: Jonathan assures me ark should work in this setting, so ignore that part of the message!

[tzakharko]

@cscheid Thank you for the reply! From your answer I gather that rendering R scripts using Jupyter is still an experimental feature. It would be a great tool for those of us who develop scripts incrementally and where RMarkdown is not an appropriate format, so it is exciting to see work being done in this direction.

Regarding ark and ir — I did more testing and it indeed seems like there is a difference between the kernels! With ir, the figure cell is rendered correctly, with cell options being honored. With ark, most cell options appear to be ignored. At the same time, output: asis d does not work with either.

I will open an issue shortly!

[mcanouil]

I've just tried a plain Quarto document. Quarto does detect the kernel (quarto check) but don't use it, so it has to be set explicitly set in the document.

---
title: "Reproducible Quarto Document"
format: html
engine: jupyter
jupyter: ark
---

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

plot(x, y)
```

```{r}
#| output: asis
cat("This is a **markdown** document.")
```

Quarto 1.7.21
[✓] Checking Python 3 installation....OK
      Version: 3.13.2
      Path: /usr/local/python/current/bin/python3
      Jupyter: 5.7.2
      Kernels: julia-1.11, ark, python3

[✓] Checking Jupyter engine render....OK

output: asis seems to work properly.

Same behaviour using an R script.

# %% [markdown]
# ---
# title: "Reproducible Quarto Document"
# format: html
# engine: jupyter
# jupyter: ark
# keep-ipynb: true
# ---

# %%
x <- c(1, 2, 3, 4, 5)
y <- c(1, 4, 9, 16, 25)

plot(x, y)

# %%
#| output: asis
cat("This is a **markdown** document.")

Note that I can reproduce the markdown table output from knitr::kable() not being rendered as markdown.
To me the issue, is not the output: asis, but the information in the Jupyter Notebook.

I've simplified the code to avoid the base64 encoded image.

# %% [markdown]
# ---
# title: A test
# engine: jupyter
# jupyter: ark
# keep-ipynb: true
# ---

# %%
#| echo: false
#| output: false
library(knitr)

# %%
#| echo: false
#| output: asis
knitr::kable(head(iris))

# %%
#| echo: false
#| output: asis
cat("Some **markdown** text _formatted_ with `rmarkdown` and **knitr**.")

The notebook:

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "48300306",
   "metadata": {},
   "source": [
    "---\n",
    "title: A test\n",
    "engine: jupyter\n",
    "jupyter: ark\n",
    "keep-ipynb: true\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "207f446e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- Project '/workspaces/quarto-codespaces' loaded. [renv 1.1.4]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "- The project is out-of-sync -- use `renv::status()` for details.\n"
     ]
    }
   ],
   "source": [
    "#| echo: false\n",
    "#| output: false\n",
    "library(knitr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "26669104",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\n",
       "\n",
       "| Sepal.Length| Sepal.Width| Petal.Length| Petal.Width|Species |\n",
       "|------------:|-----------:|------------:|-----------:|:-------|\n",
       "|          5.1|         3.5|          1.4|         0.2|setosa  |\n",
       "|          4.9|         3.0|          1.4|         0.2|setosa  |\n",
       "|          4.7|         3.2|          1.3|         0.2|setosa  |\n",
       "|          4.6|         3.1|          1.5|         0.2|setosa  |\n",
       "|          5.0|         3.6|          1.4|         0.2|setosa  |\n",
       "|          5.4|         3.9|          1.7|         0.4|setosa  |"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#| echo: false\n",
    "#| output: asis\n",
    "knitr::kable(head(iris))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9b0cc8e0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Some **markdown** text _formatted_ with `rmarkdown` and **knitr**."
     ]
    }
   ],
   "source": [
    "#| echo: false\n",
    "#| output: asis\n",
    "cat(\"Some **markdown** text _formatted_ with `rmarkdown` and **knitr**.\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Ark R Kernel",
   "language": "R",
   "name": "ark",
   "path": "/home/vscode/.local/share/jupyter/kernels/ark"
  },
  "language_info": {
   "file_extension": ".R",
   "mimetype": "text/r",
   "name": "R",
   "positron": {
    "continuation_prompt": "+ ",
    "input_prompt": "> "
   },
   "version": "R version 4.4.3 (2025-02-28)"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}

Environnement:

• ark-0.1.177-linux-x64.zip
• Codespace https://github.com/mcanouil/quarto-codespaces

[mcanouil]

Confusingly, quarto produces different HTML output when rendering a script and a notebook with otherwise identical contents.

I also cannot reproduce that behaviour.

[mcanouil]

For short, the only issues I see are:

• the auto-detection of the compatible kernel (this mechanism is documented) does not work
• some code cells output "text/plain" that at kept as code even though output: asis

[tzakharko]

Thanks @mcanouil, this all makes sense!

and the code still shows up despite setting echo: false.

@tzakharko Could you clarify because none of my tests show that nor your screenshot.

I must have gotten confused, apologies!

Reminder that fig-width etc. cannot be set at the code-cell level with Jupyter. This has nothing to do with using an R script, R code, or R kernels.

Thank you, I was not aware of this.

Confusingly, quarto produces different HTML output when rendering a script and a notebook with otherwise identical contents.

I also cannot reproduce that behaviour.

There are some subtle differences in which HTML attributes are set, however, it makes perfect sense given your explanations of the differences between Jupyter kernels and knitr. Also, with the Jupyter render I get this hidden div in my html

<div class="cell-output cell-output-stderr">
<pre><code>  2025-04-09T19:53:11.140271Z  WARN  Could not handle shell message: The comm target name 'quarto_kernel_setup' is not recognized or not supported.
    at crates/amalthea/src/socket/shell.rs:137
</code></pre>
</div>

For short, the only issues I see are:

• the auto-detection of the compatible kernel (this mechanism is documented) does not work
• some code cells output "text/plain" that at kept as code even though output: asis

Agree. I will update my open issue accordingly.

[mcanouil]

@tzakharko Let's discuss on the opened issue now.

• Rendering R scripts using Jupyter ir kernels #12507