Hacktool Docs — Grey Hack Community Tools

SETTING	DESCRIPTION
RESUME RESULTS	When enabled, shows only one result of the same type (e.g., one guest shell instead of three). Reduces clutter.
DATABASE LINK	Keep enabled. Doom will use and populate the database for library info and passwords.
REMOTE DATABASE	Configure if you want multiple Doom installs to share the same database via SSH.
METAXPLOIT / CRYPTO PATH	Recommended to move these libs to your dfiles folder rather than /lib to prevent them from being exploited.
DCALL INJECT	If a target crashes when uploading dcall, enable this to create it on-target instead.
DCALL NAME	Set a custom name for your dcall file to avoid conflicts with other Doom users.
CUSTOM LOG PATH	Path to a template file used when corrupting target logs.
INTERNAL DICT	Doom builds a brute-force dictionary at startup. Disable after running sys -ph -internal once to speed up startup.

COMMAND	ACTION
main	Close all sessions, return to main prompt
back / close / 0	Close current session, go back to previous one
backc	Close all regular target sessions, keep proxy sessions open

TYPE	CAPABILITIES
SHELL	Full access — scripts, hacking, uploading binaries, connecting to other targets, escalating privileges. Highest utility.
COMPUTER	Read/write files, interact with system, change permissions. Cannot run scripts or perform new hacks.
FILE	Read, copy, delete, list file system. Most limited but still useful for data extraction.

TYPE	DESCRIPTION
Auto Break	Triggered if a session command (hack, hacklib, escalate, rshell, rcache) fails. Prevents commands running on wrong target.
Manual Break	Triggered by the break command. Useful in conditional logic.

COMMAND	DESCRIPTION
#jump	Creates a jump point. On auto break, macro jumps here instead of stopping. Auto break also calls backc first.
#onbreak	Marks the jump point for manual break command (without auto backc).
#command	Prefix any command with # — it only executes IF the command directly before it caused an auto break. Ignored otherwise.
#hold	Pauses macro and prompts user to continue or stop. Useful when you need to take a manual action mid-macro.
#if ... #endif	Block-style conditional. Commands inside only execute if condition is true.
#loop N ... #endloop	Block-style loop. Use $n for index. Cleaner than the inline loop command for complex iterations.
#macro name ... #endmacro	Define an inline macro callable within the same file. Use 1$, 2$ for params.
// comment	Lines starting with // are ignored (comments).

5HELL

GREY HACK HACKTOOL — COMMAND REFERENCE

5hell v4.3.6 "falling_skies" by Plu70. A pipe-driven exploitation framework with flat command dispatch, GLASSPOOL session mirroring, persistent macro engine, and full .5pk package system.

75+

COMMANDS

CATEGORIES

GUIDE SECTIONS

LOCAL SOURCE

QUICK ACCESS

▶ GETTING STARTED

Install, rkit setup, do.rc config, file structure.

▶ SHELL & PIPING

Pipe engine, GLASSPOOL mirroring, EZ_CLIP tokens.

▶ CLIP & BUFFER

Clipboard slots, Memory Alpha BUFFER, malp object handling.

▶ MACROS & SCRIPTS

Persistent macros, do scripts, bat alias, SAFEWORD, do.rc.

▶ EXPLOIT WORKFLOW

probe → meta → zap/db/roil, 5phinx TUI, hashim cracking.

▶ CUSTOM OBJECT / cob

Persistent key-value store, @home config, session exports.

EXPLOIT CHAIN

probe [ip]

→

meta link [ip] [port]

→

meta scan

→

roil

→

malp

→

glasspool

→

silentclean

COMMANDS

GETTING STARTED

5hell is a pipe-driven exploitation framework for Grey Hack multiplayer. It runs as a compiled GreyScript binary using a flat command dispatch map, full pipe engine, persistent macros, and modular .5pk packages.

1. OBTAIN 5HELL

The full 5hell source is available on GitHub. Clone or download the repository to get all .5pk.src files:

GITHUBhttps://github.com/jhook777/5hell-for-Grey-Hack-the-Game

2. REQUIRED LIBRARIES

5hell uses metaxploit.so, crypto.so, and aptclient.so. At startup, super_import automatically scans the filesystem for the highest-version copies and loads them. Ensure they exist:

apt-get addrepo [HACKSHOP_IP]
apt-get update
apt-get install metaxploit /lib
apt-get install crypto /lib

3. COMPILE AND RUN

5hell ships as source files and must be compiled before first use. You have two options:

OPTION A — IN-GAME BUILD COMMAND

Copy all .src files from the repository into /root/src on your in-game machine. You can do this manually by pasting them into the Grey Hack script editor

From a root terminal inside Grey Hack, navigate to your source folder and compile:

cd /root/src
build 5hell.src /root/rkit/

OPTION B — GREYBEL VS CODE EXTENSION

Use the Greybel VS Code extension to transpile and bundle the source outside of the game. Open 5hell.src in VS Code, then use the Greybel build command to produce compiled output installer.src files you can paste into the in-game editor.

GREYBEL

The Greybel extension handles import_code() directives at transpile time, bundling all .5pk.src modules into a few output installer files. Greybel also supports direct file import/compile using a bepinex extension. Learn more and install the greybel extension from the VS Code Marketplace: search greybel-vs.

Once compiled, launch 5hell from the output directory:

cd /root/rkit
5hell

4. BUILD THE RKIT

Once running, set up the operational environment using kore -r. This creates the ~/rkit directory with 5hell, its libraries, and your database file:

|> kore -r

RKIT CONTENTS

~/rkit/ — compiled 5hell binary + metaxploit.so + crypto.so + database.csv
~/rkit/tables/ — rainbow tables (t5, tp) for hash cracking
~/Config/do.rc — auto-executed on every 5hell startup

5. FILE STRUCTURE

/root/
  src/
    5hell.src          ← entry point (user-editable)
    5hell.5pk.src      ← core: globals, CLIP, BUFFER, ls/cd/rm/ps...
    5phinx.5pk.src     ← print override, get_file, GLASSPOOL, switch engine
    kore.5pk.src       ← kore command, DaemonManager, startup RC
    dtools.5pk.src     ← macro, grep, tree, cob, code, glosure...
    contrib.5pk.src    ← pwgen, DaemonManager class, dm
    net.5pk.src        ← probe, db, zap, ssh, rsi, air, scpm...
    help.5pk.src       ← help command + summary
  rkit/
    5hell              ← compiled binary
    database.csv       ← lib scan results (grows over time)
    do.rc              ← startup resource config (auto-executed)
    tables/t5          ← rainbow table
    tables/tp          ← rainbow table (passwords)
  Config/
    do.rc              ← startup config (checked first before rkit/do.rc)

