Cheatsheet

Print working directory

Shows the absolute path of the directory you are currently in.

Change directory

Moves you into a different directory. Use cd .. to go up one level, cd ~ to jump home, or cd - to flip back to the previous directory.

List directory contents

Lists files and folders. -l shows a long listing with permissions, owner and size. -a includes hidden files (those starting with a dot).

Directory stack (cd, but remembers where you came from)

In real shells, pushd dir jumps to a new directory and pushes the current one onto a stack, popd pops back, and dirs prints the stack. The Learninx shell has no real stack, so these are documented for reference — use cd - to flip back to the previous directory.

Make a directory

Creates a new directory. -p (parents) creates any missing intermediate directories and silently succeeds if the target already exists.

Create an empty file (or update its timestamp)

Creates an empty file if it does not exist, otherwise updates the modified time of the existing file.

Copy files and directories

Copies a file to a new location. -r is required to copy a directory recursively.

Move or rename files and directories

Renames a file or moves it to a new location. Works for both files and directories — there is no separate rename command.

Remove files or directories

Deletes a file. -r deletes a directory and everything inside it. -f skips the confirmation prompt. Be careful: there is no recycle bin.

Remove empty directories

Like rm -r, but refuses to delete a directory that still contains files. Safer for scripts.

Copy a file into place (and create dirs with -D)

Copies a source file to a destination, optionally creating any missing intermediate directories (-D). The in-browser sandbox runs it as a safety-first copy.

Create a temporary file in /tmp

Makes a fresh empty file in /tmp whose name ends with a random suffix, and prints the path. Great for shell scripts that need scratch space.

Shrink or extend a file to a given size (-s N)

Sets a file to exactly N bytes. If the file was longer it is cut; if shorter, the new bytes are null-padded. Useful for log rotation in scripts.

Print the value of a symbolic link

In the in-browser sandbox there are no real symlinks, so this prints the path you pass. Provided for script compatibility.

Estimate file / directory space usage

Walks a path and prints the total bytes it uses. -h switches to human units (K, M, G), -s prints only the summary line.

Show a compact summary of a file

Prints size, line count, word count and the (sandbox) last-modified time. The in-browser equivalent of stat for a quick glance.

Create a link between files (simulated)

Simulated. In a real Linux system ln -s makes a symbolic link, ln (no flag) makes a hard link. The sandbox just acknowledges the request.

Fast incremental file transfer / sync

Syncs files between two paths, copying only what changed. Flags to remember: -a (archive, preserves perms/times), -v (verbose), --dry-run (preview), --delete (mirror deletions). Not implemented in the sandbox — shown for cheatsheet completeness.

Bulk-rename files with a Perl regex

Debian/Ubuntu rename (prename) takes a Perl substitution and applies it to every filename you pass. Powerful but easy to misuse — always run without the -f flag first to preview.

Display a directory tree

Renders a pretty ASCII tree of the directory starting at the given path. Pure visualisation — no flags supported in the sandbox.

Display file status

Prints size, permissions, inode (simulated) and modification time. Verbose alternative to ls -l.

Determine file type

Sniffs the contents and prints what kind of file it is: ASCII text, empty, directory, or which interpreter a #!/... shebang points to.

Strip the directory part of a path

Prints only the final filename component. Useful in shell loops over find results.

Strip the last component of a path

Prints everything except the final filename component — the directory portion of the path.

Print the resolved absolute path

Resolves any ., .., or relative segments and prints a clean absolute path.

Compare two files line by line

Walks both files and prints lines that differ, prefixed with < (first file) or > (second file). When files match, prints (files are identical).

Show the last lines of a file

By default prints the last 10 lines. Pass -n N to change the count. Combine with -f (simulated) to follow a growing log file.

Print MD5-style digests of files

Hashes each file and prints a 32-hex digest followed by the filename. Use it to spot-check that a file has not changed. (Sandbox: non-cryptographic.)

Print SHA-256-style digests of files

Hashes each file and prints a 64-hex digest followed by the filename. Stronger than MD5 for tamper detection. (Sandbox: non-cryptographic.)

Print printable strings (≥4 chars) from a file

Pulls out runs of printable ASCII at least 4 characters long. Classic tool for inspecting binary blobs.

Dump file in octal / hex / chars

Prints a numbered byte dump of the file. -x shows hex, -c shows printable characters (escapes for control bytes), default is octal.

Hex dump of a file

