feat: add apx documentation

- add stacks doc
- add subsystem doc
- add pkgm doc
- add getting-started doc
- add understanding pmss doc
- add introduction doc

docs/articles/en/getting-started.md

@@ -0,0 +1,114 @@
+# Getting Started with Apx
+
+Apx is designed to be a versatile, distro-agnostic tool that can be installed on any Linux distribution. Follow the steps below to get Apx up and running on your system.
+
+## Prerequisites
+
+Before installing Apx, ensure you have the following software installed:
+
+1. **Go**: This is required to compile Apx. Install it from your distribution's package manager.
+2. **Git**: Needed to clone the Apx repository.
+3. **Podman or Docker**: Either container runtime is suitable, but Podman is recommended.
+4. **Make**: This utility is used for building and installing Apx.
+
+## Installation Procedure
+
+### Clone the Apx Repository  
+   Open your terminal and run the following commands to clone the repository and navigate into it:
+   ```bash
+   git clone --recursive https://github.com/Vanilla-OS/apx.git
+   cd apx
+   ```
+
+### Build Apx  
+   Compile Apx by executing:
+   ```bash
+   make build
+   ```
+
+### Install Apx  
+   To install Apx system-wide, run:
+   ```bash
+   sudo make install
+   ```
+
+### Install Apx Manpages  
+   For the manual pages, execute:
+   ```bash
+   sudo make install-manpages
+   ```
+
+## Custom Installation Destination
+
+You can change the installation prefix or destination using `PREFIX` and `DESTDIR`. Here are examples for custom installations:
+
+- **Install Apx to `~/.local`**:
+  ```bash
+  make install PREFIX=$HOME/.local
+  make install-manpages PREFIX=$HOME/.local
+  ```
+
+- **Install Apx to a separate root**:
+  ```bash
+  make install DESTDIR=$HOME/altroot
+  make install-manpages DESTDIR=$HOME/altroot
+  ```
+
+# Getting Started with Apx-GUI
+
+Apx-GUI provides a graphical interface for managing your Apx installations. Follow the steps below to install Apx-GUI on your system.
+
+## Dependencies
+
+Before you start, ensure you have the following dependencies installed:
+
+1. **build-essential**: A package containing essential compilation tools.
+2. **meson**: A build system to configure the project.
+3. **libadwaita-1-dev**: A library for building modern GNOME applications.
+4. **gettext**: A utility for internationalization and localization.
+5. **desktop-file-utils**: Tools for handling desktop entry files.
+6. **apx (2.0+)**: Ensure you have Apx version 2.0 or higher installed.
+
+You can install these dependencies using your distribution's package manager. For example, on Debian-based systems, you can run:
+
+```bash
+sudo apt update
+sudo apt install build-essential meson libadwaita-1-dev gettext desktop-file-utils apx
+```
+
+## Installation Procedure
+
+### Clone the Apx-GUI Repository  
+Open your terminal and run the following commands to clone the repository and navigate into it:
+```bash
+git clone https://github.com/Vanilla-OS/apx-gui.git
+cd apx-gui
+```
+
+### Build Apx-GUI
+
+Once you have cloned the repository, build Apx-GUI by running:
+
+```bash
+meson setup build
+ninja -C build
+```
+> **NOTE:** you can set a custom installation destination by passing `--prefix=/path/to/dir` to `meson`
+
+### Install Apx-GUI
+
+After successfully building the application, install it with the following command:
+
+```bash
+sudo ninja -C build install
+```
+
+### Run Apx-GUI
+
+You can launch Apx-GUI using the following command:
+
+```bash
+apx-gui
+```
+
+Follow these steps to successfully install and run Apx-GUI on your system. Enjoy managing your Apx installations with the graphical interface!

docs/articles/en/introduction.md