6. CONFIGURE do.rc

The do.rc file runs automatically on every 5hell startup. Create it at ~/Config/do.rc (priority) or ~/rkit/do.rc. Each line is a 5hell command:

# do.rc example
kore --silent               # suppress startup output
target 1.2.3.4 22           # set default target
macro set autoexp "probe @pipe | sphinx"
kore --override colorDefault <#FFFFFFFF>   # override terminal color
kore --silent               # re-enable output

TIP

Wrap your do.rc with kore --silent at the start and end to suppress output during the initialization sequence. Lines beginning with # are comments and are skipped.

7. SECURITY: kore -s

After deployment on any machine, run the security sweep to harden it:

|> kore -s

This performs: chown root on all files, removes /etc/passwd, clears Bank/Mail data, runs silentclean, and locks file permissions. Use kore -sc for the same sweep using silentclean instead of rclean.

WARNING — kore -S

The paranoid mode (kore -S) also removes /home, /bin, and /usr. Use ONLY on rented servers, never on your home machine.

SHELL & PIPING

5hell's core input loop processes commands with full pipe support, EZ_CLIP token substitution, macro expansion, and GLASSPOOL session mirroring. Understanding these mechanics is key to scripting effective workflows.

THE PROMPT

The default prompt is |>. When GLASSPOOL is active, the prompt turns blue — a visual indicator that file operations are targeting a remote machine. Toggle the full decorated prompt with:

|> prompt // toggles full prompt with IP/user/path display on/off

SINGLE PIPE ( | )

The single pipe passes the return value of one command as the last argument of the next. The piped value can be any type — string, object, list.

|> probe 1.2.3.4 | clipa         // stores probe output in clipa
|> db -r 1.2.3.4 22 | malp       // push obtained shell to BUFFER via malp
|> rsi -r 0 | glasspool          // mirror rshell[0] via glasspool
|> cat /etc/passwd | gopher      // crack hashes from file

DOUBLE PIPE ( || )

The double pipe chains commands WITHOUT passing output. Both commands execute sequentially but independently.

|> probe 1.2.3.4 || echo done    // probe runs, then echo runs — no piping
|> meta link 1.2.3.4 22 || meta scan || roil   // three sequential commands

FLOATING QUOTES

Tokens wrapped in double quotes are joined into a single argument, allowing spaces inside parameter values:

|> macro set greet "echo Hello @pipe"    // "echo Hello @pipe" is one argument
|> cob set msg "this is one value"

EZ_CLIP TOKENS

Before every command is dispatched, EZ_CLIP substitutes special tokens in the argument list:

TOKEN	REPLACED WITH
@a	Contents of clipboard A (clipa)
@b	Contents of clipboard B (clipb)
@c	Contents of clipboard C (clipc)
@B [n]	BUFFER[n] — e.g., `@B 0` = first item in BUFFER
@home	`get_custom_object.HOME.ip` — your @home server IP
@tbuf	Contents of T_BUF (transmission buffer list)
@o [key]	`get_custom_object[key]` — any custom_object value

|> probe @a              // probe using IP stored in clipa
|> glasspool @B 1        // GLASSPOOL on BUFFER[1] shell object
|> ssh root@pass @home   // SSH to @home server
|> db -m @o myx0         // use metaxploit from custom_object

GLASSPOOL — SESSION MIRRORING

GLASSPOOL redirects globals.localmachine to a remote shell's computer, making all GLASSPOOL-aware commands transparently operate on the remote machine.

GLASSPOOL-AWARE COMMANDS

ls, cd, cp, mv, rm, mkdir, cat, tree, grep, ps, pwd — all operate on the remote machine when GLASSPOOL is active.

|> db -r 1.2.3.4 22      // exploit target, shell → BUFFER[1]
|> glasspool @B 1         // activate GLASSPOOL on that shell (prompt turns blue)
|> ls /etc                // lists /etc on the REMOTE machine
|> cat /etc/passwd        // reads remote /etc/passwd
|> silentclean            // cleans remote logs
|> glasspool              // deactivate (or type: exit)

NOTE

Commands that call get_shell directly — ifconfig, air, iwlist — always operate locally and ignore GLASSPOOL.

BUILT-IN ALIASES

ALIAS	EXPANDS TO
gp	glasspool
sc	silentclean
bat [file]	do 1 -f [file]
exit	quit
set key val	cob set key val
get key	cob get key
push key val	cob push key val
inspect [key]	cob inspect [key]

CLIP & BUFFER

5hell has two complementary storage systems: the CLIP clipboard (three named slots for quick scalar/object storage) and the BUFFER (an ordered list for any object type, primarily shells and files obtained during exploitation).

THE CLIPBOARD — clipa / clipb / clipc

Three clipboard slots (a, b, c) each store one value of any type. Access slots via EZ_CLIP tokens @a, @b, @c anywhere in a command.

CLIPBOARD
|> clipa foobar           // store string "foobar" in slot a
|> echo @a                // prints "foobar"
|> clipa                  // return current value without changing it

|> zap | clipa            // pipe shell object into clipa
|> glasspool @a           // use stored object directly

|> clipa @B 1             // store BUFFER[1] into clipa
|> clipa @tbuf            // store T_BUF list in clipa

ARITHMETIC OPERATIONS

When the stored value is an integer (or a string that parses to one), you can perform in-place arithmetic:

|> clipa 0
|> clipa ++               // increment → 1
|> clipa --               // decrement → 0
|> clipa += 10            // add 10 → 10
|> clipa -= 3             // subtract 3 → 7

SPECIAL VALUES

ARGUMENT	EFFECT
-n	Set slot to null
-z	Set slot to integer 0
@cc	Store the full command history as a string
@B [n]	Store BUFFER[n] in this slot
@tbuf	Store the T_BUF list in this slot

THE BUFFER — Memory Alpha

BUFFER (globals.BUFFER) is a list that holds any type. It is seeded at startup with the local shell as BUFFER[0]. Every exploit result — shells, computers, files, strings — is pushed here by commands like db, zap, roil, and ssh.

