Space Engineers

Space Engineers

880 ratings
Isy's Inventory Manager Guide
By Isy
This is a full guide that will explain all the features of my Inventory Manager script.

You can find the script here:
Basic Setup
The basic setup is very easy. You just need a programmable block with the script and that's it! Below you have a step by step description of what to do:
  • subscribe to my script in the workshop (see link in the title)
  • build a programmable block
  • open it in the terminal
  • press 'Edit'
  • in the new window, press 'Browse Workshop'
  • select my script 'Isy's Inventory Manager' and press 'Ok'
  • the code now appears in the window
  • press 'Check Code' and 'Ok' in the popup window
  • press 'Remember & Exit' and you're done

The script is now running with all its basic settings and all your containers should already be sorted.

For a more visual, video guide, watch my youtube video:

Note: Game has to be in experimental mode and ingame scripts have to enabled in world options!
How to do that, I explained here:

All items are sorted based on their type into different containers. Docked ships or vehicles are also emptied. To prevent that temporary, have a look at the upcoming guide topics.

You can also change the keyword, a container has to contain to be recognized as a type specific container, in the config section. Just make sure that they are unique as the script will find matching keywords in parts of block names as well.
// Define the string a cargo container has to contain in order to be recognized as a container of the given type. const string oreContainerKeyword = "Ores"; const string ingotContainerKeyword = "Ingots"; const string componentContainerKeyword = "Components"; const string toolContainerKeyword = "Tools"; const string ammoContainerKeyword = "Ammo"; const string bottleContainerKeyword = "Bottles";
Exclude containers from sorting
By adding the 'Locked' keyword to any block's name, this block is excluded from sorting. This could be useful if you are preparing a container with things, you want to take with you on your next trip.

Locked containers will also be excluded as a source for any balancing method (ore balancing, ice balancing, uranium balancing).

By default inventories with the tag 'Locked', 'Seat' and 'Control Station' are excluded from sorting (the last two because they have no conveyor access). You can change or expand the list in the config section:
// Keyword a block name has to contain to be skipped by the sorting (= no items will be taken out). // This list is expandable - just separate the entries with a ",". But it's also language specific, so adjust it if needed. // Default: string[] lockedContainerKeywords = { "Locked", "Seat", "Control Station" }; string[] lockedContainerKeywords = { "Locked", "Seat", "Control Station" };
Exclude containers from item counting
You can exclude specific inventories from the item counting mechanism. This could be useful if you don't want the autocrafting to see certain items in docked ships for example. Also, the inventory panels won't show the items of that inventory either.

To do that, append the 'hiddenContainerKeyword' (by default: 'Hidden') to a blockname or just disable the terminal option "Show block in Inventory Screen" after you set the 'treatNotShownAsHidden' variable to true. The list is also expandable if you want to exclude other blocknames by default:
// Keyword a block name has to contain to be excluded from item counting (used by autocrafting and inventory panels) // This list is expandable - just separate the entries with a ",". But it's also language specific, so adjust it if needed. // Default: string[] hiddenContainerKeywords = { "Hidden" }; string[] hiddenContainerKeywords = { "Hidden" }; // Treat inventories that are hidden via disbaling the terminal option "Show block in Inventory Screen" as hidden containers // just like adding the 'Hidden' keyword (see above)? (Note: It's not recommended to hide your main type containers!) bool treatNotShownAsHidden = false;
Exclude grids from sorting
It is possible to exclude whole grids from sorting by either giving a connector on the grid running IIM or any connected grid's connector the '[No Sorting]' keyword. Every ship, vehicle or whatever, that docks to IIM's grid's connector, won't be sorted (when having the tag on a ship, only the ship wearing it).
string noSortingKeyword = "[No Sorting]";

In this case, only sorting will be disabled. Special containers however are still filled and uranium and ice balancing is also active.

To completely ignore a grid, add the '[No IIM]' keyword to a connector:
string noIIMKeyword = "[No IIM]";

Every ship or other vehicle that docks to this connector won't be sorted - all inventories, special containers, reactors and O2/H2 generators on that grid are completely ignored.

It is also possible to add the tags to a gridname directly (found in the info tab). That way, even rotor connected ships, drones or vehicles without a connector can be excluded..
Container priorities
By adding '[P#]' to the container name, where # is a positive number between 0 and 2.1 billion, the container with the highest priority will always be filled first. Priorities are ordered in a way that P1 is the highest priority, P2 the next highest and so on.

