> ## Documentation Index > Fetch the complete documentation index at: https://docs.brik64.com/llms.txt > Use this file to discover all available pages before exploring further. # Monomer Catalog > Public BRIK64 monomer vocabulary from MC_00 through MC_127. This catalog lists the public BRIK64 monomer vocabulary used by the current documentation. It records IDs, names, families, short operational descriptions and available signatures from the structured repository catalog. Source used for this public table: the BRIK64 monomer catalog used by this documentation. The descriptions below are selection guidance for humans and AI agents. Detailed preconditions, postconditions, memory effects, error behavior and runtime contracts require reconciliation across the compiler-facing sources before they are published as normative semantics. Current CLI Beta14.1 direct PCD parser support is narrower than this vocabulary: numeric examples may use `MC_00.ADD8`, `MC_01.SUB8`, `MC_02.MUL8`, `MC_03.DIV8`, and `MC_04.MOD8`. Other catalog entries are vocabulary, SDK-level helpers, or roadmap parser surface until a release note says otherwise. ## Core Monomers ### Arithmetic | ID | Name | Description | Signature | | ------ | ---- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- | | MC\_00 | ADD8 | Add two 8-bit unsigned values. Use for bounded byte arithmetic where overflow behavior must be handled by the active runtime contract. | `(u8, u8) -> u8` | | MC\_01 | SUB8 | Subtract one 8-bit unsigned value from another. Use for byte-level difference logic with explicit underflow handling at the surrounding PCD boundary. | `(u8, u8) -> u8` | | MC\_02 | MUL8 | Multiply two 8-bit unsigned values. Use for bounded byte multiplication when truncation or overflow handling is made explicit by the selected contract. | `(u8, u8) -> u8` | | MC\_03 | DIV8 | Divide one 8-bit unsigned value by another and expose quotient plus remainder-shaped output. Use only when division-by-zero handling is specified outside the name alone. | `(u8, u8) -> (u8, u8)` | | MC\_04 | INC | Increment an 8-bit unsigned value by one. Use for counters, loop state or small bounded state transitions. | `(u8) -> u8` | | MC\_05 | DEC | Decrement an 8-bit unsigned value by one. Use for countdowns, bounded retries or reverse iteration state. | `(u8) -> u8` | | MC\_06 | MOD8 | Return the 8-bit remainder from byte-sized division. Use for wrap, bucket or residue logic with explicit zero-divisor handling. | `(u8, u8) -> u8` | | MC\_07 | NEG8 | Produce the byte-level negation form for an 8-bit value under the active arithmetic contract. Use when signed intent or two's-complement interpretation is documented by the PCD. | `(u8) -> u8` | ### Logic | ID | Name | Description | Signature | | ------ | ---- | -------------------------------------------------------------------------------------------------------------- | ---------------- | | MC\_08 | AND8 | Apply bitwise AND to two 8-bit values. Use for masks, flags and byte-level gating. | `(u8, u8) -> u8` | | MC\_09 | OR8 | Apply bitwise OR to two 8-bit values. Use for setting flags or merging byte masks. | `(u8, u8) -> u8` | | MC\_10 | XOR8 | Apply bitwise XOR to two 8-bit values. Use for toggles, parity-shaped checks or reversible byte transforms. | `(u8, u8) -> u8` | | MC\_11 | NOT8 | Invert all bits in one 8-bit value. Use for complement masks and byte-level negation of flags. | `(u8) -> u8` | | MC\_12 | SHL8 | Shift an 8-bit value left by a provided amount. Use when bit positions move toward more significant bits. | `(u8, u8) -> u8` | | MC\_13 | SHR8 | Shift an 8-bit value right by a provided amount. Use when bit positions move toward less significant bits. | `(u8, u8) -> u8` | | MC\_14 | ROL8 | Rotate an 8-bit value left by a provided amount. Use when shifted-out bits must re-enter on the opposite side. | `(u8, u8) -> u8` | | MC\_15 | ROR8 | Rotate an 8-bit value right by a provided amount. Use when right-shifted bits must wrap around. | `(u8, u8) -> u8` | ### Memory | ID | Name | Description | Signature | | ------ | ----- | ---------------------------------------------------------------------------------------------------------------------------- | ------------------ | | MC\_16 | LOAD | Read a value from a declared memory location or runtime state slot. Use only with an explicit address/source contract. | `runtime contract` | | MC\_17 | STORE | Write a value to a declared memory location or runtime state slot. Use only when mutation scope is explicit. | `runtime contract` | | MC\_18 | PUSH | Push a value onto a stack-like runtime structure. Use for ordered temporary state where stack discipline is part of the PCD. | `runtime contract` | | MC\_19 | POP | Remove and return the top value from a stack-like runtime structure. Use with explicit empty-stack behavior. | `runtime contract` | | MC\_20 | PEEK | Inspect the top or selected stack value without removing it. Use when read-only stack access is needed. | `runtime contract` | | MC\_21 | SWAP | Exchange the order of two stack or register-like values. Use to make dataflow ordering explicit without hidden temporaries. | `runtime contract` | | MC\_22 | DUP | Duplicate a stack or runtime value. Use when one value must feed multiple later operations. | `runtime contract` | | MC\_23 | DROP | Discard a stack or runtime value. Use to make intentional value disposal explicit. | `runtime contract` | ### Control | ID | Name | Description | Signature | | ------ | ---- | ----------------------------------------------------------------------------------------------------------------------------- | ------------------ | | MC\_24 | JMP | Transfer control to a declared target. Use for explicit branch edges, not implicit flow. | `runtime contract` | | MC\_25 | LOOP | Represent bounded or contract-defined repetition. Use only when loop bounds or stop conditions are specified. | `runtime contract` | | MC\_26 | CALL | Invoke a declared PCD, polymer or runtime callable boundary. Use when inputs, outputs and side effects are named. | `runtime contract` | | MC\_27 | RET | Return from a declared callable boundary. Use to make output handoff and control return explicit. | `runtime contract` | | MC\_28 | IF | Select a branch based on a declared condition. Use for explicit conditional logic with named true/false paths. | `runtime contract` | | MC\_29 | HALT | Stop execution for the current circuit or runtime lane. Use for terminal states and fail-closed exits. | `runtime contract` | | MC\_30 | NOP | Perform no state-changing operation. Use as an explicit placeholder, alignment point or trace marker. | `runtime contract` | | MC\_31 | WAIT | Pause until a declared condition, event or time boundary. Use only when the wait contract is bounded or externally specified. | `runtime contract` | ### I/O | ID | Name | Description | Signature | | ------ | ----- | -------------------------------------------------------------------------------------------------------------- | ------------------ | | MC\_32 | READ | Read bytes, records or values from a declared I/O source. Use with explicit source and failure behavior. | `runtime contract` | | MC\_33 | WRITE | Write bytes, records or values to a declared I/O sink. Use with explicit sink and acknowledgement behavior. | `runtime contract` | | MC\_34 | PRINT | Emit human-readable output through a declared text channel. Use for display/log-like output, not hidden state. | `runtime contract` | | MC\_35 | INPUT | Receive external input through a declared channel. Use only when validation and trust boundary are documented. | `runtime contract` | | MC\_36 | OPEN | Open a declared resource handle. Use with explicit resource type, mode and failure contract. | `runtime contract` | | MC\_37 | CLOSE | Close a declared resource handle. Use to make lifecycle release explicit. | `runtime contract` | | MC\_38 | SEEK | Move a cursor or offset inside a declared stream/resource. Use when random access is part of the contract. | `runtime contract` | | MC\_39 | FLUSH | Force buffered output or state to the declared sink. Use when durability or ordering boundary matters. | `runtime contract` | ### Strings | ID | Name | Description | Signature | | ------ | ------ | --------------------------------------------------------------------------------------------------------------------------- | ------------------ | | MC\_40 | CONCAT | Combine strings or byte-text segments in declared order. Use when concatenation is the intended operation. | `runtime contract` | | MC\_41 | SPLIT | Divide text by a declared delimiter or rule. Use with explicit delimiter, max parts and empty-field behavior when relevant. | `runtime contract` | | MC\_42 | SUBSTR | Extract a substring by declared position or range. Use with explicit indexing and out-of-range behavior. | `runtime contract` | | MC\_43 | LEN | Measure string or buffer length. Use when downstream logic depends on explicit size. | `runtime contract` | | MC\_44 | UPPER | Convert text to uppercase under the declared locale/encoding contract. Use for normalization where casing matters. | `runtime contract` | | MC\_45 | LOWER | Convert text to lowercase under the declared locale/encoding contract. Use for normalization where casing matters. | `runtime contract` | | MC\_46 | TRIM | Remove declared leading/trailing characters or whitespace. Use for input cleanup with explicit trim set. | `runtime contract` | | MC\_47 | MATCH | Test text against a declared pattern or matcher. Use with explicit pattern semantics and match result shape. | `runtime contract` | ### Crypto | ID | Name | Description | Signature | | ------ | ------- | --------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | | MC\_48 | HASH | Compute a declared hash over declared input bytes. Use only with algorithm and encoding identified by the surrounding contract. | `runtime contract` | | MC\_49 | ENCRYPT | Encrypt declared data using a declared key/material boundary. Use with explicit algorithm, mode and failure handling. | `runtime contract` | | MC\_50 | DECRYPT | Decrypt declared data using a declared key/material boundary. Use with explicit algorithm, mode and authentication behavior. | `runtime contract` | | MC\_51 | SIGN | Produce a signature over declared data. Use with explicit key identity, algorithm and message representation. | `runtime contract` | | MC\_52 | VERIFY | Check a signature, proof-shaped artifact or authenticity marker under a declared crypto contract. Use with explicit pass/fail behavior. | `runtime contract` | | MC\_53 | DIGEST | Produce or handle a digest value as a named artifact. Use when the digest itself is the dataflow output. | `runtime contract` | | MC\_54 | KEY | Create, load, derive or reference key material under a declared key-management boundary. Use without exposing secrets. | `runtime contract` | | MC\_55 | RNG | Request random or pseudo-random data from a declared source. Use with explicit entropy/source assumptions. | `runtime contract` | ### System | ID | Name | Description | Signature | | ------ | ------ | ------------------------------------------------------------------------------------------------------------------------- | ------------------ | | MC\_56 | TIME | Read a declared time source or timestamp. Use with explicit clock and determinism assumptions. | `runtime contract` | | MC\_57 | CPU | Inspect or request CPU-related runtime information. Use only when host dependency is an explicit boundary. | `runtime contract` | | MC\_58 | MEM | Inspect or request memory-related runtime information. Use only when host/resource dependency is explicit. | `runtime contract` | | MC\_59 | GETENV | Read an environment variable or environment-like setting. Use with explicit variable name and missing-value behavior. | `runtime contract` | | MC\_60 | EXIT | End the process or runtime lane with a declared status. Use for explicit terminal outcomes. | `runtime contract` | | MC\_61 | PID | Read process identity from the host/runtime. Use when process identity is an explicit external dependency. | `runtime contract` | | MC\_62 | LOG | Emit structured or textual runtime log output. Use for traceability without treating logs as certification. | `runtime contract` | | MC\_63 | ASSERT | Check a declared invariant and fail according to the active contract when it is false. Use for explicit guard conditions. | `runtime contract` | ## Extended Monomers ### Float64 | ID | Name | Description | Signature | | ------ | ----- | ---------------------------------------------------------------------------------------------------------------------------------- | ------------------ | | MC\_64 | FADD | Add floating-point values under the declared float64 contract. Use only when integer monomers do not express the requirement. | `runtime contract` | | MC\_65 | FSUB | Subtract floating-point values under the declared float64 contract. Use with explicit rounding and exceptional-value assumptions. | `runtime contract` | | MC\_66 | FMUL | Multiply floating-point values under the declared float64 contract. Use with explicit precision and exceptional-value assumptions. | `runtime contract` | | MC\_67 | FDIV | Divide floating-point values under the declared float64 contract. Use with explicit zero, infinity and NaN handling. | `runtime contract` | | MC\_68 | FABS | Return the absolute value of a floating-point value. Use when sign removal is the intended float operation. | `runtime contract` | | MC\_69 | FNEG | Negate a floating-point value. Use when sign inversion is the intended float operation. | `runtime contract` | | MC\_70 | FSQRT | Compute a floating-point square root. Use with explicit domain and exceptional-value handling. | `runtime contract` | | MC\_71 | FMOD | Compute a floating-point remainder. Use with explicit divisor and exceptional-value handling. | `runtime contract` | ### Math | ID | Name | Description | Signature | | ------ | ---- | --------------------------------------------------------------------------------------------------------------------- | ------------------ | | MC\_72 | SIN | Compute sine under the declared math/float contract. Use for trigonometric behavior with explicit unit assumptions. | `runtime contract` | | MC\_73 | COS | Compute cosine under the declared math/float contract. Use for trigonometric behavior with explicit unit assumptions. | `runtime contract` | | MC\_74 | TAN | Compute tangent under the declared math/float contract. Use with explicit handling near undefined points. | `runtime contract` | | MC\_75 | EXP | Compute exponential growth under the declared math contract. Use with explicit range and overflow assumptions. | `runtime contract` | | MC\_76 | LN | Compute natural logarithm. Use with explicit positive-domain and exceptional-value handling. | `runtime contract` | | MC\_77 | LOG2 | Compute base-2 logarithm. Use with explicit positive-domain and exceptional-value handling. | `runtime contract` | | MC\_78 | POW | Raise a value to a declared power. Use with explicit domain, exponent and exceptional-value behavior. | `runtime contract` | | MC\_79 | CEIL | Round a numeric value upward to the next integer-shaped boundary. Use with explicit numeric representation. | `runtime contract` | ### Network | ID | Name | Description | Signature | | ------ | -------- | --------------------------------------------------------------------------------------------------------------- | ------------------ | | MC\_80 | NCONNECT | Open a network connection to a declared endpoint. Use with explicit protocol, timeout and failure behavior. | `runtime contract` | | MC\_81 | NSEND | Send data through a declared network channel. Use with explicit framing, retry and acknowledgement assumptions. | `runtime contract` | | MC\_82 | NRECV | Receive data from a declared network channel. Use with explicit framing, timeout and partial-read behavior. | `runtime contract` | | MC\_83 | NCLOSE | Close a declared network channel. Use to make network lifecycle release explicit. | `runtime contract` | | MC\_84 | NBIND | Bind a network endpoint or socket. Use with explicit address, port and permission assumptions. | `runtime contract` | | MC\_85 | NLISTEN | Listen for inbound network connections. Use with explicit queue, protocol and availability assumptions. | `runtime contract` | | MC\_86 | NACCEPT | Accept an inbound network connection. Use with explicit trust boundary and failure handling. | `runtime contract` | | MC\_87 | NPOLL | Poll one or more network channels for readiness. Use with explicit timeout and event model. | `runtime contract` | ### Graphics | ID | Name | Description | Signature | | ------ | ------- | --------------------------------------------------------------------------------------------------------------- | ------------------ | | MC\_88 | GPLOT | Plot a point or pixel in a declared graphics surface. Use with explicit coordinate and color model. | `runtime contract` | | MC\_89 | GLINE | Draw a line on a declared graphics surface. Use with explicit endpoints, stroke and clipping behavior. | `runtime contract` | | MC\_90 | GRECT | Draw a rectangle on a declared graphics surface. Use with explicit bounds, stroke/fill and clipping behavior. | `runtime contract` | | MC\_91 | GCIRCLE | Draw a circle on a declared graphics surface. Use with explicit center, radius and clipping behavior. | `runtime contract` | | MC\_92 | GFILL | Fill a region or primitive on a declared graphics surface. Use with explicit fill rule and color model. | `runtime contract` | | MC\_93 | GTEXT | Render text on a declared graphics surface. Use with explicit font, encoding and positioning assumptions. | `runtime contract` | | MC\_94 | GBLIT | Copy image or buffer data into a graphics surface. Use with explicit source, destination and blending behavior. | `runtime contract` | | MC\_95 | GCLEAR | Clear a graphics surface or region. Use with explicit target region and clear value. | `runtime contract` | ### Audio | ID | Name | Description | Signature | | ------- | ------- | ---------------------------------------------------------------------------------------------------------------------- | ------------------ | | MC\_96 | APLAY | Play audio through a declared output channel. Use with explicit format, device and timing assumptions. | `runtime contract` | | MC\_97 | AREC | Record audio from a declared input channel. Use with explicit format, device and privacy boundary. | `runtime contract` | | MC\_98 | AMIX | Mix multiple audio streams or buffers. Use with explicit channel, gain and clipping behavior. | `runtime contract` | | MC\_99 | AGAIN | Apply audio gain. Use with explicit gain scale and clipping behavior. | `runtime contract` | | MC\_100 | APAN | Apply stereo or multi-channel pan. Use with explicit channel layout and pan law. | `runtime contract` | | MC\_101 | AFILTER | Apply an audio filter. Use with explicit filter type, coefficients or named preset. | `runtime contract` | | MC\_102 | AFFT | Transform audio or signal data into frequency-domain representation. Use with explicit windowing and size assumptions. | `runtime contract` | | MC\_103 | AIFFT | Transform frequency-domain data back toward time-domain representation. Use with explicit normalization assumptions. | `runtime contract` | ### Filesystem | ID | Name | Description | Signature | | ------- | ------ | -------------------------------------------------------------------------------------------------------------------------- | ------------------ | | MC\_104 | FSTAT | Read metadata for a declared filesystem path or handle. Use with explicit path boundary and missing-file behavior. | `runtime contract` | | MC\_105 | FCHMOD | Change permissions for a declared filesystem path or handle. Use only when permission mutation is an explicit requirement. | `runtime contract` | | MC\_106 | FMKDIR | Create a directory at a declared path. Use with explicit parent, permission and existing-path behavior. | `runtime contract` | | MC\_107 | FRMDIR | Remove a directory at a declared path. Use with explicit empty/non-empty and failure behavior. | `runtime contract` | | MC\_108 | FLIST | List files or entries under a declared path. Use with explicit filtering, ordering and permission assumptions. | `runtime contract` | | MC\_109 | FCOPY | Copy a file or filesystem object. Use with explicit source, destination and overwrite behavior. | `runtime contract` | | MC\_110 | FMOVE | Move or rename a file or filesystem object. Use with explicit source, destination and overwrite behavior. | `runtime contract` | | MC\_111 | FLINK | Create or inspect a filesystem link. Use with explicit link type and target behavior. | `runtime contract` | ### Concurrency | ID | Name | Description | Signature | | ------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------ | ------------------ | | MC\_112 | SPAWN | Start a declared concurrent task, process or runtime lane. Use with explicit lifecycle and isolation assumptions. | `runtime contract` | | MC\_113 | JOIN | Wait for a declared concurrent task to complete and collect its result/status. Use with explicit timeout and failure behavior. | `runtime contract` | | MC\_114 | LOCK | Acquire a declared synchronization lock. Use with explicit scope, ordering and deadlock assumptions. | `runtime contract` | | MC\_115 | UNLOCK | Release a declared synchronization lock. Use to make concurrency lifecycle release explicit. | `runtime contract` | | MC\_116 | CHAN\_SEND | Send a value through a declared channel. Use with explicit buffering, blocking and failure behavior. | `runtime contract` | | MC\_117 | CHAN\_RECV | Receive a value from a declared channel. Use with explicit blocking, timeout and closed-channel behavior. | `runtime contract` | | MC\_118 | ATOMIC\_CAS | Perform atomic compare-and-swap. Use with explicit memory ordering and comparison target. | `runtime contract` | | MC\_119 | BARRIER | Synchronize multiple tasks at a declared barrier. Use with explicit participant count and timeout/failure behavior. | `runtime contract` | ### Interop | ID | Name | Description | Signature | | ------- | ---------- | ----------------------------------------------------------------------------------------------------------------------------- | ------------------ | | MC\_120 | FFI\_CALL | Call an external function through a declared foreign interface. Use only when the external boundary is explicitly documented. | `runtime contract` | | MC\_121 | FFI\_LOAD | Load or bind an external library/symbol. Use with explicit source, symbol name and trust boundary. | `runtime contract` | | MC\_122 | FFI\_FREE | Release memory or resources allocated through a foreign interface. Use to make external lifecycle cleanup explicit. | `runtime contract` | | MC\_123 | FFI\_CAST | Convert a foreign value or pointer representation. Use with explicit type and safety assumptions. | `runtime contract` | | MC\_124 | FFI\_REF | Create or pass a reference into foreign-interface space. Use with explicit ownership and lifetime assumptions. | `runtime contract` | | MC\_125 | FFI\_DEREF | Read through a foreign reference or pointer. Use with explicit validity, ownership and bounds assumptions. | `runtime contract` | | MC\_126 | FFI\_ALLOC | Allocate memory or a resource through a foreign interface. Use with explicit size, ownership and cleanup path. | `runtime contract` | | MC\_127 | FFI\_COPY | Copy data across a foreign-interface boundary. Use with explicit source, destination, length and ownership assumptions. | `runtime contract` |