BUFFER ACCESS
|> malp                   // open the BUFFER management menu
|> malp @B 1              // open malp on BUFFER[1] specifically
|> malp -p someObject     // push object to BUFFER without opening menu
|> malp --export          // return BUFFER contents as a list

MALP OBJECT HANDLERS

When you open an object in malp, it detects the type and presents a context menu:

OBJECT TYPE	AVAILABLE ACTIONS
shell / pshell / ftpshell	Infiltrate, SCP, silentclean, glasspool, rclean, rshell
computer	File operations, read/write, ps
file	Open, edit, cat, SCP, delete
string	Echo, store to clip, write to file
list	Enumerate, push to BUFFER, store to cob
map / function	Decompile with code, p_exe interactive caller

BUFFER WITH ENUM

|> tree -r /lib            // returns list of all files in /lib
|> malp --export | enum -a // push each item in BUFFER individually
|> db -r 1.2.3.4 *         // exploit all ports, shells go to BUFFER
|> malp                    // browse results interactively

WORKFLOW TIP

@B 0 is always the local shell. After exploiting, results start at @B 1. Use malp to browse, or pipe directly: glasspool @B 1 to mirror the first obtained shell.

MACROS & SCRIPTS

5hell macros are named command chains stored persistently in get_custom_object.macros. They survive across sessions and nested launches. Fire a macro simply by typing its name at the prompt.

DEFINING MACROS

INLINE MACRO
|> macro set greet "echo Hello @pipe"
|> echo World | greet             // output: Hello World

|> macro set quickhack "probe @pipe | sphinx"
|> quickhack 1.2.3.4              // probe 1.2.3.4 then open 5phinx

|> macro set chain "meta link @pipe 22 || meta scan || roil"

MULTI-LINE MACRO FROM FILE

Load a .mac file where each line becomes a command in the chain:

MACRO FILE
// ~/rkit/exploit.mac
probe @pipe
meta link @pipe 22
meta scan
roil
malp

// Load it
|> macro set exploit -f /root/rkit/exploit.mac
|> exploit 1.2.3.4

THE @pipe PLACEHOLDER

Inside a macro body, @pipe is replaced with the argument passed when firing the macro (or the piped input from the previous command):

|> macro set scan "probe @pipe"
|> scan 1.2.3.4               // @pipe → "1.2.3.4"
|> echo 1.2.3.4 | scan        // piped input also works as @pipe

MANAGING MACROS

|> macro list              // list all defined macros
|> macro -v greet          // verbose: print chain before firing
|> macro del greet         // delete macro "greet"
|> macro set greet "echo Hi"  // update existing macro

PRIORITY NOTE

Macros take priority over commands of the same name. If a macro and a command share a name, the macro wins. Choose names that don't shadow built-in commands unless you intend to override them.

DO SCRIPTS — BATCH EXECUTION

do runs a command or a batch file N times. Each line in a batch file is executed as a full 5hell command with pipe support.

DO COMMAND
|> do 5 "echo hello"           // run echo 5 times
|> do 1 -f /root/rkit/setup.mac // run batch file once
|> bat /root/rkit/setup.mac    // alias: same as do 1 -f

BATCH FILE FORMAT

BATCH FILE (setup.mac)
# lines starting with # are comments (also | and -)
kore --silent
probe 1.2.3.4
meta link 1.2.3.4 22
meta scan
roil
@STOP              ← SAFEWORD: breaks the loop immediately if reached
silentclean
kore --silent

FEATURE	DESCRIPTION
@STOP	SAFEWORD — placing this on any line immediately breaks the do loop
# / - / \|	Comment prefixes — these lines are silently skipped
Full pipes	Each batch line supports the full pipe engine: `probe @pipe \| sphinx`
N times	`do 10 "zap addr vuln"` fires the same exploit 10 times

do.rc — AUTO-EXECUTED ON STARTUP

On every 5hell launch, globals._startup_resource_configuration checks for and executes a do.rc file automatically:

1. Checks ~/Config/do.rc first
2. Falls back to ~/rkit/do.rc
3. Decrypts if the file is binary+encrypted (using HOME.dorc_key)
4. Executes each non-comment line as a 5hell command

do.rc EXAMPLE
# startup config
kore --silent
target 1.2.3.4 22
macro set ex "probe @pipe | sphinx"
kore --override colorDefault <#00FF00FF>
kore --silent

MACRO VS COMMAND PRIORITY TABLE

ORDER	MECHANISM	HOW
1st	Macro expansion	If prompt[0] is in get_custom_object.macros, expands to macro call
2nd	Built-in aliases	set/get/push/inspect/exit/sc/gp/bat are replaced before dispatch
3rd	command map dispatch	Calls command[name](arg1, arg2, arg3, arg4)
4th	shell.launch fallback	Searches /bin and current path for a matching binary

EXPLOIT WORKFLOW

5hell's exploit system is built around the Grey Hack metaxploit library model. Libraries on remote ports expose memory/value pairs that overflow to yield shells, computers, or files. The workflow follows a consistent pattern regardless of target.

STEP 1 — PORT RECONNAISSANCE

Use probe to scan a target and populate the port map. Port colors indicate library status:

|> probe 1.2.3.4

PORT COLORS

Green = open port | Cyan = known lib in database | Gold = unknown lib
Red = closed/firewalled | Orange = no database found | Grey = no response

Set the target globally so subsequent commands don't need the IP:

|> target 1.2.3.4 22

STEP 2 — LINK THE METALIB

Link the MetaLib on the target port using meta link. This opens a net session, dumps the library, and stores it for exploitation:

|> meta link 1.2.3.4 22     // link a specific port
|> meta                      // show linked MetaLib info

STEP 3 — SCAN FOR VULNERABILITIES

Scan the linked MetaLib to find exploitable addresses. Results are stored in globals.XPLOITS:

|> meta scan                 // scan → populates globals.XPLOITS
                             // output: list of vulnerable addresses + vuln names

STEP 4 — EXPLOIT

Three options for firing exploits:

COMMAND	BEHAVIOR
zap [addr] [vuln]	Fire a single specific exploit. Result pushed to BUFFER.
roil	Fire ALL exploits in XPLOITS at once. All results pushed to BUFFER.
db -r [ip] [port]	All-in-one: link + scan + exploit + database. Most efficient.

MANUAL FLOW
|> meta link 1.2.3.4 22
|> meta scan
|> roil
|> malp            // browse results in BUFFER