Addtionally, there are two special priority tokens:
  • '[PMax]' this container has the highest priority and will always be filled FIRST
  • '[PMin]' this container has the lowest priority and will always be filled LAST

If a container is full, the container with the next highest priority gets filled and so on. Containers with no '[P#]' tag have a very low priority that is generated by their entityID and is always above 10k.
Special containers however still have a higher priority than normal containers, but can also be tagged with priority tokens. The highest priority special container will be filled first.

Here are some examples of container names with priority numbers:
  • Small Cargo Container 1 Ores [P1]
  • Small Cargo Container [P13] Ingots
  • [P5] Cargo Container Components
  • Cargo Container Bottles [PMax]
Container balancing
It is possible to equalize the amount of every item in every container of a specific type. This leads to the same item set in all of your type containers. This is very useful if you are attacked and a container is destroyed - the other containers will still have all your items as a backup (if you planned your base well enough :P ).

This feature however is very instruction heavy and could crash the script if you have many containers of the same type (successfully tested it with 15 component containers). That's why it's turned off by default. Also, container priorites of the type containers won't have any effect anymore.

To enable or disable the feature, change the respective setting in the config:
bool balanceTypeContainers = false;
Automatic container assignment
By default, new containers are assigned to be used by the script, when a container is full or no container of a specific type exists yet. Containers for tools, ammo and bottles are always assigned as one. The same applies to ingot and ore containers.

Another feature is the automatic unassignment of empty and thus unused type containers. The tag gets removed after a the container was empty for a while to free it up for other purposes.

Containers with a priority token, like [P1] won't ever be unassigned automatically.

For more control, you can set, which types are allowed to be assigned or unassigned in the script config (see below).

Change the values to 'true' or 'false' to activate or deactivate a certain feature:
// Master switch. If this is set to false, automated container un-/assignment is disabled entirely. bool autoContainerAssignment = true; // Assign switch. Assign new containers if a type is full or not present? bool assignNewContainers = true; // Which type should be assigned automatically? (only relevant if master and assign switch are true) bool assignOres = true; bool assignIngots = true; bool assignComponents = true; bool assignTools = true; bool assignAmmo = true; bool assignBottles = true; // Unassign switch. Unassign empty type containers that aren't needed anymore (at least one of each type always remains). // This doesn't touch containers with manual priority tokens, like [P1]. bool unassignEmptyContainers = true; // Which type should be unassigned automatically? (only relevant if master and unassign switch are true) bool unassignOres = true; bool unassignIngots = true; bool unassignComponents = true; bool unassignTools = true; bool unassignAmmo = true; bool unassignBottles = true; // Assign ores and ingots containers as one? (complies with type switches) bool oresIngotsInOne = true; // Assign tool, ammo and bottle containers as one? (complies with type switches) bool toolsAmmoBottlesInOne = true;
Bottle refilling
By default, the script will try to move any incoming bottle to the first found tank that has the needed gas available or to a O2/H2 generator if there are no tanks or they are empty. After that, they get pushed to the bottle container. This works for just crafted bottles, that are inside an assembler, too. As scripts can't read the bottle fill levels, the script will only move a bottle if it's not in the bottles container already. So, if you want your bottle filled, store it in any other container, like some sort of untagged input container.

To enable or disable bottle filling, change the value in config section (heading "Sorting") to true or false:
// Fill bottles before storing them in the bottle container? bool fillBottles = true;
Fill level and no conveyor connection
By default, the script shows a fill level percentage at the end of cargo container names, it manages. It can also show a [No Conveyor] tag in the name, if the block has no access to your main cargo containers.

You can activate or deactivate these features in the script config by setting the value to true or false:
// Show a fill level in the container's name? bool showFillLevel = true; // Tag inventories, that have no access to the main type containers with [No Conveyor]? bool showNoConveyorTag = false;
Internal inventory sorting
The internal inventory sorting sorts items in an inventory by name, amount or type. By default it is deactivated because it can lead to inventory desynchronization in multiplayer. Use at your own risk!
You can change the way, internal sorting works, by changing the sorting pattern in the config section:
// Sort the items inside all containers? bool enableInternalSorting = false; // Internal sorting pattern. Always combine one of each category, e.g.: 'Ad' for descending item amount (from highest to lowest) // 1. Quantifier: // A = amount // N = name // T = type (alphabetical) // X = type (number of items) // 2. Direction: // a = ascending // d = descending string sortingPattern = "Na";

