Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/hbmmods/hbm-s-nuclear-tech-git/llms.txt

Use this file to discover all available pages before exploring further.

Redstone Over Radio (RoR) is NTM’s built-in wireless signaling framework. It allows signals to be sent and received anywhere within a dimension with no delay and no distance restriction, completely bypassing the limitations of vanilla redstone dust. In its simplest form, RoR carries numeric values from 0 to 15 that directly map to redstone signal strengths — useful for remotely toggling doors, activating machines, or reading comparator-style fill levels from storage. In more advanced configurations the same channels carry arbitrary text strings, exact numeric counts in the millions, and structured command packets, enabling complex control rooms, reactor safety interlocks, and fully automated factory supervision without a single piece of redstone dust running between rooms.

​
Concepts

Frequencies are string or numeric channel identifiers. Each frequency holds one signal at a time. If two numeric signals arrive on the same frequency within the same game tick, their values are summed — useful for aggregating counts from multiple sources. The most recently received signal otherwise wins. Operating Modes — most RoR devices support two modes:
  • State Change — transmitters send one pulse when their output changes; receivers latch onto the last received value. If a transmitter is destroyed, the receiver retains its last signal.
  • Polling — transmitters broadcast every tick; receivers listen every tick. If the transmitter is removed, the receiver immediately drops to zero.
The IRadioControllable Interface — machines that can be directly commanded by an RoR Controller implement api.hbm.block.IRadioControllable: 
public interface IRadioControllable {
    public String[] getVariables(World world, int x, int y, int z);
    public void receiveSignal(World world, int x, int y, int z, String channel, String signal);
}
getVariables returns the list of command names the block accepts. receiveSignal delivers the command string. The INDEX API (see api.hbm.redstoneoverradio) extends this further with IRORValueProvider (for reading values) and IRORInteractive (for sending commands with parameters). Command strings follow the format command_name!param1:param2. The ! separates the command name from its parameters, and : separates parameters from each other. For example, setmode!2 sets a barrel’s IO mode to 2, while setmode!2:0 toggles between modes 2 and 0.

​
Setting Up a Basic Transmitter–Receiver Pair

1

Place the RoR Transmitter

Place the Redstone-over-Radio Transmitter (hbm:tile.radio_torch_sender) adjacent to the block whose redstone output you want to read (a lever, button, or comparator output). The transmitter reads the signal of the neighbouring block — connecting redstone directly to the torch itself does nothing. If no redstone signal is found, it acts as a comparator and reads fill levels from adjacent containers (0–15).
2

Configure the frequency

Open the transmitter GUI and enter a frequency string or number. Keep it unique to avoid cross-talk. Leave the mode at Redstone Passthrough for a simple 0–15 numeric signal.
3

Place the RoR Receiver

Place the Redstone-over-Radio Receiver (hbm:tile.radio_torch_receiver) anywhere in the same dimension. Open its GUI and enter the same frequency. Leave mode at Redstone Passthrough.
4

Verify the signal

Activate the input (flip a lever, press a button). The receiver should now output a redstone signal of the corresponding strength. Connect vanilla redstone dust or a comparator output from the receiver to your target mechanism.
5

Choose State Change vs. Polling

If the receiver should latch (e.g., hold a door open until explicitly closed), use State Change. If the receiver should immediately reflect the current live state (e.g., a safety interlock), use Polling.

​
Component Reference

Block: hbm:tile.radio_torch_senderThe simplest transmitting device. Reads the redstone signal strength of the adjacent block and broadcasts it on the configured frequency. In the absence of a redstone signal, it behaves like a comparator — reading container fill states as values 0–15. Supports two output modes:
  • Redstone Passthrough — sends the raw numeric value of the signal
  • Custom Mapping — translates specific redstone values to text strings before transmitting. Text that contains only digits is still interpreted as a number by receiving devices.
Block: hbm:tile.radio_torch_receiverThe simplest receiving device. Listens on a configured frequency and outputs a redstone signal. Modes:
  • Redstone Passthrough — interprets the received signal as a number and outputs the corresponding redstone strength (clamped 0–15)
  • Custom Mapping — translates specific received values to redstone signal levels. The received value must match the mapping exactly; for fuzzy comparisons, use the Logic Receiver instead.
