Snigdha-OS/documentation
2
0
Fork 0
mirror of https://github.com/Snigdha-OS/documentation.git synced 2025-09-05 19:06:37 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

🧹 chore(clean): dump all code

Browse Source
This commit is contained in:
eshanized
2024-12-30 12:00:06 +05:30
parent d45f374bbb
commit 546ab97fdd
71 changed files with 0 additions and 32954 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
README.md
View File

@@ -1,76 +0,0 @@
# Snigdha OS Documentation 📖
Welcome to the official documentation repository for **Snigdha OS**! This repository houses all the resources, guides, and references you need to understand, use, and contribute to Snigdha OS.
## 📚 About Snigdha OS
Snigdha OS is a lightweight, user-friendly Linux-based operating system designed to provide a seamless and efficient experience. With a focus on simplicity, performance, and customization, Snigdha OS is the perfect choice for developers, creators, and everyday users.
## 📂 Repository Structure
The repository is organized into the following sections:
- **Getting_Started/**
Step-by-step guides to help you install and set up Snigdha OS.
- **User_Guide/**
In-depth documentation on using Snigdha OS features and tools.
- **Developer_Guide/**
Resources for developers interested in contributing to Snigdha OS.
- **FAQ/**
Answers to frequently asked questions.
- **Community/**
Details on how to join and participate in the Snigdha OS community.
## 🚀 Quick Start
To get started with Snigdha OS documentation:
1. Clone this repository:
```bash
git clone https://github.com/snigdha-os/documentation.git
cd documentation
```
2. Navigate through the folders to find the information you need.
3. Open issues or propose changes if you have suggestions for improving the documentation.
## 🛠️ How to Contribute
We ❤️ contributions! Here's how you can help:
1. **Report Issues**: Found a bug or typo? [Open an issue](https://github.com/snigdha-os/documentation/issues).
2. **Suggest Improvements**: Have ideas for improvement? Create a new discussion or issue.
3. **Submit Pull Requests**: Fix issues or add new documentation by submitting a pull request.
Check out our [Contribution Guidelines](CONTRIBUTING.md) for more details.
## 🌐 Join the Community
Be a part of the growing Snigdha OS community:
- [Website](https://snigdhaos.org)
- [Open Collective](https://opencollective.com/snigdha-os)
- [Community Forums](https://forums.snigdhaos.org)
## 📄 License
This repository is licensed under the [MIT License](LICENSE). You’re free to use, modify, and distribute the content as per the terms of the license.
Thank you for contributing to and supporting Snigdha OS! Together, we can build an amazing platform. 🎉

3
babel.config.js
View File

@@ -1,3 +0,0 @@
module.exports = {
presets: [require.resolve('@docusaurus/core/lib/babel/preset')],
};

5
blog/authors.yml
View File

@@ -1,5 +0,0 @@
eshanized:
name: Eshan Roy
title: Lead Developer & Maintainer
url: https://eshan.snigdhaos.org
image_url: https://github.com/eshanized/eshanized/blob/main/eshanized_square.png?raw=true

35
blog/effetive_bug_report.md
View File

@@ -1,35 +0,0 @@
---
slug: /effective_bug_report
title: Write Effective Bug Report
authors: [eshanized]
tags: [bug]
---
# Write Effective Bug Report
Writing an effective bug report is crucial for helping developers understand, reproduce, and ultimately fix the issue. Here's a step-by-step guide on how to write an effective bug report:
1. **Title**: Provide a concise and descriptive title that summarizes the issue. It should give a clear indication of what the problem is without being too lengthy. For example, "Error message appears when trying to log in."
2. **Description**:
- **Overview**: Begin with a brief overview of the problem, including what you were trying to do and what went wrong.
- **Steps to Reproduce**: List the specific steps or actions taken that lead to the issue. Provide enough detail so that others can follow the same steps and encounter the same problem.
- **Expected Behavior**: Describe what you expected to happen after performing the steps mentioned above.
- **Actual Behavior**: Describe what actually happened or what you observed that indicates the presence of a bug. Include any error messages, unexpected behavior, or deviations from the expected outcome.
- **Frequency**: Indicate whether the issue occurs consistently or intermittently. If intermittent, specify any patterns or conditions that seem to trigger the problem.
- **Environment**: Mention the operating system, browser/version, device, or any other relevant environment details where the issue occurred.
- **Screenshots/Attachments**: If applicable, include screenshots, logs, error messages, or any other relevant files that can help illustrate or reproduce the problem.
3. **Impact**: Explain the impact of the bug on the user experience, system functionality, or any other relevant aspect. Include information about any workarounds or mitigations you've discovered.
4. **Additional Information**:
- **Related Issues**: If you suspect the bug may be related to other issues or if you've found similar reports, mention them and provide links if possible.
- **Priority/Severity**: Optionally, suggest a priority or severity level for the bug based on its impact and urgency.
- **Timeframe**: If applicable, specify any deadlines or time constraints that may affect the resolution of the issue.
- **Contact Information**: Provide your contact information (email, username, etc.) in case developers need clarification or further details.
5. **Submission**: Submit the bug report through the designated bug tracking system, issue tracker, or communication channel used by the development team. Follow any specific guidelines or templates provided by the project.
6. **Follow-up**: Be prepared to respond to any follow-up questions or requests for clarification from developers. Provide additional information as needed to help troubleshoot and resolve the issue.
By following these steps and providing detailed, organized information, you can help developers diagnose and address the bug more effectively, ultimately leading to quicker resolution and improved software quality.

9
docs/before_installation/_category_.json
View File

@@ -1,9 +0,0 @@
{
"label": "Before Installation",
"position": 2,
"link": {
"type": "generated-index",
"description": "System Requirements!"
}
}

12
docs/before_installation/imporatnt_notes.md
View File

@@ -1,12 +0,0 @@
---
sidebar_position: 2
---
# Important Notes
📌 We do not recommended you to install Snigdha OS via VM ('Virtual Machine' = virtual machine), as it is optimized for use on real hardware or physical machine.
📌 If there is an abnormal system shutdown occurs during installation, it is mainly due to the lack of available RAM (`nohang` kills the process to prevent the system from responding anymore).
📌 The use of inactive RAM (idle) is probably greater than other distributions since Snigdha OS uses ZRAM and other modifications to improve the general performance of the system.
📌 `Ventoy` doesn't seem to work properly because some users have reported problems. Use the utility you prefer such as, for example, dd to burn ISO to a USB stick.

4
docs/before_installation/internet_connection.md
View File

@@ -1,4 +0,0 @@
---
sidebar_position: 3
---
# Internet Connection

28
docs/before_installation/system_requirements.md
View File

@@ -1,28 +0,0 @@
---
sidebar_position: 1
---
# System Requirements
### 🌟 **System Requirements for Snigdha OS**
To ensure a smooth experience with Snigdha OS, here are the minimum and recommended hardware specifications:
---
### 🔹 **Minimum Requirements**
These are the bare minimum specifications needed to install and run Snigdha OS:
- 🖥 **Processor**: Any x86_64 processor
- 💾 **Disk Space**: 10 GB
- 🐏 **RAM**: 1 GB
---
### 🔹 **Recommended Requirements**
For better performance and to fully utilize the features of Snigdha OS, the following specifications are recommended:
- 🖥 **Processor**: Core 2 Duo or higher
- 💾 **Storage**: 30 GB HDD/SSD or more
- 🐏 **RAM**: 2 GB or higher
---
Snigdha OS is designed to be lightweight and efficient, making it suitable for a wide range of hardware configurations. Whether you're using an older machine or a modern system, Snigdha OS can adapt and deliver a seamless user experience. ✨

9
docs/dev_guide/_category_.json
View File

@@ -1,9 +0,0 @@
{
"label": "Developers Guide",
"position": 8,
"link": {
"type": "generated-index",
"description": "This will guide on how to contribute to Snigdha OS as developer."
}
}

179
docs/dev_guide/build_source.md
View File

@@ -1,179 +0,0 @@
---
sidebar_position: 1
---
# Build From Source
## Overview
Building **Snigdha OS** from the source code is very easy. In this documentation, I am going to guide you on how to build **Snigdha OS** from the source. And customizing it.
:::danger Caution
Before running or customizing any script, first examine. Remember, you are running all the scripts produced by **Snigdha OS** at your own risk!
:::
## Prerequisites
To build **Snigdha OS** from the source, we need some packages which are hosted on [SNIGDHA OS CORE](https://github.com/snosmirror/snigdhaos-core) repository and [SNIGDHA OS EXTRA](https://github.com/snosmirror/snigdhaos-extra) repository. [SNIGDHA OS TESTING](https://github.com/snosmirror/snigdhaos-testing) is an optional repository. You also need **Chaotic-AUR** because some packages come from the chaotic-aur. e.g : github-desktop.
:::info NOTE
- Make sure you have internet connection.
- If you are on **Snigdha OS**, you need not add any repository! By default all the repositories are added and enabled.
:::
## Adding Repository
First of all we will add **Snigdha OS Core** and **Snigdha OS Extra** repository in our pacman configuration. to edit `pacman.conf`, execute the following on your terminal. [I am using nano, you are free to use anything]
```bash
sudo nano /etc/pacman.conf
```
:::tip Archlinux
If you are using **Arch Linux** then you can copy and paste the following.
```bash
#
# /etc/pacman.conf
#
# See the pacman.conf(5) manpage for option and repository directives
#
# GENERAL OPTIONS
#
[options]
# The following paths are commented out with their default values listed.
# If you wish to use different paths, uncomment and update the paths.
#RootDir = /
#DBPath = /var/lib/pacman/
#CacheDir = /var/cache/pacman/pkg/
#LogFile = /var/log/pacman.log
#GPGDir = /etc/pacman.d/gnupg/
#HookDir = /etc/pacman.d/hooks/
HoldPkg = pacman glibc
#XferCommand = /usr/bin/curl -L -C - -f -o %o %u
#XferCommand = /usr/bin/wget --passive-ftp -c -O %o %u
#CleanMethod = KeepInstalled
Architecture = auto
# Pacman won't upgrade packages listed in IgnorePkg and members of IgnoreGroup
#IgnorePkg =
#IgnoreGroup =
#NoUpgrade =
#NoExtract =
# Misc options
#UseSyslog
#Color
#NoProgressBar
CheckSpace
#VerbosePkgLists
#ParallelDownloads = 5
# By default, pacman accepts packages signed by keys that its local keyring
# trusts (see pacman-key and its man page), as well as unsigned packages.
SigLevel = Required DatabaseOptional
LocalFileSigLevel = Optional
#RemoteFileSigLevel = Required
# NOTE: You must run `pacman-key --init` before first using pacman; the local
# keyring can then be populated with the keys of all official Arch Linux
# packagers with `pacman-key --populate archlinux`.
#
# REPOSITORIES
# - can be defined here or included from another file
# - pacman will search repositories in the order defined here
# - local/custom mirrors can be added here or in separate files
# - repositories listed first will take precedence when packages
# have identical names, regardless of version number
# - URLs will have $repo replaced by the name of the current repo
# - URLs will have $arch replaced by the name of the architecture
#
# Repository entries are of the format:
# [repo-name]
# Server = ServerName
# Include = IncludePath
#
# The header [repo-name] is crucial - it must be present and
# uncommented to enable the repo.
#
# The testing repositories are disabled by default. To enable, uncomment the
# repo name header and Include lines. You can add preferred servers immediately
# after the header, and they will be used before the default mirrors.
#[core-testing]
#Include = /etc/pacman.d/mirrorlist
[core]
Include = /etc/pacman.d/mirrorlist
[snigdhaos-core]
SigLevel = Never
Server = https://snosmirror.github.io/$repo/$arch
#[extra-testing]
#Include = /etc/pacman.d/mirrorlist
[extra]
Include = /etc/pacman.d/mirrorlist
[snigdhaos-extra]
Siglevel = Never
Server = https://snosmirror.github.io/$repo/$arch
# If you want to run 32 bit applications on your x86_64 system,
# enable the multilib repositories as required here.
#[multilib-testing]
#Include = /etc/pacman.d/mirrorlist
[multilib]
Include = /etc/pacman.d/mirrorlist
# An example of a custom package repository. See the pacman manpage for
# tips on creating your own repositories.
#[custom]
#SigLevel = Optional TrustAll
#Server = file:///home/custompkgs
```
:::
After executing, paste the following at the end of the file
```bash
[snigdhaos-core]
SigLevel = Never
Server = https://snosmirror.github.io/$repo/$arch
[snigdhaos-extra]
Siglevel = Never
Server = https://snosmirror.github.io/$repo/$arch
```
:::info SigLevel
If you have `SnigdhaOS-keyring` installed on the machine or you want to [install](/dev_guide/install_keyring) then you can set the **SigLevel = Required DatabaseOptional**.
:::
You are ready to build Snigdha OS!
## Cloning Source from GitHub
Now, clone the `snigdhaos-arctic` github repository. In addition, you can make a separate directory to do that. Go to your specified/choosen directory, execute the following on terminal.
```bash
git clone https://github.com/Snigdha-OS/snigdhaos-arctic.git
```
then,
```bash
cd snigdhaos-arctic/scripts
```
:::info SET EXECUTABLE
```bash
chmod +x ./01-online-build
```
:::
Now run the script by executing,
```bash
./01-online-build
```
The script will start building **Snigdha OS Arctic**. You can have a coffee break while building. The building depends on **Internet Connection** and machine's **Performance**.
After completing, you will find a directory with name **Output** containing the iso file.

200
docs/dev_guide/deploy_packages.md
View File

@@ -1,200 +0,0 @@
---
sidebar_position: 5
---
# Upload & Deploy Packages
### 🚀 Uploading and Deploying an Arch Linux Package on GitHub
Hosting an Arch Linux package on GitHub is a great way to distribute it. Users can download and install your package directly or use your repository for easier management with `pacman`. Here's how to do it step-by-step.
---
### 1️⃣ **Prepare the Package**
Ensure you’ve created your Arch package using a `PKGBUILD` file.
1. **Build the package**:
Navigate to your package directory containing the `PKGBUILD` and run:
```bash
makepkg -si
```
This will create a `.pkg.tar.zst` file (e.g., `mypackage-1.0-1-x86_64.pkg.tar.zst`).
2. **Sign the package (optional but recommended)**:
If you’re distributing the package securely, sign it with your GPG key:
```bash
gpg --detach-sign --armor mypackage-1.0-1-x86_64.pkg.tar.zst
```
This creates a signature file `mypackage-1.0-1-x86_64.pkg.tar.zst.sig`.
---
### 2️⃣ **Create a GitHub Repository**
1. Go to [GitHub](https://github.com) and create a new repository.
2. Name the repository (e.g., `arch-packages`) and add a description.
3. Initialize it with a README file (optional).
---
### 3️⃣ **Upload the Package**
1. Clone the repository to your local system:
```bash
git clone https://github.com/yourusername/arch-packages.git
cd arch-packages
```
2. Copy your package files (`.pkg.tar.zst` and `.sig`) to the repository directory:
```bash
cp ../mypackage-1.0-1-x86_64.pkg.tar.zst .
cp ../mypackage-1.0-1-x86_64.pkg.tar.zst.sig .
```
3. Commit and push the files:
```bash
git add mypackage-1.0-1-x86_64.pkg.tar.zst mypackage-1.0-1-x86_64.pkg.tar.zst.sig
git commit -m "Add mypackage version 1.0"
git push origin main
```
---
### 4️⃣ **Set Up a Repository for `pacman`**
To create a repository compatible with `pacman`, you need a database file (`.db`) and signature file (`.db.sig`).
1. **Generate the database**:
Run `repo-add` to create a repository database for your packages:
```bash
repo-add myrepo.db.tar.gz mypackage-1.0-1-x86_64.pkg.tar.zst
```
This will generate files like:
- `myrepo.db.tar.gz`
- `myrepo.db.tar.gz.sig` (if signed)
Rename `myrepo.db.tar.gz` to `myrepo.db` for convenience:
```bash
mv myrepo.db.tar.gz myrepo.db
mv myrepo.db.tar.gz.sig myrepo.db.sig
```
2. **Add repository files to GitHub**:
Copy the `.db` and `.sig` files to the repository and push them:
```bash
git add myrepo.db myrepo.db.sig
git commit -m "Add repository database"
git push origin main
```
---
### 5️⃣ **Serve the Repository on GitHub Pages**
1. Enable GitHub Pages for the repository:
- Go to your repository’s **Settings** > **Pages**.
- Under **Source**, select `main` (or the branch you’re using) and set the folder to `/root` or `/docs`.
2. Note the URL for your repository, which will be in the format:
```plaintext
https://yourusername.github.io/arch-packages/
```
---
### 6️⃣ **Configure `pacman` to Use Your Repository**
1. Add your repository to `/etc/pacman.conf`:
```plaintext
[myrepo]
SigLevel = Required
Server = https://yourusername.github.io/arch-packages
```
2. Update `pacman`:
```bash
sudo pacman -Syu
```
3. Install your package:
```bash
sudo pacman -S mypackage
```
---
### 🛠️ Automating Updates with GitHub Actions
To automate the deployment of new packages to GitHub, use **GitHub Actions**:
1. Create a `.github/workflows/deploy.yml` file in your repository:
```yaml
name: Deploy Arch Linux Package
on:
push:
branches:
- main
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v3
- name: Install Arch tools
run: |
sudo apt update
sudo apt install archlinux-keyring devscripts pacman
- name: Generate repository database
run: |
repo-add myrepo.db.tar.gz *.pkg.tar.zst
mv myrepo.db.tar.gz myrepo.db
mv myrepo.db.tar.gz.sig myrepo.db.sig
- name: Commit and push repository updates
run: |
git add myrepo.db myrepo.db.sig
git commit -m "Update repository database"
git push origin main
```
2. Push this file to your repository. The workflow will automatically run on every push to update the repository database.
---
### ✅ Final Testing
1. Clone your repository to verify it’s accessible:
```bash
git clone https://yourusername.github.io/arch-packages
```
2. Test package installation from your custom repository as described in step 6.
---
By following these steps, you'll have a fully functional Arch Linux package repository hosted on GitHub, ready for others to use. 🎉

180
docs/dev_guide/gpg_key.md
View File

@@ -1,180 +0,0 @@
---
sidebar_position: 2
---
# Generate GPG Key
### 🔐 How to Generate a GPG Key on Snigdha OS
GPG (GNU Privacy Guard) is a tool for secure communication and data encryption. It allows you to create and manage public and private keys, encrypt files, and sign documents. Here’s how you can generate a GPG key on Snigdha OS, step by step, with examples.
---
### 🛠️ Step 1: Install GPG
Most Snigdha OS installations come with GPG pre-installed. If it’s not installed, use the following command to install it:
```bash
sudo pacman -S gnupg
```
To verify the installation, check the version:
```bash
gpg --version
```
---
### 🛠️ Step 2: Create a New GPG Key Pair
1. **Start the key generation process**:
Run the following command:
```bash
gpg --full-generate-key
```
2. **Select the key type**:
You’ll see a prompt to choose the type of key. Options typically include:
- **(1) RSA and RSA (default)**
- (2) DSA and Elgamal
- (3) DSA (sign only)
- (4) RSA (sign only)
Press `1` and hit Enter to select the default **RSA and RSA** type.
3. **Set the key length**:
You’ll be prompted to specify the key size. A common recommendation is **4096 bits** for strong encryption. Type `4096` and press Enter.
4. **Set the expiration date**:
You can define how long the key should be valid. Options include:
- `0` for no expiration
- Specify a duration, e.g., `1y` for one year, `2y` for two years, or `1m` for one month.
For this example, type `0` (no expiration) and press Enter. When prompted, confirm your choice.
5. **Enter your details**:
You’ll be asked for:
- **Your real name**: Enter your full name.
- **Your email address**: Enter a valid email address.
- **A comment (optional)**: Add a description or leave it blank.
Example:
```
Real name: John Doe
Email address: johndoe@example.com
Comment: Snigdha OS User
```
Review the details and confirm by typing `O` (for OK).
6. **Set a passphrase**:
Choose a strong passphrase to protect your private key. This passphrase will be required whenever you use your private key for encryption or signing.
---
### 🛠️ Step 3: Verify the Generated Key
Once the key is generated, you can list your keys with:
```bash
gpg --list-keys
```
Output:
```
/home/username/.gnupg/pubring.kbx
---------------------------------
pub rsa4096 2023-12-05 [SC] [expires: 2025-12-05]
ABCD1234EFGH5678IJKL9012MNOP3456QRST7890
uid [ultimate] John Doe <johndoe@example.com>
sub rsa4096 2023-12-05 [E] [expires: 2025-12-05]
```
- **pub**: Your primary key (for signing and certification).
- **sub**: Subkey (for encryption).
- **[SC]**: Key capabilities: Sign and Certify.
- **[E]**: Encryption.
---
### 🛠️ Step 4: Export Your Public Key
To share your public key with others, export it:
```bash
gpg --armor --export johndoe@example.com > public_key.asc
```
This creates a file `public_key.asc` with your public key in ASCII format.
To display the key in the terminal:
```bash
gpg --armor --export johndoe@example.com
```
---
### 🛠️ Step 5: Test Encryption and Decryption
1. **Encrypt a file**:
Create a sample file to encrypt:
```bash
echo "Hello, this is a test message!" > message.txt
```
Encrypt the file with your public key:
```bash
gpg --output message.txt.gpg --encrypt --recipient johndoe@example.com message.txt
```
This generates an encrypted file `message.txt.gpg`.
2. **Decrypt the file**:
Decrypt the file using your private key:
```bash
gpg --output decrypted_message.txt --decrypt message.txt.gpg
```
Enter your passphrase when prompted. The decrypted content will be saved in `decrypted_message.txt`.
---
### 🛠️ Step 6: Back Up Your Keys
Always back up your keys to prevent losing access:
1. **Export your private key**:
```bash
gpg --armor --export-secret-keys johndoe@example.com > private_key.asc
```
2. **Export your public key**:
```bash
gpg --armor --export johndoe@example.com > public_key.asc
```
3. Store these files (`private_key.asc` and `public_key.asc`) in a safe place.
---
### 🚀 Final Tips
- Keep your private key secure. Never share it.
- Regularly update your passphrase for added security.
- Use tools like **gpg-agent** for easier key management.
That’s it! You now have a functional GPG key pair set up on Snigdha OS. 🎉

189
docs/dev_guide/install_keyring.md
View File

@@ -1,189 +0,0 @@
---
sidebar_position: 4
---
# Install Keyrings
### 🔑 Installing and Packaging Your Own Keyring on Arch Linux
When creating custom repositories or maintaining your own set of signed packages, you may need to create and package your own **GPG keyring** for secure verification. This guide walks you through the process of creating, installing, and packaging a custom keyring for Arch Linux.
---
### 1️⃣ **Generate Your GPG Key**
First, create a GPG key to sign packages or repositories if you don’t already have one.
```bash
gpg --full-generate-key
```
- Select the type: `RSA and RSA (default)`.
- Set the key size: `4096`.
- Set expiration: `0` (no expiration) or specify a validity period.
- Provide your name, email, and a strong passphrase.
To verify your key:
```bash
gpg --list-keys
```
You’ll see something like:
```plaintext
pub rsa4096 2023-12-05 [SC]
A41886F639658CA1A5519426E1415F19F21171F2
uid [ultimate] Eshan Roy <eshanized@example.com>
sub rsa4096 2023-12-05 [E]
```
---
### 2️⃣ **Export Your GPG Public Key**
Export your public key so it can be included in the keyring:
```bash
gpg --export --armor "Eshan Roy" > eshanized.gpg
```
This will create an ASCII-armored file, `eshanized.gpg`, containing your public key.
---
### 3️⃣ **Create a Keyring Directory**
Create a directory structure for the keyring:
```bash
mkdir -p eshanized-keyring
cd eshanized-keyring
```
Place the exported public key in the directory:
```bash
cp ../eshanized.gpg .
```
---
### 4️⃣ **Package the Keyring for Installation**
#### A. **Create a PKGBUILD**
Arch packages use a `PKGBUILD` script for building. Create a `PKGBUILD` file in the `eshanized-keyring` directory:
```bash
nano PKGBUILD
```
Here’s an example `PKGBUILD` for your keyring:
```bash
pkgname=eshanized-keyring
pkgver=1.0
pkgrel=1
pkgdesc="GPG keyring for Eshan Roy's repository"
arch=('any')
url="https://example.com"
license=('GPL')
source=('eshanized.gpg')
sha256sums=('SKIP') # Replace SKIP with the actual SHA-256 checksum if desired
package() {
install -Dm644 "$srcdir/eshanized.gpg" "$pkgdir/usr/share/pacman/keyrings/eshanized.gpg"
install -Dm644 "$srcdir/eshanized.gpg" "$pkgdir/usr/share/pacman/keyrings/eshanized-trusted.gpg"
}
```
#### B. **Build the Package**
Run the following command to build the package:
```bash
makepkg -si
```
- **`makepkg`** creates the package (`.pkg.tar.zst`) file.
- **`-si`** installs the package after building.
This will install your keyring to `/usr/share/pacman/keyrings/`.
---
### 5️⃣ **Verify the Installed Keyring**
After installing the keyring package, check the directory to ensure your keyring files are correctly placed:
```bash
ls /usr/share/pacman/keyrings/
```
You should see:
```plaintext
eshanized.gpg
eshanized-trusted.gpg
```
---
### 6️⃣ **Use Your Keyring for Custom Repositories**
If you're hosting your own repository, update the `pacman.conf` file to use your keyring:
```bash
sudo nano /etc/pacman.conf
```
Add your repository:
```plaintext
[eshanized-repo]
SigLevel = Required
Server = https://example.com/$arch
```
Your keyring will now be used to verify packages from your custom repository.
---
### 7️⃣ **Testing Your Setup**
1. **Add a package to your repository**:
Sign your package using your private GPG key:
```bash
gpg --detach-sign --armor your-package.pkg.tar.zst
```
Place both the `.pkg.tar.zst` file and its `.sig` file in your repository.
2. **Test the repository with pacman**:
```bash
sudo pacman -Syu
sudo pacman -Ss your-package
```
Ensure the signature is verified using your keyring.
---
### ✅ Tips and Best Practices
1. **Key Security**:
Keep your private key safe and secure. Avoid placing it on shared servers.
2. **Regular Updates**:
Update and repackage your keyring if you add new GPG keys.
3. **Checksum Validation**:
Use tools like `sha256sum` to ensure your `PKGBUILD` file includes valid checksums.
4. **Documentation**:
Document your keyring package details for users who may need to add your repository.
By following these steps, you'll have a fully functional custom keyring integrated into your Arch Linux setup. 🎉

97
docs/dev_guide/pkgbuild.md
View File

@@ -1,97 +0,0 @@
---
sidebar_position: 7
---
# PKGBUILD Template
Snigdha OS has it's own `PKGBUILD` template for building packages. We follow the the template so that we can maintain the packages in a better way. If you are building packages for Snigdha OS, then it will be a good option to follow the `PKGBUILD` template.
## What is PKGBUILD?
In Arch Linux or Snigdha OS, `PKGBUILD` is a script used to build packages. It contains metadata about the package as well as instructions on how to compile or otherwise obtain the necessary files to create a package. `PKGBUILD` scripts are used with the `makepkg` utility to create packages in the Arch Linux package format (`.pkg.tar.xz`). But in **Snigdha OS** our package format will be **`.pkg.tar.zst`**.
**PKGBUILD** typically includes information such as the package name, version, dependencies, build instructions, and optional parameters. They allow users to easily create custom packages from source code or other files, which can then be installed using the package manager (`pacman`).
Using `PKGBUILD` scripts provides a standardized and reproducible way to create packages, ensuring consistency across the Arch Linux ecosystem. Additionally, the Arch User Repository (AUR) relies heavily on `PKGBUILD` scripts submitted by users to build and distribute packages that are not available in the official repositories. Since **Snigdha OS** also comes in **Arch Linux** ecosystem, we also rely on Arch User Repository for packages.
## A simple PKGBUILD
Writing a `PKGBUILD` for Arch Linux and Snigdha OS involves several key steps. Below is a basic example of a `PKGBUILD` for a fictitious application called "exampleapp." This example assumes that "exampleapp" is a simple Python application with a `setup.py` file for installation.
```PKGBUILD
# Maintainer: Your Name <your_email@example.com>
pkgname=exampleapp
pkgver=1.0
pkgrel=1
pkgdesc="A simple example application"
arch=('any')
url="https://example.com/exampleapp"
license=('MIT')
depends=('python')
source=("https://example.com/exampleapp/exampleapp-${pkgver}.tar.gz")
build() {
cd "${srcdir}/exampleapp-${pkgver}"
python setup.py build
}
package() {
cd "${srcdir}/exampleapp-${pkgver}"
python setup.py install --root="${pkgdir}/" --optimize=1
}
# Checksums, uncomment these lines and provide the correct checksums:
# sha256sums=('SKIP')
```
Here's a breakdown of the sections:
1. **Metadata**: This section defines metadata about the package, including its name (`pkgname`), version (`pkgver`), release number (`pkgrel`), description (`pkgdesc`), architecture (`arch`), URL (`url`), and license (`license`). These fields are essential for identifying and describing the package.
2. **Dependencies**: The `depends` array lists the runtime dependencies required for the package to function correctly. You should include any libraries or packages that your application relies on.
3. **Source**: The `source` array specifies where to download the source code for the application. In this example, the source is assumed to be a tarball available at a URL. You may need to adjust this section based on the source code's location and format.
4. **Build() function**: This function contains the commands needed to build the package. It typically involves navigating to the source directory (`${srcdir}`) and running build commands specific to your application. In this example, we're assuming a Python application with a `setup.py` file, so we use `python setup.py build`.
5. **Package() function**: This function contains the commands needed to install the package into the package directory (`${pkgdir}`). It typically involves navigating to the source directory and running installation commands. Here, we're assuming a Python application with a `setup.py` file, so we use `python setup.py install`.
6. **Checksums**: Uncomment the `sha256sums` array and provide the correct checksum for the source tarball. This ensures that the source hasn't been tampered with.
Once you've written the `PKGBUILD`, save it to a file named `PKGBUILD` and place it in a directory with the same name as the package. You can then use the `makepkg` command to build the package:
```bash
$ makepkg
```
This command will generate a `.pkg.tar.zst` file containing the built package, which you can then install using `pacman`.
## Snigdha OS PKGBUILD
Here is the PKGBUILD Template we follow specifically for Snigdha OS.
```bash
# Maintainer: Your Name <your_email@provider.com>
pkgname=
org=Snigdha-OS # The username/organization username where you upload the Source Code.
branch=master # Your GitHub/GitLab/Gitea repository branch. Possible values: master, main, devlopment
pkgver= # Initiate it with 1.
pkgrel= # Initiate it with 1.
pkgdesc='' # A short description of your package.
arch=('') # Possible options: any,x86_64, arm64 etc.
url="" # Your package source code URL
license=('') # Possible options: MIT, GPL, AGPL, custom
makedepends=('') # Dependency it install or run the package
source=("") # The source of the package
sha256sums=('') # checksums
install=$pkgname.install # Further instuction after installing/building the package.
pkgver() {
printf "r%s.%s" "$(git rev-list --count HEAD)" "$(git rev-parse --short HEAD)"
}
# Since we maintain the package version with the github repository commit count an the last commit, we use pkgver() function.
# It is a good option the maintain the package version. Somtimes I forgot to change the version.
package() {
# Your package function goes here with instructions to build the package.
}
```

134
docs/dev_guide/upload_gpg_key.md
View File

@@ -1,134 +0,0 @@
---
sidebar_position: 3
---
# Upload Key => Server
### 🌐 Sending and Receiving GPG Keys Using a Key Server
Key servers are repositories for sharing and retrieving GPG public keys. They make it easy to distribute your public key and fetch others’ keys for verifying signatures or encrypted communications. Here's how to send and receive GPG keys to/from a key server.
---
### 1️⃣ **Send (Upload) Your Public Key to a Key Server**
#### A. **Export Your Key's Fingerprint**
First, identify your key by its fingerprint. List your GPG keys:
```bash
gpg --list-keys
```
Example output:
```plaintext
pub rsa4096 2023-12-05 [SC]
A41886F639658CA1A5519426E1415F19F21171F2
uid [ultimate] Eshan Roy <eshanized@example.com>
sub rsa4096 2023-12-05 [E]
```
Copy the key ID or fingerprint (e.g., `A41886F639658CA1A5519426E1415F19F21171F2`).
#### B. **Send the Key to a Key Server**
Use the following command to upload your public key to a key server:
```bash
gpg --keyserver hkp://keyserver.ubuntu.com --send-keys A41886F639658CA1A5519426E1415F19F21171F2
```
- Replace `hkp://keyserver.ubuntu.com` with your preferred key server (e.g., `keys.openpgp.org`).
- Replace the key ID with your actual key ID or fingerprint.
If successful, your public key is now available on the key server for others to retrieve.
---
### 2️⃣ **Receive (Download) a Public Key from a Key Server**
#### A. **Search for a Key by Email or Key ID**
If you know the email address or key ID of the person whose key you need, search for it:
```bash
gpg --keyserver hkp://keyserver.ubuntu.com --search-keys eshanized@example.com
```
You’ll see a list of matching keys. Example:
```plaintext
(1) Eshan Roy <eshanized@example.com>
A41886F639658CA1A5519426E1415F19F21171F2
(2) John X. Doe <eshanized@otherdomain.com>
1234EFGH5678IJKL9012MNOP3456QRST7890ABCD
```
Choose the appropriate key by typing its number (e.g., `1`) and pressing Enter.
#### B. **Receive the Key Directly by Key ID**
If you already know the key ID or fingerprint:
```bash
gpg --keyserver hkp://keyserver.ubuntu.com --recv-keys A41886F639658CA1A5519426E1415F19F21171F2
```
The public key will be downloaded and added to your keyring.
---
### 3️⃣ **Verify the Downloaded Key**
After receiving a key, verify its details to ensure it belongs to the correct person:
```bash
gpg --list-keys
```
Check the `uid` (user ID) and ensure it matches the expected email or name.
---
### 4️⃣ **Sign a Received Key (Optional)**
If you trust the key’s owner, you can sign the key to indicate trust:
```bash
gpg --sign-key A41886F639658CA1A5519426E1415F19F21171F2
```
This adds your signature to their key and shows others you vouch for its authenticity.
---
### 5️⃣ **Synchronize Keys with a Key Server**
If the key is updated (e.g., new subkeys added), synchronize it with the server:
```bash
gpg --refresh-keys
```
This ensures you have the latest version of all keys in your keyring.
---
### 6️⃣ **Tips for Key Server Usage**
- **Choose a Reliable Key Server**: Common servers include:
- `hkp://keyserver.ubuntu.com`
- `hkp://keys.openpgp.org`
- `hkp://pgp.mit.edu`
- **Use TLS for Security**:
Some key servers support HTTPS for secure communication:
```bash
gpg --keyserver hkps://keys.openpgp.org --send-keys A41886F639658CA1A5519426E1415F19F21171F2
```
- **Update Regularly**:
Synchronize your keyring periodically to stay current with any changes or revocations.
---
By following these steps, you can efficiently share your GPG public key and fetch others' keys for secure communication and verification. 🎉

14
docs/dev_guide/write.md
View File

@@ -1,14 +0,0 @@
---
sidebar_position: 6
---
# Writing Documentation
Adding documentation can help countless future of Snigdha OS users. A few ideas of what to work on:
- User guides to help Snigdha OS end users with some advanced features.
- More [frequently asked questions](/introduction/faqs).
- Expanded [troubleshooting](/category/troubleshoot) steps.
- Step-by-step tutorials for Snigdha OS [development](/category/developers-guide) or [installation](/category/installation).
- Improving literally anything else you think we should elaborate on or explain better.
A good way to find topics to write about is to look for common questions in the [support tag](https://forum.snigdhaos.org/t/support) of our community.

9
docs/installation/_category_.json
View File

@@ -1,9 +0,0 @@
{
"label": "Installation",
"position": 3,
"link": {
"type": "generated-index",
"description": "Installing Instruction"
}
}

109
docs/installation/download_snigdha_os.md
View File

@@ -1,109 +0,0 @@
---
sidebar_position: 1
---
# Download Snigdha OS
### 🌟 **Guide to Download Snigdha OS**
Snigdha OS is a beautiful Arch-based distribution that provides an intuitive and user-friendly experience, complete with eye-catching themes, performance enhancements, and pre-configured software. Here's a simple guide to help you download Snigdha OS and start using it on your system.
---
### 🔽 **Step 1: Visit the Official Snigdha OS Website**
1. **Go to the Official Snigdha OS Website**:
Open your browser and visit the official Snigdha OS website to download the ISO. The website is:
- [https://snigdhaos.org/downloads.html](https://snigdhaos.org/downloads.html)
2. **Choose Your Preferred Edition**:
Snigdha OS offers several editions based on desktop environments and use cases. Some of the most popular editions include:
- **Snigdha OS KDE Dr460nized** (KDE Plasma desktop with customizations)
- **Snigdha OS XFCE** (A lighter desktop environment)
- **Snigdha OS GNOME** (GNOME desktop environment)
- **Snigdha OS LXQt** (A very lightweight desktop environment)
- **Snigdha OS i3WM** (A minimalist tiling window manager)
Select the edition that best fits your preferences.
---
### 💻 **Step 2: Download the ISO File**
1. **Click on the Desired Edition**:
Once on the Snigdha OS download page, select the edition you want to install. The page will provide a direct download link or a mirror list for the ISO.
2. **Start the Download**:
After selecting your edition, click on the **Download** button. The file will typically be named something like:
- `snigdhaos-YYYY.MM.DD-x86_64.iso`
- Example: `snigdhaos-2024.12.01-x86_64.iso`
Wait for the download to complete. The size is typically around 2-3 GB, depending on the edition.
---
### 🔍 **Step 3: Verify the Download (Optional)**
1. **Verify the Integrity of the ISO**:
To ensure that the ISO file has not been corrupted during download, it’s a good idea to verify its checksum (SHA256 or SHA1) to compare it with the official value.
- **Check the provided checksum** on the Snigdha OS website.
- **Run the following command** in the terminal (replace the filename with your downloaded ISO file):
```bash
sha256sum snigdhaos-YYYY.MM.DD-x86_64.iso
```
- Compare the output checksum with the one on the Snigdha OS website. If they match, your download is intact.
---
### 💿 **Step 4: Create Bootable Media (USB or DVD)**
1. **Create a Bootable USB Drive on Linux**:
- **Insert your USB Drive** and check its device name using the `lsblk` command:
```bash
lsblk
```
- **Write the ISO to the USB** using the `dd` command:
```bash
sudo dd if=snigdhaos-YYYY.MM.DD-x86_64.iso of=/dev/sdX bs=4M status=progress oflag=sync
```
- Replace `/dev/sdX` with your USB drive's actual device (e.g., `/dev/sdb`).
2. **Create a Bootable USB Drive on Windows**:
- Download and install **Rufus** from [Rufus website](https://rufus.ie/).
- Insert your USB drive and launch Rufus.
- Select the Snigdha OS ISO and choose the USB drive.
- Click **Start** to create the bootable USB drive.
3. **Burn to a DVD (Optional)**:
- If you prefer a DVD, use a tool like **ImgBurn** or **Brasero** to burn the ISO to a DVD.
---
### 🚀 **Step 5: Boot from USB or DVD**
1. **Insert the Bootable USB or DVD** into the system where you want to install Snigdha OS.
2. **Enter BIOS/UEFI**:
- Restart the computer and press the key to enter BIOS/UEFI (e.g., `F2`, `DEL`, or `ESC`).
3. **Set USB/DVD as Primary Boot Device**:
- In BIOS/UEFI settings, set the USB drive or DVD as the primary boot device.
4. **Save and Reboot**:
- Save the settings and reboot. Your system should boot into the Snigdha OS live environment.
---
### 🏁 **Conclusion**
Now that you’ve successfully downloaded Snigdha OS, you are ready to move forward with installation. You can choose to use the **Calamares** graphical installer (available in Snigdha OS) for a smooth installation experience, or proceed with manual partitioning if you're an advanced user.
For more detailed installation instructions, visit the [Snigdha OS Wiki](https://wiki.snigdhaos.org/).
Enjoy the performance and beauty of Snigdha OS! 😎🚀

99
docs/installation/live_env.md
View File

@@ -1,99 +0,0 @@
---
sidebar_position: 3
---
# Live Environment
### 🌟 **Snigdha OS Live Environment: An Overview**
The **Snigdha OS Live Environment** is the initial mode you boot into when running Snigdha OS from a USB drive or DVD without installing it. It provides an opportunity to test and experience Snigdha OS before committing to the installation. The live environment allows you to explore the user interface, test hardware compatibility, and even run applications without modifying your system.
Here's everything you need to know about the **Snigdha OS Live Environment**.
---
### 🖥️ **What Is the Snigdha OS Live Environment?**
The **Live Environment** in Snigdha OS is a fully functional, bootable environment that runs directly from your USB drive or DVD without needing installation. It's a great way to:
- **Try Snigdha OS**: Get a feel for the operating system without installing it.
- **Test Hardware Compatibility**: Check if your system's hardware works well with Snigdha OS.
- **Access Tools**: Use the pre-installed tools and utilities to diagnose or repair your system.
In the live environment, you can explore Snigdha OS's features, such as the **KDE Plasma** desktop (in the default edition), graphical tools, system settings, and much more.
---
### 🌍 **Features of the Snigdha OS Live Environment**
#### 1. **Beautiful KDE Plasma Desktop**
Snigdha OS comes with a highly customized version of **KDE Plasma** as its default desktop environment. In the live environment, you can experience:
- **Eye-catching themes**: Custom themes with vibrant colors and transparent effects.
- **Pre-configured widgets**: Useful widgets like system monitoring, weather, and calendar.
- **Snigdha OS Assistant**: A tool for managing your system easily, offering options for updates, tweaks, and more.
#### 2. **Performance Optimizations**
Snigdha OS is known for its performance enhancements, and these are present in the live environment too:
- **Preconfigured optimizations** for better responsiveness and speed.
- **ZFS support**: Built-in support for advanced filesystem options like ZFS (available after installation).
- **Btrfs snapshots**: You can test out Btrfs-based snapshots and rollback features in the live environment.
#### 3. **Pre-installed Software**
The live environment comes with a wide range of pre-installed software to explore:
- **Web browser**: Typically **Firefox** or **Chromium** for web browsing.
- **Office suite**: LibreOffice or other office applications.
- **Media players**: VLC and other multimedia tools.
- **System monitoring tools**: Tools like **KSysGuard** to check system resources, and **GParted** for partitioning.
#### 4. **Hardware Compatibility Testing**
The live environment helps you test hardware compatibility before installation:
- **Graphics**: See if your graphics card works well with Snigdha OS (NVIDIA, AMD, or Intel).
- **Wi-Fi**: Test if your wireless card connects without issues.
- **Sound**: Check if your speakers or headphones work correctly.
#### 5. **Snigdha OS Welcome App**
The Snigdha OS Welcome app provides an easy-to-navigate introduction to the system, offering quick access to:
- **Installation**: Start the installation process if you're ready to install Snigdha OS.
- **Settings**: Customize settings and tweak the system.
- **Updates**: Quickly check for and apply system updates.
- **Documentation**: Access official documentation and guides to help you along the way.
#### 6. **Persistence (Optional)**
In some cases, you can configure persistence in the Snigdha OS live environment. This allows you to save changes and data across reboots, making it a more persistent experience. It is not enabled by default, but it can be set up using specific tools or settings.
---
### 🚀 **Using the Snigdha OS Live Environment**
#### 1. **Testing and Exploring**
You can explore the system freely. Here are a few things you can do:
- **Try out the desktop**: Navigate the KDE Plasma desktop, try out its features, and experience the customization that Snigdha OS provides.
- **Check out system settings**: Explore various pre-configured system settings like appearance, keyboard layout, and more.
- **Use pre-installed apps**: Open apps like Firefox, VLC, and LibreOffice to get a feel of the system’s performance.
#### 2. **Launching the Installer**
If you decide to install Snigdha OS, the live environment offers an easy-to-use graphical installer. Here's how to launch it:
- **Click the Snigdha OS Installer** icon on the desktop or in the menu.
- The installer will guide you through the process of partitioning your hard drive and setting up Snigdha OS.
- You can choose between **Btrfs**, **ext4**, or **other file systems** during installation.
#### 3. **Running Diagnostics**
If you encounter hardware issues or need to run diagnostic tests, the live environment has a range of useful tools like:
- **GParted** for managing partitions.
- **Timeshift** for system snapshots (you can install it for more advanced setups).
- **Snigdha OS Assistant** for managing system tweaks.
---
### 🏁 **When to Use Snigdha OS Live Environment**
- **Before Installing**: If you're unsure about how Snigdha OS will perform on your hardware, the live environment lets you test it out first.
- **For Repairs**: If you need to troubleshoot or repair a system, you can boot into the live environment to access system recovery tools.
- **For Exploration**: Snigdha OS's live environment is a great way to get to know the system, whether you're considering a switch from another distro or just want to see how it works.
---
### 🎉 **Conclusion**
The **Snigdha OS Live Environment** is a powerful and feature-packed way to experience Snigdha OS without committing to an installation. It offers a fully functional system with performance optimizations, a beautiful KDE Plasma desktop, pre-installed software, and various tools for hardware testing and system diagnostics.
You can use it to explore Snigdha OS, try out the desktop, check compatibility, or even install it if you're ready to make the switch. Whether you want to test, troubleshoot, or simply explore, the live environment is the perfect starting point. 😎🚀

111
docs/installation/making_bootable_usb.md
View File

@@ -1,111 +0,0 @@
---
sidebar_position: 2
---
# Bootable USB With Ventoy
### 🔥 **How to Make Snigdha OS Bootable USB with Ventoy**
Ventoy is a tool that allows you to create a bootable USB drive where you can copy multiple ISO files, and it will boot them directly without needing to format the USB drive again. This is an excellent method for creating a multi-boot USB drive with various Linux distributions, including Snigdha OS.
Here's how to use **Ventoy** to create a bootable USB with Snigdha OS:
---
### 💿 **Step 1: Download Snigdha OS ISO**
1. **Go to the Official Snigdha OS Website**:
Visit the official Snigdha OS download page:
- [https://snigdhaos.org/downloads.html](https://snigdhaos.org/downloads.html)
2. **Choose Your Desired Edition**:
Snigdha OS offers multiple desktop environments (KDE, GNOME, XFCE, etc.). Select the edition you prefer.
3. **Download the ISO**:
Click the download link for your chosen edition. The file will typically be named:
- `snigdhaos-YYYY.MM.DD-x86_64.iso`
---
### 💾 **Step 2: Download and Install Ventoy**
1. **Download Ventoy**:
Visit the official Ventoy website:
- [https://www.ventoy.net](https://www.ventoy.net)
2. **Download the Latest Version**:
Download the latest stable version of Ventoy for your operating system. You will get a compressed file.
3. **Extract the Compressed File**:
Extract the downloaded Ventoy archive to a folder.
---
### 💻 **Step 3: Create Bootable USB with Ventoy**
#### **For Linux Users**
1. **Insert Your USB Drive**:
Plug in your USB drive (at least 4 GB). Use the `lsblk` command to check the device name (e.g., `/dev/sdX`).
2. **Install Ventoy on the USB**:
Navigate to the Ventoy folder, open a terminal, and run the following command (replace `/dev/sdX` with your USB device):
```bash
sudo ./Ventoy2Disk.sh -i /dev/sdX
```
This will install Ventoy onto the USB drive. It will create a Ventoy partition and make the USB drive bootable.
3. **Wait for the Process to Complete**:
Once the process finishes, your USB drive is ready to use with Ventoy installed.
#### **For Windows Users**
1. **Insert the USB Drive**:
Plug in your USB drive (minimum 4 GB).
2. **Run Ventoy as Administrator**:
Extract the Ventoy zip file and run `Ventoy2Disk.exe` as Administrator.
3. **Select the USB Drive**:
In the Ventoy tool, select the USB drive you want to use.
4. **Install Ventoy on the USB Drive**:
Click **Install** to install Ventoy on the USB. Confirm that you want to overwrite any existing data on the USB drive.
---
### 🔄 **Step 4: Copy Snigdha OS ISO to the USB**
1. **Copy the Snigdha OS ISO**:
Once Ventoy is installed on your USB drive, simply copy the **Snigdha OS ISO** (e.g., `snigdhaos-YYYY.MM.DD-x86_64.iso`) to the USB drive. You can copy and paste it like any other file.
2. **You Can Add More ISOs**:
You can also copy additional ISOs to the USB drive to make a multi-boot USB drive with other Linux distributions.
---
### 🚀 **Step 5: Boot from USB Using Ventoy**
1. **Insert the USB Drive into the Target Computer**:
Plug the USB drive into the computer where you want to install Snigdha OS.
2. **Enter BIOS/UEFI**:
Restart the computer and enter the BIOS/UEFI by pressing the appropriate key (often `F2`, `DEL`, or `ESC`).
3. **Set USB as the Primary Boot Device**:
In BIOS/UEFI, set the USB drive as the first boot device.
4. **Save and Reboot**:
Save the settings and reboot. The system will boot into Ventoy’s boot menu.
5. **Select Snigdha OS**:
In the Ventoy boot menu, you’ll see a list of ISOs on the USB. Select **Snigdha OS** and press Enter to boot from it.
---
### 🎉 **Conclusion**
Congratulations! You've successfully created a Snigdha OS bootable USB drive using **Ventoy**. This method allows you to keep multiple Linux distributions on one USB stick, making it incredibly convenient for testing or installing multiple distros.
Enjoy your experience with Snigdha OS! 😎🚀

153
docs/installation/offline_install.md
View File

@@ -1,153 +0,0 @@
---
sidebar_position: 4
---
# Offline Installation
### 🖥️ **How to Install Snigdha OS in Offline Mode**
Installing Snigdha OS in **offline mode** means performing the installation without an active internet connection. While Snigdha OS's installation typically requires an internet connection to fetch updates and additional packages, it’s still possible to install it offline using the installation ISO and pre-downloaded packages. This method is especially useful if you're in an environment with limited or no internet access.
Here's a step-by-step guide to install Snigdha OS in **offline mode**:
---
### 📥 **Step 1: Download Snigdha OS ISO**
1. **Go to the Official Snigdha OS Website**:
Visit the Snigdha OS download page:
- [Snigdha OS Downloads](https://snigdhaos.org/downloads.html)
2. **Download the ISO File**:
Select your preferred edition (KDE, GNOME, etc.) and download the ISO file. This will be used to create the bootable USB.
3. **Optionally Download Extra Packages**:
If you know you will need additional packages (like drivers or software that may not be included in the ISO), it’s a good idea to download them beforehand using another system that has internet access. You can use a tool like **Pacman** to download packages:
```bash
sudo pacman -Sw package_name
```
---
### 💾 **Step 2: Create a Bootable USB Drive**
You need a **bootable USB** to install Snigdha OS. Use **Ventoy** or **Rufus** (for Windows) or the `dd` command (for Linux) to create a bootable USB drive.
#### **For Linux Users (Using `dd`)**
1. **Insert USB Drive**:
Plug in a USB drive (at least 4 GB).
2. **Find USB Drive Location**:
Use the `lsblk` command to identify your USB drive:
```bash
lsblk
```
3. **Create Bootable USB**:
Run the `dd` command to copy the Snigdha OS ISO to your USB drive (replace `/dev/sdX` with your USB device path):
```bash
sudo dd if=snigdhaos-YYYY.MM.DD-x86_64.iso of=/dev/sdX bs=4M status=progress oflag=sync
```
4. **Eject USB**:
After the process finishes, safely eject the USB:
```bash
sudo eject /dev/sdX
```
#### **For Windows Users (Using Rufus)**
1. **Download and Install Rufus**:
Download **Rufus** from [https://rufus.ie/](https://rufus.ie/) and install it.
2. **Open Rufus** and Select the USB Drive.
3. **Choose the Snigdha OS ISO** and select the appropriate **Partition Scheme** (usually **GPT** for modern systems).
4. **Start the Process**:
Click **Start** to create a bootable USB. Wait for it to complete.
---
### 🔌 **Step 3: Boot into Snigdha OS Live Environment**
1. **Insert the Bootable USB** into the target system.
2. **Enter BIOS/UEFI**:
Restart the system and press the appropriate key (often `F2`, `DEL`, or `ESC`) to enter BIOS/UEFI.
3. **Set USB as Primary Boot Device**:
In the BIOS/UEFI settings, set the USB drive as the first boot device.
4. **Save and Reboot**:
Save the changes and reboot the system. It will boot into the Snigdha OS live environment.
---
### ⚙️ **Step 4: Install Snigdha OS Offline**
1. **Launch the Installer**:
In the live environment, click on the **Snigdha OS Installer** icon on the desktop or in the application menu.
2. **Select Language and Region**:
Follow the prompts to select your language, region, and keyboard layout.
3. **Partitioning**:
Choose the disk where you want to install Snigdha OS. You can either let the installer automatically partition your disk or choose manual partitioning for more control.
- **Btrfs** is the default filesystem used by Snigdha OS.
- You can set up **LVM** or **ZFS** if you want advanced features.
4. **Offline Mode Warning**:
The installer will ask for an internet connection to fetch updates and additional software. **Ignore this step** since you are installing in offline mode. Proceed without an internet connection.
5. **User Configuration**:
- Set up your **username** and **password**.
- Configure **root password** if required.
6. **Installation Location**:
Confirm the partition where you want to install Snigdha OS. Double-check the partitions to avoid data loss.
7. **Begin Installation**:
Click on the **Install** button to start the installation. The system will copy files from the ISO to the target disk.
---
### 🔄 **Step 5: Install Pre-Downloaded Packages (Optional)**
If you have pre-downloaded additional packages or software (like drivers, codecs, or essential tools), you can install them during or after the installation process:
1. **Mount the USB with Packages**:
If the packages are on another USB or disk, you can mount it to the system during installation using the terminal.
2. **Use Pacman to Install Packages**:
Once Snigdha OS is installed and you’ve booted into the system, use the `pacman` package manager to install any pre-downloaded packages:
```bash
sudo pacman -U /path/to/package_file.pkg.tar.zst
```
Replace `/path/to/package_file.pkg.tar.zst` with the actual path to the downloaded package.
---
### ⚙️ **Step 6: Final Steps and Reboot**
1. **Configure Your System**:
Once the installation is complete, you may need to configure your system settings, such as display resolution, Wi-Fi (if available), and user preferences.
2. **Reboot the System**:
After installation, **reboot** your system and remove the USB drive.
3. **Boot into Snigdha OS**:
Your system should boot into Snigdha OS. If you set up a **dual-boot** with other operating systems, you’ll see the bootloader menu to choose the OS.
4. **Offline Setup**:
If you have any additional software or updates that need to be installed, you can use the **offline package manager** to install them later when you have an internet connection.
---
### 🎉 **Conclusion**
You’ve now installed Snigdha OS in **offline mode**! While some post-installation updates and software installation may require an internet connection, this method allows you to set up and use Snigdha OS in environments with no or limited internet access. This installation method is ideal for areas with poor connectivity, or for advanced users who want to configure their system fully offline.
Enjoy your new Snigdha OS setup! 😎🚀

175
docs/installation/online_install.md
View File

@@ -1,175 +0,0 @@
---
sidebar_position: 5
---
# Online Installation
### 🌐 **How to Install Snigdha OS Online (With Internet Connection)**
Snigdha OS is a powerful and feature-packed distribution, and the **online installation** method provides the easiest and most efficient way to install Snigdha OS. This method requires an active internet connection to download the latest updates, packages, and additional software during the installation process.
Here's a detailed step-by-step guide to install **Snigdha OS** using the **online installation** method:
---
### 📥 **Step 1: Download Snigdha OS ISO**
1. **Go to the Official Snigdha OS Website**:
Visit the Snigdha OS download page:
- [Snigdha OS Downloads](https://snigdhaos.org/downloads.html)
2. **Select Your Preferred Edition**:
Snigdha OS offers various desktop environments like KDE, GNOME, XFCE, and more. Choose the one that suits your preference.
3. **Download the ISO File**:
Click on the link for the desired edition to download the ISO file. The file will typically be named:
- `snigdhaos-linux-YYYY.MM.DD-x86_64.iso`
---
### 💾 **Step 2: Create a Bootable USB Drive**
You’ll need to create a bootable USB to install Snigdha OS. You can use **Ventoy**, **Rufus** (for Windows), or **dd** (for Linux) to create the bootable USB.
#### **For Linux Users (Using `dd`)**
1. **Insert USB Drive**:
Plug in a USB drive with at least 4 GB capacity.
2. **Identify USB Drive**:
Use the `lsblk` command to identify the device (e.g., `/dev/sdX`):
```bash
lsblk
```
3. **Create Bootable USB**:
Run the following `dd` command to copy the Snigdha OS ISO to your USB (replace `/dev/sdX` with your USB device path):
```bash
sudo dd if=snigdhaos-linux-YYYY.MM.DD-x86_64.iso of=/dev/sdX bs=4M status=progress oflag=sync
```
4. **Eject USB**:
After the process is complete, safely eject the USB:
```bash
sudo eject /dev/sdX
```
#### **For Windows Users (Using Rufus)**
1. **Download and Install Rufus**:
Download **Rufus** from [https://rufus.ie/](https://rufus.ie/) and install it.
2. **Open Rufus** and Select the USB Drive.
3. **Choose Snigdha OS ISO** and Select the Partition Scheme:
Choose **GPT** for UEFI-based systems and **MBR** for legacy BIOS systems.
4. **Start the Process**:
Click **Start** to create the bootable USB. Wait until it’s done.
---
### 🔌 **Step 3: Boot Into Snigdha OS Live Environment**
1. **Insert the Bootable USB** into the computer where you want to install Snigdha OS.
2. **Enter BIOS/UEFI**:
Restart the system and enter the BIOS/UEFI settings (usually by pressing a key like `F2`, `DEL`, or `ESC`).
3. **Set USB as the First Boot Device**:
In the BIOS/UEFI settings, set the USB drive as the first boot device.
4. **Save and Reboot**:
Save your settings and reboot the computer. It will boot into the Snigdha OS live environment.
---
### ⚙️ **Step 4: Start the Online Installation Process**
1. **Launch the Installer**:
Once the system boots into the Snigdha OS live environment, you’ll see a **Snigdha OS Installer** icon on the desktop. Click it to begin the installation.
2. **Select Language and Region**:
Choose your preferred language, region, and keyboard layout.
3. **Connect to the Internet**:
- **Wi-Fi**: Click on the network icon in the system tray and select your Wi-Fi network.
- **Wired Connection**: If you’re using a wired connection, the system should automatically connect to the internet.
4. **Choose Installation Type**:
You’ll have two main options:
- **Erase disk and install Snigdha OS**: Automatically partitions and installs Snigdha OS (use this if you want a clean install).
- **Manual partitioning**: If you want more control over your partitions, select this option to manually create and set partitions.
---
### 💻 **Step 5: Partitioning and Disk Setup**
1. **Select the Disk**:
Choose the disk where you want to install Snigdha OS.
2. **Automatic Partitioning (Recommended)**:
- **Erase and Install**: Select this if you want to overwrite the entire disk with Snigdha OS.
- **Manual Partitioning**: Select this if you want to set up partitions manually, allowing you to configure the disk layout.
3. **Filesystem Choices**:
- Snigdha OS uses **Btrfs** by default. You can also select **ext4** or **LVM** if preferred.
4. **Confirm and Continue**:
Confirm your partition settings and proceed. The installer will format the disk and prepare it for the installation.
---
### 🧑‍💻 **Step 6: User Configuration**
1. **Create Your User**:
Set up your **username** and **password**. You’ll also need to set the **root password**.
2. **Timezone and Locale**:
Choose your **timezone** and **locale**. The installer should detect your location automatically, but you can adjust it if needed.
---
### 🌐 **Step 7: Installing Snigdha OS**
1. **Download Updates and Packages**:
Since you’re installing online, the installer will fetch the latest updates and packages during the process. This requires an active internet connection. The installer will download:
- **System updates**
- **Additional packages** (drivers, codecs, utilities, etc.)
2. **Begin Installation**:
Click the **Install** button to start the installation process. Snigdha OS will now be installed on your disk. This process may take some time, depending on your internet speed and disk performance.
---
### 🔄 **Step 8: Finalize the Installation**
1. **Wait for Installation to Complete**:
The installation process will copy files, install software, and configure the system. This may take 15-30 minutes or more, depending on your system and internet speed.
2. **Reboot the System**:
Once the installation is complete, you’ll be prompted to reboot the system. Remove the installation USB stick and reboot into Snigdha OS.
3. **Boot into Snigdha OS**:
Your computer will now boot into Snigdha OS. If you installed it alongside another operating system, you will see the **GRUB bootloader** to select your OS.
---
### 🎉 **Step 9: Post-Installation Setup**
1. **Set Up Your System**:
After booting into Snigdha OS, you may need to:
- **Install additional software** using the **Snigdha OS Assistant** or **Pacman**.
- **Update the system** if needed:
```bash
sudo pacman -Syu
```
2. **Enjoy Your New Snigdha OS System**:
Once everything is set up, you can start using Snigdha OS, explore the KDE Plasma desktop, install apps, and customize your system!
---
### 🎉 **Conclusion**
You’ve now successfully installed **Snigdha OS** using the **online installation** method! The online installation ensures you get the latest updates and packages during the installation process, making the system up-to-date as soon as it’s ready. Enjoy using Snigdha OS and all its powerful features! 😎🚀

155
docs/installation/virtualbox_installation.md
View File

@@ -1,155 +0,0 @@
---
sidebar_position: 7
---
# Virtualbox
### 🖥️ **How to Install Snigdha OS in VirtualBox**
Installing **Snigdha OS** in **VirtualBox** is a great way to test or use Snigdha OS in a virtual environment without affecting your main system. Here's a detailed step-by-step guide to help you get Snigdha OS running in VirtualBox.
---
### 📥 **Step 1: Download Snigdha OS ISO**
1. **Go to the Official Snigdha OS Website**:
Visit the official Snigdha OS download page:
- [Snigdha OS Downloads](https://snigdhaos.org/downloads.html)
2. **Download the ISO File**:
Choose the edition (KDE, GNOME, XFCE, etc.) and download the ISO file. The file will be something like:
- `snigdhaos-YYYY.MM.DD-x86_64.iso`
---
### 💾 **Step 2: Install and Set Up VirtualBox**
1. **Download and Install VirtualBox**:
- **For Windows**: Download from [VirtualBox Website](https://www.virtualbox.org/).
- **For macOS**: Download from [VirtualBox Website](https://www.virtualbox.org/).
- **For Linux**: You can install it via your package manager:
```bash
sudo pacman -S virtualbox # For Arch Linux and derivatives
sudo apt install virtualbox # For Ubuntu/Debian
sudo dnf install virtualbox # For Fedora
```
2. **Launch VirtualBox**:
After installation, launch **VirtualBox** from your applications menu.
---
### ⚙️ **Step 3: Create a New Virtual Machine**
1. **Click on "New"**:
Open VirtualBox and click on the **New** button to create a new virtual machine.
2. **Set the Name and Type**:
- **Name**: Choose a name for your virtual machine (e.g., "Snigdha OS").
- **Type**: Select **Linux**.
- **Version**: Select **Linux 2.6 / 3.x / 4.x (64-bit)** (or a similar option depending on the version of Snigdha OS).
3. **Allocate Memory**:
- Assign **at least 2 GB of RAM** (more is recommended if your system can handle it). The default setting is usually fine, but you can increase it if you want better performance.
4. **Create a Virtual Hard Disk**:
- **Virtual Hard Disk Type**: Choose **VDI** (VirtualBox Disk Image).
- **Storage on Physical Hard Disk**: Choose **Dynamically allocated** (this will allow the virtual disk to grow as needed).
- **Size**: Allocate **at least 20 GB** of disk space (the more the better, depending on your needs).
---
### 💿 **Step 4: Mount the Snigdha OS ISO**
1. **Go to Settings**:
After creating the virtual machine, click on the **Settings** button.
2. **Mount the ISO**:
- Go to the **Storage** tab.
- Under **Controller: IDE**, click the empty **disk icon** and then click **Choose a disk file**.
- Select the Snigdha OS ISO file you downloaded earlier.
---
### 🔄 **Step 5: Configure Virtual Machine Settings (Optional)**
1. **Adjust Display Settings**:
- Go to the **Display** tab in the settings and increase the **Video Memory** to at least 64 MB to ensure smooth graphics.
- Enable **3D Acceleration** (if your hardware supports it) for better performance.
2. **Network Settings**:
- In the **Network** tab, ensure that the adapter is set to **Attached to NAT** (this allows the virtual machine to access the internet).
---
### 🔌 **Step 6: Start the Virtual Machine and Install Snigdha OS**
1. **Start the Virtual Machine**:
Click the **Start** button in VirtualBox.
2. **Boot from the ISO**:
The virtual machine will boot from the Snigdha OS ISO. You’ll see the Snigdha OS **Live Session** screen. If it doesn't boot, make sure the ISO is properly mounted in the **Storage** section.
3. **Launch the Installer**:
Once in the live environment, click on the **Garuda Installer** icon on the desktop to start the installation process.
---
### ⚙️ **Step 7: Install Snigdha OS**
1. **Select Language and Region**:
Choose your **language**, **keyboard layout**, and **timezone**.
2. **Partitioning**:
- If you're using a single disk, you can choose **Erase disk and install Garuda** for automatic partitioning.
- Alternatively, select **Manual Partitioning** if you need to create custom partitions.
3. **User Configuration**:
- Set your **username**, **password**, and **root password**.
- Choose **Btrfs** as the default filesystem for Garuda (or ext4 if preferred).
4. **Start the Installation**:
After configuring your settings, click **Install** to begin the installation process. The installer will copy files, install packages, and set up your system.
---
### 🔄 **Step 8: Complete the Installation and Reboot**
1. **Wait for Installation to Finish**:
The installation may take a while, depending on the speed of your system and the amount of software being installed. The progress will be shown in the installer.
2. **Reboot the Virtual Machine**:
Once the installation is complete, the installer will prompt you to reboot the system. Click **Reboot Now** and remove the ISO file from the virtual drive in VirtualBox.
---
### 🖥️ **Step 9: Boot into Snigdha OS**
1. **Reboot**:
After the installation, reboot the virtual machine. It will boot into your new **Snigdha OS** installation.
2. **Login**:
Enter the **username** and **password** you set during the installation to log into Snigdha OS.
---
### 🎉 **Step 10: Post-Installation Steps**
1. **Update the System**:
After logging in, open a terminal and update your system:
```bash
sudo pacman -Syu
```
2. **Install Additional Software**:
You can install additional software using the **Garuda Assistant** or the **Pacman** package manager.
3. **Enjoy Snigdha OS**:
Now that your Snigdha OS is installed and running in VirtualBox, you can explore the KDE Plasma desktop or the desktop environment you chose during the installation.
---
### 🎉 **Conclusion**
You’ve successfully installed **Snigdha OS** in **VirtualBox**! This method allows you to run Snigdha OS on your system without affecting your main operating system. VirtualBox provides an isolated environment where you can experiment with Snigdha OS, install software, and test configurations.
Enjoy exploring Snigdha OS! 😎🚀

9
docs/introduction/_category_.json
View File

@@ -1,9 +0,0 @@
{
"label": "Introduction",
"position": 1,
"link": {
"type": "generated-index",
"description": "Let's get a short overview!"
}
}

52
docs/introduction/code_of_conduct.md
View File

@@ -1,52 +0,0 @@
---
sidebar_position: 3
---
# Code of Conduct
A code of conduct outlines expected behavior and guidelines for individuals within a specific community, organization, or group.
:::info
It is mandatory to follow our **Code of Conduct**.
:::
**Introduction:**
[Snigdha OS Forum](https://forum.snigdhaos.org/) is dedicated to providing a respectful, inclusive, and safe environment for all members, regardless of race, ethnicity, gender, sexual orientation, disability, age, religion, or any other characteristic. This Code of Conduct outlines the principles and guidelines that all members are expected to follow to maintain a positive and welcoming atmosphere.
**📌 Respect and Inclusivity:**
- Treat all members with respect, kindness, and empathy.
- Value diverse perspectives and experiences, and avoid discriminatory or offensive language and behavior.
- Be mindful of the impact your words and actions may have on others, and strive to create an environment where everyone feels valued and included.
**📌 Professionalism:**
- Conduct yourself in a professional manner at all times, both online and offline.
- Refrain from engaging in personal attacks, harassment, or bullying of any kind.
- Resolve disagreements and conflicts constructively and respectfully, focusing on finding solutions rather than assigning blame.
**📌 Integrity and Honesty:**
- Be honest and transparent in your interactions with fellow members and stakeholders.
- Avoid spreading false information or engaging in deceptive practices.
- Respect the confidentiality of sensitive information shared within the organization/community.
**📌 Collaboration and Cooperation:**
- Foster a culture of collaboration, cooperation, and teamwork.
- Support and encourage fellow members, and be willing to offer assistance and guidance when needed.
- Value constructive feedback and use it as an opportunity for growth and improvement.
**📌 Accountability:**
- Take responsibility for your words and actions, and acknowledge and learn from mistakes.
- Hold yourself and others accountable for upholding the principles and guidelines outlined in this Code of Conduct.
- Report any violations of the Code of Conduct to the appropriate authorities or designated individuals within the organization/community.
**📌 Safety and Well-being:**
- Prioritize the safety and well-being of all members, both physically and emotionally.
- Refrain from engaging in behavior that may endanger or harm others.
- Report any concerns or incidents related to safety or well-being to the appropriate authorities or designated individuals promptly.
**📌 Compliance and Enforcement:**
- Comply with all applicable laws, regulations, and policies, both within and outside the organization/community.
- Violations of this Code of Conduct may result in disciplinary action, up to and including suspension or expulsion from the organization/community.
- The enforcement of this Code of Conduct will be administered fairly and impartially, with due process and consideration for all parties involved.
>**Conclusion:**
By adhering to this Code of Conduct, we can create a supportive and inclusive community where all members can thrive and contribute positively to our shared goals and objectives. Thank you for your commitment to upholding these principles and for helping to maintain a respectful and welcoming environment for everyone.

158
docs/introduction/coding-standard.md
View File

@@ -1,158 +0,0 @@
---
sidebar_position: 8
---
# Coding Standard
### ✨ **Coding Standards for Snigdha OS Development**
To ensure that Snigdha OS maintains a high-quality codebase, it’s essential to follow these coding standards. These guidelines promote readability, maintainability, and collaboration while ensuring the code remains efficient and secure. 🚀
---
### 1️⃣ **Consistent Naming Conventions**
✅ Use meaningful and descriptive names for variables, functions, and classes.
✅ Stick to a consistent naming convention across the codebase:
- **camelCase** for variables and functions.
- **PascalCase** for classes and constructors.
- **snake_case** for constants and configuration keys.
---
### 2️⃣ **Indentation and Formatting**
✅ Use consistent indentation (2 or 4 spaces preferred). Avoid using tabs.
✅ Follow a consistent formatting style (e.g., braces alignment, spacing).
✅ Limit line length to 80-100 characters for better readability.
✅ Remove unnecessary whitespaces and trailing spaces.
---
### 3️⃣ **Comments**
✅ Add comments to explain complex logic, algorithms, or unusual decisions.
✅ Keep comments concise, relevant, and synchronized with code changes.
✅ Avoid obvious comments like `// Incrementing i by 1`.
```javascript
// Good Example:
function calculateTax(income) {
// Calculates tax based on progressive slabs.
...
}
```
---
### 4️⃣ **Modularity and Code Reusability**
✅ Break down code into small, reusable functions or modules.
✅ Group related functionalities into classes or namespaces for better organization.
---
### 5️⃣ **Error Handling**
✅ Use proper error-handling mechanisms like `try-catch` blocks or error codes.
✅ Avoid exposing internal logic in error messages.
```python
try:
result = perform_operation()
except ValueError as e:
print("Invalid input. Please try again.") # Avoid exposing "ValueError: details"
```
---
### 6️⃣ **Code Readability**
✅ Write simple and clear code. Avoid unnecessary complexity.
✅ Use descriptive variable and function names instead of single-letter identifiers.
✅ Favor clarity over cleverness.
---
### 7️⃣ **Consistent Code Style**
✅ Follow the style guide for the programming language used (e.g., PEP 8 for Python, ESLint for JavaScript).
✅ Adopt consistent practices for spacing, indentation, and braces placement.
---
### 8️⃣ **Documentation**
✅ Document every function, class, and module with clear descriptions.
✅ Include parameter details, return values, and potential exceptions in documentation.
```python
def calculate_area(radius):
"""
Calculates the area of a circle.
Args:
radius (float): The radius of the circle.
Returns:
float: The area of the circle.
"""
return 3.14 * radius ** 2
```
---
### 9️⃣ **Testing**
✅ Write unit tests for all critical functionality.
✅ Aim for at least 80% code coverage.
✅ Automate tests where possible with frameworks like `pytest`, `Jest`, or `JUnit`.
---
### 🔟 **Version Control**
✅ Use Git for version control. Follow branching strategies like **Git Flow**.
✅ Write clear, descriptive commit messages in the [Conventional Commits](https://www.conventionalcommits.org) format:
```
feat: add feature for user authentication
fix: resolve bug in payment gateway integration
docs: update README with installation steps
```
---
### 1️⃣1️⃣ **Performance Considerations**
✅ Write efficient algorithms with optimal time and space complexity.
✅ Avoid unnecessary loops, nested loops, or redundant operations.
✅ Use lazy loading or caching for heavy computations or data fetching.
---
### 1️⃣2️⃣ **Security**
✅ Sanitize and validate all user inputs.
✅ Use parameterized queries for database operations to avoid SQL injection.
✅ Regularly audit code for vulnerabilities like XSS, CSRF, or buffer overflows.
---
### 1️⃣3️⃣ **Dependencies and Third-party Libraries**
✅ Use only necessary and trusted libraries.
✅ Keep dependencies updated to ensure compatibility and fix vulnerabilities.
---
### 1️⃣4️⃣ **Internationalization (i18n) and Localization (l10n)**
✅ Design code to support multiple languages and locales.
✅ Externalize strings into resource files for easy translation.
---
### 1️⃣5️⃣ **Accessibility**
✅ Ensure UI components follow accessibility standards (e.g., WCAG).
✅ Provide alternative text for images and ensure keyboard navigation.
---
### 1️⃣6️⃣ **Concurrency and Thread Safety**
✅ For concurrent operations, write thread-safe code to avoid race conditions.
✅ Use synchronization mechanisms like locks or semaphores.
---
### 🔑 **Key Principles**
1️⃣ **Readability**: Write code as if the next person maintaining it is you in six months.
2️⃣ **Modularity**: Make changes easier by keeping code decoupled and modular.
3️⃣ **Consistency**: Adopt a uniform style to avoid confusion and ensure maintainability.
Following these standards will not only improve code quality but also foster a collaborative and professional environment. Happy coding! 🎉👩‍💻👨‍💻

96
docs/introduction/contributing.md
View File

@@ -1,96 +0,0 @@
---
sidebar_position: 7
---
# Contribution Guidelines
### ✨ **Contribution Guidelines for Snigdha OS**
Thank you for your interest in contributing to **Snigdha OS**! We’re excited to have you join our community. Contributions from users like you make Snigdha OS better, stronger, and more impactful. 💻💙
---
### 🚀 **Getting Started**
Before contributing, please make sure to:
📜 **Read Our Code of Conduct**: By participating, you agree to uphold our Code of Conduct, ensuring a welcoming and respectful environment for everyone.
---
### 🌟 **How Can You Contribute?**
There are many ways to make a difference! Choose what suits you best:
#### 🐞 **Reporting Bugs**
Encountered a bug? Let us know by opening an issue on our **issue tracker**!
- **Option 1**: If you're unsure about the repository causing the bug, raise the issue on our [universal issue tracker](https://github.com/SnigdhaOS/Issues).
- **Option 2**: If you know the specific repository, raise the issue there.
👉 Be sure to include:
- Steps to reproduce the bug.
- Expected behavior vs. actual behavior.
- Screenshots, logs, or any additional information that might help us debug the issue.
#### 🌟 **Requesting Features**
Got an idea to make Snigdha OS even better? Open a feature request issue on our **issue tracker** and let us know your vision! Your feedback is invaluable to shaping the future of Snigdha OS.
#### 👩‍💻 **Code Contributions**
Want to contribute code? Follow these steps:
1️⃣ **Fork** the repository to your GitHub account. Learn [how to fork a GitHub repository](https://docs.github.com/en/get-started/quickstart/fork-a-repo).
2️⃣ **Clone** the forked repository to your local machine. Learn [how to clone a GitHub repository](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository).
3️⃣ **Create a New Branch** for your changes. Learn [how to create branches](https://git-scm.com/book/en/v2/Git-Branching-Basic-Branching-and-Merging).
4️⃣ Make your changes and ensure they align with our coding standards.
5️⃣ Write tests to cover your changes (if applicable).
6️⃣ Run existing tests to ensure they still pass.
7️⃣ **Commit** your changes with clear, descriptive commit messages. Follow [Conventional Commits](https://www.conventionalcommits.org/).
8️⃣ **Push** your changes to your forked repository.
9️⃣ Open a **pull request (PR)** against the `master` branch of our repository. Learn [how to open a PR](https://docs.github.com/en/pull-requests).
🔟 Provide a clear description in your PR, explaining your changes and any context the reviewers should know.
#### 📚 **Improving Documentation**
Clear documentation is key! If you find areas for improvement in our docs (typos, errors, missing details), submit a pull request with your suggested edits.
---
### 🎨 **Code Standards**
To maintain a high-quality codebase, please:
- Follow the coding style guide for the project's language.
- Write **clear, concise comments** to explain your code.
- Add **tests** for new functionality.
- Ensure commits are **atomic** and focused on single logical changes.
- Use descriptive commit messages following the [Conventional Commits format](https://www.conventionalcommits.org/).
- Update documentation if your changes affect functionality.
---
### 🛠️ **Code Review Process**
All contributions go through a review process to ensure quality and consistency:
1️⃣ Your pull request will be assigned to one or more reviewers.
2️⃣ Reviewers will provide feedback and may suggest changes.
3️⃣ You’ll need to address any feedback by updating your code.
4️⃣ Once your changes meet all standards, your PR will be merged into the main branch.
---
### 📜 **Code of Conduct**
By contributing, you agree to abide by our **Code of Conduct**. This ensures that Snigdha OS remains a welcoming and inclusive space. Violations may result in rejection of contributions or removal from the project. Be kind, respectful, and supportive! 💕
---
### 💬 **Need Help?**
We’re here to help you get started and make meaningful contributions! Reach out to us:
📧 **Email**: hello@snigdhaos.org
---
### ❤️ **Join Us in Building Snigdha OS**
Your contributions—whether code, documentation, or ideas—are essential to our success. Together, let’s make Snigdha OS the best it can be. Thank you for being part of our journey! 🌟
> "Alone, we can do so little; together, we can do so much." – Helen Keller
Let’s create something amazing! 🚀✨

45
docs/introduction/faqs.md
View File

@@ -1,45 +0,0 @@
---
sidebar_position: 6
---
# Frequently Asked
Here are some frequently asked questions (FAQs) about Snigdha OS (penetration distribution):
**📌 What is penetration distribution?**
Penetration distribution refers to the process of distributing penetration testing tools and techniques across different areas of a network or system to identify vulnerabilities and potential entry points for attackers.
**📌 Why is penetration distribution important?**
Penetration distribution is important because it helps security professionals identify and address vulnerabilities before attackers can exploit them. By thoroughly testing various aspects of a network or system, organizations can better protect their assets and data from cyber threats.
**📌 What are some common penetration distribution techniques?**
Common penetration distribution techniques include network scanning, vulnerability assessment, exploitation of known vulnerabilities, social engineering, phishing attacks, and physical security testing. These techniques aim to identify weaknesses in different layers of a network or system.
**📌 How does penetration distribution differ from traditional security testing?**
Penetration distribution goes beyond traditional security testing by employing a broader range of techniques and tools to assess the security posture of an organization's infrastructure. It involves simulating real-world attack scenarios to uncover vulnerabilities that may not be detected by standard security measures.
**📌 What are the benefits of using penetration distribution services?**
The benefits of penetration distribution services include improved security posture, reduced risk of data breaches, compliance with regulatory requirements, enhanced incident response capabilities, and increased confidence in the effectiveness of security controls.
**📌 How often should penetration distribution be conducted?**
Penetration distribution should be conducted regularly, ideally as part of a comprehensive security testing program. The frequency of testing may vary depending on factors such as the organization's risk profile, industry regulations, and changes to the IT environment.
**📌 What are some best practices for conducting penetration distribution?**
Best practices for conducting penetration distribution include defining clear objectives and scope, obtaining appropriate permissions and approvals, using the latest tools and techniques, documenting findings thoroughly, prioritizing remediation efforts based on risk, and conducting post-test debriefings to identify lessons learned.
**📌 How can organizations ensure the confidentiality and integrity of penetration distribution results?**
Organizations can ensure the confidentiality and integrity of penetration distribution results by restricting access to sensitive information, encrypting data in transit and at rest, using secure communication channels, and implementing proper access controls and authentication mechanisms.
**📌 What are the limitations of penetration distribution?**
Limitations of penetration distribution include the inability to guarantee the absence of all vulnerabilities, the potential for disruption to normal business operations, the reliance on assumptions and estimations, and the need for ongoing monitoring and maintenance to address emerging threats.
**📌 How can organizations measure the effectiveness of penetration distribution efforts?**
Organizations can measure the effectiveness of penetration distribution efforts by tracking key performance indicators (KPIs) such as the number of vulnerabilities identified and remediated, the time to detect and respond to incidents, the cost-effectiveness of security controls, and improvements in overall security posture over time.

68
docs/introduction/motivation.md
View File

@@ -1,68 +0,0 @@
---
sidebar_position: 8
---
# Aim & Motivation
### ✨ **Aim & Motivation of Snigdha OS**
Snigdha OS is not just another Linux distribution; it’s a carefully crafted platform built with purpose, efficiency, and innovation in mind. Here’s a detailed breakdown of its aim and motivation:
---
### 🎯 **Aim**
**Snigdha OS** aims to provide:
1️⃣ A **lightweight and efficient** Linux distribution for diverse hardware, from older machines to mobile devices and virtual environments.
2️⃣ A **customizable platform** tailored to specific use cases, particularly **penetration testing** and **ethical hacking**.
3️⃣ An operating system that bridges the gap between **professional cybersecurity practitioners** and **enthusiasts or learners**, ensuring accessibility and ease of use.
4️⃣ A **secure and innovative ecosystem** that fosters experimentation, collaboration, and advancements in cybersecurity.
---
### 💡 **Motivation**
#### **1️⃣ Resource Efficiency & Versatility**
Snigdha OS is motivated by the need for an operating system that runs efficiently on a wide range of hardware. Whether it's an older PC, a virtual environment, or a low-power device, Snigdha OS ensures optimal performance without compromising functionality.
---
#### **2️⃣ Minimalism & Customization**
Inspired by the philosophy of minimalism, Snigdha OS provides users with a clean slate—a base system that can be customized to meet individual needs.
- Users can build their environment from scratch, tailoring it with tools and features for **penetration testing** and **ethical hacking**.
- This approach minimizes bloat and maximizes usability.
---
#### **3️⃣ Security-Centric Design**
Security is at the heart of Snigdha OS:
- It is **hardened and optimized** for ethical hacking tasks, ensuring that users have a reliable platform for vulnerability assessments and cybersecurity practices.
- Pre-installed tools and configurations streamline ethical hacking workflows, saving time and reducing setup complexity.
---
#### **4️⃣ Empowering Learning & Professional Growth**
Snigdha OS supports both:
- **Experienced professionals** who need a dependable penetration testing platform.
- **Learners and enthusiasts** who want to explore cybersecurity in a structured, user-friendly environment.
Educational resources, documentation, and community support provide a nurturing space for users to grow and contribute.
---
#### **5️⃣ Fostering Innovation**
Snigdha OS encourages:
- Experimentation with **new tools, techniques, and methodologies** in the cybersecurity domain.
- A community-driven approach where users and developers collaborate, exchange ideas, and contribute improvements.
- Transparency and accessibility through its **open-source** model, ensuring that anyone can participate, learn, and innovate.
---
### 🌍 **Community-Driven Vision**
At its core, Snigdha OS is more than just software; it’s a platform for collaboration, growth, and exploration in cybersecurity. The community plays a crucial role in shaping its evolution by:
- Contributing code and tools.
- Sharing insights and expertise.
- Creating documentation and educational content.
Snigdha OS thrives on this collective effort, enabling innovation while upholding the principles of **open-source freedom**.
---
Snigdha OS is motivated by a vision of empowering users with a lightweight, secure, and customizable platform that not only meets current cybersecurity challenges but also inspires future advancements. 🚀🌟

31
docs/introduction/name_and_story.md
View File

@@ -1,31 +0,0 @@
---
sidebar_position: 2
---
# Story & Name
### 🌟 **The Story and Name Behind Snigdha OS**
#### 💡 **The Name**
The name **Snigdha OS** carries a deeply personal significance to its creator, **Eshan Roy**, widely known as **eshanized**. As the **founder, lead maintainer, and developer** of Snigdha OS, Eshan drew inspiration for the name from **Mubasshira Snigdha**, a figure of immense importance in his life.
Initially, the project was known by its codename **"Project N"** during the early development phase. However, when the first official release was launched on **December 31, 2023**, Eshan chose to rebrand it as **Snigdha OS** to honor Mubasshira Snigdha’s memory.
Eshan, the **former CEO of Tonmoy Infrastructure**, continues to receive unwavering support from the company. Tonmoy Infrastructure remains a key backer of Snigdha OS, ensuring its development thrives. 🚀
---
#### 💔 **The Story**
Behind the name lies a heartfelt and poignant story. **Mubasshira Snigdha**, Eshan Roy’s late girlfriend, tragically passed away in **18th June, 2023**. Her untimely departure left a profound impact on Eshan, inspiring him to immortalize her memory through his work.
Naming the project **Snigdha OS** was Eshan’s way of creating a **living tribute** to her—a meaningful endeavor that would preserve her name and legacy. Through this operating system, her memory continues to inspire users and developers worldwide. 💻💙
Snigdha OS is not just a technological creation—it’s a testament to love, loss, and the enduring power of remembrance. The operating system embodies a vision for innovation while standing as a beautiful memorial to Mubasshira Snigdha’s impact on Eshan's life.
---
### ✨ **A Legacy Beyond Code**
Snigdha OS represents more than an open-source Linux distribution; it is a bridge between technology and human connection. It’s a project fueled by passion, personal meaning, and the unwavering determination to turn loss into inspiration.
Through **Snigdha OS**, Mubasshira Snigdha’s name will continue to resonate, not only in Eshan's heart but also in the global community of users who benefit from his work. 🌍
Let Snigdha OS inspire you, not only as a powerful tool but also as a reminder that the stories we carry can shape the world in profound ways. ❤️✨

159
docs/introduction/overview.md
View File

@@ -1,159 +0,0 @@
---
sidebar_position: 1
slug: /
---
# Overview
### 🌟 **Overview of Snigdha OS**
Snigdha OS is a 🌟 **lightweight** and 🛠️ **highly customizable** Linux distribution built on ⚙️ Arch Linux and powered by the 🚀 **Linux Zen Kernel**. Crafted with a focus on 🎯 **minimalism** and 🌈 **user-centric design**, it offers a smooth and seamless experience for both 🖥️ **general usage** and 🔒 **penetration testing**.
The ecosystem features a dedicated 🛡️ **penetration testing distribution** and **Blackbox** 🧰, a custom framework for efficiently managing security tools.
**Powered by:** 💡 TONMOY INFRASTRUCTURE.
🚀 **Features of Snigdha OS**
As a **penetration testing distribution**, Snigdha OS offers a robust suite of features designed to empower security professionals. Here's what makes it stand out:
📌 **Tailored Toolset**
Snigdha OS comes with a pre-installed arsenal of penetration testing tools for tasks like network scanning, vulnerability assessment, and exploitation. 🛠️ Everything you need, ready to go!
💡 *Tip:* Expand your toolkit using the **Online Installation** method during setup or via **Blackbox** post-installation.
📌 **Customization and Optimization**
Fine-tune the OS to maximize performance, minimize resource usage, and streamline workflows—perfect for efficient and focused penetration testing.
📌 **Security-Focused**
Built with security as a priority:
- 🛡️ Features like **SELinux** or **AppArmor**
- 🔥 Strict firewall rules
- ❌ Disables unnecessary services to reduce the attack surface
📌 **Documentation and Support**
Comprehensive **documentation** and an active **community** make Snigdha OS beginner-friendly. From tool usage to troubleshooting, you'll have guidance every step of the way.
🛠️ *Contribute:* Help us improve our documentation!
📌 **Learning Opportunities**
Perfect for education and training, Snigdha OS offers a controlled environment to explore penetration testing tools and techniques—great for workshops, certifications, and aspiring security pros. 📚
📌 **Consistency and Reproducibility**
Standardized tools and configurations ensure **consistent results** across different testing environments—essential for compliance audits and routine security assessments. ✅
📌 **Portability and Accessibility**
Designed to work seamlessly on:
- 🖥️ **Physical hardware**
- 📦 **Virtual machines**
- ☁️ **Cloud instances**
📌 **Legal and Ethical Compliance**
Snigdha OS includes clear licenses and guidelines to promote ethical penetration testing, helping users stay aligned with industry standards. ⚖️
📌 **Innovation and Experimentation**
Be part of the **future of cybersecurity**! Contribute to creating cutting-edge tools, techniques, and methodologies that redefine possibilities in penetration testing. ✨
**Snigdha OS**: Your ultimate ally in penetration testing and cybersecurity exploration. 🌐
🎯 **Purposes of Snigdha OS**
Snigdha OS embraces the core values of **open-source development**: **transparency**, **collaboration**, and **innovation**. Here's how it aligns with these principles:
📌 **Transparency**
🔍 The source code is fully open and accessible, fostering trust by allowing anyone to inspect, verify, and enhance the system's security.
📌 **Community Collaboration**
🌍 Contributions from a global community ensure continuous improvement, the addition of innovative features, and robust, peer-reviewed development practices.
📌 **Accessibility**
📖 Freely available to all, Snigdha OS promotes inclusivity and adaptability, ensuring it meets diverse user needs.
📌 **Innovation**
💡 Snigdha OS inspires creativity, encouraging developers to experiment and design groundbreaking features and solutions that benefit everyone.
📌 **Freedom**
🛠️ No vendor lock-in! Users have the freedom to modify, customize, and share the OS according to their preferences.
📌 **Security**
🔒 A vigilant community promptly identifies and patches vulnerabilities, delivering a secure and reliable computing experience.
📌 **Stability and Reliability**
⚙️ Rigorously tested for consistent performance, Snigdha OS provides a dependable platform for various use cases.
📌 **Education and Learning**
🎓 Ideal for learning Linux systems, programming, and cybersecurity techniques through hands-on exploration—perfect for both beginners and experts.
Snigdha OS: Empowering a collaborative, innovative, and secure future in open-source computing. 🚀
### ❤️ **How You Can Help Snigdha OS**
Snigdha OS thrives on community contributions. Here’s how you can support us:
#### 📌 **For Developers**
- Contribute to the Snigdha OS codebase or packages.
- Create new tools and features that benefit the community.
#### 📌 **For Writers**
- Improve our documentation for better user onboarding.
- Write blogs, articles, or guides to help others understand Snigdha OS better.
#### 📌 **For Translators**
- Help translate Snigdha OS into multiple languages, making it accessible to a broader audience.
#### 📌 **Financial Support**
- Donations via **GitHub Sponsors** or **OpenCollective** help cover operational costs.
- Financial support has enabled us to fund core developers in the past.
#### 📌 **For Users**
- Report bugs or suggest features through **GitHub Issues**.
- Engage with the Snigdha OS community to share your experience and help newcomers.
#### 📌 **Spread the Word**
- Blog, tweet, or talk about Snigdha OS! Increased awareness brings more contributors and accelerates development.
> **Community matters!** Join us to build, improve, and make Snigdha OS better together.
### 🌟 **Conclusion**
Snigdha OS is more than just an operating system—it’s a community-driven project aimed at empowering users through transparency, security, and innovation. Whether you're a developer, learner, or enthusiast, there’s a place for you in the Snigdha OS ecosystem. Together, let’s create a better, more secure future in computing! 💻✨

41
docs/introduction/release_notes.md
View File

@@ -1,41 +0,0 @@
---
sidebar_position: 4
---
# Release Notes
**FOR IMMEDIATE RELEASE**
28-04-2024
Email: [hello@snigdhaos.org](mailto:hello@snigdhaos.org)
**BE SILENT WHEN IT IS TIME TO HEAR!**
**SNIGDHAOS** is thrilled to announce the release of its latest operating system, **SNIGDHA OS ARCTIC V** <ins>(Refers as **Arctic V**)</ins>. This cutting-edge software represents a significant advancement in user experience, security, and performance.
**ARCTIC V** boasts an array of innovative features designed to streamline productivity and enhance usability for both personal and professional users. With a sleek and intuitive interface, users can navigate seamlessly between applications and tasks, allowing for smoother multitasking and increased efficiency.
Key features of **ARCTIC V** include:
1. **Enhanced Security:** **ARCTIC V** incorporates state-of-the-art security measures to safeguard user data and protect against cyber threats. Advanced encryption protocols and real-time threat detection ensure peace of mind for users in an increasingly interconnected world.
2. **Improved Performance:** Leveraging the latest advancements in technology, **ARCTIC V** delivers lightning-fast performance and responsiveness. Whether launching applications, browsing the web, or executing complex tasks, users can expect unparalleled speed and reliability.
3. **Seamless Integration:** **ARCTIC V** seamlessly integrates with a wide range of devices and platforms, allowing for effortless connectivity and synchronization across devices. Whether accessing files from a smartphone, tablet, or desktop computer, users can enjoy a seamless experience without missing a beat.
4. **Personalization Options:** **ARCTIC V** offers extensive customization options, allowing users to tailor their experience to suit their unique preferences and workflow. From customizable desktop backgrounds to personalized settings and preferences, users have the flexibility to make **ARCTIC V** their own.
[Quote from Company Spokesperson/CEO]: "**ARCTIC V** represents the culmination of months of hard work and dedication from our team. We are incredibly proud of the result and confident that users will love the experience it offers."
**ARCTIC V** is now available for download on [Your Company Name]'s website and will be pre-installed on all new [Device Name] devices. For more information, visit [Website URL].
About [Your Company Name]:
[Your Company Name] is a leading provider of innovative software solutions, dedicated to delivering exceptional user experiences across a wide range of platforms and devices. With a commitment to innovation and excellence, [Your Company Name] continues to push the boundaries of technology to empower users around the globe.
For media inquiries, please contact:
[Your Name]
[Your Title]
[Your Company Name]
[Your Phone Number]
[Your Email Address]
> IT IS A SAMPLE RELEASE NOT TEMPLATE!

32
docs/introduction/reporting_bugs.md
View File

@@ -1,32 +0,0 @@
---
sidebar_position: 5
---
# Reporting Bugs
:::danger Vulnerabilities
If you discover a security vulnerability within Snigdha OS as well as any packages and tools, please follow our [security policy](https://github.com/Snigdha-OS/snigdhaos-arctic/security/policy) so we can address it promptly.
:::
Thank you for helping us test Snigdha OS. We're happy to have you on the team! We need people who can *troubleshoot issues patiently* and *communicate them clearly*. As you probably know, good bug reporting takes some time and effort. If you're fine with that, then let's get started!
## Duplicates
Found a bug already? Wonderful! We'd love to hear about it &mdash; but first you should check around to make sure you're not wasting your time on a known issue:
- Search our [Support forum](https://forum.snigdhaos.org/t/support) to see if it's already been reported.
- We could be working on a fix, so search our [issue tracker](https://github.com/Snigdha-OS/snigdhaos-issues/issues) too.
If you've searched *thoroughly* and come up empty-handed, we'll welcome your report. If it's just a simple issue (a misspelled word or graphics glitch, for example) skip to the next paragraph. But if you're seeing errors, or something is clearly broken, we'll need you to gather some information first. Please head over to our [Troubleshooting](/category/troubleshoot) guide and follow the instructions there. Collect as much info as you can!
## Reporting
We track issues on GitHub. Make sure you open your issue in the [correct repository](https://github.com/Snigdha-OS), and fill out all of the information in the Bug Report template.
If you can, check if the issue is reproducible with the latest version of Snigdha OS. If you are using a pre-release or development version, please indicate the specific version you are using.
Remember: the goal of a bug report is to make it easy for us to replicate the bug and fix it. You might want to read [this article](/blog/effective_bug_report) for some useful tips on how to write an effective bug report. It is **required** that you clearly describe the steps necessary to reproduce the issue you are running into. Issues with no clear reproduction steps will not be triaged. If an issue labeled "needs verification" receives no further input from the issue author for more than 5 days, it will be closed.
> Once you've posted your report, we'd ask that you please *follow the discussion* and wait patiently. We may need to ask for further details or clarification; but we've always got plenty to do, and it could be a while before we can give your report the time it deserves.

9
docs/packages/_category_.json
View File

@@ -1,9 +0,0 @@
{
"label": "Packages",
"position": 7,
"link": {
"type": "generated-index",
"description": "Troubleshoot"
}
}

4
docs/packages/snigdhaos_blackbox.md
View File

@@ -1,4 +0,0 @@
---
sidebar_position: 2
---
# Blackbox

4
docs/packages/snigdhaos_welcome.md
View File

@@ -1,4 +0,0 @@
---
sidebar_position: 1
---
# Welcome

9
docs/post_installation/_category_.json
View File

@@ -1,9 +0,0 @@
{
"label": "Post Installation",
"position": 4,
"link": {
"type": "generated-index",
"description": "After installing Snigdha OS"
}
}

174
docs/post_installation/customization.md
View File

@@ -1,174 +0,0 @@
---
sidebar_position: 3
---
# Customize Snigdha OS
### 🖌️ **Guide to Customizing Snigdha OS**
Snigdha OS, with its polished look and powerful tools, is highly customizable. Whether you want to tweak the desktop environment, improve system performance, or add your personal touch, this guide will walk you through the steps to make Snigdha OS your own.
---
### ⚙️ **Step 1: Select Your Desktop Environment (DE)**
Snigdha OS comes with several desktop environments, such as KDE Plasma, GNOME, XFCE, i3, and more. Customization options depend on your DE.
- **KDE Plasma**: Highly customizable with themes, widgets, and layouts.
- **GNOME**: Simplistic and clean with extensions.
- **XFCE**: Lightweight and minimalistic with theming options.
#### To install additional DEs:
```bash
sudo pacman -S xfce4 gnome
```
---
### 🎨 **Step 2: Change Themes**
Snigdha OS includes **Snigdha OS Settings Manager** for managing themes, icons, and cursors.
#### Using Snigdha OS Settings Manager:
1. Open **Snigdha OS Settings Manager** from the application menu.
2. Navigate to the **Appearance** or **Desktop Theme** section.
3. Select and apply a **theme**, **icon pack**, or **cursor**.
#### For KDE Plasma:
1. Go to **System Settings → Appearance**.
2. Customize:
- **Global Theme**: Change the entire desktop look.
- **Plasma Style**: Adjust panel and widget styles.
- **Icons**: Pick a new icon set.
- **Application Style**: Change the window and button styles.
#### Installing New Themes:
1. Open **System Settings → Appearance → Get New Themes**.
2. Browse and install themes, icons, or cursors.
3. Apply them from the same menu.
---
### 📂 **Step 3: Customize Widgets and Panels**
Widgets and panels enhance functionality and aesthetics.
#### For KDE Plasma:
- Right-click on the desktop or panel and select **Add Widgets**.
- Drag and drop widgets to the desired location.
- Adjust panel size, position, and contents by right-clicking the panel and selecting **Edit Panel**.
---
### 🖼️ **Step 4: Change Wallpapers**
Snigdha OS comes with stunning default wallpapers, but you can easily add your own.
#### Steps:
1. Right-click on the desktop and select **Configure Desktop** (KDE) or **Change Background** (GNOME).
2. Select a wallpaper from the list or **Add Image** to upload your own.
#### Online Wallpapers:
Install dynamic wallpaper applications like **Komorebi** or use online wallpaper tools.
---
### 🖥️ **Step 5: Modify the GRUB Bootloader**
Customize the GRUB bootloader for a personal touch.
#### Install a GRUB Theme:
1. Install `grub-customizer`:
```bash
sudo pacman -S grub-customizer
```
2. Open GRUB Customizer and select a theme.
3. Save and reboot to see the changes.
---
### 💡 **Step 6: Add Extensions and Plugins**
Extensions add extra functionality to your desktop environment.
#### For GNOME:
1. Install `gnome-shell-extensions`:
```bash
sudo pacman -S gnome-shell-extensions
```
2. Use the **GNOME Extensions** website ([extensions.gnome.org](https://extensions.gnome.org)) to enable and manage extensions.
#### For KDE:
Use the **KDE Store** to download and manage plugins, scripts, and widgets.
---
### 🔧 **Step 7: Adjust Performance Settings**
Snigdha OS includes tools for optimizing performance.
#### Using Snigdha OS Assistant:
1. Open **Snigdha OS Assistant**.
2. Enable performance tweaks like **ZRAM**, **CPU governor**, or **RAM optimization**.
3. Use **System Cleaner** to remove unnecessary files.
#### Manage Startup Applications:
Disable unnecessary startup applications to improve boot time:
1. Open **Startup and Shutdown** in **System Settings**.
2. Uncheck apps you don’t need at startup.
---
### 🔍 **Step 8: Install Useful Applications**
Snigdha OS includes essential applications, but you can add more tools to suit your workflow.
#### Example Commands:
- **Install a Web Browser**:
```bash
sudo pacman -S firefox
```
- **Install a Terminal Emulator**:
```bash
sudo pacman -S alacritty
```
- **Install AUR Packages** (e.g., Google Chrome):
```bash
yay -S google-chrome
```
---
### 🖥️ **Step 9: Configure Keybindings**
Set custom keyboard shortcuts for frequently used actions.
#### KDE Plasma:
1. Open **System Settings → Shortcuts**.
2. Customize global shortcuts for applications and system actions.
#### GNOME:
1. Open **Settings → Keyboard → Custom Shortcuts**.
2. Add and modify shortcuts for specific commands or actions.
---
### 🎵 **Step 10: Customize Sounds**
You can change system sounds to add a unique auditory flair.
#### KDE Plasma:
1. Open **System Settings → Audio → Event Sounds**.
2. Choose and apply custom sound themes.
---
### 🛡️ **Step 11: Enable Gaming Tweaks**
Snigdha OS has a **Gaming Edition** optimized for gaming, but you can also add tweaks manually.
#### Install Gaming Tools:
1. Install **Lutris** for managing game libraries:
```bash
sudo pacman -S lutris
```
2. Install **Steam**:
```bash
sudo pacman -S steam
```
3. Enable **GameMode** for performance:
```bash
sudo pacman -S gamemode
```
---
### 🚀 **Conclusion**
Snigdha OS is one of the most customizable Linux distributions, offering endless possibilities to tailor your desktop. From themes to performance tweaks, you can make it your perfect operating system. Dive in, experiment, and enjoy your personalized Linux experience! 🎉

110
docs/post_installation/install_packages.md
View File

@@ -1,110 +0,0 @@
---
sidebar_position: 4
---
# Install Packages
### 📦 **How to Install a Package on Snigdha OS**
Installing packages on Snigdha OS primarily involves using the **Pacman** package manager or an **AUR helper** for community-contributed software. Here's a step-by-step guide:
---
### 🛠️ **Step 1: Update Your System**
Before installing a package, ensure your system is up-to-date to avoid dependency issues:
```bash
sudo pacman -Syu
```
---
### 📂 **Step 2: Search for a Package**
To find the package you want to install, use the following command:
```bash
pacman -Ss package-name
```
#### Example:
Search for the Firefox browser:
```bash
pacman -Ss firefox
```
This command displays available packages with "firefox" in their name or description.
---
### ✅ **Step 3: Install the Package**
Once you know the exact package name, install it using:
```bash
sudo pacman -S package-name
```
#### Example:
Install Firefox:
```bash
sudo pacman -S firefox
```
---
### 📦 **Step 4: Verify Installation**
To check if a package is installed:
```bash
pacman -Q package-name
```
#### Example:
Verify Firefox installation:
```bash
pacman -Q firefox
```
---
### 🔍 **Step 5: Explore Package Details**
View information about an installed package:
```bash
pacman -Qi package-name
```
#### Example:
```bash
pacman -Qi firefox
```
---
### 🌐 **Installing AUR Packages**
If the package you want is not in the official repositories but is available in the **Arch User Repository (AUR)**, use an AUR helper like `yay` or `paru`.
#### Install a Package from AUR
```bash
yay -S package-name
```
#### Example:
Install Google Chrome from AUR:
```bash
yay -S google-chrome
```
---
### 🧹 **Clean Up After Installation**
After installing a package, clean up unused dependencies (optional):
```bash
sudo pacman -Rns $(pacman -Qdtq)
```
---
### ⚠️ **Tips**
1. **Enable Parallel Downloads**: To speed up installation, enable parallel downloads in `/etc/pacman.conf` by adding:
```
ParallelDownloads = 5
```
2. **Use Trusted Sources**: Only install AUR packages from trusted sources and review the `PKGBUILD` file before installation.
---
### 🎉 **Conclusion**
Installing packages on Snigdha OS is straightforward with `pacman`. For additional software, AUR helpers like `yay` expand the possibilities. With these tools, you can access a vast array of software tailored to your needs! 🚀

83
docs/post_installation/language.md
View File

@@ -1,83 +0,0 @@
---
sidebar_position: 1
---
# Language
### 🌐 **Installing Language Packs and Google Fonts on Arch/Snigdha OS**
Here’s how you can install language packs for better localization support and Google Fonts for enhanced typography.
---
### 🌏 **Step 1: Install Language Packs**
#### **Step 1.1: Install System Language Pack**
Language packs are provided by the desktop environment or specific applications. For example:
- **KDE Plasma**:
```bash
sudo pacman -S plasma-desktop kde-l10n
```
- **GNOME**:
```bash
sudo pacman -S gnome-shell gnome-getting-started-docs
```
#### **Step 1.2: Enable Your Preferred Language**
1. Open **System Settings** → **Regional Settings** or **Language**.
2. Select and add your desired language.
3. Apply the changes and reboot if necessary.
#### **Step 1.3: Install Additional Fonts for Localization**
To display text correctly in specific languages (e.g., CJK, Arabic):
```bash
sudo pacman -S noto-fonts noto-fonts-cjk noto-fonts-emoji noto-fonts-extra
```
---
### ✍️ **Step 2: Install Google Fonts**
Google Fonts can be installed to enhance the typography for web design, office applications, or general use.
#### **Option 1: Install via Pacman**
Arch Linux provides a package for Google Fonts:
```bash
sudo pacman -S ttf-google-fonts
```
#### **Option 2: Install via AUR**
For the latest collection of Google Fonts, use an AUR helper like `yay`:
```bash
yay -S ttf-google-fonts-git
```
#### **Option 3: Manual Installation**
1. Download the fonts:
- Visit the [Google Fonts](https://fonts.google.com/) website.
- Select and download your desired font(s).
2. Extract and install:
```bash
mkdir -p ~/.local/share/fonts
unzip /path/to/downloaded-fonts.zip -d ~/.local/share/fonts
```
3. Refresh the font cache:
```bash
fc-cache -fv
```
---
### 🧹 **Step 3: Verify Installation**
- **Check Available Fonts**:
```bash
fc-list | grep "font-name"
```
- Test the fonts in applications like LibreOffice, GIMP, or your web browser.
---
### 🎉 **Conclusion**
With language packs and Google Fonts installed, your system will be well-suited for multilingual usage and professional-grade typography. Enjoy customizing your experience! 🚀

106
docs/post_installation/update.md
View File

@@ -1,106 +0,0 @@
---
sidebar_position: 2
---
# Update Snigdha OS
### 🔄 **How to Update Snigdha OS**
Snigdha OS, based on Arch Linux, uses a **rolling release model**, meaning you always have access to the latest updates. Keeping your system up-to-date ensures stability, security, and access to the latest features.
Follow these steps to safely and effectively update your Snigdha OS system:
---
### 🔧 **Step 1: Open the Terminal**
Press `Ctrl + Alt + T` to open the terminal or use the **Konsole** or any terminal emulator installed on your system.
---
### 🔄 **Step 2: Update the System**
Run the following commands to update your Snigdha OS system:
#### **Basic Update Command**
Use **Pacman** (the default package manager) to synchronize and upgrade packages:
```bash
sudo pacman -Syu
```
#### **Snigdha OS Assistant (Optional)**
Snigdha OS provides a GUI tool called **Snigdha OS Assistant** for system management, including updates.
- Open **Snigdha OS Assistant** from the application menu.
- Click on **Update System** and follow the prompts.
#### **With AUR Packages (Using an AUR Helper)**
If you use AUR packages, update them alongside system packages with a tool like `yay` or `paru`:
```bash
yay -Syu
```
---
### 🛠️ **Step 3: Rebuild Outdated Configurations**
After major updates, especially those involving the kernel or critical system components, rebuild configurations to avoid issues. Snigdha OS makes this easy with:
```bash
sudo pacman -S linux-headers
```
If you use the **ZRAM** feature or **custom kernels**, ensure they're updated and aligned with the current system kernel.
---
### 🧹 **Step 4: Clean Up Unused Packages**
Remove unused or orphaned packages to free up space:
```bash
sudo pacman -Rns $(pacman -Qdtq)
```
Clear the package cache to save disk space (Snigdha OS already does this automatically with **paccache**):
```bash
sudo paccache -r
```
---
### 🚀 **Step 5: Reboot Your System**
If a kernel or other core system components were updated, reboot your system to apply the changes:
```bash
reboot
```
---
### 🌟 **Tips for Safe Updates**
1. **Use Snigdha OS's Snapshot Feature**:
- Snigdha OS uses **Btrfs** snapshots via **Timeshift**. If something goes wrong during an update, you can roll back to a previous working state.
- Before updating, create a manual snapshot:
```bash
sudo timeshift --create
```
2. **Check for Arch News**:
Before major updates, check the **Arch Linux News** page for important announcements:
- [Arch Linux News](https://archlinux.org/news/)
3. **Run Updates Regularly**:
Snigdha OS is a rolling release, so it's important to update frequently to avoid large, time-consuming updates and potential conflicts.
---
### 💻 **Example Commands**
Here’s a single command for a complete update, including AUR packages and cleaning up:
```bash
sudo pacman -Syu && yay -Syu && sudo pacman -Rns $(pacman -Qdtq)
```
---
### 🎉 **Conclusion**
Keeping Snigdha OS updated is straightforward and ensures you always have the latest features and security patches. With tools like **Snigdha OS Assistant**, **Pacman**, and **Timeshift**, managing updates is efficient and safe. 🚀

9
docs/tools/_category_.json
View File

@@ -1,9 +0,0 @@
{
"label": "Tools",
"position": 9,
"link": {
"type": "generated-index",
"description": "Troubleshoot"
}
}

154
docs/tools/aircrack-ng.md
View File

@@ -1,154 +0,0 @@
---
sidebar_position: 2
---
# Aircrack-NG
### 🔐 **Aircrack-ng: A Complete Guide with Installation on Snigdha OS**
**Aircrack-ng** is a powerful suite of tools used for monitoring, testing, cracking, and securing Wi-Fi networks. This guide will cover how to install Aircrack-ng on Snigdha OS and explain its key tools. Let’s dive in! 🚀
---
### 🛠️ **How to Install Aircrack-ng on Snigdha OS**
1. **Update Your System**:
Always ensure your system is up-to-date before installing new software:
```bash
sudo pacman -Syu
```
2. **Install Aircrack-ng**:
Aircrack-ng is available in the official Snigdha OS repositories:
```bash
sudo pacman -S aircrack-ng
```
3. **Verify Installation**:
Check that Aircrack-ng is installed correctly by running:
```bash
aircrack-ng --help
```
If installed successfully, you'll see a list of commands and options. ✅
---
### 🧰 **Aircrack-ng Tools Overview**
The Aircrack-ng suite includes several tools for various purposes:
1. **Airmon-ng (Monitor Mode Enabler) 🛰️**
Enables monitor mode on your wireless network interface.
**Usage**:
```bash
sudo airmon-ng start wlan0
```
This sets your `wlan0` device to monitor mode, allowing you to capture Wi-Fi traffic.
2. **Airodump-ng (Packet Capture) 📡**
Captures packets and displays information about nearby wireless networks.
**Usage**:
```bash
sudo airodump-ng wlan0mon
```
Replace `wlan0mon` with your monitor-enabled interface. It displays SSIDs, BSSIDs, channels, and more.
3. **Aireplay-ng (Packet Injection) 🎯**
Injects packets to test network security or deauthenticate clients.
**Usage**:
Deauthenticate a client to capture a handshake:
```bash
sudo aireplay-ng --deauth 10 -a <BSSID> -c <CLIENT_MAC> wlan0mon
```
- `<BSSID>`: MAC address of the target access point.
- `<CLIENT_MAC>`: MAC address of the client.
4. **Aircrack-ng (Password Cracker) 🔓**
Cracks WPA/WPA2 passwords using captured handshakes.
**Usage**:
```bash
aircrack-ng -w wordlist.txt -b <BSSID> capture_file.cap
```
- `wordlist.txt`: File containing potential passwords.
- `capture_file.cap`: Packet capture file with the handshake.
5. **Airdecap-ng (Decrypt Packets) 🔐**
Decrypts WEP/WPA-encrypted packets after obtaining keys.
**Usage**:
```bash
airdecap-ng -w <WPA_KEY> capture_file.cap
```
---
### 🔍 **Example Workflow: Cracking WPA/WPA2**
1. **Enable Monitor Mode**:
Start monitoring with Airmon-ng:
```bash
sudo airmon-ng start wlan0
```
2. **Capture Packets**:
Use Airodump-ng to scan for networks:
```bash
sudo airodump-ng wlan0mon
```
Focus on a target by capturing packets on its channel:
```bash
sudo airodump-ng --bssid <BSSID> --channel <CHANNEL> --write capture wlan0mon
```
3. **Deauthenticate a Client**:
Force a client to reconnect to capture the WPA handshake:
```bash
sudo aireplay-ng --deauth 10 -a <BSSID> -c <CLIENT_MAC> wlan0mon
```
4. **Crack the Handshake**:
Use Aircrack-ng with a wordlist to crack the password:
```bash
aircrack-ng -w wordlist.txt -b <BSSID> capture-01.cap
```
---
### ⚠️ **Important Notes**
1. **Ethical Use Only**:
Always obtain explicit permission before testing any network. Unauthorized use is illegal.
2. **Hardware Compatibility**:
Ensure your wireless card supports monitor mode and packet injection. Popular chipsets include **Atheros** and **Realtek**.
3. **Wordlist Quality**:
Cracking success depends on your wordlist. Use comprehensive wordlists like `rockyou.txt` or generate custom ones.
4. **Alternative Tools**:
Combine Aircrack-ng with tools like **hashcat** for advanced cracking.
---
### 🚀 **Resources and Further Learning**
- [Official Aircrack-ng Documentation](https://aircrack-ng.org/)
- Tutorials on ethical Wi-Fi testing and network security.
---
By following this guide, you’re equipped to install and use Aircrack-ng effectively. Remember to use these tools responsibly and ethically. Happy testing! 🎉

148
docs/tools/dns.md
View File

@@ -1,148 +0,0 @@
---
sidebar_position: 1
---
# DNS Enum
### 🌐 **DNS Enumeration (DNS Enum)**
DNS Enumeration (DNS Enum) is the process of discovering information about a domain's DNS records. This information can reveal a lot about a domain, including subdomains, mail servers, nameservers, and other vital data. It’s an essential part of the information gathering phase in penetration testing and network reconnaissance. Let’s dive into what DNS enumeration is and how to perform it.
---
### 🧰 **Tools for DNS Enumeration**
1. **DNSenum**: A popular command-line tool used for DNS enumeration.
2. **Dig**: A flexible tool for querying DNS records.
3. **Fierce**: A DNS reconnaissance tool.
4. **NSLookup**: Another tool for querying DNS records, commonly used for simple DNS lookups.
---
### 🔨 **How to Perform DNS Enumeration with `dnsenum`**
1. **Install `dnsenum` on Arch Linux**:
If you're using Arch Linux or an Arch-based distro, you can install `dnsenum` from the official repositories:
```bash
sudo pacman -S dnsenum
```
For other Linux distributions, you might need to install it using `apt` (Ubuntu/Debian) or `yum` (CentOS).
2. **Basic DNS Enumeration with `dnsenum`**:
To perform basic DNS enumeration on a domain, simply run:
```bash
dnsenum example.com
```
This command will attempt to gather information like:
- **Name Servers (NS)**
- **Mail Servers (MX)**
- **Subdomains**
- **Hostnames**
- **Zone Transfers**
3. **Advanced Options for `dnsenum`**:
`dnsenum` provides several options to enhance your scan:
- **Perform Reverse DNS Lookups**:
```bash
dnsenum --reverse example.com
```
- **Brute Force Subdomains** (using a wordlist):
```bash
dnsenum --subnet example.com
```
This option will attempt to find subdomains of the target domain by brute-forcing common subdomains.
- **Perform a Zone Transfer** (if allowed):
```bash
dnsenum --zonetransfer example.com
```
If the DNS server is misconfigured and allows zone transfers, it will return a list of all records for the domain.
---
### 🔍 **Using `dig` for DNS Queries**
`dig` (Domain Information Groper) is another useful tool for DNS enumeration. It's more flexible and can perform specific queries to gather detailed information about DNS records.
1. **Query for A Record (IP Address)**:
```bash
dig example.com A
```
2. **Query for MX (Mail Servers)**:
```bash
dig example.com MX
```
3. **Query for NS (Name Servers)**:
```bash
dig example.com NS
```
4. **Query for SOA (Start of Authority)**:
```bash
dig example.com SOA
```
5. **Reverse Lookup for IP**:
```bash
dig -x <IP_Address>
```
---
### 🧩 **What You Can Discover with DNS Enumeration**
1. **Subdomains**:
Subdomains are important as they may reveal hidden services or vulnerabilities. For example, `mail.example.com`, `ftp.example.com`, etc.
2. **Name Servers (NS Records)**:
These provide the names of the DNS servers authoritative for the domain. Misconfigured NS records could reveal valuable information.
3. **Mail Servers (MX Records)**:
Identifying mail servers helps in attacking email systems or phishing campaigns.
4. **Start of Authority (SOA)**:
The SOA record contains information about the DNS zone, including the primary DNS server, admin email, and serial numbers.
5. **Zone Transfer**:
In the event a DNS server is misconfigured, it may allow a zone transfer, which would give an attacker access to a list of all DNS records for the domain.
---
### ⚠️ **Important Considerations**
- **Legality**:
Always perform DNS enumeration on domains you own or have explicit permission to scan. Unauthorized DNS enumeration may be illegal in certain jurisdictions.
- **Rate Limiting**:
Be mindful of rate-limiting policies. Large-scale DNS enumeration can trigger rate-limiting or blocking by DNS servers.
- **Avoiding Detection**:
Some advanced domains may have mechanisms to detect and block enumeration attempts. Using VPNs or proxy servers can help you avoid detection, but always stay ethical.
---
### 🏁 **Conclusion**
DNS enumeration is a powerful technique to gather critical information about a domain. By using tools like `dnsenum`, `dig`, and `fierce`, you can discover DNS records, subdomains, name servers, and more, which are valuable for both security assessments and network troubleshooting.
Remember to always use DNS enumeration responsibly and ensure you have proper authorization! 🎉

9
docs/troubleshoot/_category_.json
View File

@@ -1,9 +0,0 @@
{
"label": "Troubleshoot",
"position": 6,
"link": {
"type": "generated-index",
"description": "Troubleshoot"
}
}

68
docs/troubleshoot/bluetooth.md
View File

@@ -1,68 +0,0 @@
---
sidebar_position: 2
---
# Troubleshoot: Bluetooth
Troubleshooting Bluetooth on Snigdha OS involves several steps. Here's the common practice:
1. **Check Hardware Compatibility**: Ensure that your Bluetooth hardware is supported and recognized by the system.
2. **Ensure Bluetooth is enabled**: Use the following command to check if Bluetooth is enabled:
```
systemctl status bluetooth
```
If it's not enabled, start the service using:
```
sudo systemctl start bluetooth
```
And enable it to start on boot:
```
sudo systemctl enable bluetooth
```
3. **Update System**: Make sure your system and all packages are up-to-date:
```
sudo pacman -Syu
```
or,
```
update
```
5. **Check Bluetooth Service Status**: Verify that the Bluetooth service is running without errors:
```
sudo systemctl status bluetooth
```
6. **Check for Device Recognition**: Ensure that your Bluetooth device is recognized by the system:
```
bluetoothctl
```
Then, use the command `list` to see if your device is listed.
7. **Restart Bluetooth Service**: Sometimes restarting the Bluetooth service can resolve connectivity issues:
```
sudo systemctl restart bluetooth
```
8. **Check for Interference**: Bluetooth signals can be interfered with by other wireless devices. Move the Bluetooth device closer to your computer and away from other wireless devices.
9. **Check for Driver Issues**: Ensure that you have the necessary Bluetooth drivers installed. Most Linux distributions include drivers for common Bluetooth chipsets, but you may need to manually install additional drivers for less common chipsets.
10. **Check Logs**: Review system logs for any errors related to Bluetooth:
```
journalctl -u bluetooth
```
11. **Reset Bluetooth**: Sometimes resetting the Bluetooth adapter can resolve issues:
```
sudo rfkill block bluetooth
sudo rfkill unblock bluetooth
```
12. **Pairing Devices**: If you're having trouble pairing devices, ensure that they are in pairing mode and follow the correct pairing procedure.
13. **Check Bluetooth Configuration Files**: Verify that the configuration files for Bluetooth are correctly set up. You can find these in `/etc/bluetooth/`.
14. **Community Support**: If you're still having trouble, consider asking for help on [Snigdha OS forums](https://forum.snigdhaos.org/), Reddit, or You can raise an issue on [Github](https://github.com/Snigdha-OS/snigdhaos-issues/issues)
By following these steps and troubleshooting each potential issue methodically, you should be able to resolve most Bluetooth problems on Snigdha OS.

4
docs/troubleshoot/display.md
View File

@@ -1,4 +0,0 @@
---
sidebar_position: 4
---
# Troubleshoot: Display

4
docs/troubleshoot/sound.md
View File

@@ -1,4 +0,0 @@
---
sidebar_position: 3
---
# Troubleshoot: Sound

4
docs/troubleshoot/wifi.md
View File

@@ -1,4 +0,0 @@
---
sidebar_position: 1
---
# Troubleshoot: Wifi

9
docs/user_guide/_category_.json
View File

@@ -1,9 +0,0 @@
{
"label": "User Guide",
"position": 5,
"link": {
"type": "generated-index",
"description": "User Manual"
}
}

115
docs/user_guide/aur.md
View File

@@ -1,115 +0,0 @@
---
sidebar_position: 2
---
# Installing with AUR
### 🌟 **Installing Packages with an AUR Helper on Snigdha OS**
Snigdha OS is known for its powerful **Arch User Repository (AUR)**, which provides access to user-contributed packages that are not included in the official repositories. To simplify the process of building and installing packages from the AUR, many users rely on **AUR helpers** like `yay`, `paru`, or `trizen`.
---
### 🔧 **Step 1: Install an AUR Helper**
#### **Popular AUR Helpers**
1. **Yay (Yet Another Yaourt)**
Lightweight and popular among Arch users.
- Install:
```bash
sudo pacman -S --needed git base-devel
git clone https://aur.archlinux.org/yay.git
cd yay
makepkg -si
```
2. **Paru**
A modern AUR helper written in Rust.
- Install:
```bash
sudo pacman -S --needed git base-devel
git clone https://aur.archlinux.org/paru.git
cd paru
makepkg -si
```
3. **Trizen**
Another reliable AUR helper.
- Install:
```bash
sudo pacman -S --needed git base-devel
git clone https://aur.archlinux.org/trizen.git
cd trizen
makepkg -si
```
---
### 🌟 **Step 2: Search and Install AUR Packages**
Once your AUR helper is installed, you can easily search for and install AUR packages.
#### **Basic Commands**
| **Command** | **Description** |
|----------------------------------|------------------------------------------|
| `yay -S package-name` | Install a package from AUR. |
| `paru -S package-name` | Install a package from AUR. |
| `yay -Ss package-name` | Search for a package in AUR. |
| `paru -Ss package-name` | Search for a package in AUR. |
| `yay -Syu` | Update all installed packages (including AUR). |
| `paru -Syu` | Update all installed packages (including AUR). |
| `yay -R package-name` | Remove a package. |
| `paru -R package-name` | Remove a package. |
---
### 🌐 **Step 3: Example Installations**
1. **Install `visual-studio-code-bin` (AUR package)**:
```bash
yay -S visual-studio-code-bin
```
2. **Search for a package (e.g., Brave Browser)**:
```bash
paru -Ss brave
```
3. **Update All Packages**:
```bash
yay -Syu
```
4. **Remove a Package (e.g., Discord)**:
```bash
paru -R discord
```
---
### ⚠️ **Tips and Precautions**
1. **Enable Parallel Builds**: Speed up builds by editing `/etc/makepkg.conf` and setting:
```bash
MAKEFLAGS="-j$(nproc)"
```
This uses all available CPU cores for compiling.
2. **Check PKGBUILDs**: Always review the **PKGBUILD** file for security before installing a package:
```bash
yay -G package-name
cd package-name
cat PKGBUILD
```
3. **Use Trusted Helpers**: Stick to widely-used and actively maintained AUR helpers to minimize risks.
4. **Update Regularly**: Keep your system updated, as outdated packages can lead to dependency issues:
```bash
yay -Syu
```
---
### 🚀 **Conclusion**
Using an AUR helper like `yay` or `paru` streamlines the process of installing and managing AUR packages, making Snigdha OS even more powerful and user-friendly. Happy exploring! 😄

135
docs/user_guide/cheetsheet.md
View File

@@ -1,135 +0,0 @@
---
sidebar_position: 1
---
# Cheetsheet/Shortcuts
Below is a compilation of commonly used **keyboard shortcuts** for Snigdha OS, focusing on frequently used desktop environments and terminal tasks. Keep in mind that shortcuts can vary based on the desktop environment (e.g., GNOME, KDE, XFCE) or window manager (e.g., i3, bspwm).
---
### 🔤 **General Shortcuts (Common Across Desktop Environments)**
| **Shortcut** | **Action** |
|--------------------------|---------------------------------------------|
| `Ctrl + Alt + T` | Open a terminal. |
| `Alt + Tab` | Switch between open applications. |
| `Ctrl + Shift + Q` | Close the current window or application. |
| `Ctrl + Alt + L` | Lock the screen. |
| `Alt + F2` | Open the run command dialog. |
| `Print Screen` | Take a screenshot of the entire screen. |
| `Alt + Print Screen` | Take a screenshot of the current window. |
| `Ctrl + Alt + Arrow` | Switch workspaces/desktops. |
---
### 🖥️ **Terminal Shortcuts**
| **Shortcut** | **Action** |
|--------------------------|---------------------------------------------|
| `Ctrl + C` | Cancel the current command. |
| `Ctrl + Z` | Suspend the current command. |
| `Ctrl + D` | Exit the terminal session. |
| `Ctrl + L` | Clear the terminal screen. |
| `Ctrl + A` | Move the cursor to the beginning of the line. |
| `Ctrl + E` | Move the cursor to the end of the line. |
| `Ctrl + R` | Search through command history. |
| `Ctrl + Shift + T` | Open a new tab (if supported). |
| `Ctrl + Shift + N` | Open a new terminal window. |
| `Ctrl + K` | Delete everything from the cursor to the end of the line. |
---
### 📂 **File Manager Shortcuts (Nautilus, Dolphin, Thunar)**
| **Shortcut** | **Action** |
|--------------------------|---------------------------------------------|
| `Ctrl + N` | Open a new file manager window. |
| `Ctrl + T` | Open a new tab (if supported). |
| `Ctrl + W` | Close the current tab. |
| `Ctrl + H` | Show or hide hidden files. |
| `Ctrl + L` | Focus the address bar. |
| `Alt + Up Arrow` | Navigate to the parent folder. |
| `Alt + Left Arrow` | Go back to the previous folder. |
| `Alt + Right Arrow` | Go forward to the next folder. |
| `F2` | Rename the selected file or folder. |
| `Shift + Delete` | Permanently delete a file (bypass trash). |
---
### 🖱️ **Window Management Shortcuts (Desktop Environments)**
#### **GNOME**
| **Shortcut** | **Action** |
|--------------------------|---------------------------------------------|
| `Super` (Windows key) | Open the Activities Overview. |
| `Super + A` | Show all applications. |
| `Super + Left/Right` | Snap the window to the left or right. |
| `Super + Up` | Maximize the current window. |
| `Super + Down` | Minimize or restore the window. |
| `Alt + F4` | Close the current window. |
#### **KDE Plasma**
| **Shortcut** | **Action** |
|--------------------------|---------------------------------------------|
| `Alt + F1` | Open the application launcher. |
| `Alt + Space` | Open the KRunner search bar. |
| `Ctrl + F1–F8` | Switch between virtual desktops. |
| `Alt + Drag` | Move windows by dragging anywhere. |
| `Ctrl + Alt + Delete` | Log out or lock the screen. |
#### **XFCE**
| **Shortcut** | **Action** |
|--------------------------|---------------------------------------------|
| `Alt + F1` | Open the main menu. |
| `Ctrl + Alt + D` | Show desktop (minimize all windows). |
| `Alt + F10` | Maximize the current window. |
| `Alt + F6` | Focus on the next window. |
| `Alt + F9` | Minimize the current window. |
#### **i3 Window Manager**
| **Shortcut** | **Action** |
|--------------------------|---------------------------------------------|
| `Mod + Enter` | Open a terminal. |
| `Mod + D` | Open dmenu (app launcher). |
| `Mod + H/J/K/L` | Resize windows horizontally/vertically. |
| `Mod + Shift + Q` | Close the focused window. |
| `Mod + 1–9` | Switch to workspace 1–9. |
| `Mod + Shift + 1–9` | Move the current window to workspace 1–9. |
---
### 🎥 **Media Control Shortcuts**
| **Shortcut** | **Action** |
|--------------------------|---------------------------------------------|
| `XF86AudioRaiseVolume` | Increase volume. |
| `XF86AudioLowerVolume` | Decrease volume. |
| `XF86AudioMute` | Mute/unmute audio. |
| `XF86AudioPlay` | Play or pause media. |
| `XF86AudioNext` | Play the next track. |
| `XF86AudioPrev` | Play the previous track. |
---
### 🔒 **Virtual Console Shortcuts**
| **Shortcut** | **Action** |
|--------------------------|---------------------------------------------|
| `Ctrl + Alt + F1–F6` | Switch between TTY consoles. |
| `Ctrl + Alt + F7` | Return to the graphical session. |
---
### ⚙️ **Customizing Shortcuts**
Many desktop environments allow you to customize shortcuts:
- **GNOME**: Use **Settings → Keyboard → Shortcuts**.
- **KDE Plasma**: Use **System Settings → Shortcuts**.
- **XFCE**: Use **Settings Manager → Keyboard → Application Shortcuts**.
---
### 🔗 **Conclusion**
These are just a few of the many shortcuts available on Snigdha OS. Depending on your desktop environment or window manager, additional shortcuts may apply. Experiment with your setup and consider customizing shortcuts to fit your workflow! 🚀

125
docusaurus.config.js
View File

@@ -1,125 +0,0 @@
import {themes as prismThemes} from 'prism-react-renderer';
/** @type {import('@docusaurus/types').Config} */
const config = {
title: 'SNIGDHA OS - DOCS',
tagline: 'Be silent when it is time to hear!',
favicon: 'img/snigdhaos-ico.ico',
// Set the production url of your site here
url: 'https://snigdhaos.org/',
// Set the /<baseUrl>/ pathname under which your site is served
// For GitHub pages deployment, it is often '/<projectName>/'
baseUrl: '/documentation/',
trailingSlash: false,
// GitHub pages deployment config.
// If you aren't using GitHub pages, you don't need these.
organizationName: 'Snigdha-OS', // Usually your GitHub org/user name.
projectName: 'documentation', // Usually your repo name.
onBrokenLinks: 'throw',
onBrokenMarkdownLinks: 'warn',
i18n: {
defaultLocale: 'en',
locales: ['en'],
},
presets: [
[
'classic',
/** @type {import('@docusaurus/preset-classic').Options} */
({
docs: {
sidebarPath: './sidebars.js',
sidebarCollapsible: false,
routeBasePath: '/',
// Please change this to your repo.
// Remove this to remove the "edit this page" links.
editUrl:
'https://github.com/Snigdha-OS/documentation/tree/master/',
},
blog: {
showReadingTime: true,
// Please change this to your repo.
// Remove this to remove the "edit this page" links.
editUrl:
'https://github.com/Snigdha-OS/documentation/tree/master/',
},
theme: {
customCss: './src/css/custom.css',
},
}),
],
],
themeConfig:
/** @type {import('@docusaurus/preset-classic').ThemeConfig} */
({
// Replace with your project's social card
image: 'img/docusaurus-social-card.jpg',
navbar: {
title: 'DOCUMENTATION | SNIGDHA OS',
logo: {
alt: 'Snigdha OS Docs Logo',
src: 'img/snigdhaos-docs.svg',
},
items: [
{
type: 'search',
position: 'right',
},
{
href: 'https://snigdhaos.org/',
label: 'Home',
position: 'right',
},
{
href: 'https://snigdha-os.github.io/snigdhaos-status/',
label: 'Status',
position: 'right',
},
{
href: 'http://snigdha-os.github.io/documentation/privacy_policy',
label: 'Privacy Policy',
position: 'right',
},
{
href: 'https://github.com/Snigdha-OS/',
// label: 'GitHub',
position: 'right',
className: 'navbar__icon navbar__github',
html: '<i class="fa fa-github"></i>',
},
],
},
footer: {
style: 'light',
links: [
],
copyright: `© ${new Date().getFullYear()} SNIGDHA OS. ALL RIGHTS RESERVED.`,
},
prism: {
theme: prismThemes.github,
darkTheme: prismThemes.dracula,
},
metadata: [
{name: 'google-site-verification', content: 'yn077F39pfs0VeUp9l09FZfw_uNegy4cXf7i0aPXJIc'},
],
}),
plugins: [
[
'@docusaurus/plugin-sitemap',
{
// Optional: custom options for the sitemap plugin
changefreq: 'weekly', // Frequency of updates (optional)
priority: 0.5, // Default priority for URLs (optional)
},
],
],
};
export default config;

