diff --git a/_de/items/inventories.md b/_de/items/inventories.md
new file mode 100644
index 0000000..2971378
--- /dev/null
+++ b/_de/items/inventories.md
@@ -0,0 +1,346 @@
+---
+title: ItemStacks und Inventare
+layout: default
+root: ../..
+idx: 2.4
+description: Manipuliere InvRefs und ItemStacks
+redirect_from:
+- /de/chapters/inventories.html
+- /de/chapters/itemstacks.html
+- /de/inventories/inventories.html
+- /de/inventories/itemstacks.html
+---
+
+## Einleitung  <!-- omit in toc -->
+
+In diesem Kapitel werden Sie lernen, wie man Inventare verwendet und manipuliert, egal ob
+ob es sich um ein Spielerinventar, ein Knoteninventar oder ein freistehendes Inventar handelt.
+
+- [Was sind ItemStacks und Inventare?](#was-sind-itemstacks-und-inventare)
+- [ItemStacks](#itemstacks)
+- [Inventarstandorte](#inventarstandorte)
+- [Lists](#lists)
+  - [Size and Width](#size-and-width)
+  - [Checking Contents](#checking-contents)
+- [Modifying Inventories and ItemStacks](#modifying-inventories-and-itemstacks)
+  - [Adding to a List](#adding-to-a-list)
+  - [Taking Items](#taking-items)
+  - [Manipulating Stacks](#manipulating-stacks)
+- [Wear](#wear)
+- [Lua Tables](#lua-tables)
+
+## Was sind ItemStacks und Inventare?
+
+Ein ItemStack sind die Daten hinter einer einzelnen Zelle in einem Inventar.
+
+Ein *Inventar* ist eine Sammlung von *Inventarlisten*, von denen jede
+ein 2D-Gitter aus ItemStacks ist.
+Inventarlisten werden im Kontext von Inventaren einfach *Listen* genannt.
+Der Sinn eines Inventars ist es, mehrere Raster zu ermöglichen, wenn Spieler
+und Blöcke nur maximal ein Inventar haben.
+
+## ItemStacks
+
+ItemStacks haben vier Komponenten: name, count, wear und metadata.
+
+Der Itemname kann der Itemname eines registrierten Items, ein Alias oder ein
+unbekannter Itemname sein.
+Unbekannte Items treten häufig auf, wenn Benutzer Mods deinstallieren oder wenn Mods
+Items ohne Vorsichtsmaßnahmen entfernen, z. B. durch die Registrierung von Aliasen.
+
+```lua
+print(stack:get_name())
+stack:set_name("default:dirt")
+
+if not stack:is_known() then
+    print("Ist ein unbekanntes Item!")
+end
+```
+
+Der Anzahl wird immer 0 oder größer sein.
+Bei normalem Spielverlauf sollte die Anzahl nicht größer sein als die maximale 
+Stackgröße des Gegenstands - `stack_max`.
+Allerdings können Admin-Befehle und fehlerhafte Mods dazu führen, dass Stacks die maximale Größe überschreiten.
+
+```lua
+print(stack:get_stack_max())
+```
+
+
+
+
+Ein ItemStack kann leer sein, in diesem Fall ist die Anzahl 0.
+
+```lua
+print(stack:get_count())
+stack:set_count(10)
+```
+
+ItemStacks können auf verschiedene Weise mit der Funktion ItemStack konstruiert werden.
+
+
+```lua
+ItemStack() -- name="", count=0
+ItemStack("default:pick_stone") -- count=1
+ItemStack("default:stone 30")
+ItemStack({ name = "default:wood", count = 10 })
+```
+
+Item-Metadaten sind ein unbegrenzter Schlüssel-Wert-Speicher für Daten über das Item.
+Schlüssel-Wert bedeutet, dass Sie einen Namen (den sogenannten key) verwenden, um auf die Daten (den sogenannten value) zuzugreifen.
+Einige Schlüssel haben eine besondere Bedeutung, wie z. B. `Beschreibung`, die verwendet wird, um eine pro Stack
+Beschreibung.
+Dies wird im Kapitel über Metadaten und Speicherung ausführlicher behandelt.
+
+## Inventarstandorte
+
+Ein Inventarstandort ist der Ort und die Art und Weise, wie das Inventar gespeichert wird.
+Es gibt drei Arten von Inventarstandorten: Spieler, Blöcke und freistehend.
+Ein Inventar ist direkt an einen und nur einen Ort gebunden - eine Aktualisierung des
+Inventars wird es sofort aktualisieren.
+
+Blockinventare beziehen sich auf die Position eines bestimmten Blockes, z. B. einer Truhe.
+Der Block muss geladen werden, da er in den [Block-Metadaten](../map/storage.html#metadata) gespeichert ist.
+
+```lua
+local inv = minetest.get_inventory({ type="node", pos={x=1, y=2, z=3} })
+```
+
+Auf diese Weise erhält man eine *Inventar-Referenz*, allgemein als *InvRef* bezeichnet.
+Inventar-Referenzen werden verwendet, um ein Inventar zu manipulieren.
+*Referenz* bedeutet, dass die Daten nicht tatsächlich in diesem Objekt gespeichert sind,
+sondern das Objekt aktualisiert die Daten direkt an Ort und Stelle.
+
+Der Standort eines Inventarverweises kann wie folgt ermittelt werden:
+
+```lua
+local location = inv:get_location()
+```
+
+Spielerinventare können auf ähnliche Weise oder über eine Spielerreferenz abgerufen werden.
+Der Spieler muss online sein, um auf sein Inventar zugreifen zu können.
+
+```lua
+local inv = minetest.get_inventory({ type="player", name="spieler1" })
+-- oder
+local inv = player:get_inventory()
+```
+
+Ein freistehendes Inventar ist ein Inventar, das unabhängig von Spielern oder Blöcken ist.
+Freistehende Inventare werden auch nicht bei einem Neustart gespeichert.
+
+```lua
+local inv = minetest.get_inventory({
+    type="detached", name="inventar_name" })
+```
+
+Im Gegensatz zu den anderen Inventararten müssen Sie zunächst ein freistehendes Inventar erstellen
+erstellen, bevor Sie darauf zugreifen:
+```lua
+minetest.create_detached_inventory("inventar_name")
+```
+
+Die Funktion create_detached_inventory akzeptiert 3 Argumente, wobei nur das erste - 
+der Inventarname - erforderlich ist.
+Das zweite Argument nimmt eine Tabelle von Callbacks entgegen, die verwendet werden können,
+um zu steuern, wie Spieler mit dem Inventar interagieren:
+
+```lua
+-- Eingabe nur freistehendes Inventar
+minetest.create_detached_inventory("inventar_name", {
+    allow_move = function(inv, von_liste, von_index, zu_liste, zu_index, anzahl, player)
+        return anzahl -- erlaubt bewegen
+    end,
+
+    allow_put = function(inv, listenname, index, stack, spieler)
+        return stack:get_count() -- erlaubt setzen
+    end,
+
+    allow_take = function(inv, listenname, index, stack, spieler)
+        return 0 -- erlaubt es nicht zu nehmen
+    end,
+
+    on_put = function(inv, listenname, index, stack, spieler)
+        minetest.chat_send_all(spieler:get_player_name() ..
+            " gab " .. stack:to_string() ..
+            " zu der Spendenkiste von " .. minetest.pos_to_string(spieler:get_pos()))
+    end,
+})
+```
+
+Berechtigungsaufrufe - d.h. diejenigen, die mit `allow_` beginnen - geben die Anzahl
+der zu übertragenden Items zurück, wobei 0 verwendet wird, um die Übertragung vollständig zu verhindern.
+
+Im Gegensatz dazu haben Aktionsrückrufe - beginnend mit `on_` - keinen Rückgabewert.
+
+## Lists
+
+Inventory Lists are a concept used to allow multiple grids to be stored inside a single location.
+This is especially useful for the player as there are a number of common lists
+which all games have, such as the *main* inventory and *craft* slots.
+
+### Size and Width
+
+Lists have a size, which is the total number of cells in the grid, and a width,
+which is only used within the engine.
+The width of the list is not used when drawing the inventory in a window,
+because the code behind the window determines the width to use.
+
+```lua
+if inv:set_size("main", 32) then
+    inv:set_width("main", 8)
+    print("size:  " .. inv:get_size("main"))
+    print("width: " .. inv:get_width("main"))
+else
+    print("Error! Invalid itemname or size to set_size()")
+end
+```
+
+`set_size` will fail and return false if the listname or size is invalid.
+For example, the new size may be too small to fit all the current items
+in the inventory.
+
+### Checking Contents
+
+`is_empty` can be used to see if a list contains any items:
+
+```lua
+if inv:is_empty("main") then
+    print("The list is empty!")
+end
+```
+
+`contains_item` can be used to see if a list contains a specific item:
+
+```lua
+if inv:contains_item("main", "default:stone") then
+    print("I've found some stone!")
+end
+```
+
+## Modifying Inventories and ItemStacks
+
+### Adding to a List
+
+`add_item` adds items to a list (in this case `"main"`). In the example below,
+the maximum stack size is also respected:
+
+```lua
+local stack    = ItemStack("default:stone 99")
+local leftover = inv:add_item("main", stack)
+if leftover:get_count() > 0 then
+    print("Inventory is full! " ..
+            leftover:get_count() .. " items weren't added")
+end
+```
+
+### Taking Items
+
+To remove items from a list:
+
+```lua
+local taken = inv:remove_item("main", stack)
+print("Took " .. taken:get_count())
+```
+
+### Manipulating Stacks
+
+You can modify individual stacks by first getting them:
+
+```lua
+local stack = inv:get_stack(listname, 0)
+```
+
+Then modifying them by setting properties or by using the methods which
+respect `stack_size`:
+
+
+```lua
+local stack    = ItemStack("default:stone 50")
+local to_add   = ItemStack("default:stone 100")
+local leftover = stack:add_item(to_add)
+local taken    = stack:take_item(19)
+
+print("Could not add"  .. leftover:get_count() .. " of the items.")
+-- ^ will be 51
+
+print("Have " .. stack:get_count() .. " items")
+-- ^ will be 80
+--   min(50+100, stack_max) - 19 = 80
+--     where stack_max = 99
+```
+
+`add_item` will add items to an ItemStack and return any that could not be added.
+`take_item` will take up to the number of items but may take less, and returns the stack taken.
+
+Finally, set the item stack:
+
+```lua
+inv:set_stack(listname, 0, stack)
+```
+
+## Wear
+
+Tools can have wear; wear shows a progress bar and makes the tool break when completely worn.
+Wear is a number out of 65535; the higher it is, the more worn the tool is.
+
+Wear can be manipulated using `add_wear()`, `get_wear()`, and `set_wear(wear)`.
+
+```lua
+local stack = ItemStack("default:pick_mese")
+local max_uses = 10
+
+-- This is done automatically when you use a tool that digs things
+-- It increases the wear of an item by one use.
+stack:add_wear(65535 / (max_uses - 1))
+```
+
+When digging a node, the amount of wear a tool gets may depend on the node
+being dug. So max_uses varies depending on what is being dug.
+
+## Lua Tables
+
+ItemStacks and Inventories can be converted to and from tables.
+This is useful for copying and bulk operations.
+
+```lua
+-- Entire inventory
+local data = inv1:get_lists()
+inv2:set_lists(data)
+
+-- One list
+local listdata = inv1:get_list("main")
+inv2:set_list("main", listdata)
+```
+
+The table of lists returned by `get_lists()` will be in this form:
+
+```lua
+{
+    list_one = {
+        ItemStack,
+        ItemStack,
+        ItemStack,
+        ItemStack,
+        -- inv:get_size("list_one") elements
+    },
+    list_two = {
+        ItemStack,
+        ItemStack,
+        ItemStack,
+        ItemStack,
+        -- inv:get_size("list_two") elements
+    }
+}
+```
+
+`get_list()` will return a single list as just a list of ItemStacks.
+
+One important thing to note is that the set methods above don't change the size
+of the lists.
+This means that you can clear a list by setting it to an empty table and it won't
+decrease in size:
+
+```lua
+inv:set_list("main", {})
+```
diff --git a/_de/wörterbuch.txt b/_de/wörterbuch.txt
new file mode 100644
index 0000000..5a3aeeb
--- /dev/null
+++ b/_de/wörterbuch.txt
@@ -0,0 +1,32 @@
+Chapter = Kapitel
+Cubic Nodes = Würfelförmiger Block
+detached inventory = freistehendes Inventar
+dig = abbauen
+drawtype = Zeichnungstyp
+Folder = Verzeichnis
+glasslike = Glasartig
+games = Spiele
+Introduction = Einleitung
+Inventory = Inventar
+Inventory Location = Inventarstandort
+Inventory reference = Inventar-Referenz
+ItemStack = ItemStack
+Mesh = Mesh
+Mesh Nodes = Mesh Nodes
+mod load paths = Mod-Lade-Verzeichnisse
+mod's folder = Mod-Verzeichnis
+mods = Mods
+module = Modul
+node = Block
+nodes = Blöcke
+nodebox = Nodebox
+nodeboxes = Nodeboxen
+Node inventory  = Blockinventar
+path = Verzeichnis
+placer = plazierer
+player inventory = Spielerinventar
+player reference = Spielerreferenz
+pointed_thing = angeschautes_ding
+Stack = Stack
+tile = Kachel
+tiles = Kacheln