1.19.x Datapacks

IC2 Classic has support for external datapacks, even though internally we use another system. Any recipe in a valid datapack will be added when the mod loads, though datapacks are far slower than our normal recipes, so use with care.

• Export all internal recipes
• Structure
  • General Information
  • recipes folder
    • Crafting Recipes
    • Other Vanilla Recipes
  • ic2_recipes folder
    • Basic Machines
    • Canning Machine
    • Alloy Smelter
    • Rare Earth Extractor
    • Electrolyzer
    • Mass Fabricator
    • Liquid Fuel Generator
    • Thermonuclear Reactor
    • Uranium Enricher
    • Refinery
    • Scrap Boxes
    • Special Cases
      • Recycler
      • Removing Recipes
  • Input and Output Items
    • Shared Items
      • Item
      • NBT Item
      • Empty Item
      • IC2 Seedbag
      • Fluids
    • Output Specific
      • Fluid Items
    • Input Specific
      • Fluid Items
      • Tags
      • Damaged Items
      • Sub Variants
      • Minecraft Ingredient
  • Inputs
    • Simple Inputs
    • Array
  • Outputs
    • Item Outputs
      • Simple
      • Ranged
      • Chance
    • Fluid Outputs
      • Simple
      • Ranged
    • Output Modifiers

Export all internal recipes

To export a nearly valid datapack open a single player world and use

/ic2c_export

in chat. This will generate a zip file with the correct folder structure in the ic2c config folder. Note that this will export all currently registered recipes and some of the advanced options that can be specified in ic2c datapacks will not export correctly. Share your original files, not the exported ones if you want to share your datapack with people.

In order to make the sample export into a valid datapack you need to add a pack.mcmeta file into the root folder of the zip and place it in the datapacks folder of the savefile.

Example pack.mcmeta:

{
  "pack": {
    "pack_format": 10,
    "description": "Example Datapack"
  }
}

Caution

Do not use the whole sample pack for anything other than testing, it will increase the loading time of the game by quite a bit for no gain at all. Only use recipes that you actually add or change in the datapack.

Structure

Opening up the generated datapack you will have a data folder on the first level. Next to this folder is where the pack.mcmeta needs to be placed. Opening that you will find the ic2 folder which tells you that the recipes inside are for ic2 to load. In there are two folders, recipes and ic2_recipes. The first one is used for all recipes dealing with vanilla blocks (crafting table, smithing, stonecutting and so on). Inside the ic2_recipes folder you will find everything dealing with ic2 machines.

General Information

Our implementation of the datapack loader can do more than the vanilla version, featuring things like custom stack sizes for inputs and outputs, as well as the possibility to transfer EU.

Here is the complete list:

• EU Being transferred from input to output.
• Recipes being hidden, (can be disabled in the config)
• Container items being consumed without giving items back
• Stacksize requirement being dynamically. So a recipe can say they need 16 cobblestone in one slot but only 1 in another slot.

The name of the file in the datapack is the recipe id.

recipes folder

All recipes in this folder have a type, specifying what kind of recipe it is. They also have an optional value enabled which governs if the recipe is active or not. Setting one of our recipes as "enabled": false will disable the recipe ingame. All other things depend on the actual type.

Crafting Recipes

Crafting recipes are of type ic2:crafting_ic2_automated and encompass anything that can be crafted in a vanilla crafting table. They come in three subtypes shaped, which defines where each item has to be placed and shapeless that just needs each item to be present anywhere and repair. There are some json keys that apply to both of them, and some that are subtype specific.

Common Settings