16034
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

46
package.json
View File

@@ -1,46 +0,0 @@
{
"name": "documents",
"version": "0.0.0",
"private": true,
"scripts": {
"docusaurus": "docusaurus",
"start": "docusaurus start",
"build": "docusaurus build",
"swizzle": "docusaurus swizzle",
"deploy": "docusaurus deploy",
"clear": "docusaurus clear",
"serve": "docusaurus serve",
"write-translations": "docusaurus write-translations",
"write-heading-ids": "docusaurus write-heading-ids"
},
"dependencies": {
"@docusaurus/core": "3.1.1",
"@docusaurus/plugin-sitemap": "^3.6.3",
"@docusaurus/preset-classic": "3.1.1",
"@mdx-js/react": "^3.1.0",
"clsx": "^2.1.1",
"font-awesome": "^4.7.0",
"prism-react-renderer": "^2.4.0",
"react": "^18.3.1",
"react-dom": "^18.3.1"
},
"devDependencies": {
"@docusaurus/module-type-aliases": "3.1.1",
"@docusaurus/types": "3.1.1"
},
"browserslist": {
"production": [
">0.5%",
"not dead",
"not op_mini all"
],
"development": [
"last 3 chrome version",
"last 3 firefox version",
"last 5 safari version"
]
},
"engines": {
"node": ">=18.0"
}
}