You can also sort an individual inventory by changing the name of it. The syntax goes like this:

In this case, PATTERN is a combination of characters shown above. See the following block naming examples:

Sort an inventory by item amount, ascending (from lowest to highest):
Small Cargo Container (sort:Aa)

Sort an inventory by type, descending (inverse alphabetical order Z -> A):
Small Cargo Container (sort:Td)

Sort an inventory by type and number of items, ascending (alphabetical order A -> Z, number of items from lowest to highest):
Small Cargo Container (sort:Xa)
Special loadout containers
By naming a container with the 'Special' keyword, this container can be filled with a user defined set of items. To set the items, just edit the container's custom data field (a list of items is generated there after a while). Special containers will never be drained by the autosorting but they will be available for balancing methods like ice or uranium balancing and autocrafting.

Special containers can have four different modes on a per-item-basis:
  • Normal: stores wanted amount, removes excess. Usage: "item=100"
  • Minimum: stores wanted amount, ignores excess. Usage: "item=100M"
  • Limiter: doesn't store items, only removes excess. Usage: "item=100L"
  • All: stores all items it can get until it's full. Usage: "item=All"

The Minimum mode is great for blocks that pull items themselves but should never fall below a specific item amount, like turrets or guns.
The Limiter mode is mostly used for blocks that pull items themselves but should not clog up their inventory with too much stuff, like assemblers or some modded blocks like the nanite factory.
The 'All' keyword is great for advanced sorting of items. It will store all items of that specific subtype in the container until it's full. Excess items will then be stored in the regular type container.

Example custom data:

Whether or not a Special container is allowed to steal from other Special containers can be set in the script config:
const string specialContainerKeyword= "Special"; bool allowSpecialSteal = true;
My script is able to autocraft your components using every assembler available on the grid. There is no need to assign specific assembler to specific components. The script splits the needed amount evenly between them.
To start off, you need to build an LCD and name it 'LCD Autocrafting'. The script will put a list of components, that are autocraftable on the LCD. To set a new wanted amount, you simply have to edit the text on the LCD and change the number to your likings.
When the script queued items in the assemblers a symbol after the current amount will be shown, indicating, how many items are in the queue, e.g.: [Q:100]

By default, the assembler queue is sorted based on the most needed component. Whenever a component can't be crafted, the script will move the item to the end of the queue so that other items can be crafted.

Enable/disable autocrafting and autodisassembling
Enable autocrafting or autodisassembling by changing the following config settings. All assemblers will be used. Disassembling will disassemble everything above the wanted amounts. To use an assembler manually, add the manualMachineKeyword to it (by default: "!manual")
bool enableAutocrafting = true; bool enableAutodisassembling = false;

Autocrafting LCD
A LCD with the keyword "Autocrafting" is required where you can set the wanted amount! This has multi LCD support. Just append numbers after the keyword, like: "LCD Autocrafting 1", "LCD Autocrafting 2", ..
string autocraftingKeyword = "Autocrafting";

Assemble or Disassemble only tags
If you want an assembler to only assemble or only disassemble, use the following keywords and append them to the assembler's name.
A assembler without a keyword will do both tasks.
string assembleKeyword = "!assemble-only"; string disassembleKeyword = "!disassemble-only";

Margins for autocrafting and autodisassembling
Margins for assembling or disassembling items in percent based on the wanted amount (default: 0 = exact value).

assembleMargin = 5 with a wanted amount of 100 items will only produce new items, if less than 95 are available.
disassembleMargin = 10 with a wanted amount of 1000 items will only disassemble items if more than 1100 are available.
double assembleMargin = 0; double disassembleMargin = 0;

You can add the header to every screen when using multiple autocrafting LCDs by enabling this option:
bool headerOnEveryScreen = false;

Sort the assembler queue based on the most needed components
The assembler queue is by default sorted by the most needed components. So if your assembler is producing steel plates, interior plates and bulletproof glass and you're absolutely dry on stell plates, they will be moved to the front of the queue.
bool sortAssemblerQueue = true;

