Aperture IDE

Aperture is an open-source self-hostable remote development IDE with specialised software engineers, quality assurance professionals, project managers etc.

Installation and development

Before contributing to or testing Aperture, you must ensure you have all the necessary dependencies. You can either use the provided shell.nix file with the Nix package manager by running nix-shell shell.nix after changing directory to team-100/poc or follow the manual installation instructions below.

Minimum Requirements

The following tools are required to build and run the Aperture IDE demo:

• Rust: The core of Aperture is written in Rust. You will need rustc and cargo to compile the project.
• Bun: A fast JavaScript runtime and toolkit used for the frontend.
• Tauri: A framework for building desktop apps with web technologies. cargo-tauri is required.
• A C compiler, such as GCC or Clang.
• pkg-config: A helper tool used to find information about installed libraries.
• Docker: A containerization tool we use to dynamically spin up reproducible sessions.
• Gradle: A build system for JVM languages we use to build the session binaries.

System-Specific Dependencies

Linux (including WSL)

You will need to install several development libraries. As an example, Debian-based distros (including Ubuntu) can install them as follows:

sudo apt update
sudo apt install libwebkit2gtk-4.1-dev \
    build-essential \
    curl \
    wget \
    file \
    libxdo-dev \
    libssl-dev \
    libgtk-3-dev \
    librsvg2-dev \
    libayatana-appindicator3-dev \
    librsvg2-dev \
    pkg-config \
    openjdk-21-jdk

For other distributions, refer to the Tauri documentation

For macOS

You can use Homebrew to install the necessary dependencies.

# Install command-line tools
xcode-select --install

# Install dependencies with Homebrew
brew install openssl librsvg pkg-config webkitgtk

Installation Steps

1. Install Rust: It is recommended to install Rust using rustup.

   curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

   This command will install the latest stable version of Rust. After installation, you'll also have access to Cargo, the Rust build tool and package manager.

2. Install Bun: You can install Bun using the following command:

   curl -fsSL https://bun.com/install | bash

3. Install Tauri CLI: Once Cargo is installed, you can install the Tauri CLI with the following command:

   cargo install tauri-cli

4. Install Docker: If you don't have the Docker Engine installed, do so following the Docker documentation. Also make sure to add your user to the docker group, so docker can run without root.

5. Install Gradle: Since we use Kotlin for the session code, you will need to install Gradle. The easiest way to do this is by using sdkman. If you did not do so already, you should also install OpenJDK 21.

Running the Demo

Our PoC consists of two binaries. The server can run anywhere, but the default config has it running on localhost. The client connects to sessions, which are spawned by the server using special docker images.

Container

First, build the docker image used for the session using these steps:

1. Navigate to the /team-100/poc/session directory
2. Generate the Gradle wrapper:

   gradle wrapper

3. Build the session jar:

   ./gradlew fatJar

4. Build the docker image:

   docker build -t aperture:latest .

Server

To run the server, follow these steps:

1. Navigate to the /team-100/poc directory.
2. Build the server:

   cargo build --release

3. Run the binary using the default config:

   APERTURE_SERVER_CONF="./configs/server.toml" ./target/release/apertured

Client

To run the client, follow these steps:

1. Navigate to the /team-100/poc/aperture directory.
2. Install the frontend dependencies:

bun install

3. Start the client in development mode:

bun run tauri dev

Alternatively:

3. Build the client in release mode:

bun run tauri build

4. Run the binary to start the client:

../target/release/aperture_client`

NOTE: On certain linux systems, you may need to run

export WEBKIT_DISABLE_DMABUF_RENDERER=1 

before running the client to prevent a black screen. In case you encounter a white screen instead, simply right-click inside the window and select "Reload".

Connecting to the server and creating a session

Now that both the client and the server are running, we can start to edit some code!

On the client login screen, click "Select Config File" and choose the default client config located at poc/configs/client.toml. Proceed to click the "Login" button.

This will connect you to the server and bring you to the project selection screen. Create a new project with a name of your choice. You can also select the users that will have access to this project. Refresh the project list and select your new project.

Now, create a new session. Give it any name and load the default session config located at poc/configs/container.toml. The nix field holds a nix shell configuration, which allows you to specify your dependencies, creating a reproducible environment. For this example, keep it as the default and create the session. This will automatically connect you to it, leading you to the session selection screen. Here, select the dev view to open the IDE.

You can now add files and directories using the file explorer on the top left. Open any file to start editing it. You can then execute the code you write using the console at the bottom. These commands execute directly inside the container running the session, allowing you to use any regular Linux (in this case, Ubuntu) commands.

Adding more users and using a remote server

To add more users, add more fields to the users tab in the server config. The key will be the username and the value their token. To login with a different user, change the user_id and auth_token fields in the client config to these values.

To use multiple clients, create a new user for each and make sure they use the corresponding config. If you want to share a project between multiple users, make sure to add them when creating the project. Two users can either make their own sessions or connect to the same one.

There is no special setup needed in order to run the server remotely. Just make sure to change the server_addr field in the client config to point to the remote server's address and port. Also update the server config with the same ip and port.