Configure once. Restore anywhere.
A personal backup, restoration, and customization toolkit for Kali Linux XFCE.
GhostKali customized desktop environment
Customized terminal and file manager environment
GhostKali desktop configuration and visual customization
GhostKali is a personal configuration and restoration toolkit created to preserve a customized Kali Linux XFCE environment.
Instead of manually rebuilding a customized system after a reinstall or migration, GhostKali keeps important configuration, themes, icons, cursors, wallpapers, package lists, shell configuration, and other user-level customizations organized inside a single repository.
The project provides scripts for installing, backing up, restoring, and updating the environment.
The goal: make rebuilding a familiar Kali Linux workspace faster, more consistent, and repeatable.
- 🖥️ Customized XFCE desktop environment
- 🐚 ZSH + Powerlevel10k configuration
- 🎨 GTK themes and visual customization
- 🎯 Multiple icon themes
- 🖱️ Custom cursor themes
- 🖼️ Wallpaper collection
- 📦 Package manifests
- 🔤 Automatic font installation
- 💾 Backup and restore scripts
- 🔄 Update workflow
- 🧰 Organized configuration repository
GhostKali preserves the important parts of a customized Kali Linux XFCE environment so the system can be rebuilt without manually configuring everything again.
GhostKali preserves a customized Kali Linux XFCE desktop environment, including:
- XFCE panel configuration
- Desktop settings
- Window manager settings
- Keyboard shortcuts
- Autostart entries
- Desktop appearance preferences
- User-level XFCE configuration
The goal is to reproduce the same desktop workflow after reinstalling or migrating to another Kali Linux installation.
The repository preserves shell customization through:
- ZSH configuration
- Powerlevel10k configuration
- Git configuration
- Custom shell aliases and environment settings
The primary shell configuration is maintained inside:
dotfiles/.zshrc
GhostKali includes customized GTK and desktop themes, including TokyoNight-based variants.
Available themes include:
themes/
├── Tokyonight-Dark/
├── Tokyonight-Dark-hdpi/
├── Tokyonight-Dark-xhdpi/
├── Tokyonight-Light/
├── Tokyonight-Light-hdpi/
└── Tokyonight-Light-xhdpi/
These themes are stored inside the repository so they can be restored along with the rest of the desktop environment.
GhostKali maintains custom icon themes used by the desktop environment.
Icon configurations are preserved separately so that the visual appearance of applications, folders, system elements, and desktop components can be restored consistently.
Custom cursor themes are included as part of the visual customization.
This allows the cursor appearance to be restored together with the GTK themes and icon configuration.
GhostKali maintains a collection of wallpapers used by the customized desktop environment.
Wallpapers are stored inside the repository and can be restored without manually searching for or downloading them again.
The repository includes an automatic font installation workflow.
Font installation is handled through:
scripts/install_fonts.sh
This allows required fonts to be installed automatically instead of configuring them manually after every system installation.
GhostKali maintains package manifests containing the software packages required by the environment.
Package lists allow a fresh Kali Linux installation to recreate the required software environment more easily.
Example package manifests include:
packages/
├── apt-packages.txt
├── pip-packages.txt
└── vscode-extensions.txt
The package lists are intended to make system reconstruction more consistent and repeatable.
GhostKali provides scripts for managing the configuration lifecycle.
The main scripts are:
backup.sh
restore.sh
install.sh
update.sh
Their roles are:
install.sh— Install the GhostKali environmentbackup.sh— Create a backup of the current configurationrestore.sh— Restore saved configurationupdate.sh— Update backup data from the current environment
The update workflow allows the repository to be refreshed when the local Kali environment changes.
After modifying the desktop, shell, themes, packages, or other supported configuration:
./update.shcan be used to update the stored backup data.
This keeps the repository synchronized with the current customized environment.
The project is organized into dedicated directories for configuration, themes, packages, scripts, screenshots, and documentation.
GhostKali/
├── backup.sh
├── restore.sh
├── install.sh
├── update.sh
│
├── dotfiles/
│ └── .zshrc
│
├── themes/
│ ├── Tokyonight-Dark/
│ ├── Tokyonight-Dark-hdpi/
│ ├── Tokyonight-Dark-xhdpi/
│ ├── Tokyonight-Light/
│ ├── Tokyonight-Light-hdpi/
│ └── Tokyonight-Light-xhdpi/
│
├── icons/
│
├── cursors/
│
├── wallpapers/
│
├── packages/
│ ├── apt-packages.txt
│ ├── pip-packages.txt
│ └── vscode-extensions.txt
│
├── scripts/
│ └── install_fonts.sh
│
├── screenshots/
│
├── docs/
│
├── CHANGELOG.md
├── CONTRIBUTING.md
├── SECURITY.md
├── TODO.md
├── VERSION
├── LICENSE
└── README.md
The repository includes screenshots demonstrating the customized GhostKali environment.
GhostKali customized terminal and file manager environment.
GhostKali desktop configuration and visual customization.
GhostKali follows a simple configuration lifecycle:
Current Kali Linux Environment
│
▼
./backup.sh
│
▼
Repository Backup Data
│
▼
Git Repository
│
▼
Fresh Kali Installation
│
▼
./install.sh
│
▼
Restored GhostKali
The repository separates configuration data from the scripts responsible for installing, backing up, restoring, and updating that data.
This makes the project easier to maintain and reduces the amount of manual configuration required when rebuilding the system.
Clone the repository:
git clone https://github.com/COLD7NAAVI/Gh0stKali.git
cd Gh0stKaliMake the scripts executable:
chmod +x *.shRun the installer:
./install.shThe installation process restores the supported GhostKali configuration and customization from the repository.
To create a backup of the current environment:
./backup.shThe backup process collects the supported configuration and stores it in the appropriate repository directories.
After making changes to the environment, the backup can be updated again to keep the repository current.
To update the stored configuration:
./update.shThis is useful after changing:
- XFCE settings
- Shell configuration
- Themes
- Icons
- Cursors
- Wallpapers
- Package selections
- Other supported customization
To restore the saved GhostKali configuration:
./restore.shThe restore script applies the stored configuration back to the user's environment.
This is particularly useful after:
- Reinstalling Kali Linux
- Migrating to another machine
- Rebuilding a development environment
- Recovering from a system reset
- Recreating the same desktop setup
GhostKali is designed around one simple idea:
Your customized Linux environment should be reproducible.
Instead of spending hours rebuilding the same desktop, shell, themes, fonts, packages, and visual configuration after a fresh installation, GhostKali keeps the important pieces organized inside a version-controlled repository.
The project is intended to make rebuilding a familiar Kali Linux environment:
faster • more consistent • repeatable • maintainable
GhostKali is primarily designed around:
- Kali Linux
- XFCE
- ZSH
- Powerlevel10k
- Git
Some configuration components may depend on the software and packages available on the target system.
For best results, use GhostKali on a Kali Linux installation with the required desktop environment and dependencies available.
GhostKali is a personal configuration and restoration toolkit rather than a complete operating-system image.
It does not replace a full system backup.
The repository focuses on preserving user-level configuration, customization, package information, and restoration scripts.
Always maintain separate backups of important personal files and data.
The repository is organized so that configuration files, visual assets, package information, documentation, and automation scripts remain separated and easy to maintain.
GhostKali/
├── configs/ # XFCE and application configuration
│
├── dotfiles/ # Shell and user configuration
│ └── .zshrc # ZSH configuration
│
├── fonts/ # Custom fonts
│
├── icons/ # Icon themes
│
├── cursors/ # Cursor themes
│
├── themes/ # GTK and desktop themes
│ ├── Tokyonight-Dark/
│ ├── Tokyonight-Dark-hdpi/
│ ├── Tokyonight-Dark-xhdpi/
│ ├── Tokyonight-Light/
│ ├── Tokyonight-Light-hdpi/
│ └── Tokyonight-Light-xhdpi/
│
├── wallpapers/ # Desktop wallpapers
│
├── packages/ # Package manifests
│ ├── apt-packages.txt
│ ├── pip-packages.txt
│ ├── npm-packages.txt
│ └── vscode-extensions.txt
│
├── scripts/ # Supporting scripts
│ └── install_fonts.sh
│
├── screenshots/ # Project screenshots
│ ├── desktop.png
│ ├── file-manager.png
│ ├── settings.png
│ └── terminal.png
│
├── docs/ # Additional documentation
│
├── backup.sh # Create a configuration backup
├── restore.sh # Restore the saved configuration
├── install.sh # Install GhostKali
├── update.sh # Update backup data
│
├── CHANGELOG.md # Project changelog
├── CONTRIBUTING.md # Contribution guidelines
├── SECURITY.md # Security information
├── TODO.md # Planned improvements
├── VERSION # Current project version
├── LICENSE # MIT License
└── README.md # Project documentation
GhostKali follows a simple configuration-management workflow.
┌─────────────────────┐
│ Kali Linux Host │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ backup.sh │
│ Capture configuration│
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ GhostKali │
│ Repository │
└──────────┬──────────┘
│
┌──────────┴──────────┐
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ update.sh │ │ Git / GitHub │
└─────────────┘ └─────────────┘
│ │
└──────────┬──────────┘
▼
┌─────────────────────┐
│ restore.sh │
│ Rebuild environment │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Restored Workspace │
└─────────────────────┘
The repository acts as the source of truth for the configuration that GhostKali is intended to preserve.
The backup workflow captures important user-level configuration and package information and stores it inside the repository.
Run:
./backup.shThe backup process is intended to preserve configuration such as:
- XFCE desktop settings
- Panel configuration
- ZSH configuration
- Powerlevel10k configuration
- Git configuration
- Themes
- Icons
- Cursors
- Wallpapers
- Installed package information
- Font information
- Other supported user-level configuration
After creating or updating a backup, the resulting changes can be reviewed with Git:
git statusThen commit the changes when appropriate:
git add .
git commit -m "Update GhostKali backup"The restore workflow is intended to rebuild the GhostKali environment from the repository.
Run:
./restore.shThe restoration process uses the configuration and resources stored inside the repository to recreate the supported environment.
This is particularly useful after:
- Reinstalling Kali Linux
- Migrating to another machine
- Rebuilding a development environment
- Recovering from a system reset
- Recreating the same customized desktop setup
The exact result of a restoration depends on the target system, installed dependencies, desktop environment, and packages available on that system.
Clone the repository:
git clone https://github.com/COLD7NAAVI/Gh0stKali.git
cd Gh0stKaliMake the scripts executable:
chmod +x *.shRun the installer:
./install.shAfter installation, review the restored configuration and restart applications or log out and back in when required for desktop or shell changes to take effect.
When the current Kali environment has changed and those changes should be preserved in the repository, run:
./update.shReview the resulting Git changes:
git status
git diffIf everything looks correct, commit the update:
git add .
git commit -m "Update GhostKali configuration"
git pushThis keeps the repository synchronized with the current workstation configuration.
GhostKali can capture the current user-level configuration of the Kali Linux environment and store the relevant data inside the repository.
This is useful when the workstation has been customized further and those changes need to be preserved.
Run:
./backup.shThe backup process is intended to preserve configuration such as:
- XFCE desktop configuration
- GTK configuration
- Terminal configuration
- Zsh configuration
- Powerlevel10k configuration
- Git configuration
- Themes and icons
- Cursor configuration
- Wallpapers
- Autostart entries
- Package information
- Other supported user-level configuration
After running the backup, review the changes before committing them.
git status
git diffIf the changes are correct:
git add .
git commit -m "Update GhostKali backup"
git pushThis keeps the repository synchronized with the latest known workstation configuration.
The restore workflow is intended to rebuild the GhostKali environment from the configuration stored in the repository.
Run:
./restore.shThe restoration process may restore supported configuration for:
- XFCE
- GTK
- Zsh
- Powerlevel10k
- Git
- Themes
- Icons
- Cursors
- Wallpapers
- Terminal configuration
- Other supported user-level settings
After restoration, some changes may require:
- Logging out and back in
- Restarting the affected application
- Restarting the shell
- Restarting the desktop session
For example, Zsh configuration can be reloaded with:
source ~/.zshrcThe restore script should be used carefully and reviewed before applying it to an existing environment.
GhostKali is designed around configuration preservation rather than full-system cloning.
The repository does not attempt to reproduce every file on the operating system.
Instead, it focuses on the parts of the environment that are most important for recreating the customized workspace.
The general model is:
Kali Linux
│
├── Desktop configuration
├── Shell configuration
├── Themes
├── Icons
├── Cursors
├── Wallpapers
├── Fonts
├── Package manifests
└── User-level configuration
│
▼
GhostKali Repository
│
├── Backup
├── Version control
├── Restore
└── Rebuild
This approach keeps the repository focused, portable, and easier to maintain.
GhostKali maintains package information separately from the configuration files.
This makes it possible to recreate the software environment without storing the installed packages themselves inside the repository.
Package manifests may include:
packages/
├── apt-packages.txt
├── pip-packages.txt
├── npm-packages.txt
└── vscode-extensions.txt
These files provide a reference for rebuilding the development and customization environment.
The APT package manifest records packages installed through the Debian/Kali package manager.
Example:
sudo apt install <package-name>Python dependencies can be tracked separately through the PIP package manifest.
Example:
pip install <package-name>Node.js related packages can be documented through the NPM package manifest.
Example:
npm install <package-name>Development-related VS Code extensions are maintained separately so that the development environment can also be recreated.
GhostKali includes a dedicated font installation script.
The supporting script is located at:
scripts/install_fonts.sh
Run it with:
./scripts/install_fonts.shThe purpose of this script is to make font installation repeatable instead of requiring each font to be installed manually.
Fonts are treated as part of the visual and development environment because terminal readability, editor appearance, and prompt rendering depend heavily on the selected font configuration.
GhostKali preserves important XFCE configuration so that the desktop environment can be restored without manually rebuilding every setting.
This includes configuration related to:
- XFCE panels
- Panel plugins
- Desktop appearance
- Window manager settings
- Keyboard shortcuts
- Application preferences
- Autostart entries
- File manager preferences
- Desktop behavior
The goal is not to create a completely new desktop environment.
The goal is to preserve the customized environment already established on the workstation.
The shell environment is an important part of GhostKali.
The repository preserves configuration related to:
- Zsh
- Oh My Zsh
- Powerlevel10k
- Git
- Aliases
- Environment variables
- Shell customization
The primary Zsh configuration is maintained inside:
dotfiles/.zshrc
This allows the shell environment to be restored consistently across supported installations.
GhostKali intentionally does not attempt to store everything from the operating system.
The repository should not be treated as a complete disk image or full system backup.
It is primarily intended to preserve:
- Configuration
- Customization
- Package information
- Themes
- User-level environment settings
- Restoration scripts
Personal files, private credentials, browser profiles, SSH private keys, tokens, and other sensitive information should not be committed to the repository.
Always review repository changes before pushing them to a remote Git repository.
GhostKali is designed for a security-focused Kali Linux workstation, but the repository itself should still follow normal security practices.
Do not commit:
Passwords
API keys
Authentication tokens
Private SSH keys
Private certificates
Browser session data
Personal documents
Other sensitive credentials
Before committing changes, review:
git status
git diffIf sensitive information is accidentally added, remove it from the repository and rotate the exposed credential where appropriate.
For additional security information, see:
SECURITY.md
GhostKali keeps project documentation separate from the actual configuration files.
Important documentation files include:
README.md
CHANGELOG.md
CONTRIBUTING.md
SECURITY.md
TODO.md
VERSION
LICENSE
Each file has a specific purpose:
README.md— Main project documentationCHANGELOG.md— Project changes and release historyCONTRIBUTING.md— Contribution guidelinesSECURITY.md— Security information and reportingTODO.md— Planned improvementsVERSION— Current project versionLICENSE— Project license
GhostKali is an evolving personal configuration and restoration project.
The repository may continue to grow as new customizations, packages, themes, scripts, and restoration capabilities are added.
The project prioritizes:
Reproducibility → Consistency → Maintainability → Simplicity
Future improvements may include better automation, additional configuration coverage, improved restoration handling, and more structured environment validation.