AUTOMATED FLOW
|> db -r 1.2.3.4 22        // does everything above in one command
|> db -r 1.2.3.4 *         // scan ALL open ports
|> db -r * *               // scan ALL ports at targetIP

BOUNCE EXPLOIT

Some router library vulnerabilities return a computer object. By passing a LAN IP as an inject value, that computer belongs to a machine inside the network — allowing you to target devices with no open ports:

|> db -r 1.2.3.4 0 -i 192.168.1.2   // bounce to 192.168.1.2
|> zap 0x00002934 kernel_router.so 192.168.1.2

5PHINX — THE TUI

5phinx is a full-screen TUI that wraps the entire exploit cycle in an interactive menu. It's the fastest way to hack when you don't need to script the flow:

|> sphinx 1.2.3.4 22    // launch 5phinx on specific target
|> sphinx               // use current targetIP:targetPort

5phinx menu steps: [1] Link MetaLib → [2] Fire all exploits (roil) → [3] View BUFFER results → [4] Interact with obtained objects.

HASH CRACKING — THE HASHIM WORKFLOW

After getting access to a target, gather password hashes and transmit them to your @home hashim server for cracking:

ON TARGET (via GLASSPOOL)
|> glasspool @B 1          // mirror shell
|> tree / 0 r              // recursive tree: buffer hashes to T_BUF
|> tdump                   // write T_BUF to ~/pass

TRANSMIT TO @HOME
|> transmit                // SSH to @home, write hashes to sharedfile

ON @HOME (separate session)
|> hashim -d               // start hashim daemon
// hashim monitors sharedfile, cracks hashes with t5/tp tables
// writes cracked passwords to dump.txt

DATABASE — db WRITES RESULTS

The db command writes all scan/exploit results to ~/rkit/database.csv. Future runs against the same lib version skip the scan entirely. Load saved results without rescanning:

|> linkdb 1.2.3.4 22       // load XPLOITS from database, no net_use needed
|> roil                    // fire immediately

CUSTOM OBJECT / cob

get_custom_object is a Grey Hack built-in that provides a persistent shared-memory map available across all nested shell.launch calls. 5hell stores macros, @home config, rainbow tables, session exports, and password dictionaries here. The cob command is the full interface to this store.

BASIC OPERATIONS

SET / GET
|> cob set myvar hello       // store string
|> cob get myvar             // → "hello"
|> set myvar hello           // alias: same as cob set
|> get myvar                 // alias: same as cob get

|> cob set count 0           // store string "0"
|> cob set count @z          // store integer 0 (not string)
|> cob set nothing @n        // store null
|> cob set opts {}           // create empty map
|> cob set targets []        // create empty list

DOT-SYNTAX FOR NESTED ACCESS

Dot notation traverses nested maps and lists. The parent key must already exist as a map/list:

|> cob set config {}
|> cob set config.ip 1.2.3.4
|> cob set config.port 22
|> cob get config.ip         // → "1.2.3.4"

|> cob set hosts []
|> cob push hosts 1.2.3.4   // append to list
|> cob push hosts 5.6.7.8
|> cob get hosts.0           // → "1.2.3.4" (list index 0)

INSPECTION & DELETION

|> cob inspect               // print all keys + truncated values
|> cob inspect config        // print just the config map
|> cob indexes               // return all keys as a list
|> cob del myvar             // delete a key
|> cob purge                 // ⚠ clear the ENTIRE custom_object
|> cob validate              // ensure macros/stack_pool/HOME keys exist

INSTALLING FUNCTIONS AS COMMANDS

Store a function in cob, then install it as a live command reachable from the prompt:

// In a .5pk or do.rc:
get_custom_object.myTool = function(arg1, arg2, arg3=0, arg4=0)
    print "myTool called with: " + arg1
end function

// In 5hell:
|> cob install myTool        // now "myTool" works as a command
|> myTool hello

@HOME CONFIGURATION

The HOME map in cob stores your @home hashim server config. Use set HOME.key value to update any field:

KEY	DEFAULT	PURPOSE
HOME.ip	—	SSH/rshell server public IP
HOME.loginport	22	SSH port
HOME.rshellport	1222	Reverse shell port
HOME.user	root	SSH username
HOME.pass	—	SSH password
HOME.sharedfile	/root/pass	Hash swap file for hashim
HOME.database	/root/rkit/database.csv	Exploit database path
HOME.dorc_key	0	Decryption key for do.rc (0 = no encryption)

|> set HOME.ip 1.2.3.4
|> set HOME.pass MyPass123
|> get HOME.ip               // → "1.2.3.4"
|> echo @home                // @home EZ_CLIP token → HOME.ip value

SESSION EXPORTS (myx0 / mys0 / myc0)

On startup and at each nested launch depth, 5hell exports its core objects to cob for access across sessions. The suffix increments with nesting depth (0 = top level, 1 = one launch deep, etc.):

KEY	TYPE	CONTENT
myx0	MetaxploitLib	Local metaxploit library
myc0	cryptoLib	Local crypto library
mys0	shell	Local shell object
myi0	string	"pubIP : localIP"
myx1	MetaxploitLib	Nested session 1 metaxploit
mys1	shell	Nested session 1 shell

|> db -M                     // use myx0 automatically (no re-import)
|> clipa @o mys1             // get nested session shell into clipa
|> glasspool @o mys0         // GLASSPOOL on the cob-stored home shell
|> db -m @o myx0             // explicit: use myx0 as metaxploit

WHY THIS MATTERS

When running 5hell inside a compromised target via infil, the session exports let you reference your original home shell and metaxploit from the nested context without re-importing or reconnecting.

5HELL Tool Created By: @PLU70

Hacktool Documentation Portal

PATH	PURPOSE
/root/InsecureLibs/init.so	Insecure lib for poison and LAN bounce exploits
/root/SecureLibs/librshell.so	Required for rshell start

MODE	DESCRIPTION
Default	No transformation; best general-purpose output
Uglify	NOT SUPPORTED — HEX will not work if uglified
Beautify	Formats code for readability (slower execution)

MAP	PURPOSE	COMMANDS
g.tools	Exploitation & recon	scan, nmap, hack, decipher, rshell, poison, net, sniffer
g.util	Utility commands	stack, swap, jump, proxy, log, tree, apt-get, terminal, lockdown
g.fs	Filesystem operations	cd, rm, ps, kill, reboot