Prints a hex+ASCII view of the file, 16 bytes per line. Useful for inspecting binary data and reverse engineering.

Print the contents of a file

Writes the file to standard output. Great for short files. For longer files prefer less or head / tail.

Show the first lines of a file

By default prints the first 10 lines. Pass -n to change the count.

Count lines, words and bytes

By default prints three numbers: lines, words, bytes. Common flags: -l (lines only), -w (words only), -c (bytes only).

Use stat -c to format specific fields

Beyond just printing everything, stat -c "%a %n" prints the octal mode then the name — useful in scripts. The Learninx stat command accepts -c and a small set of format tokens.

Page through a file one screen at a time

Sandbox stub — prints a TUI-style view of the file (just like nano). In a real terminal, less file lets you scroll with arrows, search with /, and quit with q.

Format and print data

Like echo but with C-style format specifiers. %s inserts the next argument as a string, %d parses the next argument as an integer. Useful in scripts where you need exact control.

Print a string repeatedly

Echoes its argument (or y) on repeat, forever in a real shell. The sandbox prints five lines and a ... (truncated) marker so it does not flood the terminal.

Print text to the screen

Writes its arguments to standard output. Combine with > to write to a file or >> to append.

Beginner-friendly text editor

In the sandbox, nano file prints a TUI-style view of the file and tells you which commands to use for real edits. Use echo > file to overwrite or >> to append.

Modal text editor

In the sandbox this prints a TUI view and lists the editing commands. In a real terminal: press i to enter insert mode, Esc to leave, :wq to save and quit.

Read a line from stdin into a variable

Built-in. read -p "name? " name prompts and stores. -s silent (for passwords), -r raw (no backslash escapes), -t N timeout after N seconds.

Evaluate a condition (used in if / while)