Block: hbm:tile.radio_torch_readerAdvanced transmitter. Attach it to a compatible machine (hover over [V] in the GUI to see supported values) and configure up to eight named value slots, each transmitting on its own frequency. Unlike a comparator (which is limited to 0–15), the Reader sends exact numeric values — for example, connecting it to a fluid barrel and selecting fill sends the precise millibucket content.Implements IRORValueProvider on supported machines.
Block: hbm:tile.radio_torch_counterAdvanced transmitter that counts matching items in an adjacent inventory (e.g., a chest or barrel). Supports up to three item filters, each broadcasting on its own frequency. Ideal for monitoring production output or triggering restocking logic. Best paired with a Logic Receiver when counts exceed 15.
Block: hbm:tile.radio_torch_logicAdvanced receiver that applies a rule list to the incoming signal. Evaluates conditions in ascending or descending order (configurable). The first matching condition determines the output redstone strength; if none match, output is 0. Supports:
  • Numeric comparisons (greater than, less than, equal to)
  • String matching (equals, not equals, substring)
Most useful paired with the Item Counter, since item quantities routinely exceed the 0–15 ceiling of vanilla redstone.
Block: hbm:tile.radio_torch_controllerAdvanced receiver that listens on one frequency for command strings and executes them on an attached IRadioControllable block. Hover over [V] in the GUI to see available commands for the connected machine.Command format: <command>!<param1>:<param2>Example — switching a fluid barrel between IO modes 0 and 2:
  • Send setmode!2 to force mode 2
  • Send setmode!2:0 to toggle between mode 2 (if already in mode 2, fall back to 0)
Implements IRORInteractive on the machine side.
Block: hbm:tile.rbmk_key_padInteractive wall-mounted panel device. Configure with a screwdriver first. Up to four buttons can be enabled via the red toggle buttons in the GUI. Each button transmits one value on its own RoR channel. Color is set via a hexadecimal RGB string (e.g., FF8000 = orange; FF = full, 80 = half, 00 = none).Operating modes:
  • Polling — button is latching; holds signal every tick while pressed
  • State Change — sends a single pulse on initial press
Ideal for sending commands to RoR Controllers — for example, adjusting RBMK control rod insertion levels with a single button press.
Block: hbm:tile.rbmk_gaugeAesthetic receiving device. Displays numeric RoR values as an analogue needle gauge. Up to four gauges per block, each on its own channel. Configure minimum and maximum scale values; setting min > max reverses the needle direction. The needle can overshoot maximum by up to 50% before entering the red danger zone. Requires screwdriver configuration.
Block: hbm:tile.rbmk_graphAesthetic receiving device. Plots a time-series line graph of a numeric RoR value, updating every half second and logging up to 15 seconds of history. Up to two graphs per block, each on its own channel. Ideal for tracking temperature curves, flux rates, or coolant flow over time. Requires screwdriver configuration.
Block: hbm:tile.rbmk_indicatorAesthetic receiving device. Lights up when a numeric RoR signal falls within a configured threshold (bounds inclusive). If min threshold > max threshold, the behavior is inverted — the indicator lights outside the range. Useful for alarm panels and go/no-go status boards. Requires screwdriver configuration.
Block: hbm:tile.rbmk_leverInteractive wall-mounted lever switch. Up to two large breaker-style switches per block, each on its own channel. Unlike the keypad, levers transmit different values depending on whether they are in the on or off position, making them ideal for mode-select switching.Operating modes:
  • Polling — continuously sends the current state’s value every tick
  • State Change — sends a single pulse when the lever is flipped
Requires screwdriver configuration.
Block: hbm:tile.rbmk_numitronAesthetic receiving device. Displays numeric RoR values on a seven-segment style display. Up to two display units per block, each on its own channel. Large values are automatically shortened using SI suffixes (k, M, G). Useful for showing item counts, fluid levels, or power readings on a control panel. Requires screwdriver configuration.

​
The INDEX API

The api.hbm.redstoneoverradio package (internally codenamed INDEX) provides the low-level interfaces that back the RoR system:
InterfacePurpose
IRORInfoBase interface — provides getFunctionInfo(), returns the list of valid function names
IRORValueProviderExtends IRORInfo — provideRORValue(String name) reads a named value without causing state changes
IRORInteractiveExtends IRORInfo — runRORFunction(String name, String[] params) executes a command, optionally returning a value
RORFunctionExceptionThrown when a command string is malformed, null, or uses an invalid parameter format
Command string parsing utilities are static methods on IRORInteractive: 
// Extracts "setmode" from "setmode!2:0"
IRORInteractive.getCommand("setmode!2:0"); // → "setmode"

// Extracts ["2","0"] from "setmode!2:0"
IRORInteractive.getParams("setmode!2:0");  // → ["2","0"]

// Parses "2" as an int, throwing RORFunctionException if out of [0,3]
IRORInteractive.parseInt("2", 0, 3);       // → 2
All signal values in INDEX are serialized as strings for NBT compatibility. Receivers that interpret values as numbers do so via Integer.parseInt internally — text-only strings will simply output 0 on those receivers.

Build docs developers (and LLMs) love

Get started for freeTalk to us