KEYS	SHADE	USE
b1 – b5	Blue	Primary UI, commands
s1 – s4	Slate / purple	Secondary elements
r1	Red	Errors, root user indicator
o1	Orange	Warnings
g1 – g2	Green	Success, exploit hits
l1 – l3	Light / tan	Filenames, hostnames, labels
y1	Yellow	Alert warnings

FIELD	TYPE	DESCRIPTION
type	string	"shell" \| "computer" \| "file"
source	string	How acquired: "home", "overflow", "proxy (N)"
shell	shell	Shell object (populated when type == "shell")
computer	computer	Computer object
file	file	Working directory file object
user	string	Resolved username
currentPath	string	Active working path (default "/")
metax	metaLib	Attached metaxploit lib
crypto	cryptoLib	Attached crypto lib
public / local	string	Public and LAN IP strings

SOURCE	FORMAT	LOAD TIME
$proxies env var	JSON list: [ip, port, user, pass][]	At startup
Map.conf files	Scanned from current filesystem	During proxy initialization (g.func.getMap)

LEVEL	FUNCTION	EFFECT
Hard Nuke	g.func.nuke_hard(file)	Delete /lib, /sys, /boot — system unbootable
Soft Nuke	g.func.nuke_soft(file)	Prepend "_" to all files — binaries unexecutable
Mail Nuke	g.func.nuke_mail(file)	Clear Mail.txt, Bank.txt, passwd files

FILE / FOLDER	PURPOSE
main.src	Entry point: imports, init(), main loop
mediator.src	ExtensionMediator (DI bus)
commands.src	All Command registrations
managers/command/	CommandManager, Command, Parameter type definitions
managers/session/	SessionManager, Session factory, handler types
managers/ui/	UI print/display logic (tables, prompt, splash)
managers/theme/	ThemeManager — hex color map, colorText() helper
managers/macro/	MacroManager — load and execute macros from files
managers/config/	ConfigManager — load/save JSON config to disk
managers/lib/	LibManager — cache metaxploit/crypto lib handles
libs/error.src	Error object — never use raw strings for errors

TYPE	SOURCE	COVERS
ShellSession	get_shell() / SSH connect	shell + computer access
ComputerSession	shell.host_computer	computer-level access only
FileSession	computer.File(path)	file/folder operations only

CONSTANT	BEHAVIOR
PARAMETER_TYPES.STRING	Any string value; passed through as-is
PARAMETER_TYPES.NUMBER	Converts via to_int(); errors if non-numeric
PARAMETER_TYPES.BOOLEAN	Accepts "true" / "false" strings
PARAMETER_TYPES.FLAG	Present = true, absent = false
PARAMETER_TYPES.OPTIONS	Must match a key from a declared options map
PARAMETER_TYPES.REST	Consumes all remaining args as a single string

LEVEL	COVERS
"file"	Any session type — file, computer, or shell
"computer"	Computer sessions and shell sessions
"shell"	Shell sessions only

LEVEL	COVERS
"guest"	guest, user, and root users
"user"	user and root users
"root"	root only

GREYSCRIPT

THE GREY HACK SCRIPTING LANGUAGE — FULL REFERENCE

GreyScript is a fork of MiniScript with a full in-game API for shells, computers, networks, files, and services. Scripts run as compiled Grey Hack binaries or as interactive commands in hacktools. File size limit: 160,000 characters.

REFERENCE SECTIONS

LANGUAGE BASICS

Types, operators, variables, string ops, type checking.

CONTROL FLOW

if/else, while, for, break, continue, functions, scopes.

OOP PATTERNS

Map-based classes, New() factory, inheritance, isa.

BUILT-IN INTRINSICS

Global functions: math, string, list, map, I/O, time.

SHELL & COMPUTER API

shell, computer, file objects — full method reference.

NETWORK & PORTS

router, port, netSession, nslookup, whois.

METAXPLOIT

metaxploit, metaLib, debugLibrary — exploit reference.

BLOCKCHAIN & CRYPTO

blockchain, wallet, coin, subwallet, crypto library.

COMMON PATTERNS

Error handling, SSH connect, file ops, exploitation loop.

KEY LANGUAGE NOTES

IMPORTANT GOTCHAS

All numerics are doubles. Booleans are 1 (true) and 0 (false). No try/catch — check return values explicitly. No class keyword — use map-based prototypes with .New() factories. Functions are always called without parentheses — use @ to get a reference without calling.

QUICK REFERENCEtypeof myVar              // "number" | "string" | "list" | "map" | "function" | "null"
myVar isa string          // 1 or 0
@myFunc                   // reference without calling
get_custom_object         // persistent state across shell.launch calls
active_user               // current username string
params                    // list of CLI args when running as a command

Language Basics

Data Types

TYPE	NOTES	EXAMPLE
number	All numerics are doubles. Booleans are 1/0.	42, 3.14, 1, 0
string	Unicode, double quotes only.	"hello world"
list	Ordered, zero-indexed.	["a", "b", "c"]
map	Key-value pairs (dictionary).	{"key": "value"}
function	First-class values.	function(x) ... end function
null	Absence of a value.	null

Operators

Numbers

2 ^ 4     // 16 (power)
7 % 3     // 1 (modulo)
a and b   // logical AND → 1 or 0
a or b    // logical OR  → 1 or 0
not a     // logical NOT → 1 or 0
a == b    // equality
a != b    // inequality

Strings

"hello" + " world"   // concatenation → "hello world"
"test" - "est"       // removal → "t"
"ab" * 3             // repeat → "ababab"
"hello"[1:4]         // slice → "ell"
"hello"[0]           // index → "h"

Lists

["a"] + ["b"]         // concat → ["a","b"]
["x"] * 2            // repeat → ["x","x"]
myList[0]            // index
myList[1:3]          // slice

String Methods

s.len                        // length
s.lower / s.upper            // case conversion
s.trim                       // strip whitespace
s.code                       // char code of first character
s.val                        // parse as number → 0 if non-numeric
s.to_int                     // parse as integer → original string if non-numeric
s.split(",")                 // → list; optional 2nd arg: regex option ("i","m","s","n","x")
s.replace("pat", "new")      // regex replace → string
s.replace_regex("pat","new") // explicit regex replace (same as replace on strings)
s.indexOf("x")               // → number or null (first occurrence)
s.indexOf("x", after)        // → number or null (start search after this index)
s.lastIndexOf("x")           // → number — last occurrence position
s.is_match("^Hello")         // regex match → 1 or 0
s.matches("\\w+")            // → map of {startIndex: matchString} for all matches
s.insert(3, "!")             // → string — insert at character index
s.remove("x")                // → string — remove first occurrence of substring
s.hasIndex(n)                // → 1 or 0 — check if character index exists
s.indexes                    // → list of character indices [0, 1, 2, ...]
s.values                     // → list of individual characters