Basic crafting with Survival Kits
You can enable basic ingot crafting in survival Kits with this option. It will however be automatically disabled if you have regular refineries built.
bool enableBasicIngotCrafting = true;

Autocrafting is also possible with survival kits, but as they are very slow, they are deactivated as soon as you have regualar assemblers. If you still want to use them, change this value to false:
bool disableBasicAutocrafting = true;

Manual crafting
If you still want an assemblers to be manually controllable, you can add the keyword "!manual" to its name. With this keyword, it won't be used by the autocrafting. The ouput of the assembler will still be sorted into your cargo containers. Example:
Assembler 1 !manual
Autocrafting Modifiers
There are 6 modifiers that can be added to the wanted item amounts, that will change the way, autocrafting handles these items. These modifiers can be set on a per-item-level:

'A' - Assemble only
'D' - Disassemble only
'P' - Priority (always craft first)
'H' - Hide (manage in custom data)
'I' - Ignore (don't manage and hide)
'Y#' - Yield modifier. Set # to the itemamount, one craft yields

Assemble only modifier
The script will assemble the item to the quantity you set but it will never disassemble it even is auto disassembling is turned on and the stored amount is greater than the wanted amount.

Component Current | Wanted SteelPlates 4123 < 5000A

Disassemble only modifier
The script will only disassemble the item, if it gets above the wanted quantity but it will never assemble more, if the stored amount drops below the wanted amount.

Component Current | Wanted SteelPlates 4123 < 5000D

Priority modifier
Whenever the stored amount of an item is not equal to the wanted amount of it, the script will move it to the front of the assembling queue (this was done with '!' before v2.8.0)

Component Current | Wanted SteelPlates 4123 < 5000P

Hide and manage modifier
If you want autocrafting to manage the amount of an item but you don't want it to be shown on the autocrafting LCD, you can use the 'H' modifier. The item with its current wanted amount will be moved to the custom data of your (first) autocrafting LCD and hidden from the LCD itself. The amount can be changed afterwards by editing it in the custom data. If you want to show it on the LCD again, just remove the line in the custom data.

Component Current | Wanted SteelPlates 4123 < 5000H

Hide and ignore modifier
If you want you want to hide an item from the autocrafting LCD and don't want autocrafting to manage it, use the 'I' modifier (this was done with a negative item amount before v2.8.0). The item will be moved to the custom data of your (first) autocrafting LCD and hidden from the LCD itself. If you want to show it on the LCD again, just remove the line in the custom data.

Component Current | Wanted SteelPlates 4123 < 5000I

Yield modifier
Some modded assembler operations yield more than one item of a kind. This results in wrong autocrafting queues and overproduction. To fix that, you can use the yield modifier followed by the number of items, one craft produces.

Component Current | Wanted Algaesample 4123 < 5000Y50

Modifiers are also combineable. 'AP' for example will assemble only and prioritize. 'AD' will basically just show the item on the LCD but neither assemble nor disassemble it.
Autocrafting unknown / modded items
The script is able to craft any modded item that is craftable in an assembler or assembler like modded structure but it has to learn the crafting blueprint first. Unknown items are hidden from the autocrafting screen by default. You can however show them by changing the following variable to true in the script config (this is not needed to teach the recipe!):

// Show unlearned (mostly modded) items on the autocrafting screen? This adds the [NoBP] tag (no blueprint) like in the old days of IIM.
bool showUnlearnedItems = false;

With the option enabled, unknown items have the tag [No BP!] (= no blueprint) behind their name:

In order to teach the script the blueprint of that item, you need to setup a learning assembler by adding one of the following tags to an assembler's name:
This will learn one item and then remove the tag so that the assembler is part of the autocrafting again.

This will learn everything you queue in it and will never be part of the autorafting again until you remove the tag (Important note: only ever queue one itemstack at a time and wait for it to finish).

To learn an item, queue it up about 100 times (Shift+Klick) and wait until the script removes it from the queue:

The script links the blueprint to the resulting item and is now able to autocraft this item. You can check that the script has properly learned the blueprint if the [No BP!] tag is gone:
Auto disassembling
If you set up your autocrafting LCD already and set all your wanted amounts, you can enable automatic disassembling in your config section (heading Autocrafting). This feature will disassemble all your excess materials automatically using all available assemblers.

Change the values to 'true' or 'false' to activate or deactivate a certain feature:
bool enableAutodisassembling = false;

Please be sure to set your wanted amounts BEFORE your enable this feature as this will disassemble all your goods imediately and turn them back into ingots. Also, manual crafting is kind of limited after enabling this because the script always tries to keep the set amount of items on the autocrafting LCD at all times.
Assembler cleanup
This cleans up assemblers, if they have nothing to do and puts the contents back into a cargo container.

Change the values to 'true' or 'false' to activate or deactivate a certain feature:
// This cleans up assemblers, if their inventory is too full and puts the contents back into a cargo container. bool enableAssemblerCleanup = true;
Refinery handling
This balances the ores in refineries. It's designed to refine ores as fast as possible by splitting the ore amounts equally between the refineries. The script won't care about the installed upgrades of a refinery, so if you want to refine a specific ore in a specific refinery, you might want to have a look at the topic "Special loadout containers".

By default, ores are pulled based on the most needed ingots. Also the refinery queues are sorted by the most needed ingots. However, this only works with vanilla ores or modded ores, that only have one outcome, so something like the "Better Stone" mod, that yield multiple ingots per ore, is not fully supported. The script will use and refine these ores but not in an intelligent way.

If you want to exclude one specific refinery from ore balance, append the keyword '!manual' to its name. Example:
Refinery 1 !manual

By enabling ore balancing, the script will balance the ores between all refinieres so that every refinery has the same amount of ore in it.
bool enableOreBalancing = true;

Enable script assisted refinery filling? This will move in the most needed ore and will make room, if the refinery is already full
Also, the script puts as many ores into the refinery as possible and will pull ores even from other refineries if needed.
bool enableScriptRefineryFilling = true;

Sort the refinery queue based on the most needed ingots?
bool sortRefiningQueue = true;

Fixed Ore Priorities
In the script config you can adjust, in which order ores are refined before the demand based refining is done. If you want an ore to always be refined first, simple remove the two // in front of the ore name to enable it. Enabled ores are refined in order from top to bottom so if you removed several // you can change the order by copying and pasting them inside the list. Just be careful to keep the syntax correct:

By default stone is enabled and will always be refined first.
List<String> fixedRefiningList = new List<string> { "Stone", //"Iron", //"Nickel", //"Cobalt", //"Silicon", //"Uranium", //"Silver", //"Gold", //"Platinum", //"Magnesium", //"Scrap", };
Ice balancing
This will balance ice between all O2/H2 generators on all connected grids. By default, they are filled to a level, that 1 bottle still fits in there, which can be increased by modifying the 'spaceForBottles' variable (see below).

Note: O2/H2 generators will pull more ice automatically if you set a value below 60%

If you want to exclude one specific O2/H2 generator from ice balancing, append the keyword '!manual' to its name. Example:
Oxygen Generator 1 !manual

Change the values to 'true' or 'false' to activate or deactivate a certain feature:
// Enable balancing of ice in oxygen generators? bool enableIceBalancing = true; // How much space should be left to fill bottles (aka how many bottles should fit in after it's filled with ice)? // WARNING! O2/H2 generators automatically pull ice and bottles if their inventory volume drops below 30%. // To avoid this, turn off "Use Conveyor" in the generator's terminal settings. int spaceForBottles = 1;
Uranium balancing
This will balance uranium between all reactors on all connected grids. The vanilla conveyor pull is deactivated in order to stop them from pulling more. A max uranium amount for large grid and small grid reactors can be set independently from each other.

If you want to exclude one specific reactor from uranium balance, append the keyword '!manual' to its name. Example:
Small Reactor 1 !manual

Change the values to 'true' or 'false' to activate or deactivate a certain feature:
// Enable balancing of uranium in reactors? (Note: conveyors of reactors are turned off to stop them from pulling more) bool enableUraniumBalancing = true; // Amount of uranium in each reactor? (default: 100 for large grid reactors, 25 for small grid reactors) double uraniumAmountLargeGrid = 100; double uraniumAmountSmallGrid = 25;
LCD panel output
The following topic explains, how to use LCD panels (regular and block LCDs) of my script. Whenever you add one of the following keywords to a LCD name, the keyword gets transformed to the universal [IsyLCD] keyword. In the custom data, you can then set different options about the LCD as well as the screen, the information should be shown (on blocks like cockpits, programmable blocks and so on). The custom data will look like this:


@# stands for the screen, the information is shown, where # is the screen identifier number from 0 to the max number of screens - 1. A programmable block for example has two screens: The main screen and the keyboard. Both can be used to show the script informations (screen 0 and screen 1). To change the screen, you want to show your informations, just edit the screen identifier number in the custom data.

It is also possible to display informations of different scripts in one block by using this syntax (MMaster's Automatic LCDs 2 uses the same syntax and all of my other scripts).

LCD Keywords
Main LCD
You can display all the main script informations like type container fill levels, managed blocks and last script actions on the main LCD. Just add the following keyword to a LCD name:

You can enable or disable specific informations on the LCD by editing its custom data.

Warning LCD
You can display all current warnings and problems on a dedicated LCD screen. Just add the following keyword to a LCD name:

Script actions LCD
You can display the latest item movements, container assignments, queue sortings and more on a dedicated LCD screen. Just add the following keyword to a LCD name:

This screen has a timestamp that can be toggled and the number of logged entries can be adjusted in the script config:
bool showTimeStamp = true;
int maxEntries = 30;

Settings for enthusiasts:
string timeFormat = "HH:mm:ss";

Performance LCD
You can display the script performance (PB terminal output) on a dedicated LCD screen. Just add the following keyword to a LCD name:
Inventory items LCDs

You can show the current amounts of your stored items on LCD panels. To display them, build a LCD panel, add the keyword 'IIM-inventory' to its name and follow the on screen instructions:

1a. Either put a item type in the custom data:
This shows all ingots
This shows all components
This shows all ores
This shows all ammo magazines
This shows all oxygen bottles
This shows all hydrogen bottles
This shows all weapons and tools

1b. Or put a item subtype in the custom data:
This shows all steel plates
This shows all small steel tubes
This shows all computers

1c. Or a combination of item type and subtype in the custom data:
This shows all gold ingots
This shows all stone
This shows all gravel

1d. Or put a partial item name in the custom data:
This shows all items containing 'Plate': SteelPlate, InteriorPlate, etc..
This shows all items containing 'Welder'
This shows all items containing 'Bottle': HydrogenBottle, OxygeBottle

1e. Or put one of the Echo commands in the custom data to show your own text or headings (v2.8.0+):
Echo My Text
This will show 'My Text' on the screen aligned left
EchoC My Text
This will show 'My Text' on the screen aligned center
EchoR My Text
This will show 'My Text' on the screen aligned right
This will just add a blank line (also works with EchoC and EchoR but makes no difference)

1f. Or put a regular expression (regex) in the custom data (v2.9.4+):
This will show every item, that the script knows
This will show every item that contains Steel OR Motor in its name
This will show every item, that ENDS with item, so most of the PistolItem(s) but not any ConsumableItem(s)
Learn more about regular expressions at:

2. Optionally, add a max amount for the bars as a second parameter:

ingot 100000

Additional feature:
If an inventory panel line has 0 as the max value, a single line only containing the item name and current amount is shown (no bars, percentages or max values).

ingot 0

3. At last, you can add modifiers for each entry:

There are 6 modifiers at this point:
  • 'noHeading' to hide the heading
  • 'singleLine' to force one line per item
  • 'noBar' to hide the bar
  • 'noScroll' to prevent the text from scrolling
  • 'hideEmpty' to hide items that have an amount of 0
  • 'hideType' to hide the type behind the item name

@0 IIM-inventory Ingot 100000 noBar Ore hideEmpty Echo EchoC Amount of Steel Plates: Echo SteelPlate 50000 noHeading noBar


Begin a new line for every item or every type you want to show on the LCD.

One 'noScroll' modifier per screen is enough. It doesn't need to be set for every custom data line.

The content of the LCD will adjust itself automatically to the set font size

Multi-panel inventory screens
You can display your inventory items over multiple screens by giving all screens the same group tag (this has to be set in the custom data of a screen after giving it the IIM-inventory tag in the name). The syntax is the following:
  • GROUP is a name of your choice (NOT a terminal group!)
  • # is the number of the LCD in the row

Custom data of LCD 1:
@0 IIM-inventory:myComp1 Component 100000 singleLine noScroll

Custom data of LCD 2:
@0 IIM-inventory:myComp2

The settings of the first panel in the row will be set for all panels of the group (font size and custom data settings).

Note: Every panel's name still has to contain the [IsyLCD] keyword in order to be recognized by the script (gets automatically set after giving the LCD the 'IIM-inventory' tag).
Commandline Arguments: Usage
Nearly every feature of the script can be temporarily enabled or disabled without the need to edit the script. Important to understand is, that these changes are really temporary and will be lost whenever the script is restarted (either via recompile or world load). To make permament changes, you still need to edit the script and adjust the settings in the script's config.

Commands are either sent to the script by writing them in the programmable block's argument field and pressing run:

Or you can also pull the programmable block to any hotbar (cockpits, button panels and so on), select run and type in the arguments in the popup window:

The syntax works like this:
variable true|false|toggle

For example:
enableAutocrafting false
This will temporarily disable autocrafting (until the script is recompiled or the world is reloaded).

enableOreBalancing toggle
This will toggle ore balancing on or off based on it's current state.

When no argument, like true, false or toggle is given, it defaults to toggle so that you can simply type in the variable name, you want to toggle.
Commandline arguments: Full List
This chapter contains a full list of variable and function names, that can be set via the script's argument field (see previous chapter for how this works).

General functions
Don't accept any additional arguments.
This will delete all stored itemIds, blueprintIds and Special container custom data that has no value set. A recompile of the script is needed afterwards!
Attempts to learn every item blueprint for autocrafting. WARNING: use sparingly as this could cause massive log files when used regularly!

Container related variables
Accept true, false or toggle as a second argument.
Keeps equal amounts of items in each container of a type.
Shows the fill percentage behind the container name.
Master switch for container un-/assignment.
Assigns new containers, if all containers of a type are full.
Unassigns empty containers of a type, that aren't needed anymore.
Assigns 'Ores' and 'Ingots' type containers as one.
Assigns 'Tools', 'Ammo' and 'Bottles' type containers as one.
Fills bottles in a tank or O2/H2 generator on their way to the bottles container.
Allows 'Special' containers to 'steal' items from other 'Special' containers with a lower priority.
Sorts items inside a single cargo container by name, type or amount. WARNING: this is very demanding and not recommended to use on servers!
This protects the type containers on a ship running IIM whenever docking to another grid/ship/station also running IIM, so that no items are stolen.

Autocrafting related variables
Accept true, false or toggle as a second argument.
Enables the script's autocrafting feature (a LCD tagged with 'Autocrafting' is needed!).
Enables the script's autodisassembling feature (a LCD tagged with 'Autocrafting' is needed!).
Shows unlearned and thus uncraftable items on the autocrafting screen (followed by [NoBP] = no blueprint).
Specifies whether assemblers on docked ships/grids should be used for autocrafting.
Specifies whether the autocrafting heading should be shown on every screen when using multiple autocrafting screens.
Sorts the autocrafting queue based on the most needed item (= lowest amount to the front of the queue).
Clears the input inventories of assemblers when they get too full or the assemblers are idle.
Automatically queues the basic ingot crafting in survival kits.
Specifies whether survival kits should still be used for autocrafting if regular (and faster) assemblers are available.

Refining related variables
Accept true, false or toggle as a second argument.
This balances the refining queues of all refineries so that every refinery has the same amount of ore in it.
Specifies whether the script should fill the refineries or if they should pull the ore themselves.
This sorts the most needed ore to the front based on a stored amount and refining time calculation.
Specifies whether refineries on docked ships/grids should be used when balancing the ores.

Ice balancing related variables
Accept true, false or toggle as a second argument.
Balances the ice between all H2/O2 generators so that they have an equal amount of ice.
Specifies whether disabled O2/H2 generators should also be filled with ice.

Uranium balancing related variables
Accept true, false or toggle as a second argument.
Balances the uranium between all reactors so that they have an equal amount of uranium (although they get different amounts based on their size).
Specifies whether disabled reactors should also be filled with uranium.

Miscellanous variables
Accept true, false or toggle as a second argument.
Slows the script down to save game ressources.
Excludes welders from sorting / item counting.
Excludes grinders from sorting / item counting.
Excludes drills from sorting / item counting.
Checks, if containers are connected to the main type containers.
Shows a [No Conveyor] tag in the name of a container, if it's not connected (connectionCheck has to enabled for this to work).