@@ -0,0 +1,20 @@
+# Introduction to APX
+
+APX is a versatile command-line interface (CLI) tool designed to simplify the management of operating system containers. With a focus on efficiency and user-friendliness, APX empowers users to create, manage, and customize containers for a variety of applications and services.
+
+Key features of APX include:
+
+- **Subsystems**: APX supports the management of container-based operating systems running on top of the host.  These are called subsystems in APX.  They are lightweight and provide flexible environments that have no effect on the host system.
+
+- **Stacks**: Organize related configurations and dependencies into cohesive groups called stacks. This feature creates consistent, reproducable environments to develop software, deploy workloads, or install packages that may be incompatible with your host system.
+
+- **Package Manager Integration**: APX includes built-in support for various package managers, enabling users to manage software installations and dependencies directly within their container environments. Users can easily create, update, and remove package managers, streamlining the setup process for their applications.
+
+- **Configuration Management**: APX offers robust tools for creating, updating, importing, and exporting configurations. This capability ensures that users can maintain their setups effectively and share them across different environments or automation tools.
+
+- **User-Friendly Interface**: With intuitive commands and clear feedback, APX is designed for ease of use, making it accessible to both novice and experienced users.
+
+By integrating these powerful features, APX provides developers and system administrators with the tools they need to efficiently manage their containerized applications and associated dependencies. Whether you're deploying microservices or managing development environments, APX helps you streamline your container management process.
+
+Explore APX and discover a more efficient approach to managing your operating system containers, stacks, subsystems, and package managers!
+

docs/articles/en/understanding-pmss.md

@@ -0,0 +1,40 @@
+## Package Managers
+In APX, package managers are essential components that facilitate the management of software packages within operating system containers. They provide a way to install, update, remove, and manage software dependencies seamlessly. Here’s an overview of what package managers do in APX:
+
+### Key Functions of Package Managers in APX
+
+1. **Installation of Software**: Package managers allow users to install new software packages easily with a simple command, streamlining the process of setting up applications and services within containers.
+
+2. **Dependency Management**: They automatically handle dependencies, making sure that all required libraries and components are present when a package is installed.
+
+3. **Custom Package Managers**: Users can define and configure custom package managers for different operating systems or environments, ensuring flexibility and adaptability to specific needs.
+
+By integrating package managers into APX, users gain powerful tools to efficiently manage software installations and maintain their container environments, ultimately enhancing productivity and reducing complexity in application deployment and management.
+
+## Stacks
+In APX, stacks serve as the foundational templates from which subsystems are created. Each stack defines a combination of a container base and a curated list of packages to preinstall using a package manager, establishing a consistent environment for deployment. By using stacks, developers can ensure that all necessary components and configurations are in place before instantiating subsystems, simplifying the setup process and promoting uniformity across different applications. This structured approach facilitates efficient management of dependencies and enhances the overall reliability of the containerized environment.
+
+### Key Features of Stacks in APX
+
+1. **Simplified Deployment**: By grouping related software and configurations, stacks facilitate streamlined deployment processes. Users can deploy a stack with a single command, ensuring that all necessary components are included.
+
+2. **Version Control**: Stacks are versioned through container tags, enabling users to maintain different configurations or setups for various environments.
+
+3. **Collaboration and Sharing**: Users can easily share stacks with others or import stacks created by different teams, promoting collaboration and consistency across projects.
+
+4. **Environment Management**: Stacks allow for easy management of different environments, making it simple to switch between configurations tailored for specific tasks or projects.
+
+By utilizing stacks in APX, users can enhance their ability to manage complex applications, maintain organized workflows, and ensure that all components work harmoniously within their containerized environments. This structured approach leads to more efficient development, testing, and deployment processes.
+
+## Subsystems
+In APX, subsystems function as containerized sandboxes that isolate and manage specific functionalities or services within an application environment. Each subsystem operates independently, ensuring that dependencies and configurations do not interfere with one another. This encapsulation enhances security, stability, and scalability, allowing developers to build and deploy applications with confidence, knowing that each subsystem can be maintained and updated without affecting the overall system.
+
+### Key Features of Subsystems in APX
+
+1. **Modularity**: Subsystems are designed to be self-contained, allowing users to develop, test, and deploy individual components independently. This modularity promotes easier maintenance and updates.
+
+2. **Configurability**: Users can configure subsystems to meet specific requirements, adjusting parameters to suit different environments or application needs. This flexibility enhances customization and usability.
+
+3. **Interoperability**: Subsystems in APX enable interoperability in software by providing isolated, containerized environments that facilitate seamless communication and integration between diverse applications and components.
+
+By leveraging subsystems in APX, users can build complex applications in a structured and efficient manner, enhancing their ability to manage individual components while maintaining a cohesive overall architecture. This approach supports rapid development cycles, easy integration of new features, and streamlined maintenance processes.