Identifiers and functions

Identifiers ($something) get replaced with their value before a script line (or a command typed with //) is executed.

Arguments

Identifier	Value
`$1` ... `$9`	The arguments passed to the command/alias.
`$0`	How many arguments were passed.
`$N-`	From N onward, e.g. `$2-`.
`$N-M`	A range, e.g. `$2-4`.
`%variable`	The value of a variable set with `set` (see Scripting).

Context (who/where/what)

Identifier	Value
`$nick`	Who wrote/clicked (or, in nicklist popups, the nick you right-clicked).
`$chan`	The channel/group name for channel events, empty for private chats/Status.
`$network`	The current window's network: `telegram`, `whatsapp`, or - for an IRC window - an identifier starting with `irc:` that tells each connected server apart (one per server, since IRC is multi-server, see IRC) - use `iswm` to recognize it in general: `if ($network iswm irc:*)`.
`$me`	Your name.
`$event`	The name of the current event - handy if several "on" events share the same alias/code.

Media (our own addition - IRC has no attachments)

Identifier	Value
`$mediatype`	Inside "on message": `photo`/`video`/`audio`/`document`/`sticker` if the message has an attachment, empty if it's text only.
`$filename`	File name for documents, empty otherwise.

Notifications (our own addition)

Identifier	Value
`$noticetype`	Inside "on notice": distinguishes the type of synthetic notification. See Notifications and system events for the full list of values.

Paths (as in real mIRC)

Identifier	mIRC equivalent	Value
`$yoakedir`	`$mircdir`	The application's data folder.
`$yoakeexe`	`$mircexe`	The path to the executable.
`$yoakeini`	`$mircini`	The full path to Yoake.ini.
`$scriptdir`	`$scriptdir`	The scripts folder (`userData/scripts/`).
`$script`	`$script`	Full path of the .ini file the currently running alias/event/popup comes from (aliases.ini/remote.ini/popups.ini).
`$logdir`	`$logdir`	The logs folder (`userData/logs/`) - written to by the "Log conversations to file" option (Settings, off by default): one .log file per window, named after it (e.g. `Mario.log`), inside a `telegram/` or `whatsapp/` subfolder depending on the network.

Constants (bare identifiers, as in real mIRC)

Identifier	Value
`$true` / `$false`	`1` / `0` - usable in comparisons, e.g. `if ($isnum(%x) == $true)`.
`$null`	Always empty.
`$cr` / `$lf` / `$crlf`	Newline (carriage return / line feed / both together).
`$date`	Current date.
`$time`	Current time.
`$ctime` / `$gmt`	Seconds since January 1st, 1970 (epoch) - only the parameter-less form: `$ctime(text)` to convert a hand-written date is not supported.
`$fulldate`	Full date and time in a single string.
`$feof`	1/0 depending on whether the last `$fread()`/`$fgetc()` run in ANY script reached the end of the file (as in real mIRC, it's not per handle).
`$ferr`	1/0 depending on whether the last file operation (`fopen`/`fwrite`/`$fread`/`$fgetc`) run in ANY script failed.
`$sockname`	Inside `on sockopen`/`on sockread`/`on sockclose`: the name of the socket that triggered the event. Empty elsewhere.
`$sockerr`	The message of the last network error (connection failed, closed by the other side, etc.), empty if no error.
`$sockbr`	Bytes read by the last `sockread` - 0 when there's nothing left to read in the buffer (a signal to exit the read loop).
`$runoutput`	Our addition (see `/run` in Commands): the output (stdout) of the last `/run` that finished, full text with the original line breaks intact.
`$runerror`	Our addition: any error output (stderr) of the last `/run` that finished.
`$runcode`	Our addition: the exit code of the last `/run` that finished (0 = normally no error).

Token manipulation

A "token" is a piece of text separated by a character of your choice (usually a space) - these functions split/reassemble lists of this kind. As in real mIRC, the separator C is always an ASCII code (e.g. 32=space, 46=dot), not the character itself - if absent, space is used.

Function	What it does
`$gettok(text,N,C)`	The Nth token, or a range `"N-M"` (negative values too, counted from the end; `"N-"` = from N onward).
`$numtok(text,C)`	How many tokens there are.
`$findtok(text,token,N,C)`	Position of the Nth occurrence (case-insensitive). N=0 = how many times it occurs.
`$istok(text,token,C)`	1/0 depending on whether the token exists (case-insensitive).
`$matchtok(text,substring,N,C)`	Nth token that CONTAINS substring (case-insensitive). N=0 = how many contain it.
`$wildtok(text,wildcard,N,C)`	Nth token that matches a `*`/`?` pattern (case-insensitive). N=0 = how many match.
`$addtok(text,token,C)`	Appends at the end, only if not already present (case-insensitive comparison).
`$instok(text,token,N,C)`	Inserts at position N, even if already present elsewhere.
`$puttok(text,token,N,C)`	Overwrites the Nth token.
`$deltok(text,N,C)`	Removes the Nth token (or the range `"N-M"`).
`$remtok(text,token,N,C)`	Removes the Nth occurrence of token (case-insensitive, N=0 = all).
`$reptok(text,token,new,N,C)`	Replaces the Nth occurrence of token with "new" (case-insensitive, N=0 = all).
`$sorttok(text,C,ncra)`	Sorts the tokens: default alphabetic case-insensitive, `n`=numeric, `r`=reverse.

Functions that compare a token's CONTENT (not just position) also have a ...cs (case-sensitive) variant, same parameters: $addtokcs, $findtokcs, $istokcs, $matchtokcs, $remtokcs, $reptokcs, $sorttokcs, $wildtokcs. $gettok/$deltok/$instok/ $numtok/$puttok have no cs variant because they only work by position, upper/lower case doesn't affect them.

$gettok(a.b.c.d.e,3,46)      ; c
$gettok(a.b.c.d.e,2-,46)     ; b.c.d.e
$addtok(a.b.c,d,46)          ; a.b.c.d
$deltok(a.b.c.d,2-3,46)      ; a.d
$istok(a.B.c,b,46)           ; 1 (case-insensitive: B counts as b)
$istokcs(a.B.c,b,46)         ; 0 (case-sensitive: B is not b)

$gettok already existed but with a literal string separator instead of an ASCII code - if you had scripts using it, they need updating to the new format (e.g. $gettok(%x,2,44) instead of $gettok(%x,2,",")).

Date/time with parameters, math, validation

Function	What it does
`$duration(seconds,N)`	Readable format "1w 2d 3h 4m 5s". N=2 without seconds, N=3 hh:nn:ss format.
`$iif(condition,T,F)`	The ternary: if condition is true returns T (or "1" if absent), otherwise F (or empty if absent).
`$str(text,N)`	Repeats text N times.
`$strip(text)`	Removes formatting codes (bold/underline/color/etc.) - see the "Control codes" section for how to insert them.
`$isnum(text)`	1/0 depending on whether it's a number.
`$isupper(text)` / `$islower(text)`	1/0 depending on whether it's all uppercase/lowercase.
`$eval(text,N)`	Re-evaluates text (identifiers/%variables) N more times (default 1) - handy for indirect references.
`$abs(N)`	Absolute value.
`$round(N,D)`	Rounds N to D decimal places (default 0).
`$floor(N)` / `$ceil(N)` / `$int(N)`	Rounds down/up/truncates.
`$min(...)` / `$max(...)`	Minimum/maximum of a list of numbers (comma or space separated).

Files and hashes

Simplified compared to real mIRC (which has many more switches/options for each of these).

Function	What it does
`$exists(path)`	1/0 depending on whether the file or folder exists.
`$isfile(path)` / `$isdir(path)`	1/0 depending on whether it's a file/a folder.
`$read(file[,N])`	A random line from the file, or line N (1-based) if given. Doesn't support real mIRC's text/wildcard search switches.
`$md5(text)` / `$sha1(text)`	MD5/SHA1 hash of the text.
`$fread(handle)`	The next line (up to the next newline) of the handle opened with `fopen`, advancing the read pointer. Empty if there's nothing left to read (see `$feof`).
`$fgetc(handle)`	The next character of the handle, advancing by 1. Empty at end of file.
`$findfile(folder,wildcard,N[,depth])`	The Nth file (full path) inside `folder` whose name matches `wildcard` (`*`/`?`, a single pattern per call - real mIRC accepts more than one separated by `;`, this doesn't). `N=0` returns the count instead of the path (same convention as `$chan(0)`/`$nick(0)`). `depth` (optional): how many subfolder levels to explore - `0` = that folder only, a number = how many levels, omitted = all with no limit.
`$finddir(folder,wildcard,N[,depth])`	Like `$findfile` but searches among subfolders instead of files.
`$file(path).property`	Information about a file: `.size` (bytes), `.mtime` (last modified date, `$ctime` format), `.name` (file name with extension), `.ext` (extension only, without the dot), `.path` (the folder containing it). Without a given property, equals `.size`. Empty if the file doesn't exist. Simplified compared to real mIRC, which also has `.ctime`/`.atime`/`.shortfn`/`.longfn`/`.attr`/`.sig`/`.version`.
`$nofile(path)`	The folder containing the file (with the trailing slash), without the file name. E.g. `$nofile(C:\music\song.mp3)` → `C:\music\`.

See also Commands for fopen/fclose/fwrite, and the $feof/$ferr constants above.

Building an "fserve" with these identifiers: by combining $findfile with on message/haltdef/echo (see Scripting) and dcc send <nick> <path> (see Commands) you can write a script that lists and sends real files from a folder, like real mIRC's File Server - without needing a real DCC connection (the files pass through Telegram/WhatsApp's servers, more reliable). Security warning: never pass a path written by the remote user directly to dcc send (e.g. dcc send $nick $2) - anyone could ask for any file on your computer. Instead build a list with $findfile/%variables and use that, never the user's input as a direct path.

Binary Files

Simplified compared to real mIRC. See Commands for bread/ bwrite/bset/bunset/bcopy/breplace/btrunc, which create and modify the binary variables &name read by these functions.

Function	What it does
`$bvar(&binvar,N,M)`	M ascii values (space separated) starting at byte N (1-based). `$bvar(&binvar,0)` (or N absent) instead returns the variable's length.
`$bfind(&binvar,N,M)`	Position (1-based) of the first occurrence of M starting at byte N; 0 if not found. M can be a single ascii value (e.g. `32`), a space-separated sequence of ascii values (e.g. `87 65 86`), or plain text (case-insensitive search).

bset &v 1 72 101 108 108 111    ; &v = "Hello" in bytes
$bvar(&v,1,5)                   ; 72 101 108 108 111
$bfind(&v,1,101)                ; 2 (position of the "e")
$bfind(&v,1,ello)               ; 2

Real mIRC's dot-properties (.text/.textcs/.regex on $bfind, .text/.word/.nword/.long/.nlong on $bvar) are not supported - here $bvar always returns space-separated ascii values, not text or multi-byte numbers in a specific byte order.

Sockets

See Commands for sockopen/sockwrite/sockread/ sockclose/sockmark, and the $sockname/$sockerr/ $sockbr constants above.

Function	What it does
`$sock(name).mark`	The label set with `sockmark`, empty if not set.
`$sock(name).ip`	The address it's connected to (the one passed to `sockopen`).
`$sock(name).port`	The port it's connected to.
`$sock(name).connected`	1/0 depending on whether it's currently connected.
`$sock(name).listening`	1/0 depending on whether `name` is a listener opened with `socklisten` (instead of a connected socket).
`$sock(name).ssl`	1/0 depending on whether it's a TLS connection (opened with `sockopen -e`).
`$sock(name)` (no property)	The name itself, if the socket exists; empty otherwise - handy for a quick check like `if ($sock(name)) { ... }`.

Reduced compared to real mIRC: missing .sent/.rcvd/.sq/ .rq/.to/.type (besides a fixed "tcp")/.wserr/.wsmsg and wildcard/index N search ($sock(name,N)) - here name is always an exact name.

Text/number functions

Function	What it does
`$len(text)`	Length of the text.
`$upper(text)` / `$lower(text)`	Uppercase/lowercase.
`$left(text,N)`	First N characters from the left. Negative N = everything except the last N.
`$right(text,N)`	Last N characters from the right. Negative N = everything except the first N.
`$mid(text,start[,length])`	"length" characters starting at "start" (1-based). Without "length" (or with 0): to the end.
`$pos(text,substring[,N])`	Position (1-based) of the Nth occurrence of "substring" in "text", case-insensitive. Without N (or with 0): how many times it occurs in total. Empty if not found.
`$replace(text,from,to[,from2,to2,...])`	Replaces all occurrences, case-insensitive. Accepts multiple from/to pairs in sequence, as in real mIRC.
`$chr(N)`	The character with ASCII code N, e.g. `$chr(32)` = space.
`$asc(C)`	The ASCII code of character C.
`$rand(N1,N2)` / `$r(N1,N2)`	Random integer between N1 and N2, inclusive, in either order (official mIRC docs - `$r` is the same identifier under another name). Numbers only: real mIRC also accepts a character range, not implemented here.
`$+(a,b,c,...)`	Joins multiple items with no spaces.
`$calc(expression)`	Evaluates an arithmetic expression.
`$nick(N)`	Nth participant (1-based) of the current window's nicklist; `$nick(0)` returns the total.
`$avatarfile(nick)`	Our own addition (real mIRC has nothing like this) - local path of that nick's profile photo, ready for `/drawpic`. See the note right below: it can return empty the first time.
`$contact(N)`	Our own addition (real mIRC has no address book separate from channels/nicklists) - N-th contact (1-based) of the address book for the NETWORK the current window belongs to, `$contact(0)` the total. Same sync/async tradeoff as `$avatarfile` above - see the note below.
`$contactphone(N)`	Our own addition - like `$contact(N)` (same numbering, same address book), but returns the phone number instead of the name. Unlike the name (two contacts can share it), the number always identifies exactly one person - useful for a `msg` with no ambiguity risk, see the note below.
`$input(text,type,title,default)`	Opens a genuinely blocking text prompt window (see note below) and returns what was typed, or `$null` if cancelled.
`$sfile(dir,title,oktext)`	Official mIRC documentation: opens the real system file selection dialog and genuinely blocks the script until you choose or cancel (same principle as `$input` above) - returns the chosen path, or an empty string if cancelled. `dir` can include a wildcard mask at the end (e.g. `C:\Ascii\*.txt`) to filter by extension. `oktext` (button text) has no equivalent in the native dialog, ignored.
`$file="title" dir`	Official mIRC documentation (legacy syntax, no longer in the recent help file but still supported): the exact same thing as `$sfile` above, written differently - no parentheses, the title in quotes with an equals sign, then a space, then the folder/mask (which can use `$+` to build itself from several pieces, e.g. `$mircdir $+ Ascii\*.txt`, see the note below). Do NOT confuse with `$file(filename)` with parentheses: in real mIRC that's a completely different identifier (info about a file that already exists - size/dates/attributes), not implemented here.
`$mircdir`	Official mIRC documentation: mIRC's data folder. Here it's Yoake's data folder (where `Yoake.ini`, the database and scripts live) - read once at startup, never changes during a session.

$input() is different from $dialog()//dialog -m (which do NOT truly block, see Dialogs): here we use the browser's window.prompt()/ window.confirm(), the only genuinely blocking functions available - the script really does stop until you answer, exactly like in real mIRC, so var %x = $input(...) followed by an if on the line after works. The trade-off is looks: it's the system/browser's native window, not the app's mIRC style - real mIRC's i/w/q icons are ignored (no control over the icon of a native prompt()/confirm()). If type contains e a text box appears (with default as the initial value); if it contains y or n it's a yes/no question (yes/no); otherwise it's a simple OK/Cancel.

alias changenick {
  var %newnick = $input(Enter the new nickname:, e, Change Nickname, $me)
  if (%newnick != $null) {
    /nick %newnick
  }
}

; /away is a real command (see the "Away/idle" section below) - the app already
; sends the notice to anyone who writes to you while you're away on its own, no need to write it:
alias setaway {
  var %msg = $input(Message to show if someone writes to you while away:, e, Set Away)
  if (%msg != $null) {
    away %msg
  }
}

$avatarfile(nick) - explicit live request: rebuilding a channel via script by drawing the photo of whoever's writing, like the old GUI scripts of real mIRC. It resolves nick first in the current window's nicklist, otherwise (in a query) it uses the query's own person - it does not search contacts/address book like /whois (that search is too slow for an identifier, which has to answer right away). Downloading the photo from Telegram/WhatsApp takes time (it's a network request): the first time you call it for a nick it returns an empty string and starts the download in the background, ready for the next call - exactly the same trade-off real mIRC had, where /drawpic always wants an already-downloaded file, never a direct link: even the old scripts had to fetch the image first (via DCC or webspace) and only draw it on the next round.

on message {
  if ($avatarfile($nick) != $null) drawpic @channel $avatarfile($nick) 5 5 32 32
  drawtext @channel 1 Arial 12 45 10 $nick $+ : $1-
}

$contact(N) - explicitly requested live: a script that needs to go through the ENTIRE address book of a network (e.g. for a bulk send), not just the nicklist of an open channel/group (that's $nick(N)). Same exact sync/async tradeoff as $avatarfile above: the address book is downloaded from Telegram/WhatsApp with a network request, an identifier can't wait for it - the first call in a network returns empty (or 0 for $contact(0)) and starts loading in the background, ready on the next call. Inside a while loop fired twice in a row (or after an on connect, once the address book has had time to load) it works normally.

msg <nick> <text> (official mIRC documentation) looks first in the nicklist of the window you launch the script from - if it doesn't find anyone there, it also searches the whole network's address book: by number/id (always unique) or by name, but only if the name is unique. Two contacts sharing the same name are a real ambiguity: msg won't guess one at random, it just warns - in that case use $contactphone(N) instead of $contact(N) as the target, the number is never ambiguous.

Careful: blasting the whole address book with messages is exactly the kind of behavior Telegram and WhatsApp flag as spam and punish with account limits or bans - that's not a Yoake risk, it's platform policy, worth knowing before scripting it.

alias messageeveryone {
  var %i = 1
  while (%i <= $contact(0)) {
    msg $contactphone(%i) Hi! This is a test message.
    inc %i
  }
}

$sfile/$mircdir/play together - a popup to send an ASCII drawing to the channel you're viewing, with the speed chosen separately (official mIRC documentation, see Commands for play). $active (Window Identifiers, official documentation) is the name of the active window - here the channel you open the popup from. The two lines below do the EXACT same thing - $sfile(...) (modern form, with parentheses) or $file="..." ... (legacy form, the one in many '90s scripts - see above), use whichever you prefer.

[channel]
Ascii
.Drawings (sfile):play $active $sfile($mircdir $+ \Ascii\*.txt, Choose the file) %ascspeed
.Drawings (legacy file):play $active $file="Choose the file " $mircdir $+ \Ascii\*.txt %ascspeed
.-
.Speed
..Slow:set %ascspeed 1500
..Normal:set %ascspeed 1000
..Fast:set %ascspeed 500

set %i 1
while (%i <= $nick(0)) {
  echo $nick(%i)
  inc %i
}

echo $+(Hello, ,$nick,!)   ; no unwanted spaces between the pieces

Identifiers tied to media/notifications/Yoake-specific paths are our own additions: IRC (and therefore real mIRC) has no attachments, NOTICE subtypes, or a second product name to distinguish. Everything else on this page (tokens, date/time, math, files, hashes, text) instead follows the official mIRC documentation as faithfully as possible - identifiers tied to IRC/DCC/Windows with no real equivalent here (ban lists, IRC channels/modes, Windows editbox/clipboard, DDE, etc.) haven't been replicated.

See also Dialogs for $did()/$dialog()/$didtok()/ $didwm()/$didreg()/$dbuw/$dbuh, and the /dialog//did//didtok commands; and Custom Windows for $window()/$line()/$fline()/$flinen, and the /window//aline//cline//dline//iline//rline/ /sline//renwin commands.

Window Identifiers

From the official mIRC documentation (window_identifiers.html): only the subset that has a real equivalent in this app has been implemented here. DCC chat really exists as a feature (see dcc chat in Commands), but with no scripting identifier to reach it: real mIRC's $chat() hasn't been replicated. The concepts of a file server, "single query window" ($compact), fullscreen mode ($fullscreen) or application state ($appactive/$appstate) don't exist either - so $chat(), $compact, $dqwindow, $fserve(), $fullscreen, $appactive, $appstate, $lactive and $lactivewid haven't been replicated.

Identifier	Description
`$active`	The title of the active window (the one in the foreground).
`$activewid`	The internal id of the active window.
`$wid`	The id of the window the current script is running in (not necessarily the one active on screen).
`$chan(N)` / `$chan(#name)`	Nth open group/channel (1-based), or the one with that name; `$chan(0)` returns the total. Groups/channels only, not queries/status.
`$chan(N).topic`	In this app this matches the group's title (Telegram/WhatsApp have no separate topic field, see `/topic`).
`$chan(N).wid`	That group/channel's internal id.
`$query(N)` / `$query(nick)`	Nth open private chat (1-based), or the one with that nick; `$query(0)` returns the total.
`$query(N).wid`	That private chat's internal id.
`$send(N)` / `$send(nick)`	The `/dcc send` transfer in progress, if any (here only one at a time, not a real queue like in real mIRC); `$send(0)` returns 1/0 instead of a queue count.
`$send(N).file` / `.size` / `.pc` / `.status`	File name, size, percentage completed, textual status of the transfer.
`$msg(channel,N)`	The Nth already-loaded message of that channel/group/query (name with or without a leading #, or the window id); `$msg(channel,0)` (or without N) returns the total. The message text if used without a dot-property.
`$msg(channel,N).id`	The message id - used by `/playmedia` to open it.
`$msg(channel,N).type`	The message's media type (`video`/`photo`/etc, like `$mediatype`), empty if it's text only.
`$msg(channel,N).sender`	Who wrote that message.

echo Active window: $active ($activewid) - I'm in $wid
echo Open groups: $chan(0)
if ($chan(0) > 0) echo The first one is $chan(1), id $chan(1).wid
echo Open private chats: $query(0)
if ($send(0) == 1) echo Transfer in progress: $send(1).file at $send(1).pc%
echo Loaded messages in #channel: $msg(#channel,0)
if ($msg(#channel,3).type == video) echo The third message is a video, id $msg(#channel,3).id

$msg() is something real mIRC never had: in real mIRC, $line (and the commands that read/modify line by line, /aline//cline/ /dline//iline//rline) work ONLY on custom windows (the ones with a @ in front) - it's a known, documented limitation, never removed despite being requested many times on the official forum: a real IRC channel is plain text, with no data structure to query. Here instead messages are already saved in a structured way (with media type, sender, id), so $msg() can read them for a real chat/channel too, not just custom windows. See /playmedia and the on videoend event in Commands/Scripting for an example of an automatic video playlist built with this identifier.

Control codes (bold, color, underline...)

The same control codes as real mIRC, insertable with $chr(N) inside any text (messages, say/echo commands, Custom Window lines). They are actually rendered in plain text mode (MESSAGE_FORMAT=text in Options) - in HTML mode they don't apply, that mode uses Telegram/WhatsApp's native formatting, a different and unrelated system.

Code	Effect
`$chr(2)`	Bold - toggles on/off (write it twice around the text).
`$chr(31)`	Underline - same scheme.
`$chr(29)`	Italic - same scheme.
`$chr(22)`	Reverse (swaps text/background color) - same scheme.
`$chr(3)NN[,MM]`	Color: NN = text (0-15, standard mIRC palette), MM = optional background. `$chr(3)` alone resets the color.
`$chr(15)`	Resets everything (bold/underline/italic/reverse/color) in one go.

say $chr(2)Warning!$chr(2) This is $chr(3)4red$chr(15) and this is $chr(31)underlined$chr(31).

Ctrl+K (as in real mIRC): opens a 16-color palette right inside any window's text box - click a color to insert it at the cursor position, without having to type $chr(3) by hand. Foreground color only (real mIRC also allows a background with a second click); for the background you can still type ,MM right after by hand.

Away / idle

Identifier	Value
`$away`	`1` if you're away (see `/away` in Commands), `0` otherwise.
`$awaymsg`	The current away message, empty if you're not away.
`$awaytime`	Since when you're away, in Unix seconds (like `$ctime`) - not a countdown.
`$idle`	Seconds since the last key pressed in one of the app's text boxes - identical to real mIRC (since 1996): it's not an OS-level "away from the PC" detection, it only counts activity inside the client.

Real mIRC has no automatic timer inside /away itself ("come back online on its own after N minutes") - anyone who wants that writes it with a script that checks $idle periodically, exactly like the example below. A real IRC server automatically notifies anyone who writes to you while you're away (the server's automatic reply); Telegram/WhatsApp have nothing like it, so here it's the app itself sending the away message instead of the server - once per private chat, never in groups (see /away in Commands).

; auto-away after 10 minutes of inactivity, checked every 60 seconds
on start { timer99 0 60 { if ($idle >= 600) && (!$away) { away Away for a bit, back soon } } }

Other identifiers

Identifier	Value
`$version`	The version of Yoake in use (from package.json).
`$isalias(name)`	`1` if an alias with that name exists, `0` otherwise - handy for defensive checks before overwriting/calling it.
`$titlebar`	The text set with `/titlebar` (without the "Yoake -" prefix), empty if not set.
`$ignore(N/nick)`	Nth ignored nick (1-based, `$ignore(0)` the total), or the nick itself if you pass it by name and it's ignored. Real mIRC's `.type`/`.secs` dot-properties (ignore flags, automatic expiry) always return empty - our `/ignore` is a simple mute, with no flags or expiry.
`$count(text,sub,...)` / `$countcs(...)`	How many times each of the substrings occurs in text, summed. `cs` = case-sensitive.
`$remove(text,sub,...)` / `$removecs(...)`	Removes every occurrence of the given substrings. `cs` = case-sensitive.
`$bytes(N)`	Readable size (e.g. `1.5 KB`, `2 MB`).
`$nofile(path)`	The folder only, without the file name.
`$nopath(path)`	The file name only, without the folder.
`$asctime(N,format)` / `$asctime(format)` / `$asctime(N)`	Converts a `$ctime` value (or the current time, if N isn't given) into readable text. Supported format tokens: `yyyy yy mmmm mmm mm dddd ddd dd HH hh nn ss tt TT` (a subset of the official tokens - timezone ones and single-digit forms aren't supported). Without a format, our own readable default (not guaranteed to be byte-for-byte identical to real mIRC, which doesn't document its exact format).
`$mediadir`	The folder "Save to default folder" (right-click on an open photo/video) saves into - see `/mediadir` in Commands. Our own addition: real mIRC has no identifier for this, only a setting in the Options window.

echo $count(hello world hello,hello) occurrences of "hello"
echo $bytes($nick(0))                 ; obviously nonsensical, just for the example
echo Today is $asctime(dd/mm/yyyy) at $asctime(hh:nn:ss)
echo File: $nopath(%path) in $nofile(%path)

Real mIRC's official "Other Identifiers" page lists many more identifiers tied to IRC: some have no equivalent even for a real IRC window (see IRC), because they haven't been implemented - $server, $status, $ssl*... ($network already exists instead, including for IRC windows, see above). Others stay out for the same reason as always, tied to features with no equivalent in this app: DCC ($dccport, $passivedcc...), Windows dialogs/settings ($isadmin, $darkmode, $lock...). The same goes for real mIRC's "File and Directory", "Nick and Address" and "Time and Date" pages: most of it concerns IRC ban lists, hostmask addresses, native Windows file-picker dialogs, or features tied to a real file log - no equivalent here.