Returns success or failure based on a test. Common operators: -f file (is a file), -d dir (is a dir), -z "$s" (empty string), n1 -eq n2. [ and test are the same program.

Replace the current shell with a command

exec vim replaces the current shell — no return, no subshell. exec > log.txt redirects all subsequent stdout to a file without forking.

Sort lines of text (supports -r -n -u)

Orders lines alphabetically by default. -n sorts numerically, -r reverses, -u keeps only unique lines.

Remove adjacent duplicate lines (supports -c -i)

Collapses runs of identical adjacent lines into one. For a global unique pass, pipe through sort first: sort file | uniq. -c prefixes each line with a count.

Cut fields or characters from input

Splits each line by a delimiter (-d, default Tab) and prints the chosen fields (-f) or character positions (-c). Lists like 1,3-5 are supported.

Translate or delete characters

Maps characters in SET1 to characters in SET2 (one-to-one, by position). -d deletes the listed characters instead. Reads from a file argument or piped stdin.

Print lines in reverse order

Reads a file and prints its lines from bottom to top. cat reversed, character-by-character.

Reverse each line of input

Reads input and prints each line with its characters in reverse order. Lines themselves stay in order.

Number lines of input

Prefixes each non-empty line with its 1-based line number, right-aligned in 6 columns. Pair with cat to get a numbered listing.

Merge lines of files side by side (-d delim)

Reads two or more files in parallel and joins their lines column-by-column with a delimiter (default Tab).

Join two files on a common field

Merges two files by matching the first whitespace-separated field of each line. Both files must be sorted on that field.

Stream editor — supports s/find/replace/[g]

Applies a substitution expression to one or more files. The sandbox only supports the s/find/replace/g form (no addresses, no other commands). Add g to replace every match on a line.

Simple awk — awk "{print $N}" prints field N

The sandbox accepts the most common form: awk "{print $N}" file prints whitespace-separated field N of every line. $0 prints the whole line.

base64 encode or decode

Reads a file and either base64-encodes it (default) or decodes it (-d). Handy for embedding binary in JSON or copying certs as text.

Read stdin, write to file and stdout (-a appends)

Splits a pipeline: the data flows through to stdout and is also written to one or more files. -a appends instead of overwriting.

Build and execute command lines (simulated)

Takes whitespace-separated tokens from stdin and runs the given command once per token, appending the token as the last argument. Lets you turn find output into a batch job.

Format input as aligned columns (-t table)

Reads whitespace- or delimiter-separated input and re-emits it in neat aligned columns. -t auto-detects column widths; -s changes the delimiter; -o sets a separator for the output.

Convert tabs to spaces (or back)

expand replaces TAB characters with spaces (default 8). unexpand does the reverse — useful when pasting into code that disallows tabs.

Reformat text to fit a width

Reflows long lines so they fit within a maximum width (default 75). Keeps paragraph breaks intact. Pair with pr for printable output.

Wrap each line at a width (no word awareness)

Like fmt but dumber: it wraps at an exact column, breaking words in half if needed. Use -s to break only on spaces.

Paginate text for printing

Adds headers, footers and page breaks to a text file so it can be printed or archived cleanly. -l N changes page length, -w N the width.

Shuffle lines randomly

Writes a random permutation of input lines. -n N prints only N of them. Great for picking a random sample or choosing a winner.

Print a numeric sequence (start [step] end)

Writes one number per line, from start (default 1) to end, optionally stepping by step. -w equalises widths with leading zeros.

Prime-factor decomposition of an integer

For each input integer, prints the prime factors. factor 60 → 60: 2 2 3 5. Pure command-line arithmetic fun.

Compare two sorted files line by line (3 columns)

Outputs three columns: lines only in the first file, lines only in the second, and lines in both. -i is a typo; use -12 to suppress columns 1 and 2 and show only common lines.

Topological sort of a partial order

Reads pairs A B meaning A must come before B and prints a valid total order. Useful in build systems for figuring out which targets depend on which.

Convert text between character encodings

Re-encodes text from one charset to another (e.g. UTF-8 ↔ Latin-1). -l lists all known encodings. Sandbox is informational.

Use -n, -I{}, -0 for safer batched commands

Advanced flags: -n 2 runs the command two args at a time; -I{} replaces {} with the input (lets the placeholder sit anywhere); -0 splits on NUL bytes (safe for filenames with spaces — pair with find -print0).

Find files by name (supports -name <glob>)

Walks a directory tree and prints the paths that match. -name "*.log" is the most common use; supports * and ? wildcards.

Search text for a pattern (supports -i -v -n)

Prints lines that match a pattern. -i ignores case, -v inverts the match, -n prefixes each hit with its line number. Combine with | to filter any command’s output.

Find files by name using a prebuilt index

Real locate queries a database (usually updated nightly by updatedb) so it is far faster than find. The sandbox does not run it — use find <path> -name "<glob>" here.

Locate the binary, source and man page for a command

Returns the absolute paths of the executable, its source file (if any) and its man page. The sandbox only simulates the binary path.

Fast recursive grep (typically faster than grep -r)

Default on many modern systems. Recursively greps a directory, respects .gitignore, and skips binary files automatically. Not in the sandbox; shown for cheatsheet completeness.

Recursive grep, ignores .gitignore, very fast

A predecessor to rg. Same idea — recursive grep that skips ignored files. Not in the sandbox; included for reference.

grep replacement aimed at source code

Defaults to recursive search and skips VCS metadata dirs. Less popular than ag / rg now, but still in many tutorials.

grep with fixed strings (no regex)

grep -F shortcut. Treats the pattern as a literal string, so no escaping needed for ., *, (, etc. Faster on huge inputs.

grep with extended regex (same as grep -E)

Treats the pattern as an ERE — so +, ?, (), | are metacharacters without a backslash. Modern usage is just grep -E.

Print group memberships for a user

With no argument, lists the groups of the current user. With a username, lists that user’s groups.

Print user identity

Prints the numeric UID, primary GID and the full list of group memberships for the current user.

Run a command as another user (simulated)

Pretends to elevate privileges and runs the command. The sandbox cannot really escalate, but the call is accepted so scripts keep working.

Change file permissions

Updates the read / write / execute bits. The octal form is easiest: 7 = rwx, 6 = rw-, 5 = r-x, 4 = r--, 0 = ---.

Change file owner and group

Changes which user and/or group owns a file. chown user:group file sets both; chown :group file changes only the group.

List running processes

Shows the processes started in the current sandbox shell. Informational only — you cannot kill other sessions.

Change the group ownership of a file

Like chown :group file but only changes the group. Useful when you want to share a file with a project team without touching the owner.

Default permission mask for new files

Returns the mask subtracted from 0666 (files) and 0777 (dirs) when new files are created. Default 022 means new files come out as 0644. Set it per-session: umask 077 for private files.

Change / list file attributes (ext2/3/4)

Lower-level than chmod. Lets you mark files immutable (+i), append-only (+a), or compress (+c). Requires root. Sandbox is informational.

Switch user (default root)

With no argument, su opens a root shell. su learner switches to another user. The - flag also loads that user’s environment. Sandbox informational.

Change a user password

With no argument, changes the current user’s password. As root, passwd learner resets another user’s. Sandbox informational.

Manage user accounts

useradd name creates a user, userdel -r name removes one (and their home), usermod -aG group user adds them to a group. All require root.

Add or remove groups

groupadd devs creates a group, groupdel devs removes one. Pair with usermod -aG to add users to it.

Safely edit the sudoers file

Opens /etc/sudoers in the system editor with a syntax check before saving — never edit that file with a regular editor. Sandbox informational.

Show network interfaces

Older but still-common tool for inspecting IP addresses, MAC addresses and packet counts per interface. (ip addr is the modern equivalent.)

Show / manipulate routing (simulated, ip addr)

Modern replacement for ifconfig. The sandbox only supports ip addr, which prints the active IPv4 and IPv6 addresses per interface.

Ping a host (simulated)

Sends ICMP echo requests to a host and reports round-trip times. The sandbox simulates a successful three-packet exchange.

Fetch a URL (simulated)

Pretends to make an HTTP request. -I / --head returns just the response headers; without it, returns a small HTML stub.

Download a URL to disk (simulated)

Like curl, but writes the response to a file by default. Sandbox reports a successful download with byte count.

Open a remote shell (simulated)

Pretends to log into the given host (format user@host) and prints a sample welcome banner.

DNS lookups (query name servers)

Both query DNS to resolve a hostname to an IP. dig is more verbose and scriptable; nslookup is shorter and more interactive-friendly. Sandbox informational.

Show the path packets take to a host

Sends packets with increasing TTLs and lists each router that responds, showing where the route slows or fails. Sandbox informational.

Show open ports and active connections

ss is the modern replacement for netstat. Common flags: -tuln (listening TCP/UDP, numeric), -p (show process), -s (summary stats).

Secure copy (over SSH)

Copies files between hosts using SSH for transport. Format: scp source user@host:dest or the reverse. -r recurses, -P sets a non-default port.

Interactive FTP over SSH

Starts an interactive session for browsing and transferring files on a remote host. Commands: get, put, ls, cd, bye.

Talk to a TCP port in plaintext

Old but still handy: telnet host port opens a raw TCP connection. Useful for hand-testing protocols like SMTP, HTTP, or Redis. Plaintext — do not use for anything sensitive.

Swiss-army knife for TCP and UDP

Read or write to any TCP/UDP port from the shell. -l listens, -z does a port scan, -v is verbose. Combine with mkfifo for quick file transfer.

Routes, links and neighbour tables

Beyond ip addr, real Linux supports ip route, ip link, ip neigh and more. The Learninx sandbox only handles ip addr — other forms print not implemented in sandbox.

List all sockets with owning processes

Power-user shortcut. t TCP, u UDP, n numeric, a all, p process — shows you what is listening and which PID owns it. Requires root for the p column.

Tape archive — pack/unpack files (-c -x -t -z -j -J)

The classic archive tool. Common flag combinations: -czf out.tgz files (gzip-compressed create), -xzf in.tgz (extract), -tzf in.tgz (list contents). -C changes directory for the operation.

Compress / decompress a single file (.gz)

gzip file replaces file with file.gz. gunzip file.gz does the reverse. Pair with tar -czf to get .tar.gz archives. -k keeps the original.

Higher-ratio compression than gzip (.bz2)

Slower but compresses better than gzip. Same interface: bzip2 file, bunzip2 file.bz2. Often seen as .tar.bz2 or .tbz2.

LZMA compression — often the smallest (.xz)

Modern, high-ratio compressor. Common extension .tar.xz (used by many Linux kernel releases). Slower than gzip.

Cross-platform archive format (.zip)

zip out.zip file adds file to a new zip. unzip in.zip extracts. -r recurses, -e encrypts, -l lists. Common for sharing files with Windows users.

7-Zip — supports many formats, high compression

p7zip provides 7z on Linux. Compresses to .7z (often smallest) and can read .zip, .tar.gz, .rar and more. a adds, x extracts, l lists.

Selective extraction and listing

Common flags: -l list, -d DIR extract into DIR, -o overwrite without prompt, -n never overwrite, -p print to stdout, -q quiet.

Exclude files, append, stream through a pipe

Useful extras: --exclude="*.log" skips matches; -rf archive.tar newfile appends to an existing archive; --strip-components=N strips N leading path components on extract; pipe to compress on the fly.

Copy files in / out of an archive (low-level)

Predecessor to tar; still used inside initramfs images. find . | cpio -o > archive.cpio creates one, cpio -i < archive.cpio extracts.

Operate directly on gzip-compressed files

Family of helpers: zcat file.gz is cat for gzip; zless file.gz is less; zgrep PATTERN file.gz is grep — no manual decompression step needed.

Print environment variables

Lists all variables currently set in the shell’s environment, one per line as NAME=value. Use export NAME=value to set one.

Set an environment variable

Adds (or updates) a variable in the shell’s environment. Format is export NAME=value. Variables set this way are visible to subsequent commands in the same session.

Exit the shell (simulated)

Acknowledges the request and prints logout. The in-browser shell cannot really be closed — refresh the page to start a new session.

Pause for N seconds (simulated)

Real sleep waits in real time. The sandbox returns immediately so your lesson does not stall.

Do nothing, successfully

Exits with status 0 and produces no output. Mostly useful in shell scripts: while true; do ...; done.

Do nothing, unsuccessfully

Exits with a non-zero status and produces no output. Useful for testing && / || chains.

Print machine architecture

Always reports x86_64 in the sandbox. In real Linux it returns the CPU architecture of the host.

Print the number of processing units available

Returns the number of logical CPU cores. The sandbox reports 4. Used in build scripts to parallelise jobs.

List block devices

Prints a tree of disks and partitions: names, sizes, mountpoints. Sandbox returns a small fixed example so you can recognise the columns.

Display CPU architecture information

Detailed dump of CPU model, cores, threads, cache sizes and feature flags. Sandbox returns a representative sample.

List the ranges of available memory

Summarises the physical memory ranges the kernel can see, with size and online/offline state. Sandbox returns a small sample.

List open files (simulated)

Classic sysadmin tool. In a real shell it lists every open file descriptor. The sandbox returns a few example entries so the columns make sense.

Print the kernel ring buffer (simulated)

Shows the kernel’s recent log messages — useful for spotting hardware or driver problems at boot. Sandbox returns a representative slice.

Show last logged-in users (simulated)

Reads /var/log/wtmp (sandbox: a small static sample) and prints the recent login history, with session durations.

Show who is logged on

Prints one line per currently logged-in user: username, terminal, login time, and remote host (in parentheses).

Return the user's login name

Prints the account name that was used to log into the current session, even after a su switch.

Report virtual memory statistics

A one-line snapshot of process, memory, swap, I/O and CPU activity. Sandbox returns a representative line.

Report CPU and I/O statistics

Per-device and CPU utilisation numbers — useful for spotting I/O bottlenecks. Sandbox returns a representative table.

Send a signal to a process (simulated)

Takes a process ID and (in real shells) sends a signal — default TERM. Sandbox acknowledges the request and refuses non-numeric PIDs.

Locate a command

Prints the absolute path of the executable that would run if you typed the command. In the sandbox it returns /usr/bin/<cmd> for known commands.

Run a command immune to hangups (simulated)

In real Linux, nohup lets a command keep running after you log out. The sandbox acknowledges the request but does not background processes.

Control systemd services (simulated)

Manages systemd units. daemon-reload picks up unit file edits, enable wires a service into the boot targets, start/stop/restart control it right now, and status shows whether it is active.

Print system information

Prints the kernel name. -a includes the version, architecture and hostname.

Show how long the system has been up

Prints a short uptime line. In the sandbox this is a simulated value.

Show memory usage

Prints total, used and free memory. -h switches to human-readable units (K, M, G).

Show disk space usage

Reports the filesystem disk space usage. -h switches to human-readable units.

Print the current user

Writes your current username. In the sandbox you are always learner.

Print the system hostname

Writes the name of the current machine.

Show the current date and time

Prints the current local date and time.

Clear the terminal

Scrolls the terminal so the prompt sits at the top of the visible area. Shortcut: Ctrl+L.

Flush filesystem buffers to disk

Forces all pending writes in memory to be written to the disk(s). Run before risky operations or as a final step in shutdown scripts. Sandbox no-op.

Debian/Ubuntu package manager (simulated)

apt update refreshes the package index, apt install X pulls X in (and reports missing packages), apt remove X takes it out again, apt search TERM finds candidates, and apt list --installed shows what is on the system. This sandbox tracks a small real catalogue and installed-state, mirroring how real Debian/Ubuntu systems record installs under /var/lib/dpkg.

Low-level Debian package tool (underneath apt)

apt is the friendly front end; dpkg does the actual unpacking and bookkeeping. dpkg -l lists installed packages, dpkg -L pkg lists the files it owns, dpkg -i file.deb installs a local .deb. Sandbox informational.

Red Hat / Fedora / CentOS package manager

The apt equivalent on the Red Hat family. dnf replaced the older yum but keeps the same subcommands: install, remove, search, list installed, update. Sandbox informational.

Arch Linux package manager

Arch’s package tool. -S installs (pacman -S git), -R removes, -Ss searches, -Syu syncs the index and upgrades everything in one step. Sandbox informational.

SysV-style service control

Older interface (service nginx restart) still works on most distros thanks to systemd compatibility shims. Prefer systemctl on new systems.

Read the systemd journal (logs)

journalctl -u nginx shows logs for one unit; -f follows; --since "1 hour ago" filters by time; -p err filters by priority.

Schedule recurring jobs

Edit with crontab -e, list with crontab -l. A line is m h dom mon dow command. @reboot, @daily etc. are shortcuts.

Schedule a one-shot job at a specific time

at 14:00 then type commands, Ctrl+D to finish. Unlike cron, jobs run once and disappear. atq lists pending, atrm N removes.

Stop, restart, or power off the machine

shutdown -h now halts immediately; shutdown -r +5 reboots in 5 minutes; reboot and poweroff are short aliases. All require root in a real shell.

Legacy init control (SysV)

init 0 halts, init 6 reboots, runlevel prints the current and previous level. Largely replaced by systemctl. Sandbox informational.

Job control: move processes between background and foreground

Append & to start in background, jobs lists them, fg %1 brings #1 to the front, Ctrl+Z suspends, bg %1 resumes in background, disown %1 detaches.

Run with adjusted scheduling priority (-20 highest, 19 lowest)

Default nice value is 0. nice -n 10 make runs make at lower priority so it does not starve interactive jobs. renice changes an existing process.

Measure how long a command takes

time command reports wall time, user CPU time and system CPU time. The Learninx shell exposes a builtin time; the binary /usr/bin/time -v gives even more detail in real shells.

Run a command with a hard time limit

timeout 5s long-cmd kills the command after 5 seconds. Sends TERM by default; --signal=KILL for a more aggressive end. Sandbox no-op.

Re-run a command every N seconds

watch -n 2 "df -h" re-runs df -h every 2 seconds, highlighting changes. -d highlights differences between runs. Sandbox informational.

List PCI / USB devices and loaded kernel modules

lspci enumerates PCI/PCIe hardware, lsusb does USB, lsmod shows currently loaded kernel modules. All require a real kernel — sandbox prints a representative sample.

Load / unload kernel modules

modprobe name loads a module and its dependencies. rmmod name removes it. insmod path.ko loads by file path, no dependency resolution. All require root.

Trace syscalls / library calls of a process

strace -e openat cmd shows which files a command opens. ltrace does the same for library calls. Powerful debugging tools — slow the target down, so do not use in production.

Show or set per-process resource limits

Built-in. Common values: -n (open files), -u (max processes), -t (cpu seconds), -v (virtual memory). Adjusts limits for the current shell.

Google Cloud CLI (simulated)

Creates and manages Google Cloud resources from the terminal. Commands are groups plus a verb: gcloud compute instances create, gcloud storage buckets list. Set defaults with gcloud config set project ID and gcloud config set compute/zone ZONE, and get machine-readable output with --format=json or --format="value(name)". The sandbox simulates config, projects and IAM bindings, service accounts, Compute Engine VMs, networks and firewall rules, Cloud Storage, Cloud Run, and GKE clusters, with no real account involved.

Show recent commands

Prints the in-memory history of commands you have run in the current sandbox session, numbered so you can refer to them.

Show most-used commands from this session

Tallies how many times each command appears in the current session’s history and ranks them. Great for spotting your habits.

Show short help for a command

Like help but for one command at a time. Prints a small man-page-style summary (NAME, SYNOPSIS, DESCRIPTION).

Chain commands with ;, &&, ||, and pipe with |

The Learninx shell supports the four classic control operators. ; runs unconditionally. && runs the right side only if the left side succeeded. || runs only on failure. | passes the left side’s stdout into the right side’s stdin.