Atlas App

Atlas App is a host for installable extensions. The host is implemented in Rust, with a Tauri desktop and Android application and a standalone HTTP/gRPC-Web server. Each extension can provide a native shared library implementing the versioned C ABI, a client-rendered web frontend, and a manifest.json file. The host loads the library, starts its gRPC service, and mounts its web assets and API under the extension's route.

Repository layout

Features

• Multiple user accounts, login/logout, account activation, and password changes.
• Per-user, per-extension read and write permissions; administrator account and permission management.
• Extension discovery, installation, removal, status reporting, and frontend/API routing.
• Runtime extension libraries are checked against the host's C-ABI interface version before activation.
• A standalone server and a Tauri-hosted desktop/mobile UI share the host backend.

Prerequisites

• Git with submodule support, Rust/Cargo, Node.js, and Yarn 4.12.x (the version recorded in package.json).
• For the desktop Tauri application: the platform's Tauri prerequisites.
• For Android: Android Studio/SDK, a compatible Android NDK, and Java; initialize the Tauri Android project if it has not been generated yet.
• For native extension builds: CMake 3.21 or newer, Ninja, a C++20 compiler, and vcpkg. Android extension builds additionally need ANDROID_NDK_HOME.

Clone with submodules, or initialize it in an existing checkout:

git submodule update --init --recursive
yarn install

Build the host

Run the application scripts from the app/ directory:

cd app
yarn build:app       # Tauri desktop application
yarn build:server    # standalone atlas-server binary
yarn build:android   # Android app package

The Android build uses Tauri's generated Android project under app/gen/android. If it has not been initialized, run yarn tauri android init from app/ after installing/configuring the Android toolchain. See app/README.md for build and development details.

Build the utility tools and example extension

The build/ crate contains manifest and ZIP packaging tools. CMake at the repository root imports the Rust crates and provides the plugin_zip target for extensions. To build the Greeter example on Linux:

cmake --preset "Examples Linux Debug"
cmake --build --preset "Examples Linux Debug"

The preset enables vcpkg manifest mode and builds the packaged extension ZIP. Other example presets are listed in CMakePresets.json. See build/README.md and examples/greeter/README.md.

Generate the C-ABI header

The public C header is generated from the Rust interface crate with cbindgen:

cargo build -p interface

This writes interface/gen/inc/plugin_api.h. See interface/README.md for the ABI contract and generation details.

Create an extension

An extension ZIP contains a root manifest.json, optional client-only static web files in client/, and one or more platform shared libraries under lib/<architecture>/. The shared library exports the lifecycle API declared by the C-ABI header. The manifest describes the extension and the ABI version it targets.

Start from examples/greeter/ for a working CMake-based example, and see its README for the complete metadata field table and packaging steps. Runtime extensions can be installed through the host's plugin management UI or the server's plugins add command; a host restart is required before newly installed extensions are activated.

The manifest is a protobuf-JSON PluginMetadata object. Its JSON keys and enum values use the spellings shown here: