No-Code Workspace — Block Reference

Flow ControlBlock usage recipe

Call Group (GROUP_CALL)

Runs a Group Folder like a function

Documented for app version 1.0.50Updated: October 2, 2026

What Does It Do?

Runs a Group Folder in your project. Each folder parameter gets an argument, and a returned value can be stored in a variable.

Pro note: modularize with arguments and result values

GROUP_CALL is not merely a function call. With arguments and a result variable, it turns groups into reusable builder-side routines.

When to Use?

The same sequence is needed in more than one place

Run a routine with different arguments

Bring a calculated result back to the main flow

How to Use?

Create a Group Folder; if needed, add Parameters and a return expression with "Has return value" in its settings

Pick the folder with "Select Group"; the picker shows its parameter count and return

Arguments: a value, variable name or expression per parameter (a variable can also be bound with the lightbulb)

If the folder returns a value, type a name in Result Variable

Parameters

Select Group

The Group Folder to call

Arguments

One value per parameter; the count must match

Result Variable

Shown when the folder has "Has return value"

Parameter	Description
Select Group	The Group Folder to call
Arguments	One value per parameter; the count must match
Result Variable	Shown when the folder has "Has return value"

Example Usage

Folder "Read Score": OCR_VALUE → score; Has return value, expression score

Call Group → Read Score, Result Variable currentScore

COMPARE: currentScore >= 1000

Combinations / Used With

GROUP_CALL + RETURN: return a result early from the folder

COMPARE + GROUP_CALL: call a different folder by condition

TRY_CATCH + GROUP_CALL: catch an error raised in the folder

Tip

Runs a Group Folder like a function

Warnings / Cautions

An empty or unknown group name, an argument count that differs from the parameters, and cyclic calls (A → B → A) are validation errors

A target missing at runtime raises "GROUP_CALL target not found"; errors inside the folder also propagate

A folder disabled by Event State is not called; the skip is logged

Renaming a folder updates the blocks that call it

Step-by-Step Mastery: Basic → Advanced → Pro

The same block at three levels: a quick start, the real options, and professional techniques.

Basic

GROUP_CALL runs a Group Folder in your project. First create a Group Folder and put the steps inside, then add GROUP_CALL to the flow and pick the folder with "Select Group". Instead of rewriting the same sequence everywhere, you define it once and call it from anywhere, just like a function.

Advanced

You can add Parameters in the folder settings; GROUP_CALL then shows one field per parameter under Arguments, where you enter a value, variable name or expression (a variable can also be bound with the lightbulb). The argument count must match the parameter count. If the folder has "Has return value" with a return expression, GROUP_CALL shows a Result Variable field and the returned value is written there; a RETURN block inside the folder returns a value early. Validation reports an empty or unknown group name, an argument-count mismatch and folders that call each other in a cycle (A → B → A) as errors, and the macro does not start. At runtime a missing target raises "GROUP_CALL target not found". For safety the same folder can be nested at most 32 calls deep; beyond that the call is skipped and logged.

Pro

Use GROUP_CALL as the call layer of a modular macro: let the main flow be meaningfully named calls while the real work lives in Group Folders. Calling different folders from a COMPARE or SWITCH_CASE result gives you clean routing. With parameters and a Result Variable a folder becomes a small computation function. Renaming a folder updates the blocks that call it. An error inside the folder propagates out of GROUP_CALL, so wrap critical calls in TRY_CATCH. A folder disabled by Event State is not called and the skip is logged.

Real-World Scenarios — Step-by-Step Recipes

Small, reproducible examples that combine several blocks — build them straight into your own macro.

Shared "Go to Main Menu" routine

1New Group Folder: "Go to Main Menu"
2Add to the folder: SYSTEM (Back) + WAIT 500 ms + IMAGE (main menu check)
3Add GROUP_CALL wherever needed and pick this folder with "Select Group"
4Change the folder’s steps once and every call site uses them

Mini function that returns a result

1Group Folder "Read Score": OCR_VALUE writes the score into score
2Folder setting: Has return value, expression score
3In the main flow GROUP_CALL → Read Score, Result Variable currentScore
4COMPARE: currentScore >= 1000 → collect the reward on TRUE

Which Blocks to Pair With — Pro Combinations

This block is useful on its own — but it shines when paired with the right partners.

+ GROUP (Group Folder)

The target GROUP_CALL runs; parameters and the return value are defined in the folder settings.

+ RETURN

The called group returns a value via RETURN and GROUP_CALL writes it into the result variable.

+ COMPARE

Call different groups by condition to build a dispatch table.

+ EVENT_STATE

If the called group is gated off by state, GROUP_CALL skips it; toggle branches without rewriting the flow.

+ TRY_CATCH

If an error occurs inside the called group, catch it and run a recovery flow.

Common Mistakes and Fixes

Not matching the argument count to the parameter count. Validation reports it as an error and the macro does not start; when you add a parameter to a folder, fill the arguments in its calls too.

Deleting a folder but leaving the GROUP_CALL that calls it. Validation cannot find the target and reports an error; remove the call too or pick another folder.

Folders that call each other in a cycle (A → B → A). Validation rejects it; move the shared work into a third folder.

Not finding the Result Variable field. It appears only when the folder has "Has return value" selected.

Pro Tips

Build the main flow from meaningfully named GROUP_CALLs only; let the real logic live in Group Folders for readability.

Turn groups into small computation functions with a result variable; the RETURN value lands in groupCallResultVar.

Build a clean dispatch pattern by calling different groups based on a COMPARE result; you escape giant nested IF/ELSE blocks.

This Block's Code (Editor View)

Lua

The Lua below is what the Code Editor generates for this block with sample settings. Adding cases, branches, actions or loops, or changing settings, extends the generated code accordingly. Study it to see what the block does under the hood, to learn Lua, or to copy and adapt it. Use the Copy button (top-right) to paste it into the Code Editor, or “Try in Editor →” to run it in the live editor.

lua

Try in Editor →

local groupResult = nil

local _vb_group_Utility_docs_group_u

_vb_group_Utility_docs_group_u = function(_vb_matchCtx)
  _lastMatch = _vb_matchCtx
 wait(1)
end

if type(_vb_group_Utility_docs_group_u) ~= "function" then
 error("GROUP_CALL target not found: Utility")
end
local _gDepth1 = (_groupCallDepth["_vb_group_Utility_docs_group_u"] or 0)
if _gDepth1 >= _groupCallMaxDepth then
 System.log("GROUP_CALL derinlik limiti asildi: Utility")
else
 _groupCallDepth["_vb_group_Utility_docs_group_u"] = _gDepth1 + 1
 local _gcOk1, _gcRes1 = pcall(_vb_group_Utility_docs_group_u, _lastMatch)
 _groupCallDepth["_vb_group_Utility_docs_group_u"] = _gDepth1
 if not _gcOk1 then error(_gcRes1) end
 groupResult = _gcRes1
end

Note: generated code can evolve across versions; helper names (e.g. _reg1, m1) and internal optimizations may change. The logic and the called APIs reflect the block’s behavior.

Block ↔ Lua Mapping →

Shared Controls for This Block Family

The guidance below is not identical for every block. It summarizes the professional controls that most often repeat in the selected block family.

🔀Branch and Exit Rules

Define TRUE/FALSE, try/catch, and loop exit behavior before chaining more blocks.

📦Results and Scope

Keep it explicit where group, dialog, and loop variables are created and where they are consumed.

🛑Safety Bounds

Long flows become brittle quickly without timeouts, ASSERT blocks, BREAK logic, or explicit guards.

🧩Modularity

Moving repeated steps into GROUP and GROUP_CALL improves readability in larger projects.

Builder vs Lua Boundary

Raw touch pointer lifecycle stays code-first

TOUCH and TOUCH_BREAK cover recipe-style touch flows. Raw pointer choreography such as Touch.down, Touch.move, Touch.up, Touch.dispatch, Touch.reset, Touch.breakAll, and Touch.releaseAfter is not exposed as a first-class builder block.

Touch.downTouch.moveTouch.upTouch.dispatchTouch.resetTouch.breakAllTouch.releaseAfter

Bounded dialog design is builder-backed; freer composition stays code-first

The DIALOG block and dialog designer cover a bounded field set in the builder: Info Text, Text Input, Checkbox, Description, Radio Group, Dropdown, Multi Select, Tab Group, Date Time, Number Range, Slider, Image Picker, Color Picker, File Picker, Recorder Picker, Tag, Signature, and Spacer. The buttons are designed too: the Positive button and Negative button tabs set each button’s text, background, and border color, corner radius, and minimum height next to a preview. Freer Setting.builder composition, multi-step wizard flows, and mixed HUD/dialog choreography still do not map 1:1 into the builder.

Coming soonv1.0.51Two more fields: Agent Detect references (agent_detect_editor) lets the user pick a saved reference set or add and edit references, and Save confirms the selection; Navigation setup editor (navigation_editor) edits a saved map, marker and route from the Dialog and returns the setup and route selection without moving the character.

Setting.builderDialogHudTextViewAgentDetectEditorNavigationEditor

Advanced HTTP request chaining stays code-first

HTTP_GET, HTTP_POST, and HTTP_PUT cover common fixed-method flows; HTTP_REQUEST covers one bounded request with method, header lines, body, content type, query parameters (GET and DELETE), timeout, and a bounded retry. These blocks never throw; they write the status code (-1 on a network failure). Cookie handling, chained request objects, and lower-level client flows still need the code editor.

Request()Request.setCookieRequest.getCookiesCUSTOM_CODE

General programming surfaces stay code-first

The MAP, LIST, JSON_PARSE, REGEX_MATCH, and METRICS blocks cover the everyday cases: map actions, a static list, reading a value from a JSON path, regex match, find, replace, and split, and metrics actions. The rest of the Map, Array, JSON, Regex, and Metrics APIs (for example Array sort, filter, and map) is broader than the builder recipe model and stays on the CUSTOM_CODE and code editor side.

MapArrayJSONRegexMetrics

Low-level runtime and Lua composition stays code-first

Runtime helpers, raw Request objects, Lua built-ins such as print/pcall/xpcall, and free-form object chaining patterns are represented through CUSTOM_CODE or the code editor.

RuntimeRequestprintpcallxpcallCUSTOM_CODE

Debug Mode and Breakpoints

Each block card now exposes an independent breakpoint toggle. When enabled, the breakpoint preference is stored with the block.

Breakpoints are only emitted into runtime code when Debug Mode is enabled from Visual Builder settings. When Debug Mode is off, breakpoints stay saved but do not pause execution.

Use ASSERT for fail-fast validation, and use breakpoints for step-by-step tracing and controlled pauses in the same flow.

Variable Scope

Variables defined with SET_VARIABLE are accessible throughout the macro (global scope). All blocks can read/write the same variable.

However, a variable defined inside a GROUP will be 'nil' (undefined) until the GROUP executes. Blocks outside the GROUP using this variable may produce unexpected results.

FOR_EACH loop variables (item and index) only carry valid values inside the loop body. Outside the loop they are outside local scope and should not be used.

TRY_CATCH error variable is only valid within the catch block. If the try block succeeds, the catch branch is not entered and the error variable remains undefined.

TIP: Before using a variable inside a GROUP, assign a default value with SET_VARIABLE outside the GROUP. This way the variable won't be nil even if the GROUP has not run.

Inline Expressions

You can embed variable values and calculations into text fields using {{ expression }} syntax. Expressions inside double curly braces are evaluated as Lua code and the result is inserted into the text.

Syntax

{{ expression }}

Examples

Skor: {{ score + 1 }} → "Skor: " .. tostring(score + 1)

{{ name }} kazandı! → tostring(name) .. " kazandı!"

X:{{ x }} Y:{{ y }} → "X:" .. tostring(x) .. " Y:" .. tostring(y)

Supported Blocks

SET_VARIABLELOGCOMPARECLIPBOARD_WRITENOTIFY_TOASTKV_SET

Security Note

Expressions are checked by the sandbox policy. Security-sensitive calls like loadstring, require, debug are automatically blocked.

General Tips

Keep scan regions as small as possible — improves speed, reduces false matches.

Always add an exit condition when using infinite loops (BREAK, timeout, or conditional exit).

Use network operations and error-prone steps inside TRY_CATCH.

If you need global error handling, use the Error Handler (ERROR_HANDLER) block as a singleton in the project.

Small coordinate offsets (CLICK/SWIPE) improve tap accuracy across different DPI and screen scales.

Customize macros with Dialog block — different parameters each run.

Define repeating steps once with GROUP_CALL, call from many places.

Cross-macro local library

Local Shared Macro Area

The Local Shared Macro Area moves blocks, variables, dialog fields, gallery assets, and imported media dependencies between macros on the same device. It is device-local, not cloud sync, not Firebase sharing, and not a replacement for public macro sharing.

Professional usage model: put a reusable login flow, common scan region, shared dialog form, variable group, template image, color profile, replay recording, or imported PLAY_SOUND media file into the shared area from one macro, then import it from the relevant + menu in another macro.

VISUAL_BLOCKSVARIABLESDIALOG_FIELDSTEMPLATE_IMAGECOLOR_SWATCHREPLAY_RECORDMEDIA_FILE

Send to the shared area

When one item or a multi-selection is active, the shared-area button can copy the selected part from the workspace, group, true/false action branch, dialog, and variables surfaces into the device-local library.

Import into another macro

The shared-area entry under the + menu imports the selected item into the surface that opened it. Main workspace, group, action branch, dialog, and variables each receive the compatible item type.

Share gallery assets

Gallery items include template images, color swatches, replay records, and imported audio/media files. They can move between macros on the same device so repeated templates, colors, recordings, and PLAY_SOUND media assets do not need to be captured again.

Keep it clean

The shared area is not a permanent dumping ground. Delete stale shared items from the shared-library panel; imports create a copy in the target macro and do not rewrite the source macro flow.

Checkpoint: after importing, review block names, linked template/image/color/record/media assets, and variable names in the target macro. The shared area creates a copy; delete stale shared items from the shared-library panel to keep the library clean.

AI assistant

Build a block chain with MH AI in natural language

Tell MH AI what you want in plain language; it proposes the right block sequence and lands it in the workspace after you approve. In the current release it works with cloud providers such as Gemini, Claude, and OpenAI; on-device local models are on the roadmap.

Learn more →