List Methods

myList.push("item")            // append → list
myList.pop                     // remove + return last item
myList.pull                    // remove + return first item
myList.insert(1, "x")         // insert at index → list
myList.remove(n)               // remove item at index n → null
myList.replace(old, new)       // replace all matching values → list
myList.replace(old, new, max)  // replace up to max occurrences → list
myList.sort                    // sort in-place ascending → null
myList.sort(key)               // sort list-of-maps by field name → null
myList.sort(key, asc)          // asc: 1 = ascending (default), 0 = descending → null
myList.reverse                 // reverse in-place → null
myList.shuffle                 // randomize in-place → null
myList.indexOf("x")            // → index or null (first match)
myList.indexOf("x", after)     // → index or null (start search after this index)
myList.hasIndex(n)             // → 1 or 0 — check if index exists
myList.len                     // length
myList.sum                     // → sum of all numeric values
myList.values                  // → returns the list itself
myList.join(", ")              // → string

Map Methods

myMap.hasIndex("key")        // → 1 or 0 — check if key exists
myMap.indexOf(value)         // → key whose value matches, or null
myMap.indexOf(value, after)  // → key after the given key, or null
myMap.indexes                // → list of all keys
myMap.values                 // → list of all values
myMap.len                    // → number of entries
myMap.remove("key")          // delete entry → 1 (found) or 0 (not found)
myMap.push("tag")            // add key with value 1 (set-like insertion) → map
myMap.pop                    // remove and return the first key
myMap.pull                   // remove and return the first key (alias of pop)
myMap.sum                    // → sum of all numeric values
myMap.shuffle                // randomize key order in-place → null
myMap.replace(old, new)      // replace all values matching old with new → map
myMap.replace(old, new, max) // replace up to max occurrences → map

TIP

Maps support the + operator for merging: {"a": 1} + {"b": 2} → {"a": 1, "b": 2}. Duplicate keys are overwritten by the right operand.

Rich Text Output

GreyScript's terminal supports TextMeshPro rich text tags in any printed string:

"<color=#00FF00FF><b>green bold</b></color>"
"<color=red>error!</color>"
"<size=75%>smaller text</size>"
"<u>underlined</u>"
"<mark=yellow>highlighted</mark>"
"<noparse>raw text</noparse>"

Control Flow

If / Else

if x > 0 then
    print "positive"
else if x < 0 then
    print "negative"
else
    print "zero"
end if

// Single-line form:
if x > 0 then print "positive"

While Loop

i = 0
while i < 10
    print i
    i = i + 1
end while

For Loop

for i in range(0, 9)
    print i
end for

for item in myList
    print item
end for

for key in myMap.indexes
    print key + ": " + myMap[key]
end for

Break & Continue

for i in range(0, 10)
    if i == 5 then break     // exit loop
    if i == 3 then continue  // skip to next iteration
    print i
end for

Functions

myFunc = function(a, b = "default")
    return a + b
end function

myFunc("hello")          // "hellodefault"
myFunc("hello", " world") // "hello world"

// @ operator — reference without calling
ref = @myFunc
ref("test")              // calls myFunc("test")

Scopes

// Each function has its own local scope
globals.x = 42          // write to global scope from anywhere
outer.x   = 42          // write to enclosing function's scope
locals.x  = 42          // explicitly target local scope

// Example: closure with outer
factory = function
    locals.count = 0
    inc = function
        outer.count = outer.count + 1
        return outer.count
    end function
    return @inc
end function

exit & print

print "message"           // output to terminal
print("message")          // also valid (with parens)
exit "error message"      // terminate with message
exit                      // terminate with no message
print(output, 1)          // 1 = clear screen before printing (live dashboards)

OOP Patterns

Map-Based Class

GreyScript has no class keyword. Define a prototype map and use a New() factory:

MyClass = {
    "classID": "myClass",
    "counter": 0
}

MyClass.init = function(startVal)
    self.counter = startVal
end function

MyClass.inc = function
    self.counter += 1
    return self
end function

// Instantiate
instance = new MyClass
instance.init(10)
instance.inc.inc          // chaining
print instance.counter    // 12

New() Factory Pattern

MyClass.New = function(startVal)
    result = new MyClass
    result.counter = startVal
    return result
end function

obj = MyClass.New(5)

Inheritance

MySubClass = new MyClass
MySubClass.classID = "mySubClass"

MySubClass.describe = function
    return "Counter: " + super.counter
end function

sub = new MySubClass
print sub isa MyClass     // 1 — true
print sub isa MySubClass  // 1

Extending Built-In Types

Register methods directly on map, string, or list — they become available on every instance of that type, including all Grey Hack game objects:

// Add a method to all strings
string.trimEnd = function(text)
    if self[-1*text.len:] == text then return self[:-1*text.len]
    return self
end function

// Add a method to all maps (works on shell, computer, file objects too)
map.getPublicIP = function
    if typeof(self) == "shell" then return self.host_computer.public_ip
    if typeof(self) == "computer" then return self.public_ip
    return null
end function

// Add a method to all lists
list.distinct = function
    seen = {}
    i = 0
    while i < self.len
        key = str(self[i])
        if seen.hasIndex(key) then
            self.remove(i)
        else
            seen[key] = 1
            i += 1
        end if
    end while
    return self
end function

Always register built-in type extensions once at startup before any code uses them. Extensions are available globally for the rest of the session once registered.

Built-in Intrinsics

I/O & Control

FUNCTION	RETURNS
print(value)	Output to terminal
print(value, 1)	Clear screen then print (live mode)
clear_screen	Clear terminal
user_input(prompt, isPassword, anyKey, addToHistory)	string — read user input
exit(code)	Terminate script
wait(seconds)	Pause execution
yield	Waits for the next tick.

Type & Conversion

FUNCTION	RETURNS
typeof(value)	"number" \| "string" \| "list" \| "map" \| "function" \| "null" \| "etc...", Custom types can be added as well by using the classID property in a map
str(value)	Convert to string
char(code)	Char from ASCII/Unicode code
code(char)	ASCII/Unicode code of first char
hash(value)	Numeric hash of any value → number