12503
pnpm-lock.yaml generated
View File

File diff suppressed because it is too large Load Diff

33
sidebars.js
View File

@@ -1,33 +0,0 @@
/**
* Creating a sidebar enables you to:
- create an ordered group of docs
- render a sidebar for each doc of that group
- provide next/previous navigation
The sidebars can be generated from the filesystem, or explicitly defined here.
Create as many sidebars as you want.
*/
// @ts-check
/** @type {import('@docusaurus/plugin-content-docs').SidebarsConfig} */
const sidebars = {
// By default, Docusaurus generates a sidebar from the docs folder structure
tutorialSidebar: [{type: 'autogenerated', dirName: '.'}],
// But you can create a sidebar manually
/*
tutorialSidebar: [
'intro',
'hello',
{
type: 'category',
label: 'Tutorial',
items: ['tutorial-basics/create-a-document'],
},
],
*/
};
export default sidebars;

64
src/components/HomepageFeatures/index.js
View File

@@ -1,64 +0,0 @@
import clsx from 'clsx';
import Heading from '@theme/Heading';
import styles from './styles.module.css';
const FeatureList = [
{
title: 'Easy to Use',
Svg: require('@site/static/img/undraw_docusaurus_mountain.svg').default,
description: (
<>
Docusaurus was designed from the ground up to be easily installed and
used to get your website up and running quickly.
</>
),
},
{
title: 'Focus on What Matters',
Svg: require('@site/static/img/undraw_docusaurus_tree.svg').default,
description: (
<>
Docusaurus lets you focus on your docs, and we&apos;ll do the chores. Go
ahead and move your docs into the <code>docs</code> directory.
</>
),
},
{
title: 'Powered by React',
Svg: require('@site/static/img/undraw_docusaurus_react.svg').default,
description: (
<>
Extend or customize your website layout by reusing React. Docusaurus can
be extended while reusing the same header and footer.
</>
),
},
];
function Feature({Svg, title, description}) {
return (
<div className={clsx('col col--4')}>
<div className="text--center">
<Svg className={styles.featureSvg} role="img" />
</div>
<div className="text--center padding-horiz--md">
<Heading as="h3">{title}</Heading>
<p>{description}</p>
</div>
</div>
);
}
export default function HomepageFeatures() {
return (
<section className={styles.features}>
<div className="container">
<div className="row">
{FeatureList.map((props, idx) => (
<Feature key={idx} {...props} />
))}
</div>
</div>
</section>
);
}

