The p-command system provides a unified, extensible command-line interface for automating and visualizing workflows across tools, APIs, directories, WSL distributions, Git repositories, and model runtimes. Commands are invoked using the simple pattern:

p <subcommand>

This lightweight abstraction layer bridges scripting with intuitive commands and GUI/terminal interfaces. Whether you're querying system resources or launching a model pipeline, p makes it seamless.

• Unified command format
• Modular Python backend (via pp-commands\)
• Terminal and GUI support
• Dynamic model and directory listing
• Interactive API & GitHub integration
• Full WSL distro handling
• Optimized for extensibility and automation

Each p <subcommand> is internally mapped to a Python script located under:

pp-commands\

These scripts may present a GUI (via PyQt, tkinter, etc.), a rich terminal interface (curses, rich, prompt_toolkit), or API-driven logic.

The pp-Command-System enables the unconditional execution of security-critical commands with administrator privileges. It is designed to securely and directly execute system-level functions — file operations, process management, network scans, and PowerShell commands — via

pp <command>

Each command in the pp system internally uses

run_command_with_admin_python_privileges

to provide a secure elevated environment for PowerShell or Python-compatible operations.

• Every command is executed with elevated privileges — no prompt or confirmation!
• Faulty or dangerous commands such as pp-rm * can cause serious damage.
• All inputs should be handled carefully — logging records all operations.

The ps Command-System (short for Peharge Search) provides direct access to curated developer resources, search engines, and platforms. Instead of manually navigating through dozens of tabs, you can perform precise searches — directly from the shell.

Note: All searches are performed via specialized functions such as search_stackoverflow(), search_paperswithcode(), etc., depending on the platform.

The pa commands are used to communicate with locally running AI models via Ollama.

• pa <input>: Standard access to the primary AI model (e.g., qwen:14b).

• pa-qwen3:0.6b <input>: Uses the small Qwen model (0.6B).
• pa-qwen3:1.7b <input>: Uses Qwen 1.7B.
• pa-qwen3:4b <input>: Uses Qwen 4B.
• pa-qwen3:8b <input>: Uses Qwen 8B.
• pa-qwen3:14b <input>: Uses Qwen 14B.
• pa-qwen3:30b <input>: Uses Qwen 30B.
• pa-qwen3:32b <input>: Uses Qwen 32B.
• pa-qwen3:235b <input>: Uses Qwen 235B.

• pa-llama4:scout <input>: Uses LLaMA 4 Scout model.
• pa-llama4:maverick <input>: Uses LLaMA 4 Maverick model.

• pa-deepseek-r1:1.5b <input>: DeepSeek R1 with 1.5B parameters.
• pa-deepseek-r1:7b <input>: DeepSeek R1 with 7B.
• pa-deepseek-r1:8b <input>: DeepSeek R1 with 8B.
• pa-deepseek-r1:14b <input>: DeepSeek R1 with 14B.
• pa-deepseek-r1:32b <input>: DeepSeek R1 with 32B.
• pa-deepseek-r1:70b <input>: DeepSeek R1 with 70B.
• pa-deepseek-r1:671b <input>: DeepSeek R1 with 671B.

• pa-gemma3:1b <input>: Gemma 3 model with 1B parameters.
• pa-gemma3:4b <input>: Gemma 3 model with 4B.
• pa-gemma3:12b <input>: Gemma 3 model with 12B.
• pa-gemma3:27b <input>: Gemma 3 model with 27B.

• pa-devstral <input>: Access to a special developer model called Devstral.

This documentation describes all available text commands and their professional usage within your WSL environment. Each command is categorized by prefix, distribution, and language/compiler.

• lx <command> Executes <command> directly in the default WSL distribution (default Linux). Example: lx ls -la → lists all files in the current directory.

• pl <command> Alias for lx, stands for “peharge linux”. Identical functionality.

Examples:

• lx-cpp g++ main.cpp -o main compiles a C++ file
• pl-p python3 script.py runs a Python script

Each distribution can optionally be combined with language extensions. Replace <dist> with one of the following values:

ubuntu, debian, kali, arch, openSUSE, mint, fedora, redhat, sles, pengwin, oracle, alpine, clear

Syntax:

<dist>[-cpp|-c|-p] <command>

Examples:

• ubuntu apt update → updates package lists on Ubuntu
• debian-c gcc hello.c -o hello → executes the command in a C shell and forwards it to Debian
• arch-p python3 -m venv venv → creates a Python virtual environment on Arch Linux

This overview lists typical commands for running or compiling code in various programming languages.

The placeholder <code>{user_input}</code> represents the respective source code filename or script.

pc g++ {user_input}            // Compile a C++ file

pc gcc {user_input}            // Compile a C file

wsl g++ --version              // Show installed G++ version

wsl {user_input}               // Run a compiled program inside WSL

...                            // more distributions possible     

pc-cpp {user_input}            // Compile a C++ file

cppc {user_input}              // Compile a C++ file

prcpp {user_input}             // Compile a C++ file and run the executable

...                            // more distributions possible  

pc-c {user_input}              // Compile a C file

cc {user_input}                // Compile a C file

prc {user_input}               // Compile a C file and run the executable

...                            // more distributions possible  

pc-ss {user_input}             // Compile a C# file

csc {user_input}               // Compile a C# file

prcs {user_input}              // Compile a C# file and run the executable
...                            // more distributions possible  

pc-rust {user_input}           // Compile a Rust file

rustc {user_input}             // Compile a Rust file

prr {user_input}               // Compile a Rust file and run the executable

...                            // more distributions possible  

pc-js {user_input}             // Run a JavaScript file