Math

FUNCTION	RETURNS
abs(n)	Absolute value
sign(n)	Sign of number → -1, 0, or 1
ceil(n) / floor(n)	Round up / down
round(n, decimals)	Round to N decimal places (decimals defaults to 0)
sqrt(n)	Square root
pi	π constant → 3.14159…
rnd(seed)	Random number 0–1. Optional seed (any type) makes output deterministic.
sin(n) / cos(n) / tan(n)	Trig functions (radians)
asin(n) / acos(n) / atan(n)	Inverse trig functions (radians)
log(n, base)	Logarithm (base defaults to 10)
bitAnd(a, b)	Bitwise AND → number
bitOr(a, b)	Bitwise OR → number
bitXor(a, b)	Bitwise XOR → number
bitwise(op, a, b)	Generic bitwise op → number. ops: `&` `\|` `^` `<<` `>>` `>>>` `~`
sum(list)	Sum of list elements → number
range(from, to, step)	Generate number list (step defaults to 1 or -1)

Environment & Paths

EXPRESSION	RETURNS
active_user	Current username string
home_dir	Current user's home directory
current_path	Current working directory
program_path	Path to running script
params	List of CLI args when script runs as a command
get_abs_path(path)	Convert relative path to absolute
parent_path(path)	Parent directory of path
time	Returns a number of seconds representing the elapsed time since the script started.
current_date	Formatted date string

Network Utilities

FUNCTION	RETURNS
nslookup(domain)	Resolve domain → IP string
whois(ip)	Whois lookup → string
is_valid_ip(ip)	1 or 0
is_lan_ip(ip)	1 or 0
get_router(ip)	Router object
get_switch(ip)	Switch object

Persistence

FUNCTION	RETURNS
get_custom_object	Persistent map — survives nested shell.launch calls
include_lib(path)	Load a .so shared library → object or null
get_shell(user, pass)	Get local (or authenticated) shell object
md5(str)	MD5 hash → string
format_columns(list)	Format list as aligned columns → string

Shell & Computer API

shell Object

Obtained via get_shell or shell.connect_service:

s = get_shell
s.host_computer                              // → computer
s.ping(ip)                                   // → 1 or 0
s.build(srcPath, binPath, allowImport)       // compile .src → binary
s.connect_service(ip, port, user, pass)      // → shell / ftpShell / string / null
s.launch(program, params)                    // run binary → number / string
s.scp(file, folder, remoteShell, isUpload)   // file transfer → 1 or error
s.start_terminal                             // Launches an active terminal**-Script execution will be stopped upon starting a new terminal, 
unless this is called from another script that was executed via 
shell.launch. In that case, you will enter the shell after closing 
your root-level script within that terminal window

computer Object

Obtained via shell.host_computer:

c = get_shell.host_computer
c.get_ports                   // → list<port>
c.get_name                    // → string (hostname)
c.local_ip                    // → string
c.public_ip                   // → string
c.File(path)                  // → file or null
c.create_folder(path, name)   // → 1 or error string
c.touch(path, fileName)       // create file → 1 or error string
c.show_procs                  // → string (process list)
c.change_password(user, pass) // → 1 or error string
c.create_user(user, pass)     // → 1 or error string
c.delete_user(user, removeHome) // → 1 or error string
c.close_program(pid)          // → 1, 0, or error string
c.reboot(safeMode)            // → 1 or error string

file Object

Obtained via computer.File(path) or directory methods:

f = c.File("/home/user/file.txt")
f.name                        // → string
f.path                        // → string
f.parent                      // → file (directory) or null
f.is_folder                   // → 1 or 0
f.is_binary                   // → 1 or 0
f.size                        // → string
f.owner / f.group             // → string
f.permissions                 // → "drwxr-xr-x" style string
f.has_permission(perms)       // → 1 or 0
f.get_content                 // → string or null (local only)
f.set_content(text)           // → 1 or error (local only)
f.get_files                   // → list<file> or null (folder only)
f.get_folders                 // → list<file> or null (folder only)
f.chmod(perms, recursive)     // → string or error
f.copy(path, name)            // → 1 or error
f.move(path, fileName)        // → 1 or error
f.rename(name)                // → string or 0
f.delete                      // → string (error) or void
f.set_owner(owner, recursive) // → string or null

Network & Ports

router Object

r = get_router("1.2.3.4")
r.public_ip               // → string
r.local_ip                // → string
r.bssid_name              // → string
r.kernel_version          // → string
r.used_ports              // → list<port>
r.devices_lan_ip          // → list<string>
r.firewall_rules          // → list<string>
r.device_ports(ip)        // → list<port> or string or null
r.ping_port(portNum)      // → port or null
r.port_info(port)         // → string or null

port Object

p = router.used_ports[0]
p.port_number             // → number
p.get_lan_ip              // → string (LAN IP this port points to)
p.is_closed               // → 1 if closed, 0 if open

Default Port Numbers

PORT	SERVICE
21	FTP
22	SSH
25	SMTP
80 / 8080	HTTP
141 / 3306-3308	SQL
1222	RShell
1542	Repository / Hackshop
6667	Chat
37777	CCTV

SSH Connection

remoteShell = get_shell.connect_service("1.2.3.4", 22, "user", "pass")
if typeof(remoteShell) != "shell" then exit "Failed: " + remoteShell
remoteComputer = remoteShell.host_computer
print "Connected: " + remoteComputer.get_name

netSession Object

Obtained via metaxploit.net_use(ip, port). Port 0 returns a kernel router session.

session = mx.net_use("1.2.3.4", 22)
session.dump_lib                // → metaLib (running lib on that port)
session.get_num_users           // → number of user accounts
session.is_any_active_user      // → 1 or 0
session.is_root_active_user     // → 1 or 0
session.flood_connection        // initiate DDoS (requires 4x calls from different IPs)

Metaxploit

metaxploit Object

mx = include_lib("/lib/metaxploit.so")
mx.net_use(ip, port)              // → netSession or null
mx.load(path)                     // → metaLib or null
mx.scan(metaLib)                  // → list<string> memory addresses or null
mx.scan_address(metaLib, address) // → vulnerability details string or null
mx.sniffer(saveEncSource)         // → captured packet string or null
mx.rshell_client(ip, port, name)  // → 1 or error
mx.rshell_server                  // → list<shell> or error

metaLib Object

