inspect-ai 0.3.57__py3-none-any.whl → 0.3.59__py3-none-any.whl

inspect_ai/tool/_tool_with.py

@@ -1,4 +1,4 @@
-from copy import copy
+from copy import deepcopy
 
 from inspect_ai._util.registry import (
     registry_info,
@@ -6,8 +6,9 @@ from inspect_ai._util.registry import (
     set_registry_info,
     set_registry_params,
 )
+from inspect_ai.tool._tool_call import ToolCallModelInput, ToolCallViewer
 
-from ._tool import Tool
+from ._tool import TOOL_MODEL_INPUT, TOOL_PARALLEL, TOOL_VIEWER, Tool
 from ._tool_description import ToolDescription, set_tool_description
 from ._tool_info import parse_tool_info
 
@@ -17,6 +18,9 @@ def tool_with(
     name: str | None = None,
     description: str | None = None,
     parameters: dict[str, str] | None = None,
+    parallel: bool | None = None,
+    viewer: ToolCallViewer | None = None,
+    model_input: ToolCallModelInput | None = None,
 ) -> Tool:
     """Tool with modifications to name and descriptions.
 
@@ -25,6 +29,11 @@ def tool_with(
        name (str | None): Tool name (optional).
        description (str | None): Tool description (optional).
        parameters (dict[str,str] | None): Parameter descriptions (optional)
+       parallel (bool | None): Does the tool support parallel execution
+          (defaults to True if not specified)
+       viewer (ToolCallViewer | None): Optional tool call viewer implementation.
+       model_input (ToolCallModelInput | None): Optional function that determines how
+           tool call results are played back as model input.
 
     Returns:
        A copy of the passed tool with the specified descriptive information.
@@ -46,8 +55,16 @@ def tool_with(
             ]
 
     # copy the tool and set the descriptions on the new copy
-    tool_copy = copy(tool)
-    set_registry_info(tool_copy, registry_info(tool))
+    tool_copy = deepcopy(tool)
+    info = registry_info(tool).model_copy()
+    if parallel is not None:
+        info.metadata[TOOL_PARALLEL] = parallel
+    elif viewer is not None:
+        info.metadata[TOOL_VIEWER] = viewer
+    elif model_input is not None:
+        info.metadata[TOOL_MODEL_INPUT] = model_input
+
+    set_registry_info(tool_copy, info)
     set_registry_params(tool_copy, registry_params(tool))
     set_tool_description(
         tool_copy,

inspect_ai/tool/beta/__init__.py

@@ -0,0 +1,5 @@
+from ._computer import computer
+
+__all__ = [
+    "computer",
+]

inspect_ai/tool/beta/_computer/__init__.py

@@ -0,0 +1,3 @@
+from ._computer import computer
+
+__all__ = ["computer"]

inspect_ai/tool/beta/_computer/_common.py

@@ -0,0 +1,133 @@
+import json
+from textwrap import dedent
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from inspect_ai._util.content import ContentText
+from inspect_ai._util.error import PrerequisiteError
+from inspect_ai.model import ContentImage
+from inspect_ai.tool import ToolError, ToolResult
+from inspect_ai.util._sandbox.context import sandbox_with
+from inspect_ai.util._sandbox.environment import SandboxEnvironment
+
+Action = Literal[
+    "key",
+    "type",
+    "mouse_move",
+    "left_click",
+    "left_click_drag",
+    "right_click",
+    "middle_click",
+    "double_click",
+    "screenshot",
+    "cursor_position",
+]
+
+
+class ToolExecResult(BaseModel):
+    output: str | None = Field(default=None)
+    error: str | None = Field(default=None)
+    base64_image: str | None = Field(default=None)
+
+
+async def _send_cmd(cmdTail: list[str], timeout: int | None = None) -> ToolResult:
+    from inspect_ai.log._samples import sample_active
+
+    sample = sample_active()
+    assert sample
+    sample_id = sample.sample.id
+    assert sample_id
+
+    cmd = ["python3", "/opt/inspect/tool/computer_tool.py", "--action"] + cmdTail
+
+    raw_exec_result = await (await computer_sandbox()).exec(cmd, timeout=timeout)
+
+    if not raw_exec_result.success:
+        raise RuntimeError(
+            f"Failure executing command: ${cmd} {raw_exec_result.stderr}"
+        )
+
+    result = ToolExecResult(**json.loads(raw_exec_result.stdout))
+
+    if result.error:
+        raise ToolError(result.error)
+
+    image = (
+        ContentImage(image=f"data:image/png;base64,{result.base64_image}")
+        if result.base64_image
+        else None
+    )
+    text = result.output if result.output and len(result.output) > 0 else None
+
+    if text is not None and image is not None:
+        return [ContentText(text=text), image]
+
+    if text is not None:
+        return text
+
+    if image is not None:
+        return [image]
+
+    return "OK"
+
+
+async def cursor_position(timeout: int | None = None) -> ToolResult:
+    return await _send_cmd(["cursor_position"], timeout=timeout)
+
+
+async def screenshot(timeout: int | None = None) -> ToolResult:
+    return await _send_cmd(["screenshot"], timeout=timeout)
+
+
+async def mouse_move(x: int, y: int, timeout: int | None = None) -> ToolResult:
+    return await _send_cmd(
+        ["mouse_move", "--coordinate", f"{x}", f"{y}"], timeout=timeout
+    )
+
+
+async def left_click(timeout: int | None = None) -> ToolResult:
+    return await _send_cmd(["left_click"], timeout=timeout)
+
+
+async def left_click_drag(x: int, y: int, timeout: int | None = None) -> ToolResult:
+    return await _send_cmd(
+        ["left_click_drag", "--coordinate", f"{x}", f"{y}"], timeout=timeout
+    )
+
+
+async def right_click(timeout: int | None = None) -> ToolResult:
+    return await _send_cmd(["right_click"], timeout=timeout)
+
+
+async def middle_click(timeout: int | None = None) -> ToolResult:
+    return await _send_cmd(["middle_click"], timeout=timeout)
+
+
+async def double_click(timeout: int | None = None) -> ToolResult:
+    return await _send_cmd(["double_click"], timeout=timeout)
+
+
+async def press_key(key: str, timeout: int | None = None) -> ToolResult:
+    return await _send_cmd(["key", "--text", key], timeout=timeout)
+
+
+async def type(text: str, timeout: int | None = None) -> ToolResult:
+    return await _send_cmd(["type", "--text", text], timeout=timeout)
+
+
+async def computer_sandbox() -> SandboxEnvironment:
+    sb = await sandbox_with("/opt/inspect/tool/computer_tool.py")
+    if sb:
+        return sb
+    else:
+        raise PrerequisiteError(
+            dedent("""
+                The computer tool service was not found in any of the sandboxes for this sample. Please add the computer tool service to your configuration. For example, the following Docker compose file uses the aisiuk/inspect-computer-tool:latest-beta image as its default sandbox:
+
+                services:
+                  default:
+                    image: "aisiuk/inspect-computer-tool:latest-beta"
+                    init: true
+                """).strip()
+        )

inspect_ai/tool/beta/_computer/_computer.py

@@ -0,0 +1,155 @@
+from typing import Awaitable, Callable
+
+from inspect_ai._util.content import Content, ContentImage, ContentText
+from inspect_ai.tool import Tool, ToolResult, tool
+from inspect_ai.tool._tool import (
+    TOOL_INIT_MODEL_INPUT,
+    ToolParsingError,
+)
+from inspect_ai.tool._tool_call import ToolCallModelInput
+
+from . import _common as common
+from ._common import Action
+
+ActionFunction = Callable[[str], ToolResult | Awaitable[ToolResult]]
+
+
+@tool
+def computer(max_screenshots: int | None = 1, timeout: int | None = 180) -> Tool:
+    async def execute(
+        action: Action,
+        text: str | None = None,
+        coordinate: list[int] | None = None,
+    ) -> ToolResult:
+        """
+        Use this tool to interact with a computer.
+
+        Use a mouse and keyboard to interact with a computer's desktop GUI.
+
+        Keep in mind that icons require double clicks to open while other UI affordances like menu items and buttons require a single click.
+
+        Args:
+          action (Action): The action to perform.
+              - `key`: Press a key or key-combination on the keyboard.
+                  - Example: execute(action="key", text="ctrl+s")
+                  - Text can be any key name supported by xdotool's `key` such as:
+                      "Return", "Escape", "alt+Tab", "BackSpace", "Tab", "alt+Tab", "ctrl+s", "Up", "KP_0" (for the numpad 0 key),
+                      "Insert", "Delete", "Home", "End", "Prior", "Next", "Left", "Up", "Right", "Down",
+                      "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12",
+                      "Shift_L", "Shift_R", "Control_L", "Control_R", "Alt_L", "Alt_R", "Scroll_Lock", "Num_Lock", "Caps_Lock", "Pause",
+                      "KP_Multiply", "KP_Home", "KP_Up", "KP_Prior", "KP_Subtract", "KP_Left", "KP_Begin", "KP_Right", "KP_Add", "KP_End","KP_Down",
+                      "KP_Next", "KP_Insert", "KP_Delete", "KP_Enter", "KP_Divide", "KP_Equal", "KP_Decimal",
+              - `type`: Type a string of text on the keyboard. If the text contains spaces, enclose it in quotes.
+                  - Example: execute(action="type", text="The crux of the biscuit is the apostrophe!")
+              - `cursor_position`: Get the current (x, y) pixel coordinate of the cursor on the screen.
+              - `mouse_move`: Move the cursor to a specified (x, y) pixel coordinate on the screen.
+                  - Example: execute(action="mouse_move", coordinate=(100, 200))
+              - `left_click`: Click the left mouse button.
+              - `left_click_drag`: Click and drag the cursor to a specified (x, y) pixel coordinate on the screen.
+                  - Example: execute(action="left_click_drag", coordinate=(150, 250))
+              - `right_click`: Click the right mouse button.
+              - `middle_click`: Click the middle mouse button.
+              - `double_click`: Double-click the left mouse button.
+              - `screenshot`: Take a screenshot.
+          text (str | None): The text to type or the key to press. Required when action is "key" or "type".
+          coordinate (tuple[int, int] | None): The (x, y) pixel coordinate on the screen to which to move or drag. Required when action is "mouse_move" or "left_click_drag".
+
+        Returns:
+          The output of the command. Many commands will include a screenshot reflecting the result of the command in their output.
+        """
+        if action in ("mouse_move", "left_click_drag"):
+            if coordinate is None:
+                raise ToolParsingError(f"coordinate is required for {action}")
+            if text is not None:
+                raise ToolParsingError(f"text is not accepted for {action}")
+            if not isinstance(coordinate, list) or len(coordinate) != 2:
+                raise ToolParsingError(f"{coordinate} must be a tuple of length 2")
+            if not all(isinstance(i, int) and i >= 0 for i in coordinate):
+                raise ToolParsingError(
+                    f"{coordinate} must be a tuple of non-negative ints"
+                )
+
+            if action == "mouse_move":
+                return await common.mouse_move(
+                    coordinate[0], coordinate[1], timeout=timeout
+                )
+            elif action == "left_click_drag":
+                return await common.left_click_drag(
+                    coordinate[0], coordinate[1], timeout=timeout
+                )
+
+        if action in ("key", "type"):
+            if text is None:
+                raise ToolParsingError(f"text is required for {action}")
+            if coordinate is not None:
+                raise ToolParsingError(f"coordinate is not accepted for {action}")
+            if not isinstance(text, str):
+                raise ToolParsingError(output=f"{text} must be a string")
+
+            if action == "key":
+                return await common.press_key(text, timeout=timeout)
+            elif action == "type":
+                return await common.type(text, timeout=timeout)
+
+        if action in (
+            "left_click",
+            "right_click",
+            "double_click",
+            "middle_click",
+            "screenshot",
+            "cursor_position",
+        ):
+            if text is not None:
+                raise ToolParsingError(f"text is not accepted for {action}")
+            if coordinate is not None:
+                raise ToolParsingError(f"coordinate is not accepted for {action}")
+
+            if action == "screenshot":
+                return await common.screenshot(timeout=timeout)
+            elif action == "cursor_position":
+                return await common.cursor_position(timeout=timeout)
+            elif action == "left_click":
+                return await common.left_click(timeout=timeout)
+            elif action == "right_click":
+                return await common.right_click(timeout=timeout)
+            elif action == "middle_click":
+                return await common.middle_click(timeout=timeout)
+            elif action == "double_click":
+                return await common.double_click(timeout=timeout)
+
+        raise ToolParsingError(f"Invalid action: {action}")
+
+    # if max_screenshots is specified then polk model input into where @tool can find it
+    if max_screenshots is not None:
+        setattr(execute, TOOL_INIT_MODEL_INPUT, _computer_model_input(max_screenshots))
+
+    return execute
+
+
+def _computer_model_input(max_screenshots: int) -> ToolCallModelInput:
+    def model_input(
+        message_index: int, message_total: int, content: str | list[Content]
+    ) -> str | list[Content]:
+        # nothing to do for scalars
+        if isinstance(content, str):
+            return content
+
+        # if we are inside max_screenshots then return as is
+        elif (message_total - message_index) <= max_screenshots:
+            return content
+
+        # otherwise convert images to text placeholdrs
+        else:
+            input_content: list[Content] = []
+            for c in content:
+                if isinstance(c, ContentImage):
+                    input_content.append(
+                        ContentText(
+                            text="Screenshot removed to reduce size of input. Please consult the latest screenshots for the most up to date state of the screen."
+                        )
+                    )
+                else:
+                    input_content.append(c)
+            return input_content
+
+    return model_input

inspect_ai/tool/beta/_computer/_computer_split.py

@@ -0,0 +1,198 @@
+"""
+This module provides the same functionality as the computer tool but via a list of per-action tools . e.g. computer_mouse_move(100, 100).
+
+The split version is not publicly exported, but is retained until we decide if it performs better than the monolithic computer tool.
+"""
+
+from typing import Awaitable, Callable
+
+from inspect_ai.tool import Tool, ToolResult, tool
+
+from . import _common as common
+
+ActionFunction = Callable[[str], ToolResult | Awaitable[ToolResult]]
+
+
+def computer_split(timeout: int | None = None) -> list[Tool]:
+    """
+    Computer interaction tools.
+
+    Args:
+      timeout (int | None): Timeout (in seconds) for command.
+
+    Returns:
+       List of computer interaction tools.
+    """
+    return [
+        computer_cursor_position(),
+        computer_screenshot(),
+        computer_mouse_move(),
+        computer_left_click(),
+        computer_double_click(),
+        computer_left_click_drag(),
+        computer_right_click(),
+        computer_key(),
+        computer_type(),
+    ]
+
+
+@tool()
+def computer_cursor_position(timeout: int | None = None) -> Tool:
+    async def execute() -> ToolResult:
+        """
+        Get the current (x, y) pixel coordinate of the cursor on the screen.
+
+        Args:
+          None
+
+        Returns:
+          A `str` of the form "x y" where x and y are the current mouse coordinates.
+        """
+        return await common.cursor_position(timeout=timeout)
+
+    return execute
+
+
+@tool()
+def computer_screenshot(timeout: int | None = None) -> Tool:
+    async def execute() -> ToolResult:
+        """
+        Take a screenshot.
+
+        Args:
+          None
+
+        Returns:
+          A `list` with a single `ContentImage` of the screen.
+        """
+        return await common.screenshot(timeout=timeout)
+
+    return execute
+
+
+@tool()
+def computer_mouse_move(timeout: int | None = None) -> Tool:
+    async def execute(x: int, y: int) -> ToolResult:
+        """
+        Move the cursor to a specified (x, y) pixel coordinate on the screen.
+
+        Args:
+          x: X coordinate of the mouse destination.
+          y: Y coordinate of the mouse destination.
+
+        Returns:
+          A `list` with a single `ContentImage` of the screen.
+        """
+        return await common.mouse_move(x, y, timeout=timeout)
+
+    return execute
+
+
+@tool()
+def computer_left_click(timeout: int | None = None) -> Tool:
+    async def execute() -> ToolResult:
+        """
+        Click the left mouse button.
+
+        Args:
+          None
+
+        Returns:
+          A `list` with a single `ContentImage` of the screen.
+        """
+        return await common.left_click(timeout=timeout)
+
+    return execute
+
+
+@tool()
+def computer_double_click(timeout: int | None = None) -> Tool:
+    async def execute() -> ToolResult:
+        """
+        Double-click the left mouse button.
+
+        Args:
+          None
+
+        Returns:
+          A `list` with a single `ContentImage` of the screen.
+        """
+        return await common.double_click(timeout=timeout)
+
+    return execute
+
+
+@tool()
+def computer_left_click_drag(timeout: int | None = None) -> Tool:
+    async def execute(x: int, y: int) -> ToolResult:
+        """
+        Click and drag the cursor to a specified (x, y) pixel coordinate on the screen.
+
+        Args:
+          x: X coordinate of the mouse destination.
+          y: Y coordinate of the mouse destination.
+
+        Returns:
+          A `list` with a single `ContentImage` of the screen.
+        """
+        return await common.left_click_drag(x, y, timeout=timeout)
+
+    return execute
+
+
+@tool()
+def computer_right_click(timeout: int | None = None) -> Tool:
+    async def execute() -> ToolResult:
+        """
+        Click the right mouse button.
+
+        Args:
+          None
+
+        Returns:
+          A `list` with a single `ContentImage` of the screen.
+        """
+        return await common.right_click(timeout=timeout)
+
+    return execute
+
+
+# keysm list is from https://gist.github.com/rvaiya/be31f42049a4b5ad46666a8e120d9843
+@tool()
+def computer_key(timeout: int | None = None) -> Tool:
+    async def execute(key: str) -> ToolResult:
+        """
+        Press a key or key-combination on the keyboard.
+
+        Args:
+          key: The key or key-combination to press. Can be any key name supported by xdotool's `key` such as:
+            "Return", "Escape", "alt+Tab", "BackSpace", "Tab", "alt+Tab", "ctrl+s", "Up", "KP_0" (for the numpad 0 key),
+            "Insert", "Delete", "Home", "End", "Prior", "Next", "Left", "Up", "Right", "Down",
+            "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12",
+            "Shift_L", "Shift_R", "Control_L", "Control_R", "Alt_L", "Alt_R", "Scroll_Lock", "Num_Lock", "Caps_Lock", "Pause",
+            "KP_Multiply", "KP_Home", "KP_Up", "KP_Prior", "KP_Subtract", "KP_Left", "KP_Begin", "KP_Right", "KP_Add", "KP_End","KP_Down",
+            "KP_Next", "KP_Insert", "KP_Delete", "KP_Enter", "KP_Divide", "KP_Equal", "KP_Decimal"
+
+        Returns:
+          A `list` with a single `ContentImage` of the screen.
+        """
+        return await common.press_key(key, timeout=timeout)
+
+    return execute
+
+
+@tool()
+def computer_type(timeout: int | None = None) -> Tool:
+    async def execute(text: str) -> ToolResult:
+        """
+        Type a string of text on the keyboard.
+
+        Args:
+          text: The text to type. If the text contains spaces, enclose it in quotes.
+
+        Returns:
+          A `list` with a single `ContentImage` of the screen.
+        """
+        return await common.type(text, timeout=timeout)
+
+    return execute

inspect_ai/tool/beta/_computer/_resources/Dockerfile

@@ -0,0 +1,100 @@
+FROM docker.io/ubuntu:22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV DEBIAN_PRIORITY=high
+
+# Core/system layer
+RUN apt-get update && \
+    apt-get -y upgrade && \
+    apt-get -y install \
+      # A virtual framebuffer for running GUI applications without a physical display.
+      xvfb \    
+      # A lightweight desktop environment for UNIX-like operating systems.
+      xfce4 \
+      # The terminal emulator for the xfce4 desktop environment.
+      xfce4-terminal\
+      # A VNC server for sharing X11 desktops.
+      x11vnc \
+      # A web based VNC client
+      novnc \
+      # A WebSocket to TCP proxy/bridge for noVNC
+      websockify \
+      # The Python programming language interpreter.
+      python3 \
+      # The package installer for Python.
+      python3-pip \
+      # A command-line tool for automating X11 applications (e.g., simulating keyboard/mouse inputs).
+      xdotool \
+      # A command-line tool for taking screenshots.
+      scrot \
+      # A suite for image manipulation — needed for scaling images.
+      imagemagick && \
+    apt-get clean
+
+# Userland apt-get'able apps
+RUN apt-get install -y --no-install-recommends \
+      # A simple image viewer.
+      xpaint \
+      # A calculator application.
+      galculator && \
+    apt-get clean
+
+# install Firefox
+RUN apt-get install -y software-properties-common && \
+    add-apt-repository ppa:mozillateam/ppa && \
+    apt-get update && \
+    apt-get install -y --no-install-recommends firefox-esr && \
+    apt-get clean
+
+# install VS Code
+RUN apt-get install -y \
+      gpg \
+      wget \
+      apt-transport-https \
+      software-properties-common && \
+    wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > packages.microsoft.gpg && \
+    install -D -o root -g root -m 644 packages.microsoft.gpg /etc/apt/keyrings/packages.microsoft.gpg && \
+    sh -c 'echo "deb [arch=amd64,arm64 signed-by=/etc/apt/keyrings/packages.microsoft.gpg] https://packages.microsoft.com/repos/code stable main" > /etc/apt/sources.list.d/vscode.list' && \
+    apt-get update && \
+    apt-get install -y code && \
+    apt-get clean
+
+# configure noVNC
+RUN ln -s /usr/share/novnc/vnc.html /usr/share/novnc/index.html
+
+# We copy requirements.txt by itself so that changes to the scripts will be in a later layer
+# and we only pip install if requirements.txt changes
+COPY tool/requirements.txt /opt/inspect/tool/requirements.txt
+RUN cd /opt/inspect/tool && pip3 install --no-cache-dir -r requirements.txt
+
+COPY tool/ /opt/inspect/tool
+COPY entrypoint/ /opt/inspect/entrypoint
+RUN chmod -R 755 /opt/inspect
+
+# setup user
+ENV USERNAME=user
+ENV HOME=/home/$USERNAME
+RUN useradd -m -s /bin/bash -d $HOME $USERNAME
+RUN echo "${USERNAME} ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers
+USER ${USERNAME}
+WORKDIR $HOME
+COPY --chown=$USERNAME:$USERNAME image_home_dir/ $HOME
+
+# configure Firefox to skip all 'first run' UI
+RUN mkdir -p $HOME/.mozilla/firefox-esr/profile.default && \
+    echo 'user_pref("browser.startup.homepage_override.mstone", "ignore");' >> $HOME/.mozilla/firefox-esr/profile.default/user.js && \
+    echo 'user_pref("browser.aboutwelcome.enabled", false);' >> $HOME/.mozilla/firefox-esr/profile.default/user.js && \
+    echo 'user_pref("datareporting.policy.firstRunURL", "");' >> $HOME/.mozilla/firefox-esr/profile.default/user.js 
+    
+EXPOSE 5900
+EXPOSE 6080
+
+ARG DISPLAY_NUM=1
+ARG WIDTH=1920
+ARG HEIGHT=1080
+ENV DISPLAY_NUM=$DISPLAY_NUM
+ENV DISPLAY=:${DISPLAY_NUM}
+ENV HEIGHT=$HEIGHT
+ENV WIDTH=$WIDTH
+
+ENTRYPOINT [ "/opt/inspect/entrypoint/entrypoint.sh" ]

inspect_ai/tool/beta/_computer/_resources/README.md

@@ -0,0 +1,30 @@
+# About This Image
+
+This image was inspired by Anthropic's Computer Use Demo [here](https://github.com/anthropics/anthropic-quickstarts/tree/main/computer-use-demo/image).
+
+Its goal is to provide the minimum infrastructure to support the use of Inspect's `computer_tool` to interact with the computer via X11 and `xdotool`, while also providing observability and interaction via VNC and noVNC.
+
+The image extends this minimal functionality by adding a few basic applications — VS Code, Firefox, XPaint, and galculator.
+
+## Entrypoint Directory
+
+1. **Xvfb (X Virtual Framebuffer)**
+   - **Script:** `xvfb_startup.sh`
+   - **Description:** Xvfb is a display server that implements the X11 display server protocol. It runs in memory and does not require a physical display, useful for running graphical applications in a headless environment.
+
+1. **xfce4**
+   - **Script:** `xfce4_startup.sh`
+   - **Description:** xfce4 is a lightweight desktop environment for UNIX-like operating systems. It aims to be fast, low on system resources, and user-friendly.
+
+1. **x11vnc**
+   - **Script:** `x11vnc_startup.sh`
+   - **Description:** x11vnc is a VNC server that allows remote access to the X11 display. It enables users to connect to the virtual display environment from a remote machine using a VNC client.
+
+1. **noVNC**
+   - **Script:** `novnc_startup.sh`
+   - **Description:** noVNC is a VNC client that runs in a web browser. It allows users to access the virtual display environment through a web interface without needing a separate VNC client application.
+
+## Desktop Directory
+
+The `Desktop` directory contains launchers for VS Code, Firefox and XPaint.
+