# Applications

## What are applications?

Applications in Nuvolos are software tools used to interact with data or code, such as:

* JupyterLab
* RStudio
* VS Code
* MATLAB
* Stata

Nuvolos provides a curated selection of applications in commonly used configurations, so you can get started quickly. Custom configurations can also be set up. Any application that runs on Linux is supported, whether it is GUI-based, a web server, or a command-line tool.

For details on managing application settings, persistent storage locations, and shared mode, see [Configuring applications](/features/applications/configuring-applications.md).

Applications are always run within a particular Nuvolos [instance](/features/nuvolos-basic-concepts/organisational-hierarchy.md#instances). A given application can be run once, repeatedly, continuously, or multiple times in parallel. Applications are always containerised, meaning the tool and all of its dependencies are treated as a single whole (see below).

To run an application on Nuvolos, you must have at least the [editor role](/administration/roles.md) in an instance.

#### Use Case: Streamlining Research and Coursework

{% tabs %}
{% tab title="Problem" %}
**Managing multiple software environments**\
\
Researchers and students often struggle with installing, configuring, and maintaining different software environments - such as JupyterLab, RStudio, or MATLAB - across local machines. This leads to version conflicts, compatibility issues, and the "it works on my machine" problem, consuming time that should be spent on actual work.
{% endtab %}

{% tab title="Solution" %}
**Integrated, containerized applications**\
\
Nuvolos provides a curated selection of containerized applications ready to use out-of-the-box. Users can instantly launch isolated tools directly within their cloud instances, with no local installation required. Because each application environment is fully containerized, different custom configurations can run concurrently without any cross-interference.
{% endtab %}

{% tab title="Result" %}
**Increased productivity**\
\
By eliminating environment setup, maintenance, and software distribution overhead, teams and classes can get straight to work. Seamless access and guaranteed reproducibility mean users spend less time on tooling and more time on their data, code, and collaboration.
{% endtab %}
{% endtabs %}

## Application containerisation

Every application in Nuvolos is *containerized*. Containerization bundles an application together with all of its configuration files, libraries, and dependencies. As a result, applications are isolated and independent of each other. This has several benefits:

* Different configurations of the same application can run concurrently.
* The functioning of the container is guaranteed, which is useful for scientific reproducibility.
* The application can be [distributed](/features/nuvolos-basic-concepts/distribution.md) to other instances.

Initially, each application contains the default configuration, libraries, and dependencies. Once you start an application, you can install new packages and libraries. Because applications are containerized, changing the configuration of one application does not affect any others. This includes concurrent usages of the same application: if you run JupyterLab and install a package, a second JupyterLab environment started from its default state will not share that package.

## Application distribution

Because applications are containerised, they can be [distributed](/features/nuvolos-basic-concepts/distribution.md) wholesale to other instances. The application, with all of its configuration and dependencies, is sent to the current state of another instance and can then be run there. For education purposes, you can use mass distribution to deliver not just teaching material, but also the working environment to all students in a course.

## Application scaling

Application [resources](/features/applications/application-resources.md) can be changed at any time. Each application runs in a *size* that determines its CPU, RAM, and optionally GPU allocation. Sizes included in your Nuvolos subscription consume Compute Units (CUs), while high-end configurations — such as large-memory or GPU nodes — are paid for in credits. You can scale an application up for a demanding computation and back down afterwards, so you only use (and pay for) the resources you need, when you need them.

## Exporting applications

Nuvolos applications can be [exported](/features/applications/exporting-applications.md) as public Docker images hosted on DockerHub. This lets you reuse your Nuvolos applications outside the platform, for example:

* Students experimenting with course code on their own machines.
* Authors sharing applications for peer review or long-term archival.
* Researchers running applications across multiple infrastructures (e.g. HPC clusters).
* Researchers submitting containerized workloads to HPC systems that support [Apptainer](https://apptainer.org/) (formerly Singularity).

Exported images include your application configuration, installed packages, environment variables, and optionally your workspace files. For more details, see [Exporting applications](/features/applications/exporting-applications.md).

## Applications in snapshots

Applications can be versioned using the [snapshot process](/features/snapshots.md) built into Nuvolos. Thanks to containerisation, this is a single operation regardless of the application's configuration or dependencies. You don't need to worry about correctly copying every library, dependency, and configuration file — the snapshot captures everything.

## FAQ

<details>

<summary>What applications are supported by Nuvolos?</summary>

Nuvolos provides a curated selection of commonly used applications out-of-the-box, including JupyterLab, RStudio, VS Code, MATLAB, and Stata. Beyond these, Nuvolos supports any application that runs on Linux - whether it is GUI-based, a web server, or a command-line tool.

</details>

<details>

<summary>How does Nuvolos handle application containerization?</summary>

Every application in Nuvolos is containerized. This means the application is bundled together with all of its specific configuration files, libraries, and dependencies into a single, isolated unit. Because they are containerized, applications run independently of one another - even if you start multiple instances of the same application, changing the environment of one will not affect the others.

</details>

<details>

<summary>Can users customize application configurations?</summary>

Yes. While Nuvolos provides default configurations to help you get started quickly, users can set up custom configurations. Once an application is started, you can easily install new packages and libraries. Because of containerization, different custom configurations of the same application can even run concurrently.

</details>

<details>

<summary>What are the benefits of using containerized applications?</summary>

Containerization in Nuvolos offers several key benefits:

* Isolation & concurrency - different configurations of the exact same application can run at the same time without interfering with each other.
* Scientific reproducibility - the exact functioning of the container and its dependencies is guaranteed, making research highly reproducible.
* Seamless distribution - applications, along with their full environments and dependencies, can be distributed wholesale to other instances (e.g., providing a complete working environment to all students in a course).
* Easy exportation - applications can be exported as Docker images to be used outside the platform, such as on local machines or HPC clusters.
* Simplified versioning - entire application environments can be easily captured and saved using Nuvolos's snapshot process.

</details>

<details>

<summary>How do users run applications on Nuvolos?</summary>

Applications are always run within a specific Nuvolos instance. They can be executed once, repeatedly, continuously, or multiple times in parallel. To run an application, a user must be assigned at least the "editor" role within that particular instance. Users can also dynamically scale the resources (CPU, RAM, GPU) allocated to the application when they run it.

</details>


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.nuvolos.com/features/nuvolos-basic-concepts/applications.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.