• sub_type: Defines if the recipe is shaped, shapeless or a repair recipe.
• hidden: Is the recipe visible to players or hidden? Most UU-Matter recipes use this, for example.
• consume: if container items should be consumed. Including their container.
• inputs: The inputs for the recipe uses Inputs.
• output: The output of the recipe. This can be any of those outputs (not the fluid tank one, though, and I don't see why you would want an empty output here)

Shaped

• pattern: The pattern of the items in the crafting grid. Uses letters defined in letter.
• letter: An extra field in each input item telling the parser which letter in the grid it is.

This example recipe shows you all features of the shaped recipe:

{
  "type": "ic2:crafting_ic2_automated",
  "sub_type": "ic2:shaped",
  "output": {
    "item": "ic2:iron_furnace",
    "count": 1
  },
  "hidden": false,
  "consume": false,
  "inputs": [
    {
      "tag": "forge:ingots/iron",
      "size": 1,
      "type": "ic2:tag",
      "letter": "X"
    }
  ],
  "pattern": [
    "XXX",
    "X X",
    "XXX"
  ]
}

Shapeless

This example recipe shows you all features of the shapeless recipe:

{
  "type": "ic2:crafting_ic2_automated",
  "sub_type": "ic2:shapeless",
  "output": {
    "item": "ic2:bronze_double_insulated_cable_item",
    "count": 1
  },
  "hidden": false,
  "consume": false,
  "inputs": [
    {
      "item": "ic2:bronze_cable_item",
      "size": 1,
      "type": "ic2:item"
    },
    {
      "tag": "ic2:rubber",
      "size": 1,
      "type": "ic2:tag"
    },
    {
      "tag": "ic2:rubber",
      "size": 1,
      "type": "ic2:tag"
    }
  ]
}

Repair

The repair recipe type is special because it requires the item to be repaired to implement the IRepairable interface. If that is not the case the recipe will not be loaded at all. All repair recipes are shapeless and if you fill more slots with the repair material the amount being repaired is multiplied.

• repair: The item id of the item to be repaired.
• material: The item that is used for the repair. The json syntax is identical with Inputs.
• size: Defines the amount to be repaired per material item. This can be positive or negative.

{
  "type": "ic2:crafting_ic2_automated",
  "sub_type": "ic2:repair",
  "repair": "ic2:reflector_iridium",
  "material": {
    "tag": "forge:dust/coal",
    "size": 4,
    "type": "ic2:tag"
  },
  "size": 10000,
  "hidden": false,
  "consume": false
}

Other Vanilla Recipes

To add recipes for smithing, cooking (furnace) and the stonecutter use the vanilla datapack syntax. The only ic2 specific thing that can be done here is disabling the recipes we add via code. To decide which recipe to disable the file name is used. Just get the recipe id out of JEI or something similar and name your file like that.

{
  "type": "ic2:cooking_ic2_serializer",
  "enabled": false
}

Recipe	Type
Cooking	ic2:cooking_ic2_serializer
Smithing	ic2:smithing_ic2_serializer
Stonecutting	ic2:single_item_ic2_serializer

ic2_recipes folder

In this folder you find a subfolder for every ic2c machine type. For which machine a recipe is depends on the folder it is in. So a recipe for the macerator can look exactly the same as one for the extractor. There are a few machines that work differently, but they will all be explained below.

Basic Machines

The following machines are considered basic machines:

• macerator
• extractor
• compressor
• recycler
• sawmill

All that can be configured for those machines are the inputs and outputs.

Example

• input: The input of the recipe. For more information see Inputs.
• output: The output of the recipe. For more information see Outputs.

{
  "input": {
    "item": "ic2:wet_cfoam",
    "size": 1,
    "type": "ic2:item"
  },
  "output": {
    "xp": 0.0,
    "outputs": [
      {
        "item": "ic2:cf_pellet",
        "size": 1,
        "type": "ic2:item"
      }
    ],
    "type": "ic2:simple"
  }
}

Canning Machine

The canning machine has two different modes, canning and fuel. Fuel deals with putting fuel into fuel cans, jetpacks and anything else that can accept fuel directly, and canning is the rest.

Canning Example

• input: For more information see Inputs.
• container: The container to be filled. Can be any of those items that is valid for outputs. Size will be ignored though.
• output: The output of the recipe. Can be any of those items
• remove: When true, the recipe will be removed from the game instead of added.

{
  "type": "canning",
  "input": {
    "item": "ic2:compressed_hydrated_coal",
    "size": 1,
    "type": "ic2:item"
  },
  "container": {
    "item": "ic2:cell_empty",
    "size": 1,
    "type": "ic2:item"
  },
  "output": {
    "item": "ic2:cell_coal_fuel",
    "size": 1,
    "type": "ic2:item"
  },
  "remove": false
}

Fuel Example

The canner in fuel mode needs multiple items (5 for the normal canning machine) before it outputs into the fuel acceptor.

• input: Can be any of those items that are valid for outputs (Why outputs? ask Speiger). Size is ignored here.
• multiplier: When true, multiplies the accumulated amount from the items added before by value, when false, it just adds value to the amount of fuel that will eventually be outputted.
• value: The amount of fuel to add, or the multiplier for the fuel.
• remove: When true, the recipe will be removed from the game instead of added.

{
  "type": "fuel",
  "input": {
    "item": "ic2:cell_coal_fuel",
    "size": 1,
    "type": "ic2:item"
  },
  "multiplier": false,
  "value": 2548,
  "remove": false
}

Alloy Smelter

The alloy smelter is called mixing_furnace in code, and that is also the name of the folder in the datapack. The recipes are configured nearly the same as the basic machines, but because the alloy smelter has two input slots, the format of input is slightly different.

Example

• input: A list of exactly two inputs. For more information see Inputs.
• output: The output of the recipe. For more information see Outputs.

{
  "input": [
    {
      "tag": "forge:dust/copper",
      "size": 3,
      "type": "ic2:tag"
    },
    {
      "tag": "forge:dust/tin",
      "size": 1,
      "type": "ic2:tag"
    }
  ],
  "output": {
    "xp": 0.0,
    "outputs": [
      {
        "item": "ic2:ingot_bronze",
        "size": 4,
        "type": "ic2:item"
      }
    ],
    "type": "ic2:simple"
  }
}

Rare Earth Extractor

Unlike most machines, the rare earth extractor accepts multiple inputs that accumulate progress, and only outputs once the progress reaches 1000. This number is hardcoded and therefore can't be changed, but you can define how much progress each item adds, so it is still pretty configurable.

Example

• output: The output item. This needs to be type ic2:item, ic2:nbt or ic2:crop.
• inputs: A list of valid inputs and how much progress they add. This does not use the normal item system.
  • item: The registry name of the item
  • value: The progress one item adds as a decimal value

{
  "output": {
    "item": "ic2:dust_rare_earth",
    "size": 1,
    "type": "ic2:item"
  },
  "inputs": [
    {
      "item": "minecraft:stone",
      "value": 3.125,
    },
    {
      "item": "minecraft:deepslate",
      "value": 3.125,
    },
    {
      "item": "minecraft:granite",
      "value": 62.5,
    }
  ]
}

Electrolyzer

The Electrolyzer takes an input item and changes it into an output item by charging or discharging it with energy. Discharging is lossy and the loss is calculated with the following formula:

60% + Energy Storage Tier * 10%

Example

• input: is a ItemStack of the item that should be charged. This needs to be type ic2:item or ic2:nbt.
• output: is a ItemStack of the item that should be the output. This needs to be type ic2:item or ic2:nbt.
• energy: Amount of EU to charge/discharge. This also controls the progress.
• charging: When true the energy amount will be drained from the connected energy storage.
• discharging: When true energy will be added to a connected energy storage.

It is technically possible to charge and discharge at the same time.

{
  "input": {
    "item": "minecraft:quartz",
    "size": 1,
    "type": "ic2:item"
  },
  "output": {
    "item": "minecraft:diorite",
    "size": 1,
    "type": "ic2:item"
  },
  "energy": 1000,
  "charging": false,
  "discharging": true
}

Mass Fabricator

The mass fabricator has recipes, but the only thing that can be configured here is what amplifiers will work and how much they amplify.

Example

• input: The item that can be used as an amplifier. It uses the Input System.
• output: A dummy output. All that is used is the "nbt":"{Amplifier:100000}" part.
  • Amplifier: The amplifier amount per input item.

{
  "input": {
    "item": "ic2:scrap_metal",
    "size": 1,
    "type": "ic2:item"
  },
  "output": {
    "xp": 0.0,
    "nbt": "{Amplifier:100000}",
    "outputs": [
      {
        "item": "ic2:uumatter",
        "size": 1,
        "type": "ic2:item"
      }
    ],
    "type": "ic2:simple"
  }
}

Liquid Fuel Generator

Example

• fluid: the registry id of the liquid.
• burntime: The burntime in ticks for a full bucket of the liquid.
• production: EU/t
• remove: When true, the recipe will be removed from the game instead of added.

{
  "fluid": "ic2:woodgas",
  "burn_time": 250,
  "production": 10,
  "remove": false
}

Thermonuclear Reactor

In the code and the datapack this is called fusion reactor.

Example

• input: registry id of the item.
• fuelValue: the amount of lava one item returns.
• productionRate: how fast the input is turned into lava, 1.0 is 100% speed.
• consumed: When true, the input item will be consumed, when false it will stay infinitely.
• remove: When true, the recipe will be removed from the game instead of added.

{
  "input": "ic2:upgrade_cobble_generator",
  "consumed": false,
  "fuelValue": 1000,
  "productionRate": 1.0,
  "remove": false
}

Uranium Enricher

The Uranium Enricher is a accumulator recipe list, where you can provide items that give a accumulative value.

Example

• input: registry id of the item
• fuels: A List of Inputs and their values towards the output.
  • input: The input for the specific fuel value. Uses the Input system.
  • value: How much it adds towards the enriching fuel.
• output: The output of the recipe. For more information see Outputs.
• color: the RGB value of the Fuel Color.
• energy_usage: How much EU/t is required to craft the ingot. Can be multiplied by 1000 to see the total energy required.
• points: How many points are required to get the ingot. Internal Point tank has a capacity of 1000 points. Anything higher is not supported.

{
  "input": "ic2:ingot_uranium",
  "fuels": [
    {
      "input": {
        "item": "minecraft:charcoal",
        "size": 1,
        "type": "ic2:item"
      },
      "value": 25
    },
    {
      "input": {
        "item": "ic2:charcoal_block",
        "size": 1,
        "type": "ic2:item"
      },
      "value": 200
    }
  ],
  "output": {
    "item": "ic2:ingot_uranium_enriched_charcoal",
    "size": 1,
    "type": "ic2:item"
  },
  "color": -13224394,
  "energy_usage": 5,
  "points": 100,
}

Refinery

The Refinery is the Magic New machine for 1.19.2 and is also one of the most complex one provided.
It can be viewed as a Mixer or Ore Washer but that isn't really accurate either.

Example

• input: Item following the Input system.
• first_tank: The primary fluid required. Uses Fluids.
• secondary_tank: The secondary fluid required. Uses Fluids. If empty it will be viewed as if the tank has to be empty. Note: Duplicated recipes that are flipped are autogenerated. So fluid order isn't important.
• output: Defines the output, which can be a fluid aswell. Uses the Output System.

{
  "input": {
    "tag": "forge:ores/aluminium",
    "size": 1,
    "type": "ic2:tag"
  },
  "first_tank": {
    "fluid": "minecraft:lava",
    "amount": 375
  },
  "second_tank": {
    "fluid": "minecraft:empty",
    "amount": 0
  },
  "output": {
    "output": {
      "item": "ic2:raw_aluminium",
      "type": "ic2:item",
      "size": 1
    },
    "minOut": 15,
    "maxOut": 45,
    "fluidOutput": {
      "fluid": "minecraft:empty",
      "amount": 0
    },
    "minFluid": 0,
    "maxFluid": 0,
    "nbt": "{time_mod:0.5d}",
    "type": "ic2:range"
  }
}

Scrap Boxes

While not machines, scrap boxes can still be edited using this api. When you export the example datapack each drop has its own file, but there is an optional bulk mode where you can define more than one recipe per file.

Example

• drop: Can be any of those items valid for outputs.
• chance: How likely it is to spawn. This works similar to the Minecraft Loot System.
• remove: When true, the entry will be removed from the game instead of added.

{
  "drop": {
    "item": "minecraft:cooked_beef",
    "size": 1,
    "type": "ic2:item"
  },
  "chance": 0.9,
  "remove": false
}

Bulk Example

This is just a list of the single entries as described in the example. Be sure that you add a , between the entries and you don't loose a bracket, those are important.

{
  "drops": [
    {
      "drop": {
        "item": "minecraft:cooked_beef",
        "size": 1,
        "type": "ic2:item"
      },
      "chance": 0.9,
      "remove": false
    },
    {
      "drop": {
        "item": "minecraft:grass",
        "size": 1,
        "type": "ic2:item"
      },
      "chance": 3.0,
      "remove": false
    }
  ]
}

Special Cases

Recycler

While the recycler recipes are configured the same way as all other basic machines, it also comes with an optional blacklist. This can be configured in blacklist.json in the recycler folder of the datapack.

Example

• filter: This needs to be true for the blacklist to work.
• remove: If this is true, it will remove the specified items from the blacklist instead of adding them. Does not need to be present.
• simple: An array of item ids, resource locations that should be blacklisted. Does not need to be present.
• special: An array of Inputs for things more complex than a simple item. Does not need to be present.

{
  "filter": true,
  "remove": false,
  "simple": ["minecraft:apple"],
  "special": []
}

Removing Recipes

Unlike the recipes in the recipes folder, there is no enabled property for ic2 machine recipes. Some machines have their own remove flag, and for all those where that is not present in this documentation you just throw a json file in the folder of the machine you want to remove recipes from with the following content:

• remove: The recourse location of the recipe you want to remove.

{
  "remove": ["ic2:cfoam_pellets", "ic2:compress_mv_solar_panel"]
}

You can also put the list in any random file, but the rest of the file it is in will be ignored.

Input and Output Items

While inputs and outputs can be written in many different ways, how to write one specific input or output is remarkably similar. There are some ways to write things that work for both input and output, as well as a few more, like tags, that only work for inputs. What exactly the output is is decided by the type.

Shared Items

While inputs and outputs can be written in many different ways, how to write one specific input or output is remarkably similar. There are some ways to write things that work for both input and output, as well as a few more, like tags, that only work for inputs. What exactly the output is is decided by the type.

Item

Just a simple output of one or more items.

{
  "item": "minecraft:blaze_rod",
  "size": 1, 
  "type": "ic2:item"
}

NBT Item

One or more items with nbt data.

{
  "item": "minecraft:blaze_powder",
  "size": 5,
  "nbt": {
    "Damage": 5
  },
  "type": "ic2:nbt"
}

Empty Item

Sometimes you just need to leave something empty, be it an input or output slot.

  "type": "ic2:empty"

IC2 Seedbag

For crops you can specify the type of crop, all relevant stats as well as the scan level.

For inputs there is also the exact flag, specifying if your input cares about the exact values for the crop, or if any values are okay. You do not have to specify exact as well as growth, gain, resistance, scan, though if you set exact to true, they are all required.

For outputs you can leave out the exact flag.

{
  "crop": "ic2:allium",
  "size": 1,
  "growth": 5,
  "gain": 5,
  "resistance": 5,
  "scan": 1,
  "exact": false,
  "type": "ic2:crop"
}

Fluids

This means the fluids inside machines with tanks, you get to specify the amount, as well as the type of fluid.

{
  "fluid": "minecraft:water",
  "amount": 1000,
}

Output Specific

Some things are specific to only outputs, so here they are.

Fluid Items

Fluids items are items that contain fluids. IC2C can only handle vanilla buckets and cells, but you can chose which one you want to output.

{
  "fluid": "minecraft:water",
  "size": 1,
  "container": "bucket",
  "type": "ic2:fluid",
}

Input Specific

Here are input specific formats for items and fluids.

Fluid Items

This is a strange one (blame Speiger for that). You have to tell the game how many items you have to put in, as well as the minimum fluid each item has to contain. So if you specify a size of 5, and amount 1000, your recipe will always need a stack of 5 fluid containers, but it does not care if each container has 1000 or 10000 milliBuckets in it. And to make it even stranger, it might consume the full amount of fluid, or just the needed amount, depending on what container you used...

• fluid: The fluid
• size: Stack size of the fluid containers
• amount: minimum amount that has to be in each fluid container

{
  "fluid": "minecraft:water",
  "amount": 1000,
  "size": 1,
  "type": "ic2:fluid",
}

Tags

Sometimes you might want to specify a forge tag instead of a specific item.

{
  "tag": "forge:ores/gold",
  "size": 1,
  "type": "ic2:tag"
}

Damaged Items

Sometimes you care about if the item has received damage or not, so here you go. If undamaged is set to true, only truly pristine items will be accepted. Once undamaged is false, it will only take damaged items.

{
  "item": "minecraft:golden_axe",
  "undamaged": false,
  "type": "ic2:damaged"
}

Sub Variants

If you don't care about the variant of an item but instead just want any of it, use the variant system. This will allow all variants of seedbags, instead of one specific kind.

{
  "item": "ic2:crop_seed",
  "size": 1,
  "type": "ic2:sub_item",
}

Minecraft Ingredient

In case the many different variants we offer are not satisfying your need, you can use the Minecraft Ingredient System instead.

{
  "ingredient": {
    "item": "minecraft:blaze_rod"
  }
  "size": 1, 
  "type": "ic2:ingredient"
}

Inputs

There are different ways inputs can be written, some recipes are restricted to specific ones, while others can use the full range of them.

Simple Inputs

Quite a few machines just take an Input Item directly.

Array

When you want to specify multiple inputs that are all required, or just a list of input choices that is not already done with a tag, this array lets you do it.

• size: How many of each item is required
• and: When true, all items will be required, when false only one of them
• elements: The list of the input items. Uses Input Item format, but the size is ignored.

{
  "size": 1,
  "and": false,
  "elements": [
    {
      "tag": "forge:ingots/silver",
      "size": 1,
      "type": "ic2:tag"
    },
    {
      "tag": "forge:ingots/bronze",
      "size": 1,
      "type": "ic2:tag"
    }
  ],
  "type": "ic2:array"
}

Outputs

Caution

This section is updated to the new datapack structure but is still mostly in Speiger-talk. It still needs a proper restructure eventually

IC2Classic adds a custom output system to machines. This allows you fine control over your outputs.

There are 2 types of outputs.

Item Outputs

Machines support multiple outputs at once. As long as 1 item fits into the output the recipe will be processed. If there is stuff left it will be put into a "to output queue".

There are 3 types of Item Outputs:

Simple

This is your Simple output, no logic applied at all.
Format:

• xp: How much xp the recipe should provide.
• nbt: field for adding Modifiers
• outputs: A list of items (Can be empty)
• type: Identifier of the Output Type

"output": {
  "xp": 0.0,
  "nbt": "{time_mod:10.0d}",
  "outputs": [
    {
      "item": "ic2:scrap_metal",
      "size": 1,
      "type": "ic2:item"
    }
  ],
  "type": "ic2:simple"
}

Ranged

A Recipe output that can be between a minimum and maximum number.
Format:

• output: one output item following this format (Can be empty)
• minOut: The minimum stack size of the output.
• maxOut: The maxmium stack size of the output.
• nbt: field for adding Modifiers
• type: Identifier of the Output Type

"output": {
  "output": {
    "item": "ic2:fertilizer",
    "size": 1,
    "type": "ic2:item"
  },
  "nbt": "{time_mod:10.0d}",
  "minOut": 0,
  "maxOut": 1,
  "type": "ic2:range"
}

Chance

A Chance based Recipe output that may or may not come out.
Format:

• chance: How likely it to be dropped. 1.0 => 100%, 0.0 => 0%, 0.25 => 25%
• outputs: A list of items (Can be empty)
• xp: How much XP should be produced when this recipe was processed.
• nbt: field for adding Modifiers
• type: Identifier of the Output Type

"output": {
  "chance": 0.25,
  "xp": 0.0,
  "nbt": "{time_mod:10.0d}",
  "outputs": [
    {
      "item": "ic2:fertilizer",
      "size": 1,
      "type": "ic2:item"
    }
  ],
  "type": "ic2:chance"
}

Fluid Outputs

Fluid outputs area mix of Fluid/Item outputs for the Refinery.
And they can not be used by any other Machine Basic either.

There are 2 types of fluid outputs:

Simple

The simple fluid output is a basic processing output. Format:

• xp: How much xp the recipe should provide.
• nbt: field for adding Modifiers
• outputs: A list of items (Can be empty)
• fluidOutputs: A list of fluids
• type: Identifier of the output type

"output": {
  "xp": 0.0,
  "nbt": "{time_mod:10.0d}",
  "outputs": [],
  "fluidOutputs": [
    {
      "fluid": "ic2:bio_fuel",
      "amount": 250
    }
  ],
  "type": "ic2:simple"
}

Ranged

The Ranged fluid output is your Output.
Format:

• output: one output item following this format (Can be empty)
• minOut: The minimum stack size of the output.
• maxOut: The maxmium stack size of the output.
• fluidOutput: a Fluid
• minFluid: The Minimum Fluid Output of the recipe.
• maxFluid: The maximum fluid output of the recipe.
• nbt: field for adding Modifiers
• type: Identifier of the Output Type

"output": {
  "output": {
    "item": "ic2:raw_aluminium",
    "size": 1,
    "type": "ic2:item"
  },
  "minOut": 75,
  "maxOut": 105,
  "fluidOutput": {
    "fluid": "minecraft:empty",
    "amount": 0
  },
  "minFluid": 0,
  "maxFluid": 0,
  "nbt": "{time_mod:0.5d}",
  "type": "ic2:range"
}

Output Modifiers

Machine outputs can have output modifiers applied.

There is 5 total Modifiers that can be applied:

• consume_containers: true or false, if true fluid containers from the input will not be returned
• time_add: number without decimals, adds a flat amount of time to the recipe time.
• time_mod: number with decimals, multiples the recipe time, after the flat addition was made.
• energy_add: number without decimals, adds a flat amount to the energy the machine consumes per tick.
• energy_mod: number with decimals, multiplies the amount of energy the machine consumes per tick, after the flat addition was made.

The modifiers are applied after the upgrades were applied. Meaning if your machine takes normally 16 EU and configure 4x the cost, it would then take 64EU/t to run it. If there are enough efficiency upgrades in the machine to get it down to 1EU/t, the absolute minimum it can reach is 4EU/t.

The time modifier isn't affected by Overclocker upgrades.
You configure the maximum time needed to process an item, while the Overclockers decide how much progress towards the maximum is made.

The formular for how the modifiers are applied is the following:

   round((base + add) * multiplier)

Base being the input after the upgrades were applied.