lib = mx.net_use("1.2.3.4", 22).dump_lib
lib.lib_name                      // → "init.so"
lib.version                       // → "1.0.0"
lib.is_patched(getDate)           // → 1 or date-patched-string or error-string or null
lib.overflow(address, value)      // → shell / computer / file / string / null
lib.debug_tools(user, pass)       // → debugLibrary or null

Exploit Loop

The standard pattern: get net session → dump lib → scan addresses → fire overflows on vulnerabilities with no requirements (*):

EXPLOIT LOOPmx  = include_lib("/lib/metaxploit.so")
ses = mx.net_use(targetIP, portNumber)
if ses == null then exit "no session"

lib  = ses.dump_lib
addrs = mx.scan(lib)
if addrs == null then exit "nothing found"

for addr in addrs
    details = mx.scan_address(lib, addr)
    for seg in details.split("Unsafe check: ")
        hasReq = seg.indexOf("*") != null
        if not hasReq then
            exploit = seg[seg.indexOf("<b>") + 3 : seg.indexOf("</b>")]
            result  = lib.overflow(addr, exploit)
            if typeof(result) != "string" and result != null then
                print "Got: " + typeof(result)
            end if
        end if
    end for
end for

debugLibrary Object

dbg = lib.debug_tools("user", "pass")
dbg.scan                          // → vulnerability report string
dbg.unit_testing(errorLines)      // → string or null (errorLines: list<number>)
dbg.apply_patch(path)             // → string or null
dbg.payload(memZone, pathFile)    // → list<map> or string or null

SCAN_ADDRESS FORMAT

scan_address returns a string with segments split by "Unsafe check: ". Each segment contains the vulnerability name in <b>tags</b>. A * in the segment means a requirement must be injected as the optional 3rd arg to overflow.

Blockchain & Crypto

crypto Library

crypto = include_lib("/lib/crypto.so")

// Password cracking
crypto.decipher(encPass)             // crack MD5 → plaintext or null

// File encryption
crypto.encrypt(filePath, password)   // → 1 or error
crypto.decrypt(filePath, password)   // → 1 or error
crypto.is_encrypted(filePath)        // → 1, 0, or error

// WiFi cracking
crypto.airmon("start", "wlan0")      // enable monitor mode
crypto.aireplay(bssid, essid, maxAcks) // capture handshake → null or error-string
crypto.aircrack(capFilePath)         // crack cap file → password or null

// SMTP recon
crypto.smtp_user_list(ip, port)      // → list<string> of usernames or null

blockchain / wallet / coin / subwallet

blockchain = include_lib("/lib/blockchain.so")

// Login or create wallet
wallet = blockchain.login_wallet("user", "pass")
if typeof(wallet) == "string" then
    wallet = blockchain.create_wallet("user", "pass")
end if

// Get a coin
coin = blockchain.get_coin("MyCoin", "coinUser", "coinPass")

// Get or create subwallet
sw = coin.get_subwallet("myWallet")
if typeof(sw) == "string" then
    pin = wallet.get_pin
    coin.create_subwallet("user", pin, "myWallet", "pass")
    sw = coin.get_subwallet("myWallet")
end if

// Mine
sw.mining                // mine one reward cycle → 1 or error
sw.get_balance           // → number
sw.last_transaction      // → [dest, amount, direction, date]

// Trade
wallet.buy_coin("MyCoin", 10, unitPrice, subwalletUser)
coin.transaction(origSW, destSW, amount)

WiFi Crack Pattern

crypto = include_lib("/lib/crypto.so")
networks = get_shell.host_computer.wifi_networks("wlan0")
parts = networks[0].split(" ")
bssid = parts[0]
pwr   = parts[1][:-1].to_int
essid = parts[2]
crypto.aireplay(bssid, essid, 300000 / (pwr+15))
password = crypto.aircrack(home_dir + "/file.cap")
print password

Common Patterns

Error Handling

GreyScript has no try/catch. Check return values explicitly:

result = someGHApiCall(args)
if typeof(result) == "string" then
    print "Error: " + result
    return
end if
if result == null then
    print "Returned null"
    return
end if
// success — use result

SSH Connect

remoteShell = get_shell.connect_service("1.2.3.4", 22, "user", "pass")
if typeof(remoteShell) != "shell" then exit "Failed: " + remoteShell
c = remoteShell.host_computer

Root Check

if active_user != "root" then exit "<color=red>Run As Root!</color>"

Read & Write a File

c = get_shell.host_computer
f = c.File("/home/user/notes.txt")
if f != null then
    content = f.get_content
    f.set_content(content + char(10) + "New line")
end if

Create a File

c = get_shell.host_computer
result = c.touch("/home/user", "newfile.txt")
if result == 1 then
    c.File("/home/user/newfile.txt").set_content("Hello!")
end if

Recursive File Search

findFile = function(folder, name)
    for f in folder.get_files
        if f.name == name then return f
    end for
    for d in folder.get_folders
        result = findFile(d, name)
        if result then return result
    end for
    return null
end function

root  = get_shell.host_computer.File("/")
found = findFile(root, "metaxploit.so")

Iterate a Directory

folder = get_shell.host_computer.File("/home/user")
if folder != null and folder.is_folder then
    for f in folder.get_files
        print f.name + "  " + f.size
    end for
end if

params-Based CLI Command

if params.len < 1 or params[0] == "-h" then
    exit command_info("usage_string")
end if

target = params[0]
path   = get_abs_path(target)

Live-Updating Display

while true
    output = buildDisplay()
    print(output, 1)   // 1 = clear_screen before print
    wait(0.5)
end while

Detect Home Computer

// Home computers run Xorg — detect via show_procs
procs = shell.host_computer.show_procs.split(char(10))
isHome = 0
for proc in procs
    if proc.split(" ").len > 4 and proc.split(" ")[4] == "Xorg" then
        isHome = 1
        break
    end if
end for

get_custom_object Persistence

g = get_custom_object

// Guard against missing keys
if not g.hasIndex("myData") then g.myData = {}

// Write
g.myData.key = "value"

// Read
val = g.myData.key

// Survives across nested shell.launch calls

DEVELOPMENT TOOLS

greybel-vs — VSCode extension with syntax highlighting, autocomplete, build, and debug.
greybel-js — CLI transpiler, bundler, minifier, and interpreter.
editor.greyscript.org — Browser-based online editor and interpreter.

Hacktool Documentation Portal