pc-node {user_input}           // Run a JavaScript file

node {user_input}              // Run a JavaScript file

tsc {user_input}               // Compile a TypeScript file

ts-node {user_input}           // Run a TypeScript file directly

...                            // more distributions possible  

pc-java {user_input}           // Compile a Java file

javac {user_input}             // Compile a Java file

java -jar {user_input}         // Run a .jar file

prj {user_input}               // Compile a Java file and run the executable

...                            // more distributions possible  

pc-kotlin {user_input}         // Compile with runtime environment

kotlinc hello.kt -include-runtime -d {user_input}  
                              // Compile with runtime environment

kotlinc -script {user_input}   // Run a Kotlin script

...                            // more distributions possible  

prp {user_input}               // Run a Python script

pcp {user_input}               // Create an executable file

pc-python {user_input}         // Create an executable file

python {user_input}            // Run a Python script

pythonc {user_input}           // Create an executable file

pyinstaller --onefile {user_input}  
                              // Create an executable file

pyinstaller --onefile --noconsole --icon={user_input}  
                              // Create executable with icon and no console

...                            // more distributions possible  

pc-go {user_input}             // Compile or run Go code

go run {user_input}            // Run Go code

go build {user_input}          // Build Go code

...                            // more distributions possible  

pc-julia {user_input}          // Julia

pc-php {user_input}            // PHP

pc-lua {user_input}            // Lua

pc-tsc {user_input}            // Lua with srlua (Lua compiler)

pc-swift {user_input}          // Swift

pc-dart {user_input}           // Dart

pc-haskell {user_input}        // Haskell interactive

pc-dotnet {user_input}         // F# interactive shell

pc-scalac {user_input}         // Compile Scala

pc-clj {user_input}            // Clojure

pc-ocamlc {user_input}         // OCaml

pc-elixir {user_input}         // Elixir

...                           // More possible

Our debugger commands provide you with an efficient and clear way
to analyze your programs in the following programming languages and quickly identify errors:

• pd-cpp (C++)
• pd-c (C)
• pd-cs (C#)
• pd-p (Python)
• pd-rust (Rust)
• pd-node (Node.js)
• pd-java (Java)
• pd-ruby (Ruby)
• pd-r (R)
• pd-go (Go)
• pd-julia (Julia)
• pd-php (PHP)
• pd-lua (Lua)
• pd-ts (TypeScript)
• pd-kotlin (Kotlin)
• pd-swift (Swift)
• pd-dart (Dart)
• ...

With short, precise debug commands, we enable you to perform fast error analysis
and fixing directly in your development process. Our tools are specially designed
to maximize the efficiency of your debugging work while maintaining clarity.

These commands activate various fun console animations, ASCII games, or amusing effects.
Ideal for terminal entertainment or demonstrations.

• fun
  Starts a general fun overview or default animation.

• fun sl
  Displays an animated train, inspired by typos of the command ls.

• fun aafire
  Simulates animated ASCII fire in the terminal.

• fun cmatrix
  Matrix-style green code rain animation.

• fun cow
  ASCII cow that “speaks” text. Uses cowsay or similar logic.

• fun dragon
  ASCII dragon that outputs text (similar to cowsay).

• fun figlet
  Creates large ASCII letters from text.

• fun fortune
  Displays a random humorous or wise quote.

• install fun main
  Installs main components of the fun command collection.

• fun ponysay
  Extension of cowsay with ASCII ponies (My Little Pony).

• fun telnet
  Opens Telnet to classic ASCII services (e.g., Star Wars).

• fun train
  ASCII-style train animation.

• fun train a
  Variant A of the train animation.

• fun train F
  Variant F of the train animation (e.g., fast speed).

• fun train l
  Slow or different animated train track.

• fun train S
  Special train variant (e.g., steam locomotive).

• fun train t
  Variant with transparent layout or special effect.

• fun install games
  Installs games playable with the fun commands.

• fun bastet
  Terminal version of Tetris with “smart” blocks (Bastet).

• fun chess
  Starts a chess game (e.g., GNU Chess in the terminal).

• fun moon-buggy
  ASCII game with a moon buggy avoiding obstacles.

• fun nethack
  Starts the classic ASCII role-playing game NetHack.

• fun nsnake
  Snake game for the terminal (ASCII graphics).

• fun pacman
  ASCII version of Pacman.

• fun tictactoe
  Tic-Tac-Toe (three in a row) in the terminal.

• fun tint
  A text-based RPG or adventure game.

• fun tetris
  Classic Tetris in the terminal (e.g., vitetris).

• fun calculator
  Starts a console calculator.

• fun calc
  Alias for fun calculator.

• fun install calculator
  Installs the required calculator environment.

• fun matrix
  Matrix effect (green rain of numbers).

• fun matrix green
  Matrix effect in green – the classic.

• fun aquarium
  ASCII aquarium with fish and bubbles.

• fun aqua
  Alias for fun aquarium.

• fun bb
  Shows a complex ASCII animation with music – a classic!

• jup-p {FILE}
  Creates a Jupyter environment for Python inside the current venv and optionally opens a specified file like test.jup or a classic .ipynb notebook.

• jup-r {FILE}
  Creates a Jupyter environment for R (Rscript) inside the current venv. A file such as test.jup or .ipynb can also be opened directly.

• jup-j {FILE}
  Sets up a Jupyter environment for Julia in the current venv. Similarly, files like test.jup or .ipynb can be opened directly.

• jupl
  Starts JupyterLab, a modern web interface for Jupyter notebooks.

Note: These commands support both classic .ipynb files and .jup files like test.jup.

...