Code execution for other languages (i.e. other than R, Python, and Julia)

[cmhh]

Since Python and Julia code can be executed via Jupyter kernels, I got curious and tried some others. To my suprise (I don't think I saw this documented anywhere), the following worked just fine for me:

---
...
jupyter: scala213
---

```{scala}
println("Hello, World!")
``` 

Is this something that is expected / intended? If I make use of this functionality, do we expect it to break at some point?

[jjallaire]

Yes, this is indeed expected and intended! We don't play up the other kernels because we haven't tested them but they should definitely all work.

[cmhh]

I mean, this is amazing. And it means I can mix languages in the same document. I'm going to try IHaskell as soon as I finish work!

[jjallaire]

Note that you can only have a single kernel per document. There are some ways around this e.g. Python cell magics but in general the design of Jupyter is one language per notebook.

[pbowyer]

I really like this idea @mgiugliano. When documenting how to do something in multiple languages I always think of https://docusaurus.io/docs/markdown-features/code-blocks#multi-language-support-code-blocks as the ideal kind of output for the web version - especially how it remembers your language choice and changes all blocks. Taking this presentation and extending it to executing the code and showing the output would be phenomenal. Though if all are meant to produce the same output you might want to pick a single output to include in the document and suppress the others, to save space/files/weight.

[cmhh]

@pbowyer I love the idea of having the different language examples in tabs. Give that julyter is the underlying engine, I suspect the feedback is going to be that it's technically challenging to mix languages in a single document. But it would be an amazing feature for sure.

[mgiugliano]

@pbowyer @cmhh I must have initially misunderstood Quarto: I thought each "cell" was a stand-alone notebook. Instead I realise that a Quarto document is basically a Jupyter notebook, so each cell share the workspace/memory/variables/functions etc.

I see the advantages, but I wonder whether one could enforce the "one-cell --> one notebook" limit case.

[eitsupi]

It would be truly fantastic to have multiple kernels per document: each cell is already bound to a single language.

Any possible workaround? I would love to use Python3 and Julia for writing a book or a paper, demonstrating computer simulations (involving heavy use of Python libraries) and otherwise showing Julia code for more hands-on numerical solution of equations.

As @cderv points out, just use the knitr engine instead of the jupyter engine.

In addition to R and knitr, you will need the reticulate package to run Python and the JuliaCall package to run Julia.

---
title: multi-lang sample
engine: knitr
---

:::{.panel-tabset}

## python

```{python}
x = "this is python code."
```

## julia

```{julia}
x = "this is julia code."
```

:::

:::{.panel-tabset}

## python

```{python}
print(x)
```

## julia

```{julia}
println(x)
```

:::

[mgiugliano]

Thank you @eitsupi ! I will study that.

It is already sad (for me) that Quarto comes bundled with its own Pandoc. If I have to install R to use knitr it, to use Quarto, then it might be a no-go for me. I might be too sensitive to minimalism though :-)