The IDEs¶
This page describes the IDEs a workspace offers and how sessions, home directories and packages
work in them. After logging in at https://velonde.<your domain>, you see one tile per IDE:
RStudio Server, VS Code and JupyterLab. Each tile starts a session, which is a container of its
own with the workspace's R and Python stacks, the coding agent, and your home directory mounted.
Starting a session¶
Before the session starts, the tile asks for a size: Small (2 CPU, 4 GiB), Standard (4 CPU, 8 GiB) or Large (8 CPU, 16 GiB). The size sets the session's limits. The default is Standard, so one click on the tile is enough. Starting takes a few seconds while the container comes up. A user's first session also creates their home volume.
You can run several sessions of one IDE at the same time, three by default, each with its own
size. The instance menu in the bar at the top of a session lists them, and lets you start
another one under a name or stop one. Sessions keep running when you close the browser tab.
The workspace can be configured to stop a session after a period with no open tab
(ide_idle_timeout). Files on the home survive this,
but the R process and unsaved editor state are lost.
The home directory¶
Every user has one persistent home volume. The workspace creates it at the user's first session, with the size the workspace configures, 20 GiB by default. All three IDEs mount the same volume, so a project you started in RStudio is also there in VS Code, and a terminal in JupyterLab sees the same files. No other user can see your home.
The home appears at a different path in each IDE, because each image runs as its own Linux user:
| IDE | Home path | Opens in |
|---|---|---|
| RStudio | /home/rstudio |
the home itself |
| VS Code | /home/coder |
~/workspace |
| JupyterLab | /home/jupyter |
~/workspace |
This is why the folder VS Code opens is called coder for everyone. It also means that an
absolute path one IDE stores, in a recent-projects list for instance, is wrong in the others.
The files themselves are the same.
A project you create in RStudio sits directly in the home, at ~/sales for a project named
sales. That is outside the ~/workspace folder that VS Code and JupyterLab open. In VS Code,
open it with File > Open Folder. JupyterLab's file browser does not reach it, but its terminal
does. To have a project in the file browsers of all three IDEs, create it under ~/workspace.
Everything outside the home belongs to the image and is reset when a session starts. A
session has no root access, so you cannot install system packages with apt. To add a system
library to the images, see System libraries. Only tooling you install
locally into a project on the home persists.
Shared volumes¶
Your workspace administrator can make team shares available, such as a project folder on the
company's file server. A share you have access to appears in every session at
/srv/volumes/<name>, and as a folder volumes where the IDE's file browser opens: in your
home in RStudio, and in ~/workspace in VS Code and JupyterLab. The folder is a link, so the
files stay on the share and do not count towards your home volume.
You can write to a share unless the administrator made it read-only, or let only some people
write to it. A share can also be one folder of a file server, or your own folder there, such
as your personal drive. Everyone who has access writes as the same Linux user, so the share
does not record who changed a file. To use a
share in a deployed app, name it under volumes in the app's
velonde.yaml. The app finds it at the same path.
Packages¶
R. Inside a project, renv::install() and install.packages() install into the project's
library on the home, and renv::snapshot() records the package for the deploy. Outside a
project, the same calls install into a personal library on the home. That library persists,
but renv does not record it. The workspace's stack, the packages every image ships, is available
everywhere. A project sees the stack as an external library, and renv::snapshot() records a
stack package with its source, so a deploy restores it. RStudio and VS Code have the same R,
the same stack and the same personal library, so a project behaves the same in both.
Python. The image's shared environment is read-only. A project gets its own .venv on the
home through uv sync. To use that environment in a JupyterLab notebook, select a kernel from
it. In RStudio, R uses the .venv of the project you are in, and the shared environment
where there is none.
System libraries¶
Most R packages install as binaries from Posit Package Manager and load at once, because the
images carry the system libraries the common ones need. A package whose library is missing
fails with an error such as libgsl.so.27: cannot open shared object file, and a package that
is built from source, from GitHub for instance, can fail in its configure step.
A workspace admin adds the missing library with one command in any session:
--for takes the R package and looks up the Ubuntu packages it needs. You can also name
Ubuntu packages directly. The workspace rebuilds the IDE images with them in a
few minutes, and every session started after that has the library. Restart your session to
get it. velonde ide-packages list shows what the workspace adds and the state of each image. If you
are not an admin, the same command tells you which packages are missing and what to ask an
admin to run. Deployed apps are not affected: a deploy installs the system libraries of the
app's own packages, whatever the IDE images have.
Libraries that every workspace of your company needs, such as an ODBC driver, belong in the
overlay's apt-packages.txt instead (see The overlay).
RStudio¶
The RStudio image runs RStudio Server from rocker, with the velonde package, Posit Assistant, and
Claude Code in the terminal. File > New Project > New Directory > Velonde project creates a project
from one of the workspace's templates. A suspended session resumes where it left off, including an
open renv project. Run App and Run API open a Shiny app or a Plumber API in a new browser tab.
The menu next to the Run App button changes that for you.
The image also has Python, uv and the workspace's Python stack, for projects that use both
languages. RStudio runs a .py file line by line in a Python console and shows Python objects
in the Environment pane. R and Python share one session through the reticulate package: py$x in R is the Python object x, and r.x in Python is the R object.
A Quarto or R Markdown document can mix R and Python chunks in the same way. To add a Python
package, run uv add in the project's directory in the Terminal and restart R. RStudio's
Python support is made for R users who need some Python. For work that is mostly Python,
VS Code and JupyterLab are the better fit. Addins do not run while the console is in Python,
so type exit there before you use one.
The Addins menu has two entries of the velonde package. "Deploy to the workspace" saves the open files
and deploys the project as a background job. The build output scrolls in the Background Jobs
pane and the console stays free. The addin deploys the directory with the velonde.yaml nearest to
the file you are editing, or the open project. "Velonde: deployed apps" opens a page in the Viewer
pane that lists what you deployed and what others deployed, with the logs, the runs of a
pipeline, the history of builds and the rollback. Anything else you view in the Viewer replaces
the page, and the addin brings it back. Both addins are also in the command palette, and you
can give them a keyboard shortcut under Tools > Modify Keyboard Shortcuts. From the console,
they are velonde::deploy_job() and velonde::page().
VS Code¶
The VS Code image runs VS Code in the browser (code-server) with R, Python and Claude Code. It
opens ~/workspace, and keeps recent workspaces and settings on the home. Extensions you install
persist on the home as well. code-server ships GitHub Copilot Chat as a built-in extension. We
remove it from the image, and the default settings of a new user turn VS Code's built-in chat
off (chat.disableAIFeatures).
The image has a Velonde extension. Its icon in the activity bar opens a list of what you deployed,
grouped into apps, documents, APIs, MCP servers, pipelines and packages. What others deployed
on the workspace is listed below your own. Each row has a button that opens the app in the browser
and one that shows its logs, and its context menu has the history of builds and the rollback.
The Deploy button in the status bar deploys the project of the file you are editing, as
velonde deploy does in a terminal, and prints the build output into the Output panel. When no
file is open and the folder holds several projects, it asks which one to deploy. The command
palette has the same commands under "Velonde", and "Velonde: New Project..." creates a project from
one of the workspace's templates.
R works in VS Code through the R extension (vscode-R). Ctrl+Enter in an R file sends the line or the selection to R. The first time in a window, the extension asks where the code should run:
- Create R terminal runs R in the Terminal pane. Plots open in a tab of their own, and
View()opens a data frame in a tab. - New R Interactive window starts an R session of its own and opens a window for it beside the editor. Each piece of code you run appears there with its result below it. Plots and data frames are shown inline, and a data frame can be paged, sorted and filtered. The session keeps running when you reload the page or close the tab, and its window shows the earlier results when you come back. The "Interactive Sessions" list under the R icon shows these sessions, and you stop one there when you no longer need it.
In both cases the R icon in the activity bar lists the objects of the session, and the editor completes and checks R code as you type.
Interactive windows are an experimental feature of the R extension, and we ship them as they
are. A session uses about 650 MB of memory for as long as it runs, so stop the ones you have
finished with. It ends when your VS Code session ends, and its results are not kept after
that. Claude Code can inspect the R session of an R terminal, but not that of an Interactive
window.
Alt+- inserts <- and Ctrl+Shift+M inserts |>, as in RStudio. The R is the
one of the RStudio image, with the same stack, and velonde new creates R projects here as well.
In a Quarto document with R chunks, "Run Cell" sends R chunks to the R terminal and Python
chunks to the same R session through the reticulate package. The two languages then share
their objects: r.x in a Python chunk is the R object x, and py$y in an R chunk is the
Python object y. A document with only Python chunks runs in Jupyter's interactive window.
When you open a session from another browser, VS Code shows the R terminal again, but the R extension may report it as not attached. The objects list and the plot tab then stay empty until you start a new R terminal ("R: Create R terminal" in the command palette).
JupyterLab¶
The JupyterLab image has the workspace's Python stack and Claude Code in the terminal. The file
browser's root is ~/workspace.
In every IDE, velonde new <name> --template <template> in a terminal creates a
Python project from one of the workspace's templates (see New projects).
VS Code and JupyterLab have Quarto, the version the deploy renders with, so a Quarto report with Python
renders in the session before you deploy it.
What the agents know¶
Claude Code and Posit Assistant describes what the workspace gives the coding agents in every IDE and how you add your own instructions.