11
src/components/HomepageFeatures/styles.module.css
View File

@@ -1,11 +0,0 @@
.features {
display: flex;
align-items: center;
padding: 2rem 0;
width: 100%;
}
.featureSvg {
height: 200px;
width: 200px;
}

73
src/css/custom.css
View File

@@ -1,73 +0,0 @@
/**
* Any CSS included here will be global. The classic template
* bundles Infima by default. Infima is a CSS framework designed to
* work well for content-centric websites.
*/
@import 'font-awesome/css/font-awesome.min.css';
@import url('https://fonts.googleapis.com/css2?family=Fira+Code:wght@400;700&display=swap');
/* You can override the default Infima variables here. */
:root {
--ifm-color-primary: #4f46e5;
--ifm-color-primary-dark: #4f46e5;
--ifm-color-primary-darker: #4f46e5;
--ifm-color-primary-darkest: #4f46e5;
--ifm-color-primary-light: #4f46e5;
--ifm-color-primary-lighter: #4f46e5;
--ifm-color-primary-lightest: #4f46e5;
--ifm-code-font-size: 95%;
--docusaurus-highlighted-code-line-bg: rgba(0, 0, 0, 0.1);
/* Custom font for code */
--ifm-font-family-code: 'Fira Code', monospace;
}
/* For readability concerns, you should choose a lighter palette in dark mode. */
[data-theme='dark'] {
--ifm-color-primary: #4f46e5;
--ifm-color-primary-dark: #4f46e5;
--ifm-color-primary-darker: #4f46e5;
--ifm-color-primary-darkest: #4f46e5;
--ifm-color-primary-light: #4f46e5;
--ifm-color-primary-lighter: #4f46e5;
--ifm-color-primary-lightest: #4f46e5;
--docusaurus-highlighted-code-line-bg: rgba(0, 0, 0, 0.3);
}
.navbar__icon {
height: 2rem;
width: 2rem;
}
.navbar__github {
-webkit-tap-highlight-color: transparent;
display: flex;
align-items: center;
justify-content: center;
border-radius: 50%;
font-size: 1.5rem;
transition: background var(--ifm-transition-fast);
}
html[data-theme='light'] .navbar__github {
color: #4f46e5;
}
html[data-theme='dark'] .navbar__github {
color: #4f46e5;
}
.navbar__github:hover {
background: var(--ifm-color-emphasis-200);
}
/* Apply Fira Code to code blocks and preformatted text */
code, pre {
font-family: 'Fira Code', monospace;
}
/* Optionally apply Fira Code globally for body */
body {
font-family: 'Fira Code', monospace;
}

40
src/pages/cookie-consent.md
View File

@@ -1,40 +0,0 @@
---
slug: /cookie-consent
title: Cookie Consent Policy
---
# Cookie Consent Policy
This Cookie Consent Policy explains how **Snigdha OS** uses cookies on [Snigdha OS Forum](https://forum.snigdhaos.org/). By using our **Forum**, you consent to the use of cookies as described in this policy.
## What are cookies?
Cookies are small pieces of data stored on your device (computer or mobile device) when you visit a website. They are widely used to make websites work more efficiently and to provide information to the owners of the site.
## How do we use cookies?
We use cookies for the following purposes:
📌 **Essential Cookies:** These cookies are necessary for *SNIGDHA OS FORUM* to function properly. They enable basic functionalities such as page navigation and access to secure areas of *SNIGDHA OS FORUM*. *SNIGDHA OS FORUM* cannot function properly without these cookies.
📌 **Analytics Cookies:** These cookies allow us to analyze how visitors use *SNIGDHA OS FORUM*, so we can measure and improve the performance of our site. We use services like Google Analytics to gather this information.
📌 **Marketing Cookies:** These cookies are used to track visitors across websites. The intention is to display ads that are relevant and engaging for the individual user.
## Your consent
By using *SNIGDHA OS FORUM*, you consent to the use of cookies in accordance with this Cookie Consent Policy. You can withdraw your consent at any time by disabling cookies in your browser settings.
**NOTE :** Disabling cookies may affect the functionality of SNIGDHA OS FORUM.
## Managing cookies
You can control and/or delete cookies as you wish. You can delete all cookies that are already on your computer and you can set most browsers to prevent them from being placed. If you do this, however, you may have to manually adjust some preferences every time you visit *SNIGDHA OS FORUM*, and some services and functionalities may not work.
## Changes to this policy
We may update this Cookie Consent Policy from time to time. Any changes will be posted on this page with an updated revision date.
**Contact us**
If you have any questions about our Cookie Consent Policy, please contact us via [email](mailto:hello@snigdhaos.org).

23
src/pages/index.module.css
View File

@@ -1,23 +0,0 @@
/**
* CSS files with the .module.css suffix will be treated as CSS modules
* and scoped locally.
*/
.heroBanner {
padding: 4rem 0;
text-align: center;
position: relative;
overflow: hidden;
}
@media screen and (max-width: 996px) {
.heroBanner {
padding: 2rem;
}
}
.buttons {
display: flex;
align-items: center;
justify-content: center;
}

7
src/pages/markdown-page.md
View File

@@ -1,7 +0,0 @@
---
title: Markdown page example
---
# Markdown page example
You don't need React to write simple standalone pages.

123
src/pages/privacy_policy.md
View File

@@ -1,123 +0,0 @@
---
slug: /privacy_policy
title: Privacy Policy
---
### Privacy Policy 🔒
Welcome to the Snigdha OS Team's website! Your privacy is incredibly important to us. Here's a user-friendly breakdown of how we handle your data and why we collect it, explained in detail with clarity and transparency. 😊
---
### **Who We Are** 👥
The **Snigdha OS Team** (referred to as "Snigdha OS" or "we") operates the website and services at [https://snigdhaos.org](https://snigdhaos.org), including its subdirectories.
If you have questions about your privacy, you can reach us at:
📧 **Email:** privacy@snigdhaos.org
---
### **Why We Collect Your Data** 🧐
We collect and process data to:
- Ensure our website works smoothly. 🚀
- Provide the services you love, like forums and wikis. 🛠️
- Keep our platform secure from spammers and malicious actors. 🔐
When applicable, we adhere to the **GDPR** (General Data Protection Regulation) for protecting your rights.
---
### **What Data We Collect & Why** 📊
#### 1. **When You Visit Our Website** 🌐
Our hosting provider automatically collects some technical details:
- **IP address**
- **Content accessed**
- **Date and time of access**
- **Amount of data transmitted**
- **Referrer (the website you came from)**
- **Web browser and user agent details**
💡 **Why?**
- To establish a connection and display the website to you.
- To maintain the security of our systems and detect malicious activity.
🕒 **How Long?**
Log files are stored for **30 days** and then automatically deleted.
---
#### 2. **When You Create an Account** ✍️
For services like forums or wikis, you’ll need to sign up. We collect:
- **Username**
- **Email address**
- **Password** (securely stored)
- **Language preference** 🌍
- **Time zone** 🕰️
💌 You’ll also get a confirmation email when signing up.
💡 **Why?**
To give you a personalized experience and ensure account security.
---
#### 3. **When You Use Specific Services** 🛠️
##### **Forums** 💬
- You can read posts anonymously.
- To participate, you’ll need an account.
- We’ll collect:
- Username and email address.
- Captcha responses (to block spam 🤖).
When posting, certain account details (like your username and registration date) will be visible to other users.
💡 **Why?**
To prevent spam and provide a safe, engaging forum for discussion.
🕒 **What Happens If I Delete My Account?**
- Your posts will remain for the forum’s continuity.
- The author’s name will be anonymized to protect your identity.
---
##### **Docs/Wiki** 📚
- Reading content is free for everyone.
- To contribute, you’ll need an account.
- Similar to forums, we collect:
- Username and email address.
- Captcha responses.
- Optional details like your time zone and language.
💡 **Why?**
To personalize your experience and protect the platform from spam.
🕒 **What Happens If I Delete My Account?**
- Your contributions will stay visible for the community’s benefit.
- Your author details will be anonymized.
---
### **Legal Basis for Data Processing (GDPR)** ⚖️
- **Providing Services (Art. 6 para. 1 lit. b GDPR):** We process your data to fulfill our contract with you (like offering account-based services).
- **Protecting Security (Art. 6 para. 1 lit. f GDPR):** We use data for legitimate interests like ensuring system stability and preventing abuse.
---
### **Your Rights** ✨
Under the GDPR, you have the right to:
- **Access Your Data:** See what data we have about you.
- **Correct Inaccuracies:** Update incorrect or incomplete data.
- **Delete Your Data:** Ask us to erase your data (within legal constraints).
- **Restrict Processing:** Limit how we use your data.
- **Data Portability:** Receive your data in a usable format.
💌 To exercise your rights, contact us at: privacy@snigdhaos.org
---
### **Conclusion** 💡
We’re committed to protecting your privacy while delivering a seamless experience. If you have any concerns or suggestions, don’t hesitate to reach out! Together, we can make Snigdha OS a safer and better place. 💜
Thank you for trusting us! 🙏
**Your Snigdha OS Team** 🛡️

10
src/theme/SearchBar.js
View File

@@ -1,10 +0,0 @@
import React from 'react';
import SearchBar from '@theme-original/SearchBar';
export default function SearchBarWrapper(props) {
return (
<>
<SearchBar {...props} />
</>
);
}

0
static/.nojekyll
View File

BIN
static/img/docusaurus-social-card.jpg
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 54 KiB

11
static/img/snigdhaos-docs.svg
View File

@@ -1,11 +0,0 @@
<svg version="1.2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" width="512" height="512">
<title>snigdhaos-svg</title>
<style>
.s0 { fill: #28282b }
.s1 { fill: #4f46e5 }
.s2 { fill: #ff0000 }
</style>
<path id="Path 2" class="s0" d="m331.4 12c-18.4 62.3-63.1 95.1-111.3 119.6-31 15.5-53 33.2-69.1 50l13.7-46.8c0 0-57.7 33.4-83.7 97.8-13.9 34.3-12.5 77.3 12.2 121.7l-32.7-8.3c35 77.6 111.8 124.6 169.7 125.1l-28.9 28.9c65-5.3 139.4-20.6 182.8-70.4 6.5 15.2 12.5 31.9 18.6 47.7 24.5-47.9 31.5-124.5 15.6-169.7h33.9c-27.1-26.9-58.5-54.7-87.8-65.2-13.5-32.8-30.4-44.1-58.7-58.7 55.7-50.9 48.9-107.9 25.7-171.7z"/>
<path id="Path 3" fill-rule="evenodd" class="s1" d="m351.1 256.5c30.4 7.4 57.6 33.6 57.6 33.6h-18.7c38.9 60.1 12 136.5 12 136.5-7.1-18.4-16.3-31.8-16.3-31.8-30.4 67.9-135.8 81.4-135.8 81.4l21.9-22c-127.3 9.9-176.8-81.3-176.8-81.3l41.7 10.6c-104.7-107.5 2.1-207.3 2.1-207.3-17.6 34.7-9.2 71.5-9.2 71.5 0 0 13.5-58 98.4-100.5 84.9-42.4 102.5-86.3 102.5-86.3 0 0 30.4 83.5-84.7 143.5l26.6 5.5c0 0-92.1 8-103.6 76-11.5 68.1 51.5 97.1 70.5 99.6 0 0-12.7-9.4-18.4-24.6 0 0 31.5 26.5 90.5 12.3 0 0-0.3 12.1-10.9 26.6 0 0 44.9-26.6 25.8-64.4l22.6-9.6c0 0-43.8 5-66.1 20.9-22.3 15.9-44.6-9.9-44.6-9.9 0 0 9.9-6.4 9.2-14.2 0 0 22-21.4 31.3-26.3 9.4-5 30.4-10.6 28.5-29.5l9-9.1c0 0-24.7 13.5-29.9 19-5.1 5.5-5.6 10.9-5.6 10.9 0 0-2.9 3.2-5.3 2.2-2.5-1.1-4.6-6.8-4.6-6.8 0 0 6.3-15.3 42.4-37.1 0 0 5.7-23 3.5-36.8 0 0 24.1 12.4 34.4 47.4zm-89.9 35c-23.7 17-36.4 33.3-36.4 35.7 0 2.5 1.8 13.5 1.8 13.5-11.7-9.6-17-24.8-17-24.8-4.6 13.5-3.2 22.3-3.2 22.3-40.9-44.5 8.4-107.9 92.8-118.3 0 0 0 11.1-1.7 18.7 0 0-29.2 14-39.8 38.8 0 0 1.4 9.2 3.5 14.1z"/>
<path id="Path 4" class="s2" d="m285.9 286.6c0 0 16.6-4.7 14.9-14.3 0 0-14.2 5.5-14.9 14.3z"/>
</svg>
Side by Side

Before

Width:  |  Height:  |  Size: 1.7 KiB

17
static/img/snigdhaos-face.svg
View File

@@ -1,17 +0,0 @@
<svg version="1.2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" width="512" height="512">
<title>snigdhaos-face</title>
<style>
.s0 { fill: #ffffff }
.s1 { fill: #754ffe }
</style>
<filter id="f0">
<feFlood flood-color="#754ffe" flood-opacity="1" />
<feBlend mode="normal" in2="SourceGraphic"/>
<feComposite in2="SourceAlpha" operator="in" />
</filter>
<g id="Folder 1" filter="url(#f0)">
<path id="Layer" fill-rule="evenodd" class="s0" d="m224.1 312.9l31.7-31.7 31.7 31.7 31.7 31.7-63.4 63.4q-92.4-92.4-184.8-184.8 0-95.1 0-190.2l121.4 121.4-31.7 31.7-44.9-44.9v63.5l108.3 108.2z"/>
<path id="Layer" fill-rule="evenodd" class="s0" d="m319.2 154.4l121.4-121.4q0 95.1 0 190.2-44.9 44.9-89.7 89.7l-95.1-95.1-31.7 31.7-31.7-31.7 63.4-63.4 95.1 95.1 44.8-44.8v-63.5l-44.8 44.9z"/>
</g>
<path id="SNIGDHA OS" class="s1" aria-label="SNIGDHA OS" d="m101.5 425.5h0.7v17.3q0 0.9 0.4 1.4 0.5 0.4 2.1 0.4h4.5v5.7h-7.7q-3.4 0-5.5-0.7-2.1-0.7-3.1-2.5-1-1.9-1.3-4-0.2-2.1-0.2-5.7 0-3.6 0.2-5.5 0.3-1.8 1.3-3.5 1-1.6 3.1-2.3 2.1-0.6 5.5-0.6zm10.1 43.5v-24.4h0.7q2.6 0 4 0.1 1.4 0.1 2.7 0.6 1.4 0.4 1.9 1 0.5 0.6 0.9 2.1 0.5 1.4 0.6 3.1 0 1.7 0 4.8 0 3.2 0 5-0.1 1.9-0.6 3.5-0.4 1.7-0.9 2.3-0.5 0.7-1.9 1.2-1.3 0.5-2.7 0.6-1.4 0.1-4 0.1zm-19.4-13.4h7.6q0.9 0 1.1 0.2 0.1 0.2 0.1 1v4.7q0 1 0.3 1.4 0.3 0.4 1.4 0.4h6.5v5.7h-8.9q-4.4 0-6.7-1.5-2.2-1.5-2.2-5.3v-5.4q0-1.2 0.8-1.2zm12.5-24.5v-5.7h7.6q4.4 0 6.6 1.5 2.3 1.5 2.3 5.3v5.4q0 1.3-0.8 1.3h-7.6q-0.8 0-1-0.3-0.2-0.2-0.2-1v-4.7q0-1-0.3-1.3-0.3-0.5-1.3-0.5zm52-5.7h6.3v40.2q0 2.1-0.6 2.7-0.7 0.7-2.7 0.7h-8.6q-3.5 0-4.7-1.1-1-1.1-1.9-5.6-1.7-8.9-4.9-28.8-0.2-1.5-0.7-1.9-0.4-0.5-1.5-0.5h-7.4v-5.7h13.1q1.5 0 2.4 0.4 0.9 0.3 1.4 1.5 0.6 1.2 0.8 2.3 0.2 1.1 0.5 2.5 0.3 1.8 0.8 5.1 1.1 6.8 3.2 19.3 0.9 5.3 1.2 5.9 0.3 0.6 1.2 0.8v-35.4q0-1.1 0.6-1.7 0.6-0.7 1.5-0.7zm-26.7 43.6v-35.8h6.3q0.9 0 1.5 0.7 0.6 0.6 0.6 1.7v30q0 2-0.5 2.7-0.6 0.7-2.2 0.7zm51.3-43.6v43.6h-6.3q-2.1 0-2.7-0.7-0.6-0.6-0.6-2.7v-36.7q0-2.2 0.6-2.8 0.6-0.7 2.7-0.7zm18.2 0h0.8v36.1q0 0.9 0.4 1.4 0.5 0.4 2 0.4h4.5v5.7h-7.7q-2.4 0-4-0.4-1.6-0.3-2.8-1.4-1.1-1.2-1.8-2.5-0.6-1.4-0.9-4.2-0.6-4.2-0.6-11.2 0-7 0.1-9.9 0.1-2.9 0.5-5.6 0.3-2.8 0.9-4.1 0.7-1.4 1.8-2.5 1.2-1.1 2.8-1.4 1.6-0.4 4-0.4zm3.2 25.6v-5.7h10.6q5.9 0 5.9 5.4v12.5q0 3.8-0.6 4.8-0.6 1-3.3 1h-5.7v-16.3q0-0.9-0.3-1.3-0.2-0.4-1.3-0.4zm0-19.9v-5.7h7.6q4.4 0 6.7 1.5 2.3 1.5 2.3 5.3v5.4q0 1.3-0.9 1.3h-7.6q-0.8 0-1-0.3-0.2-0.2-0.2-1v-4.7q0-1-0.3-1.3-0.2-0.5-1.3-0.5zm53.3 4.2l-0.2 11.8 0.1 10.2q0 7.2-1.8 9.5-1.8 2.2-6.6 2.2h-8.8v-5.7h4.4q1.5 0 2-0.4 0.5-0.3 0.5-1.4v-28.5q0-1.1-0.5-1.5-0.5-0.4-2-0.4h-4.4v-5.7h9.4q4.4 0 6.1 2.1 1.8 2 1.8 7.8zm-19.1-9.9v43.7h-6.4q-2 0-2.6-0.7-0.7-0.7-0.7-2.8v-36.7q0-2.1 0.7-2.8 0.6-0.7 2.6-0.7zm43.7 17.7v5.7h-6.6v20.2h-6.3q-2.1 0-2.7-0.7-0.6-0.6-0.6-2.7v-40.2h7.4q1 0 1.6 0.7 0.6 0.6 0.6 1.7v15.3zm2.4 23.5v-41.2h6.3q2.1 0 2.7 0.7 0.7 0.6 0.7 2.8v40.1h-7.5q-1 0-1.6-0.7-0.6-0.6-0.6-1.7zm34.5-41.2v5.7h-5.6q-1 0-1 0.5v37.4h-6.3q-2.1 0-2.7-0.7-0.6-0.6-0.6-2.7v-36.7q0-2.2 0.6-2.8 0.6-0.7 2.7-0.7zm2.4 17.7v-17.7h6.3q2.1 0 2.7 0.7 0.6 0.6 0.6 2.8v36.6q0 2.1-0.6 2.8-0.7 0.7-2.7 0.7h-6.3v-20.2h-6.6v-5.7zm40.3-17.7h0.7v36.1q0 0.9 0.4 1.4 0.5 0.4 2.1 0.4h4.5v5.7h-7.7q-2.4 0-4-0.4-1.6-0.3-2.8-1.4-1.2-1.2-1.8-2.5-0.6-1.4-1-4.2-0.5-4.2-0.5-11.2 0-7 0-9.9 0.2-2.9 0.5-5.6 0.4-2.8 1-4.1 0.6-1.4 1.8-2.5 1.2-1.1 2.8-1.4 1.6-0.4 4-0.4zm3.1 5.8v-5.7h7.7q2.4 0 4 0.3 1.6 0.4 2.7 1.5 1.2 1.1 1.8 2.5 0.7 1.4 1.1 4.2 0.5 4.1 0.5 11.2 0 7-0.1 9.9-0.1 2.9-0.4 5.6-0.4 2.8-1.1 4.1-0.6 1.4-1.8 2.5-1.1 1.1-2.7 1.5-1.6 0.3-4 0.3h-0.7v-36.1q0-1-0.5-1.4-0.4-0.4-2-0.4zm35.1-5.7h0.7v17.3q0 0.9 0.4 1.4 0.5 0.4 2.1 0.4h4.4v5.7h-7.6q-3.5 0-5.6-0.7-2-0.7-3-2.5-1-1.9-1.3-4-0.3-2.1-0.3-5.7 0-3.6 0.3-5.5 0.3-1.8 1.3-3.5 1-1.6 3-2.3 2.1-0.6 5.6-0.6zm10 43.5v-24.4h0.8q2.6 0 3.9 0.1 1.5 0.1 2.8 0.6 1.3 0.4 1.8 1 0.6 0.6 1 2.1 0.5 1.4 0.5 3.1 0.1 1.7 0.1 4.8 0 3.2-0.1 5 0 1.9-0.5 3.5-0.4 1.7-1 2.3-0.5 0.7-1.8 1.2-1.3 0.5-2.8 0.6-1.3 0.1-3.9 0.1zm-19.4-13.4h7.6q0.9 0 1 0.2 0.2 0.2 0.2 1v4.7q0 1 0.3 1.4 0.3 0.4 1.3 0.4h6.6v5.7h-8.9q-4.4 0-6.7-1.5-2.2-1.5-2.2-5.3v-5.4q0-1.2 0.8-1.2zm12.4-24.5v-5.7h7.7q4.4 0 6.6 1.5 2.3 1.5 2.3 5.3v5.4q0 1.3-0.8 1.3h-7.6q-0.9 0-1.1-0.3-0.1-0.2-0.1-1v-4.7q0-1-0.3-1.3-0.3-0.5-1.4-0.5z"/>
</svg>
Side by Side

Before

Width:  |  Height:  |  Size: 4.1 KiB

BIN
static/img/snigdhaos-ico.ico
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 10 KiB

BIN
static/img/snigdhaos-icon-docs.ico
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 2.8 KiB