diff --git a/src/main/java/cam72cam/mod/gui_v2/GuiUtils.java b/src/main/java/cam72cam/mod/gui_v2/GuiUtils.java
new file mode 100644
index 000000000..209cef332
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/GuiUtils.java
@@ -0,0 +1,84 @@
+package cam72cam.mod.gui_v2;
+
+import cam72cam.mod.MinecraftClient;
+import cam72cam.mod.ModCore;
+import cam72cam.mod.gui_v2.control.AbstractWidget;
+import cam72cam.mod.gui_v2.control.PositionedPanel;
+import cam72cam.mod.gui_v2.core.ScreenWrapper;
+import cam72cam.mod.text.PlayerMessage;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.ScaledResolution;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TextComponentString;
+import net.minecraft.util.text.event.ClickEvent;
+
+public class GuiUtils {
+    public static int mouseX;
+    public static int mouseY;
+
+    public static int getMouseX() {
+        return mouseX;
+    }
+
+    public static int getMouseY() {
+        return mouseY;
+    }
+
+    public static int getTextWidth(PlayerMessage text) {
+        return getTextWidth(text.internal.getFormattedText());
+    }
+
+    public static int getTextWidth(String text) {
+        return Minecraft.getMinecraft().fontRenderer.getStringWidth(text);
+    }
+
+    public static int getScreenWidth() {
+        return new ScaledResolution(Minecraft.getMinecraft()).getScaledWidth();
+    }
+
+    public static int getScreenHeight() {
+        return new ScaledResolution(Minecraft.getMinecraft()).getScaledHeight();
+    }
+
+    public static boolean isPrintable(char c) {
+        return !Character.isISOControl(c) && Character.isDefined(c);
+    }
+
+    public static boolean insidePositionedPanel(AbstractWidget<?> widget) {
+        AbstractWidget<?> parent = widget;
+        while ((parent = parent.getParent()) != null) {
+            if (parent instanceof PositionedPanel) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /** Try to open an external link in player's browser */
+    public void openLink(String url){
+        if (ScreenWrapper.getInstance() != null) {
+            ITextComponent component = new TextComponentString("");
+            component.getStyle().setClickEvent(new ClickEvent(ClickEvent.Action.OPEN_URL, url));
+            ScreenWrapper.getInstance().handleComponentClick(component);
+        } else {
+            ModCore.error("Trying to open a link outside a screen: %s", url);
+            if (MinecraftClient.isReady() && MinecraftClient.getPlayer() != null) {
+                MinecraftClient.getPlayer().sendMessage(PlayerMessage.url(url));
+            }
+        }
+    }
+
+    /** Try to open an external link in player's browser */
+    public static void openFile(String path){
+        if (ScreenWrapper.getInstance() != null) {
+            ITextComponent component = new TextComponentString("");
+            component.getStyle().setClickEvent(new ClickEvent(ClickEvent.Action.OPEN_FILE, path));
+            ScreenWrapper.getInstance().handleComponentClick(component);
+        } else {
+            ModCore.error("Trying to open a file outside a screen: %s", path);
+            if (MinecraftClient.isReady() && MinecraftClient.getPlayer() != null) {
+                MinecraftClient.getPlayer().sendMessage(PlayerMessage.direct("Please check this location on your computer: " + path));
+            }
+        }
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/control/AbstractPanel.java b/src/main/java/cam72cam/mod/gui_v2/control/AbstractPanel.java
new file mode 100644
index 000000000..c168283a4
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/control/AbstractPanel.java
@@ -0,0 +1,249 @@
+package cam72cam.mod.gui_v2.control;
+
+import cam72cam.mod.entity.Player;
+import cam72cam.mod.gui_v2.GuiUtils;
+import cam72cam.mod.gui_v2.core.actions.*;
+import cam72cam.mod.gui_v2.core.layout.ILayoutable;
+import cam72cam.mod.gui_v2.core.ScissorStack;
+import cam72cam.mod.gui_v2.rendering.GuiRenderer;
+import cam72cam.mod.input.Keyboard;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public abstract class AbstractPanel<T extends AbstractPanel<T>> extends AbstractWidget<T>
+        implements IClickable, IDraggable, IUpdatable, IScrollable, IKeyboardListener {
+    private final List<ILayoutable<?>> children;
+    private final List<ILayoutable<?>> controller;
+
+    private IFocusable active;
+
+    public AbstractPanel(int width, int height) {
+        super();
+        this.setBound(0, 0, width, height);
+        this.children = new ArrayList<>();
+        this.controller = new ArrayList<>();
+
+//        this.setForegroundRenderFunc((gui, panel) -> panel.renderBound(gui, 0xFFFFFFFF));
+    }
+
+    public void addChildren(ILayoutable<?> child) {
+        addChildren(Collections.singleton(child));
+    }
+
+    public void addChildren(ILayoutable<?>... children) {
+        addChildren(Arrays.asList(children));
+    }
+
+    public void addChildren(Iterable<ILayoutable<?>> children) {
+        for (ILayoutable<?> child : children) {
+            if (child == this) {
+                throw new IllegalArgumentException("Cannot add self as child panel!");
+            }
+            this.children.add(child);
+            if (child instanceof AbstractWidget<?>) {
+                ((AbstractWidget<?>) child).parent = this;
+            }
+        }
+        layout(this.x(), this.y());
+    }
+
+    public List<ILayoutable<?>> getChildren() {
+        return children;
+    }
+
+    public List<ILayoutable<?>> getVisibleChildren() {
+        return children.stream().filter(ILayoutable::isVisible).collect(Collectors.toList());
+    }
+
+    public void clearChildren() {
+        this.children.clear();
+    }
+
+    protected void addController(ILayoutable<?> ctrl) {
+        this.controller.add(ctrl);
+        if (ctrl instanceof AbstractWidget<?>) {
+            ((AbstractWidget<?>) ctrl).parent = this;
+        }
+    }
+
+    public void renderPanel(GuiRenderer renderer, ScissorStack stack) {
+        stack.pushPanel(this);
+        this.getVisibleChildren().forEach(child -> {
+            stack.push(child);
+            drawWidget(child, renderer, stack);
+            stack.pop();
+        });
+        stack.pop();
+        stack.push(this);
+        this.controller.forEach(ctrl -> {
+            stack.push(ctrl);
+            drawWidget(ctrl, renderer, stack);
+            stack.pop();
+        });
+        drawWidget(this, renderer, stack);
+        stack.pop();
+    }
+
+    private void drawWidget(ILayoutable<?> widget, GuiRenderer renderer, ScissorStack stack) {
+        if (widget instanceof IUpdatable) {
+            ((IUpdatable) widget).preRender();
+        }
+        if (widget != this && widget instanceof AbstractPanel) {
+            ((AbstractPanel<?>) widget).renderPanel(renderer, stack);
+        } else {
+            widget.renderBackground(renderer, stack);
+            widget.render(renderer, stack);
+            widget.renderForeground(renderer, stack);
+        }
+        if (widget instanceof IUpdatable) {
+            ((IUpdatable) widget).postRender();
+        }
+    }
+
+    public void renderBound(GuiRenderer renderer, int argb) {
+        renderer.drawRect(x(), y(), 1, height(), argb);
+        renderer.drawRect(x(), y(), width()-1, 1, argb);
+        renderer.drawRect(x() + width()-1, y(), 1, height(), argb);
+        renderer.drawRect(x(), y() + height()-1, width(), 1, argb);
+    }
+
+    /* Indicate actual range excluded panel basics like ScrollPane's scroll bar */
+    public int panelX() {
+        return x();
+    }
+    public int panelY() {
+        return y();
+    }
+    public int panelWidth() {
+        return width();
+    }
+    public int panelHeight() {
+        return height();
+    }
+
+    protected boolean isHoveringPanel() {
+        return isHoveringPanel(GuiUtils.getMouseX(), GuiUtils.getMouseY());
+    }
+    protected boolean isHoveringPanel(int mouseX, int mouseY) {
+        boolean flag = true;
+        if (parent != null) {
+            flag = parent.isHovering(mouseX, mouseY);
+        }
+        return flag && mouseX >= this.panelX() && mouseX <= this.panelX() + this.width()
+                    && mouseY >= this.panelY() && mouseY <= this.panelY() + this.height();
+    }
+
+    @Override
+    public boolean onClick(Player.Hand hand, int x, int y) {
+        if (!isHovering()) {
+            return false;
+        }
+        if (castedStream(controller, IClickable.class).anyMatch(c -> c.onClick(hand, x, y))) {
+            return true;
+        }
+        return isHoveringPanel() && castedStream(getVisibleChildren(), IClickable.class)
+                .anyMatch(c -> c.onClick(hand, x, y));
+    }
+
+    @Override
+    public boolean onDrag(Player.Hand hand, int mouseX, int mouseY) {
+        if (active instanceof IDraggable) {
+            return ((IDraggable) active).onDrag(hand, mouseX, mouseY);
+        }
+        if (!isHovering()) {
+            return false;
+        }
+        if (castedStream(controller, IDraggable.class).anyMatch(c -> c.onDrag(hand, mouseX, mouseY))) {
+            return true;
+        }
+        return isHoveringPanel() && castedStream(getVisibleChildren(), IDraggable.class)
+                .anyMatch(c -> c.onDrag(hand, mouseX, mouseY));
+    }
+
+    @Override
+    public boolean onRelease(Player.Hand hand, int mouseX, int mouseY) {
+        if (active instanceof IDraggable) {
+            return ((IDraggable) active).onRelease(hand, mouseX, mouseY);
+        }
+        if (!isHovering()) {
+            return false;
+        }
+        if (castedStream(controller, IDraggable.class).anyMatch(c -> c.onRelease(hand, mouseX, mouseY))) {
+            return true;
+        }
+        return isHoveringPanel() && castedStream(getVisibleChildren(), IDraggable.class)
+                .anyMatch(c -> c.onRelease(hand, mouseX, mouseY));
+    }
+
+    @Override
+    public boolean onScroll(int mouseX, int mouseY, double deltaScroll) {
+        if (!isHovering()) {
+            return false;
+        }
+        if (castedStream(controller, IScrollable.class).anyMatch(c -> c.onScroll(mouseX, mouseY, deltaScroll))) {
+            return true;
+        }
+        return isHoveringPanel() && castedStream(getVisibleChildren(), IScrollable.class)
+                .anyMatch(c -> c.onScroll(mouseX, mouseY, deltaScroll));
+    }
+
+    @Override
+    public void onTick() {
+        castedStream(controller, IUpdatable.class).forEach(IUpdatable::onTick);
+        castedStream(getVisibleChildren(), IUpdatable.class).forEach(IUpdatable::onTick);
+    }
+
+    @Override
+    public boolean onKeyPressed(Keyboard.KeyCode key) {
+        if (active instanceof IKeyboardListener) {
+            return ((IKeyboardListener) active).onKeyPressed(key);
+        }
+        if (castedStream(controller, IKeyboardListener.class).anyMatch(c -> c.onKeyPressed(key))) {
+            return true;
+        }
+        return castedStream(getVisibleChildren(), IKeyboardListener.class)
+                .anyMatch(c -> c.onKeyPressed(key));
+    }
+
+    @Override
+    public boolean onCharTyped(char ch) {
+        if (active instanceof IKeyboardListener) {
+            if (((IKeyboardListener) active).onCharTyped(ch)) return true;
+        }
+        if (castedStream(controller, IKeyboardListener.class).anyMatch(c -> c.onCharTyped(ch))) {
+            return true;
+        }
+        return castedStream(getVisibleChildren(), IKeyboardListener.class)
+                .anyMatch(c -> c.onCharTyped(ch));
+    }
+
+    @Override
+    protected void requestFocus(IFocusable focusing) {
+        if (this.parent != null) {
+            super.requestFocus(focusing);
+            return;
+        }
+        if (this.active != null) {
+            this.active.onFocusLost();
+        }
+        focusing.onFocusGained();
+        this.active = focusing;
+    }
+    @Override
+    public void freeFocus() {
+        if (this.parent != null) {
+            super.freeFocus();
+            return;
+        }
+        if (this.active != null) {
+            this.active.onFocusLost();
+        }
+        this.active = null;
+    }
+
+    private static <E, I> Stream<I> castedStream(Collection<E> elements, Class<I> interface1) {
+        return elements.stream().filter(interface1::isInstance).map(interface1::cast);
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/control/AbstractWidget.java b/src/main/java/cam72cam/mod/gui_v2/control/AbstractWidget.java
new file mode 100644
index 000000000..16c430b35
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/control/AbstractWidget.java
@@ -0,0 +1,193 @@
+package cam72cam.mod.gui_v2.control;
+
+import cam72cam.mod.gui_v2.GuiUtils;
+import cam72cam.mod.gui_v2.core.actions.IFocusable;
+import cam72cam.mod.gui_v2.core.layout.ILayoutable;
+import cam72cam.mod.gui_v2.core.ScissorStack;
+import cam72cam.mod.gui_v2.rendering.GuiRenderFunc;
+import cam72cam.mod.gui_v2.rendering.GuiRenderer;
+import cam72cam.mod.text.PlayerMessage;
+import cam72cam.mod.util.With;
+
+/**
+ * Basic UMC widget
+ */
+public abstract class AbstractWidget<T extends AbstractWidget<T>>
+        implements ILayoutable<T> {
+    private PlayerMessage name;
+    private int nameColor;
+
+    protected AbstractWidget<?> parent;
+
+    private boolean visible = true;
+    private boolean enabled = true;
+
+    public AbstractWidget() {}
+
+    /**
+     * Change current widget's visibility
+     */
+    public void setVisible(boolean visible) {
+        this.visible = visible;
+        if (this instanceof IFocusable && ((IFocusable) this).isFocusing()) {
+            parent.freeFocus();
+        }
+        if (GuiUtils.insidePositionedPanel(this)) {
+            requestLayout();
+        }
+    }
+
+    public boolean isVisible() {
+        return visible;
+    }
+
+    /**
+     * Enable or disable current widget
+     */
+    public void setEnabled(boolean enabled) {
+        this.enabled = enabled;
+    }
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    /**
+     * Get/set current widget's display name
+     */
+    public PlayerMessage getName() {
+        return name;
+    }
+
+    public void setName(PlayerMessage text) {
+        this.name = text;
+    }
+
+    /** Override the text color */
+    public int getNameColor() {
+        return nameColor;
+    }
+
+    public void setNameColor(int argb) {
+        this.nameColor = argb;
+    }
+
+    /**
+     * Is mouse over?
+     */
+    protected boolean isHovering() {
+        return isHovering(GuiUtils.getMouseX(), GuiUtils.getMouseY());
+    }
+
+    protected boolean isHovering(float mouseX, float mouseY) {
+        boolean flag = true;
+        if (parent != null) {
+            flag = parent.isHovering(mouseX, mouseY);
+        }
+        return flag && mouseX >= this.x() && mouseX <= this.x() + this.width() && mouseY >= this.y() && mouseY <= this.y() + this.height();
+    }
+
+    public AbstractWidget<?> getParent() {
+        return parent;
+    }
+
+    /* ILayoutable */
+    private int x, y, width, height;
+
+    @Override
+    public int x() {
+        return x;
+    }
+    @Override
+    public int y() {
+        return y;
+    }
+    @Override
+    public int width() {
+        return width;
+    }
+    @Override
+    public int height() {
+        return height;
+    }
+    @Override
+    public void setX(int x) {
+        this.x = x;
+    }
+    @Override
+    public void setY(int y) {
+        this.y = y;
+    }
+    @Override
+    public void setWidth(int width) {
+        this.width = width;
+    }
+    @Override
+    public void setHeight(int height) {
+        this.height = height;
+    }
+    @Override
+    public void setBound(int x, int y, int width, int height) {
+        this.setX(x);
+        this.setY(y);
+        this.setWidth(width);
+        this.setHeight(height);
+    }
+
+    protected GuiRenderFunc<T> background = (gui, widget) -> {};
+    protected GuiRenderFunc<T> content = (gui, widget) -> {};
+    protected GuiRenderFunc<T> foreground = (gui, widget) -> {};
+
+    @Override
+    public void renderBackground(GuiRenderer renderer, ScissorStack stack) {
+        try (With ctx = stack.applyScissor()) {
+            background.draw(renderer, (T) this);
+        }
+    }
+    @Override
+    public void render(GuiRenderer renderer, ScissorStack stack) {
+        try (With ctx = stack.applyScissor()) {
+            content.draw(renderer, (T) this);
+        }
+    }
+    @Override
+    public void renderForeground(GuiRenderer renderer, ScissorStack stack) {
+        try (With ctx = stack.applyScissor()) {
+            foreground.draw(renderer, (T) this);
+        }
+    }
+
+    @Override
+    public void setBackgroundRenderFunc(GuiRenderFunc<T> handler) {
+        background = handler;
+    }
+    @Override
+    public void setRenderFunc(GuiRenderFunc<T> handler) {
+        content = handler;
+    }
+    @Override
+    public void setForegroundRenderFunc(GuiRenderFunc<T> handler) {
+        foreground = handler;
+    }
+
+    public void requestLayout() {
+        if (this.parent != null) {
+            parent.requestLayout();
+            return;
+        }
+        //Only handle in root
+        layout(this.x(), this.y());
+    }
+
+    protected void requestFocus(IFocusable focusing) {
+        if (this.parent != null) {
+            this.parent.requestFocus(focusing);
+        }
+        //Implemented in AbstractPanel
+    }
+    protected void freeFocus() {
+        if (this.parent != null) {
+            this.parent.freeFocus();
+        }
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/control/ComposedWidget.java b/src/main/java/cam72cam/mod/gui_v2/control/ComposedWidget.java
new file mode 100644
index 000000000..427e3f2d8
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/control/ComposedWidget.java
@@ -0,0 +1,112 @@
+package cam72cam.mod.gui_v2.control;
+
+import cam72cam.mod.entity.Player;
+import cam72cam.mod.gui_v2.control.panel.SimplePane;
+import cam72cam.mod.gui_v2.core.ScissorStack;
+import cam72cam.mod.gui_v2.core.actions.*;
+import cam72cam.mod.gui_v2.core.layout.ILayoutable;
+import cam72cam.mod.gui_v2.rendering.GuiRenderer;
+import cam72cam.mod.input.Keyboard;
+
+public abstract class ComposedWidget<T extends ComposedWidget<T>> extends AbstractWidget<T>
+        implements IClickable, IDraggable, IUpdatable, IScrollable, IKeyboardListener {
+
+    private final SimplePane internal;
+
+    public ComposedWidget(int width, int height) {
+        this.internal = new SimplePane(width, height);
+        this.internal.parent = this;
+        this.setWidth(width);
+        this.setHeight(height);
+    }
+
+    //Redirects
+    @Override
+    public void setX(int x) {
+        super.setX(x);
+        internal.setX(x);
+    }
+    @Override
+    public void setY(int y) {
+        super.setY(y);
+        internal.setY(y);
+    }
+    @Override
+    public void setWidth(int width) {
+        internal.setWidth(width);
+        super.setWidth(width);
+    }
+    @Override
+    public void setHeight(int height) {
+        internal.setHeight(height);
+        super.setHeight(height);
+    }
+
+    @Override
+    public int width() {
+        return internal.width();
+    }
+    @Override
+    public int height() {
+        return internal.height();
+    }
+
+    public int getChildRelativeX(ILayoutable<?> child) {
+        return internal.getChildRelX(child);
+    }
+    public int getChildRelativeY(ILayoutable<?> child) {
+        return internal.getChildRelY(child);
+    }
+    public void setChildRelativeX(ILayoutable<?> child, int relX) {
+        internal.setChildPosition(child, relX, internal.getChildRelY(child));
+    }
+    public void setChildRelativeY(ILayoutable<?> child, int relY) {
+        internal.setChildPosition(child, internal.getChildRelX(child), relY);
+    }
+
+    protected void addChildren(ILayoutable<?> widget, int relX, int relY) {
+        internal.addChildren(widget, relX, relY);
+    }
+
+    @Override
+    public void layout(int x, int y) {
+        this.setX(x);
+        this.setY(y);
+        internal.setBound(0, 0, width(), height());
+        internal.layout(x, y);
+    }
+    @Override
+    public void render(GuiRenderer renderer, ScissorStack stack) {
+        stack.push(this);
+        internal.renderPanel(renderer, stack);
+        stack.pop();
+    }
+    @Override
+    public boolean onClick(Player.Hand hand, int x, int y) {
+        return internal.onClick(hand, x, y);
+    }
+    @Override
+    public boolean onDrag(Player.Hand hand, int mouseX, int mouseY) {
+        return internal.onDrag(hand, mouseX, mouseY);
+    }
+    @Override
+    public boolean onRelease(Player.Hand hand, int mouseX, int mouseY) {
+        return internal.onRelease(hand, mouseX, mouseY);
+    }
+    @Override
+    public boolean onScroll(int mouseX, int mouseY, double deltaScroll) {
+        return internal.onScroll(mouseX, mouseY, deltaScroll);
+    }
+    @Override
+    public void onTick() {
+        internal.onTick();
+    }
+    @Override
+    public boolean onKeyPressed(Keyboard.KeyCode key) {
+        return internal.onKeyPressed(key);
+    }
+    @Override
+    public boolean onCharTyped(char ch) {
+        return internal.onCharTyped(ch);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/cam72cam/mod/gui_v2/control/PositionedPanel.java b/src/main/java/cam72cam/mod/gui_v2/control/PositionedPanel.java
new file mode 100644
index 000000000..461a8fb53
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/control/PositionedPanel.java
@@ -0,0 +1,41 @@
+package cam72cam.mod.gui_v2.control;
+
+import cam72cam.mod.gui_v2.core.layout.ILayoutable;
+import it.unimi.dsi.fastutil.objects.Object2LongArrayMap;
+
+/**
+ * Abstraction of panels that could set children's relative positions statically, like AnchorPane
+ */
+public abstract class PositionedPanel<T extends PositionedPanel<T>> extends AbstractPanel<T> {
+    private final Object2LongArrayMap<ILayoutable<?>> childrenPositions = new Object2LongArrayMap<>();
+
+    public PositionedPanel(int width, int height) {
+        super(width, height);
+    }
+
+    public void addChildren(ILayoutable<?> child, int relX, int relY) {
+        super.addChildren(child);
+        setChildPosition(child, relX, relY);
+    }
+
+    public void setChildPosition(ILayoutable<?> child, int relX, int relY) {
+        if (!getChildren().contains(child)) {
+            return;
+        }
+        childrenPositions.put(child, (long) relX << 32 | relY);
+    }
+
+    public int getChildRelX(ILayoutable<?> child) {
+        if (childrenPositions.containsKey(child)) {
+            return (int) (childrenPositions.getLong(child) >> 32);
+        }
+        return 0;
+    }
+
+    public int getChildRelY(ILayoutable<?> child) {
+        if (childrenPositions.containsKey(child)) {
+            return (int) childrenPositions.getLong(child);
+        }
+        return 0;
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/control/composed/ItemPicker.java b/src/main/java/cam72cam/mod/gui_v2/control/composed/ItemPicker.java
new file mode 100644
index 000000000..bf7e83ea2
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/control/composed/ItemPicker.java
@@ -0,0 +1,99 @@
+package cam72cam.mod.gui_v2.control.composed;
+
+import cam72cam.mod.gui_v2.control.ComposedWidget;
+import cam72cam.mod.gui_v2.control.panel.HBox;
+import cam72cam.mod.gui_v2.control.panel.VBox;
+import cam72cam.mod.gui_v2.rendering.GuiRenderer;
+import cam72cam.mod.item.ItemStack;
+
+import cam72cam.mod.gui_v2.control.panel.ScrollPane;
+import cam72cam.mod.gui_v2.control.widget.Button;
+import cam72cam.mod.gui_v2.control.widget.TextField;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
+public class ItemPicker extends ComposedWidget<ItemPicker> {
+    private static final int SEARCH_HEIGHT = 20;
+
+    private final TextField searchField;
+    private final ScrollPane scrollPane;
+    private final VBox rowsContainer;
+
+    private final List<ItemStack> allItems = new ArrayList<>();
+    private final Consumer<ItemStack> onItemSelected;
+    private List<ItemStack> filteredItems = new ArrayList<>();
+
+    public ItemPicker(int width, int height, Consumer<ItemStack> onItemSelected) {
+        super(width, height);
+        rowsContainer = new VBox(0);
+        scrollPane = new ScrollPane(width, height);
+        scrollPane.addChildren(rowsContainer);
+        addChildren(scrollPane, 0, 0);
+
+        this.onItemSelected = onItemSelected;
+
+        searchField = new TextField(width, SEARCH_HEIGHT, this::onSearchTextChanged);
+        searchField.setValidator(s -> true);
+
+        addChildren(searchField, 0, 0);
+        addChildren(scrollPane, 0, SEARCH_HEIGHT);
+    }
+
+    public void addItems(Collection<ItemStack> items) {
+        allItems.addAll(items);
+        applyFilter();
+    }
+
+    public void setItems(List<ItemStack> items) {
+        allItems.clear();
+        allItems.addAll(items);
+        applyFilter();
+    }
+
+    public void clearItems() {
+        allItems.clear();
+        applyFilter();
+    }
+
+    private void onSearchTextChanged(String text) {
+        applyFilter();
+    }
+
+    private void applyFilter() {
+        String searchText = searchField.getText().toLowerCase();
+        String[] parts = searchText.isEmpty() ? new String[0] : searchText.split(" ");
+        filteredItems = allItems.stream()
+                                .filter(stack -> Arrays.stream(parts).allMatch(part -> stack.getDisplayName().toLowerCase().contains(part)))
+                                .collect(Collectors.toList());
+        rebuildGrid();
+    }
+
+    private void rebuildGrid() {
+        rowsContainer.clearChildren();
+        int cols = Math.max(1, (scrollPane.panelWidth()) / GuiRenderer.ITEM_SIZE);
+        HBox currentRow = null;
+        for (int i = 0; i < filteredItems.size(); i++) {
+            if (i % cols == 0) {
+                currentRow = new HBox(0);
+                rowsContainer.addChildren(currentRow);
+            }
+            int finalI = i;
+            currentRow.addChildren(Button.item(filteredItems.get(i), (btn) -> {
+                if (onItemSelected != null) {
+                    onItemSelected.accept(filteredItems.get(finalI));
+                }
+            }));
+        }
+        requestLayout();
+    }
+
+    @Override
+    public void layout(int x, int y) {
+        super.layout(x, y);
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/control/composed/NumberField.java b/src/main/java/cam72cam/mod/gui_v2/control/composed/NumberField.java
new file mode 100644
index 000000000..0c810c5b1
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/control/composed/NumberField.java
@@ -0,0 +1,122 @@
+package cam72cam.mod.gui_v2.control.composed;
+
+import cam72cam.mod.gui_v2.control.ComposedWidget;
+import cam72cam.mod.gui_v2.control.widget.Button;
+import cam72cam.mod.gui_v2.control.widget.Slider;
+import cam72cam.mod.gui_v2.control.widget.TextField;
+import cam72cam.mod.text.PlayerMessage;
+
+import java.util.function.Consumer;
+import java.util.regex.Pattern;
+
+public class NumberField extends ComposedWidget<NumberField> {
+    private static final Pattern DECIMAL = Pattern.compile("-?\\d*\\.?\\d*");
+    private static final Pattern INTEGER = Pattern.compile("-?\\d+");
+
+    private final TextField textField;
+    private final Slider slider;
+    private final Button button;
+
+    private final Consumer<Double> callback;
+    private final boolean allowDecimal;
+    private final String formatter;
+
+    private double value;
+    private boolean showSlider;
+
+    public NumberField(int width, int height, PlayerMessage name, double min, double max, double orig, boolean allowDecimal, Consumer<Double> callback) {
+        super(width, height);
+        this.value = Math.max(min, Math.min(max, orig));
+        this.button = Button.vanilla(height, height, PlayerMessage.direct("↺"), (hand, btn) -> onButtonChange());
+        this.slider = Slider.horizontal(width - height, height, name, min, max, value, allowDecimal ? 4 : 0, this::onSliderChange);
+        this.textField = new TextField(width - height, height, this::onTextChange) {
+            @Override
+            public void onFocusLost() {
+                super.onFocusLost();
+                String str = getText();
+                double d = str.isEmpty() ? slider.getMinBound() : Double.parseDouble(str);
+                setText(String.format(formatter, Math.max(slider.getMinBound(), Math.min(slider.getMaxBound(), d))));
+            }
+        };
+        this.textField.setValidator(this::verify);
+        this.allowDecimal = allowDecimal;
+        this.formatter = allowDecimal ? "%.4f" : "%.0f";
+        this.callback = callback;
+
+        this.addChildren(this.textField, 0, 0);
+        this.addChildren(this.slider, 0, 0);
+        this.addChildren(this.button, width - height, 0);
+        //Wrapped true for triggering refreshment
+        this.showSlider = false;
+        this.onButtonChange();
+    }
+
+    //TODO Use HBox for auto scaling
+    @Override
+    public void setWidth(int width) {
+        super.setWidth(width);
+        if (this.textField != null) {
+            //Initialized, safe to use
+            int h = this.height();
+            this.slider.setWidth(width - h);
+            this.textField.setWidth(width - h);
+            this.button.setWidth(h);
+            this.setChildRelativeX(this.button, this.slider.width());
+            requestLayout();
+        }
+    }
+
+    @Override
+    public void setHeight(int height) {
+        super.setHeight(height);
+        if (this.textField != null) {
+            //Initialized, safe to use
+            int w = this.width();
+            this.slider.setWidth(w - height);
+            this.textField.setWidth(w - height);
+            this.button.setWidth(height);
+            this.setChildRelativeX(this.button, this.slider.width());
+            this.slider.setHeight(height);
+            this.textField.setHeight(height);
+            this.button.setHeight(height);
+            requestLayout();
+        }
+    }
+
+    protected void onButtonChange() {
+        this.showSlider = !this.showSlider;
+        if (this.showSlider) {
+            this.textField.setVisible(false);
+            this.slider.setValue(this.value);
+            this.slider.setVisible(true);
+        } else {
+            this.slider.setVisible(false);
+            this.textField.setText(String.format(formatter, this.value));
+            this.textField.setVisible(true);
+        }
+    }
+
+    protected void onSliderChange(Slider slider) {
+        this.value = slider.getValue();
+        if (!allowDecimal) {
+            this.value = Math.round(this.value);
+        }
+        callback.accept(this.value);
+    }
+
+    protected void onTextChange(String newText) {
+        if (newText.isEmpty()) {
+            this.value = 0;
+            return;
+        }
+        this.value = Double.parseDouble(newText);
+        callback.accept(this.value);
+    }
+
+    protected boolean verify(String text) {
+        if (text.isEmpty()) {
+            return true;
+        }
+        return allowDecimal ? DECIMAL.matcher(text).matches() : INTEGER.matcher(text).matches();
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/control/panel/AnchorPane.java b/src/main/java/cam72cam/mod/gui_v2/control/panel/AnchorPane.java
new file mode 100644
index 000000000..ac1a12548
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/control/panel/AnchorPane.java
@@ -0,0 +1,99 @@
+package cam72cam.mod.gui_v2.control.panel;
+
+import cam72cam.mod.gui_v2.GuiUtils;
+import cam72cam.mod.gui_v2.control.PositionedPanel;
+import cam72cam.mod.gui_v2.core.layout.HorizontalAlign;
+import cam72cam.mod.gui_v2.core.layout.ILayoutable;
+import cam72cam.mod.gui_v2.core.layout.VerticalAlign;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class AnchorPane extends PositionedPanel<AnchorPane> {
+    private final Map<ILayoutable<?>, AnchorInfo> anchorMap = new HashMap<>();
+
+    public AnchorPane(int width, int height) {
+        super(width, height);
+    }
+
+    public static AnchorPane fullScreen() {
+        return new AnchorPane(GuiUtils.getScreenWidth(), GuiUtils.getScreenHeight());
+    }
+
+    @Override
+    public void addChildren(ILayoutable<?> child, int relX, int relY) {
+        addChildren(child, HorizontalAlign.LEFT, relX, VerticalAlign.TOP, relY);
+    }
+
+    @Override
+    public void addChildren(Iterable<ILayoutable<?>> children) {
+        super.addChildren(children);
+        for (ILayoutable<?> child : children) {
+            anchorMap.put(child, new AnchorInfo(HorizontalAlign.LEFT, 0, VerticalAlign.TOP, 0));
+        }
+    }
+
+    public void addChildren(ILayoutable<?> child, HorizontalAlign hAlign, int marginX, VerticalAlign vAlign, int marginY) {
+        super.addChildren(child);
+        anchorMap.put(child, new AnchorInfo(hAlign, marginX, vAlign, marginY));
+        requestLayout();
+    }
+
+    public void setChildAnchor(ILayoutable<?> child, HorizontalAlign hAlign, int marginX, VerticalAlign vAlign, int marginY) {
+        if (!anchorMap.containsKey(child))
+            throw new IllegalArgumentException("AnchorPane does not contain child");
+        anchorMap.put(child, new AnchorInfo(hAlign, marginX, vAlign, marginY));
+        requestLayout();
+    }
+
+    @Override
+    public void layout(int x, int y) {
+        this.setX(x);
+        this.setY(y);
+
+        int panelW = width();
+        int panelH = height();
+
+        for (ILayoutable<?> child : getVisibleChildren()) {
+            AnchorInfo info = anchorMap.get(child);
+            if (info != null) {
+                int relX = 0, relY = 0;
+
+                switch (info.hAlign) {
+                    case LEFT:   relX = info.marginX; break;
+                    case MIDDLE: relX = (panelW - child.width()) / 2; break;
+                    case RIGHT:  relX = panelW - child.width() - info.marginX; break;
+                }
+
+                switch (info.vAlign) {
+                    case TOP:    relY = info.marginY; break;
+                    case MIDDLE: relY = (panelH - child.height()) / 2; break;
+                    case BOTTOM: relY = panelH - child.height() - info.marginY; break;
+                }
+
+                setChildPosition(child, relX, relY);
+            }
+
+            int childX = x + getChildRelX(child);
+            int childY = y + getChildRelY(child);
+            child.setX(childX);
+            child.setY(childY);
+            child.layout(childX, childY);
+        }
+    }
+
+    private static class AnchorInfo {
+        final HorizontalAlign hAlign;
+        final int marginX;
+
+        final VerticalAlign vAlign;
+        final int marginY;
+
+        AnchorInfo(HorizontalAlign hAlign, int marginX, VerticalAlign vAlign, int marginY) {
+            this.hAlign = hAlign;
+            this.marginX = marginX;
+            this.vAlign = vAlign;
+            this.marginY = marginY;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/cam72cam/mod/gui_v2/control/panel/HBox.java b/src/main/java/cam72cam/mod/gui_v2/control/panel/HBox.java
new file mode 100644
index 000000000..78cd03eed
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/control/panel/HBox.java
@@ -0,0 +1,96 @@
+package cam72cam.mod.gui_v2.control.panel;
+
+import cam72cam.mod.gui_v2.core.layout.ILayoutable;
+import cam72cam.mod.gui_v2.core.layout.VerticalAlign;
+import cam72cam.mod.gui_v2.control.AbstractPanel;
+
+public class HBox extends AbstractPanel<HBox> {
+    private int spacing;
+    private VerticalAlign alignType;
+
+    public HBox(int spacing) {
+        this(spacing, VerticalAlign.TOP);
+    }
+
+    public HBox(int spacing, VerticalAlign alignType) {
+        super(0, 0);
+        this.spacing = spacing;
+        this.alignType = alignType;
+    }
+
+    public int getSpacing() {
+        return spacing;
+    }
+
+    public void setSpacing(int spacing) {
+        this.spacing = spacing;
+        requestLayout();
+    }
+
+    public VerticalAlign getAlignType() {
+        return alignType;
+    }
+
+    public void setAlignType(VerticalAlign alignType) {
+        this.alignType = alignType;
+    }
+
+    @Override
+    public void layout(int x, int y) {
+        this.setX(x);
+        this.setY(y);
+
+        int maxHeight = getVisibleChildren().stream()
+                                            .mapToInt(ILayoutable::height)
+                                            .max().orElse(0);
+
+        int currentX = x;
+        int totalWidth = 0;
+
+        for (ILayoutable<?> widget : getVisibleChildren()) {
+            int childWidth = widget.width();
+            int childHeight = widget.height();
+
+            int childYOffset;
+            switch (alignType) {
+                case MIDDLE:
+                    childYOffset = (maxHeight - childHeight) / 2;
+                    break;
+                case BOTTOM:
+                    childYOffset = maxHeight - childHeight;
+                    break;
+                case TOP:
+                default:
+                    childYOffset = 0;
+                    break;
+            }
+
+            widget.setX(currentX);
+            widget.setY(childYOffset);
+            widget.layout(currentX, y + childYOffset);
+
+            currentX += childWidth + spacing;
+            totalWidth += childWidth;
+        }
+
+        if (getVisibleChildren().size() > 1) {
+            totalWidth += spacing * (getVisibleChildren().size() - 1);
+        }
+        setWHInternal(totalWidth, maxHeight);
+    }
+
+    @Override
+    public void setWidth(int width) {
+        // NO-OP for HBox
+    }
+
+    @Override
+    public void setHeight(int height) {
+        // NO-OP for HBox
+    }
+
+    protected void setWHInternal(int width, int height) {
+        super.setWidth(width);
+        super.setHeight(height);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/cam72cam/mod/gui_v2/control/panel/ScrollPane.java b/src/main/java/cam72cam/mod/gui_v2/control/panel/ScrollPane.java
new file mode 100644
index 000000000..8f32241e5
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/control/panel/ScrollPane.java
@@ -0,0 +1,87 @@
+package cam72cam.mod.gui_v2.control.panel;
+
+import cam72cam.mod.gui_v2.control.AbstractPanel;
+import cam72cam.mod.gui_v2.control.widget.Slider;
+import cam72cam.mod.gui_v2.core.layout.ILayoutable;
+import cam72cam.mod.gui_v2.core.actions.IScrollable;
+import cam72cam.mod.text.PlayerMessage;
+
+//TODO Controller position and visibility
+public class ScrollPane extends AbstractPanel<ScrollPane> implements IScrollable {
+    private final Slider controller;
+    // 0 stands for top
+    private double scrolled;
+    private int contentHeight;
+
+    public ScrollPane(int width, int height) {
+        super(width, height);
+        this.controller = Slider.vertical(10, height, PlayerMessage.direct(""),
+                                          0, 1, 0, 0, this::onControllerChange);
+        addController(controller);
+    }
+
+    public static ScrollPane vertical(int width, int height) {
+        return new ScrollPane(width, height);
+    }
+
+    @Override
+    public void layout(int x, int y) {
+        this.setX(x);
+        this.setY(y);
+
+        contentHeight = getVisibleChildren().stream().mapToInt(ILayoutable::height).sum();
+
+        double maxScroll = contentHeight - height();
+        if (maxScroll <= 0) {
+            maxScroll = 0;
+            scrolled = 0;
+            controller.setHandleSize(controller.height());
+        } else {
+            int handleSize = controller.height();
+            handleSize *= height();
+            handleSize /= contentHeight;
+            controller.setHandleSize(handleSize);
+        }
+
+        double scrollOffset = scrolled * maxScroll;
+
+        int currentY = y() - (int) scrollOffset;
+        for (ILayoutable<?> widget : getVisibleChildren()) {
+            widget.setX(x());
+            widget.setY(currentY);
+            widget.layout(x(), currentY);
+            currentY += widget.height();
+        }
+
+        this.controller.layout(x() + width() - controller.width(), y());
+    }
+
+    @Override
+    public int panelWidth() {
+        return super.width() - controller.width();
+    }
+
+    @Override
+    public boolean onScroll(int mouseX, int mouseY, double deltaScroll) {
+        if (!isHovering()) return false;
+
+        double maxScroll = Math.max(0, contentHeight - height());
+        if (maxScroll <= 0) return false;
+
+        //Fixed at 20px
+        double step = 20.0 / maxScroll;
+        if (deltaScroll > 0) {
+            scrolled = Math.max(0, scrolled - step);
+        } else if (deltaScroll < 0) {
+            scrolled = Math.min(1.0, scrolled + step);
+        }
+
+        this.controller.setValue(scrolled);
+        return true;
+    }
+
+    private void onControllerChange(Slider ctrl) {
+        scrolled = ctrl.getValue();
+        requestLayout();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/cam72cam/mod/gui_v2/control/panel/SimplePane.java b/src/main/java/cam72cam/mod/gui_v2/control/panel/SimplePane.java
new file mode 100644
index 000000000..01230fe1e
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/control/panel/SimplePane.java
@@ -0,0 +1,34 @@
+package cam72cam.mod.gui_v2.control.panel;
+
+import cam72cam.mod.gui_v2.GuiUtils;
+import cam72cam.mod.gui_v2.control.PositionedPanel;
+import cam72cam.mod.gui_v2.core.layout.ILayoutable;
+
+/**
+ * Fixed size panel
+ */
+public class SimplePane extends PositionedPanel<SimplePane> {
+    public SimplePane(int width, int height) {
+        super(width, height);
+    }
+
+    public static SimplePane fullScreen() {
+        return new SimplePane(GuiUtils.getScreenWidth(), GuiUtils.getScreenHeight());
+    }
+
+    @Override
+    public void layout(int x, int y) {
+        this.setX(x);
+        this.setY(y);
+        int width = 0, height = 0;
+        for (ILayoutable<?> child : getVisibleChildren()) {
+            int childX = x + getChildRelX(child);
+            int childY = y + getChildRelY(child);
+            child.layout(childX, childY);
+            width = Math.max(child.width() + childX - x, width);
+            height = Math.max(child.height() + childY - y, height);
+        }
+        this.setWidth(width);
+        this.setHeight(height);
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/control/panel/VBox.java b/src/main/java/cam72cam/mod/gui_v2/control/panel/VBox.java
new file mode 100644
index 000000000..c8a847941
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/control/panel/VBox.java
@@ -0,0 +1,83 @@
+package cam72cam.mod.gui_v2.control.panel;
+
+import cam72cam.mod.gui_v2.core.layout.HorizontalAlign;
+import cam72cam.mod.gui_v2.core.layout.ILayoutable;
+import cam72cam.mod.gui_v2.control.AbstractPanel;
+
+public class VBox extends AbstractPanel<VBox> {
+    private int spacing;
+    private HorizontalAlign alignType;
+
+    public VBox(int spacing) {
+        this(spacing, HorizontalAlign.LEFT);
+    }
+
+    public VBox(int spacing, HorizontalAlign alignType) {
+        //Left empty for auto width/height
+        super(0, 0);
+        this.spacing = spacing;
+        this.alignType = alignType;
+    }
+
+    public int getSpacing() {
+        return spacing;
+    }
+
+    public void setSpacing(int spacing) {
+        this.spacing = spacing;
+        requestLayout();
+    }
+
+    public HorizontalAlign getAlignType() {
+        return alignType;
+    }
+
+    public void setAlignType(HorizontalAlign alignType) {
+        this.alignType = alignType;
+    }
+
+    @Override
+    public void layout(int x, int y) {
+        this.setX(x);
+        this.setY(y);
+        int maxWidth = getVisibleChildren().stream().mapToInt(ILayoutable::width).max().orElse(0);
+        int currentHeight = y;
+        for (ILayoutable<?> widget : getVisibleChildren()) {
+            int childWidth = widget.width();
+            int childXOffset;
+            switch (alignType) {
+                case MIDDLE:
+                    childXOffset = (maxWidth - childWidth) / 2;
+                    break;
+                case RIGHT:
+                    childXOffset = maxWidth - childWidth;
+                    break;
+                case LEFT:
+                default:
+                    childXOffset = 0;
+                    break;
+            }
+            widget.setX(childXOffset);
+            widget.setY(currentHeight);
+            widget.layout(x + childXOffset, currentHeight);
+            currentHeight += widget.height() + spacing;
+        }
+        int totalHeight = currentHeight - y - spacing;
+        setWHInternal(maxWidth, Math.max(totalHeight, 0));
+    }
+
+    @Override
+    public void setWidth(int width) {
+        //NO-OP for VBox
+    }
+
+    @Override
+    public void setHeight(int height) {
+        //NO-OP for VBox
+    }
+
+    protected void setWHInternal(int width, int height) {
+        super.setWidth(width);
+        super.setHeight(height);
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/control/widget/Button.java b/src/main/java/cam72cam/mod/gui_v2/control/widget/Button.java
new file mode 100644
index 000000000..1652f18c9
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/control/widget/Button.java
@@ -0,0 +1,120 @@
+package cam72cam.mod.gui_v2.control.widget;
+
+import cam72cam.mod.entity.Player;
+import cam72cam.mod.gui_v2.control.AbstractWidget;
+import cam72cam.mod.gui_v2.core.actions.IClickable;
+import cam72cam.mod.gui_v2.core.actions.ITooltipper;
+import cam72cam.mod.gui_v2.rendering.GuiRenderer;
+import cam72cam.mod.item.ItemStack;
+import cam72cam.mod.render.opengl.RenderContext;
+import cam72cam.mod.render.opengl.RenderState;
+import cam72cam.mod.render.opengl.Texture;
+import cam72cam.mod.resource.Identifier;
+import cam72cam.mod.text.PlayerMessage;
+import cam72cam.mod.util.With;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+
+public class Button extends AbstractWidget<Button>
+        implements IClickable, ITooltipper {
+    /*
+     * Handler consumer, called upon clicked
+     * Hand -> PRIMARY is a left-click, SECONDARY is a right-click
+     * Button -> Reference of self, as it may not be fully constructed
+     */
+    protected BiConsumer<Player.Hand, Button> handler;
+    protected List<PlayerMessage> tooltip;
+
+    /* Constructor with no rendering */
+    public Button(int width, int height, PlayerMessage text, BiConsumer<Player.Hand, Button> handler) {
+        this.setName(text);
+        this.setBound(0, 0, width, height);
+        this.handler = handler;
+
+        setVanillaFacade();
+    }
+
+    /* Semitic constructors */
+    public static Button vanilla(int width, int height, PlayerMessage text, BiConsumer<Player.Hand, Button> handler) {
+        return new Button(width, height, text, handler);
+    }
+
+    /* Render full texture */
+    public static Button textured(int width, int height, PlayerMessage text, BiConsumer<Player.Hand, Button> handler,
+                                  Identifier tex) {
+        return textured(width, height, text, handler, tex, 0, 0, 1, 1);
+    }
+
+    /* Render sprite texture */
+    public static Button textured(int width, int height, PlayerMessage text, BiConsumer<Player.Hand, Button> handler,
+                                  Identifier tex, float startU, float startV, float endU, float endV) {
+        Button button = new Button(width, height, text, handler);
+        button.setBackgroundRenderFunc((gui, btn) -> {
+            try (With ctx = RenderContext.apply(new RenderState().texture(Texture.wrap(tex)))) {
+                gui.drawTexturedUvRect(tex, btn.x(), btn.y(), btn.width(), btn.height(), startU, startV, endU, endV);
+            }
+        });
+        button.setRenderFunc((gui, btn) -> {
+            int color = btn.getNameColor() != 0 ? btn.getNameColor() :
+                        !btn.isEnabled() ? 0xA0A0A0 :
+                        btn.isHovering() ? 0xFFFFA0 : 0xE0E0E0;
+            gui.drawCenteredString(btn.getName().internal.getFormattedText(), btn.x() + btn.width() / 2, btn.y() + (btn.height() - 8) / 2, color);
+        });
+        return button;
+    }
+
+    public static Button item(ItemStack stack, Consumer<Button> callback) {
+        Button button = new Button(GuiRenderer.ITEM_SIZE, GuiRenderer.ITEM_SIZE, PlayerMessage.direct(""),
+                                   ((hand, btn) -> callback.accept(btn)));
+        button.setBackgroundRenderFunc((gui, btn) -> {
+//            gui.drawRect(btn.x(), btn.y(), btn.width(), btn.height(), 0x00000000);
+        });
+        button.setRenderFunc((gui, btn) -> {
+            gui.drawItem(stack, btn.x(), btn.y());
+        });
+        return button;
+    }
+
+    @Override
+    public void layout(int x, int y) {
+        this.setX(x);
+        this.setY(y);
+    }
+
+    @Override
+    public boolean onClick(Player.Hand hand, int x, int y) {
+        if (isHovering()) {
+            this.handler.accept(hand, this);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void setTooltip(List<PlayerMessage> text) {
+        this.tooltip = text;
+    }
+
+    @Override
+    public List<PlayerMessage> getTooltips() {
+        return Collections.singletonList(this.getName());
+    }
+
+    /* Facades */
+    public void setVanillaFacade() {
+        this.setBackgroundRenderFunc((gui, btn) -> {
+            int state = !btn.isEnabled() ? 0
+                    : btn.isHovering() ? 2 : 1;
+            gui.drawVanillaButton(btn.x(), btn.y(), btn.width(), btn.height(), state);
+        });
+        this.setRenderFunc((gui, btn) -> {
+            int color = btn.getNameColor() != 0 ? btn.getNameColor() :
+                        !btn.isEnabled() ? 0xA0A0A0 :
+                        btn.isHovering() ? 0xFFFFA0 : 0xE0E0E0;
+            gui.drawCenteredString(btn.getName().internal.getFormattedText(), btn.x() + btn.width() / 2, btn.y() + (btn.height() - 8) / 2, color);
+        });
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/control/widget/CheckBox.java b/src/main/java/cam72cam/mod/gui_v2/control/widget/CheckBox.java
new file mode 100644
index 000000000..4c5201c75
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/control/widget/CheckBox.java
@@ -0,0 +1,95 @@
+package cam72cam.mod.gui_v2.control.widget;
+
+import cam72cam.mod.entity.Player;
+import cam72cam.mod.gui_v2.GuiUtils;
+import cam72cam.mod.gui_v2.control.AbstractWidget;
+import cam72cam.mod.gui_v2.core.actions.IClickable;
+import cam72cam.mod.text.PlayerMessage;
+
+import java.util.function.Consumer;
+
+public class CheckBox extends AbstractWidget<CheckBox>
+        implements IClickable {
+    protected static final int CHECK_BOX_SIZE = 11;
+
+    protected boolean checked;
+    private final Consumer<CheckBox> callback;
+
+    public CheckBox(PlayerMessage name, Consumer<CheckBox> callback) {
+        this(name, false, callback);
+    }
+
+    public CheckBox(PlayerMessage name, boolean checked, Consumer<CheckBox> callback) {
+        this.setName(name);
+        this.checked = checked;
+        this.callback = callback;
+
+        int width = CHECK_BOX_SIZE + 2 + GuiUtils.getTextWidth(this.getName());
+        setWHInternal(width, CHECK_BOX_SIZE);
+
+        setVanillaFacade();
+    }
+
+    public boolean isChecked() {
+        return checked;
+    }
+
+    public void setChecked(boolean newValue) {
+        this.checked = newValue;
+        callback.accept(this);
+    }
+
+    @Override
+    public void layout(int x, int y) {
+        this.setX(x);
+        this.setY(y);
+    }
+
+    @Override
+    public boolean onClick(Player.Hand hand, int x, int y) {
+        if (!isHovering()) {
+            return false;
+        }
+        checked = !checked;
+        this.callback.accept(this);
+        return true;
+    }
+
+    @Override
+    public void setName(PlayerMessage text) {
+        super.setName(text);
+        int newWidth = CHECK_BOX_SIZE + 2 + GuiUtils.getTextWidth(this.getName());
+        setBound(0, 0, newWidth, height());
+    }
+
+    @Override
+    public void setWidth(int width) {
+        //NO-OP
+    }
+
+    @Override
+    public void setHeight(int height) {
+        //NO-OP
+    }
+
+    protected void setWHInternal(int width, int height) {
+        super.setWidth(width);
+        super.setHeight(height);
+    }
+
+    public void setVanillaFacade() {
+        this.setBackgroundRenderFunc((gui, cb) -> {
+            gui.drawVanillaButton(cb.x(), cb.y(), CHECK_BOX_SIZE, CHECK_BOX_SIZE, 0);
+
+            if (cb.isChecked()) {
+                //TODO Better appearance
+                gui.drawCenteredString("x", cb.x() + CHECK_BOX_SIZE / 2 + 1, cb.y() + 1, 14737632);
+            }
+        });
+        this.setRenderFunc((gui, cb) -> {
+            int color = cb.getNameColor() != 0 ? cb.getNameColor() :
+                        !cb.isEnabled() ? 0xA0A0A0 : 0xE0E0E0;
+            gui.drawString(cb.getName().internal.getFormattedText(), cb.x() + CHECK_BOX_SIZE + 2, cb.y() + 2, color);
+        });
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/control/widget/Image.java b/src/main/java/cam72cam/mod/gui_v2/control/widget/Image.java
new file mode 100644
index 000000000..cf3065f7e
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/control/widget/Image.java
@@ -0,0 +1,37 @@
+package cam72cam.mod.gui_v2.control.widget;
+
+import cam72cam.mod.gui_v2.control.AbstractWidget;
+import cam72cam.mod.resource.Identifier;
+
+public class Image extends AbstractWidget<Image> {
+    protected Identifier tex;
+    protected float uStart;
+    protected float uEnd;
+    protected float vStart;
+    protected float vEnd;
+
+    public Image(int width, int height, Identifier tex, float uStart, float uEnd, float vStart, float vEnd) {
+        this.setWidth(width);
+        this.setHeight(height);
+        this.tex = tex;
+        this.uStart = uStart;
+        this.uEnd = uEnd;
+        this.vStart = vStart;
+        this.vEnd = vEnd;
+
+        this.setRenderFunc((gui, image) -> {
+            gui.drawTexturedUvRect(image.tex, image.x(), image.y(), image.width(), image.height(),
+                                   image.uStart, image.uEnd, image.vStart, image.vEnd);
+        });
+    }
+
+    public static Image fullTex(int width, int height, Identifier tex) {
+        return new Image(width, height, tex, 0, 1, 0, 1);
+    }
+
+    @Override
+    public void layout(int x, int y) {
+        this.setX(x);
+        this.setY(y);
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/control/widget/Label.java b/src/main/java/cam72cam/mod/gui_v2/control/widget/Label.java
new file mode 100644
index 000000000..6c1a66b61
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/control/widget/Label.java
@@ -0,0 +1,58 @@
+package cam72cam.mod.gui_v2.control.widget;
+
+import cam72cam.mod.gui_v2.GuiUtils;
+import cam72cam.mod.gui_v2.control.AbstractWidget;
+import cam72cam.mod.gui_v2.rendering.GuiRenderer;
+import cam72cam.mod.text.PlayerMessage;
+
+//TODO
+// 1.How to handle multiline?
+// 2.Scaling
+public class Label extends AbstractWidget<Label> {
+    private String formatted;
+
+    public Label(PlayerMessage text, int textColor) {
+        this.setName(text);
+        this.setNameColor(textColor);
+        this.setWidth(GuiUtils.getTextWidth(text));
+        this.setHeight(GuiRenderer.TEXT_HEIGHT);
+        this.formatted = text.internal.getFormattedText();
+        this.setRenderFunc((gui, label) -> gui.drawString(formatted, x(), y(), getNameColor()));
+    }
+
+    public static Label direct(String text) {
+        return direct(text, 0xE0E0E0);
+    }
+
+    public static Label direct(String text, int nameColor) {
+        return new Label(PlayerMessage.direct(text), nameColor);
+    }
+
+    public static Label trans(String text) {
+        return trans(text, 0xE0E0E0);
+    }
+
+    public static Label trans(String text, int nameColor) {
+        return new Label(PlayerMessage.translate(text), nameColor);
+    }
+
+    public static Label url(String text) {
+        return url(text, 0xE0E0E0);
+    }
+
+    public static Label url(String text, int nameColor) {
+        return new Label(PlayerMessage.url(text), nameColor);
+    }
+
+    @Override
+    public void setName(PlayerMessage text) {
+        super.setName(text);
+        this.formatted = text.internal.getFormattedText();
+    }
+
+    @Override
+    public void layout(int x, int y) {
+        this.setX(x);
+        this.setY(y);
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/control/widget/Slider.java b/src/main/java/cam72cam/mod/gui_v2/control/widget/Slider.java
new file mode 100644
index 000000000..9be669950
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/control/widget/Slider.java
@@ -0,0 +1,208 @@
+package cam72cam.mod.gui_v2.control.widget;
+
+import cam72cam.mod.entity.Player;
+import cam72cam.mod.gui_v2.GuiUtils;
+import cam72cam.mod.gui_v2.control.AbstractWidget;
+import cam72cam.mod.gui_v2.core.actions.IClickable;
+import cam72cam.mod.gui_v2.core.actions.IDraggable;
+import cam72cam.mod.gui_v2.core.actions.IFocusable;
+import cam72cam.mod.gui_v2.core.actions.IUpdatable;
+import cam72cam.mod.gui_v2.rendering.GuiRenderer;
+import cam72cam.mod.text.PlayerMessage;
+
+import javax.annotation.Nonnull;
+import java.util.function.Consumer;
+
+public class Slider extends AbstractWidget<Slider>
+        implements IClickable, IDraggable, IFocusable, IUpdatable {
+    protected final boolean isHorizontal;
+
+    protected int handleSize;
+
+    private double min;
+    private double max;
+    private double value;
+    private int displayPrecision;
+
+    protected String formatted;
+
+    protected boolean isDragging;
+
+    @Nonnull
+    protected Consumer<Slider> handler;
+
+    public Slider(int width, int height, PlayerMessage text, double min, double max, double start, int displayPrecision, Consumer<Slider> handler, boolean isHorizontal) {
+        this.setBound(0, 0, width, height);
+        this.min = min;
+        this.max = max;
+        this.value = start;
+        this.displayPrecision = displayPrecision;
+        this.handler = handler;
+        this.isHorizontal = isHorizontal;
+        this.setName(text);
+
+        this.handleSize = 8; //Default
+
+        setVanillaFacade();
+    }
+
+    /* Semitic constructors */
+    public static Slider horizontal(int width, int height, PlayerMessage text, double min, double max, double start, int displayPrecision, Consumer<Slider> handler) {
+        return new Slider(width, height, text, min, max, start, displayPrecision, handler, true);
+    }
+
+    public static Slider vertical(int width, int height, PlayerMessage text, double min, double max, double start, int displayPrecision, Consumer<Slider> handler) {
+        return new Slider(width, height, text, min, max, start, displayPrecision, handler, false);
+    }
+
+    public double getValue() {
+        return value;
+    }
+
+    public void setValue(double value) {
+        this.value = value;
+        this.handler.accept(this);
+    }
+
+    public double getMinBound() {
+        return min;
+    }
+
+    public double getMaxBound() {
+        return max;
+    }
+
+    public void setSliderBound(double min, double max) {
+        this.min = min;
+        this.max = max;
+        this.value = Math.max(min, Math.min(value, max));
+        this.handler.accept(this);
+    }
+
+    public void setDisplayPrecision(int displayPrecision) {
+        this.displayPrecision = displayPrecision;
+        this.formatName();
+    }
+
+    public void setHandleSize(int handleSize) {
+        if (handleSize > this.height()) {
+            handleSize = this.height();
+        }
+        this.handleSize = handleSize;
+    }
+
+    @Override
+    public void layout(int x, int y) {
+        this.setX(x);
+        this.setY(y);
+    }
+
+    @Override
+    public void setName(PlayerMessage text) {
+        super.setName(text);
+        this.formatName();
+    }
+
+    @Override
+    public boolean onClick(Player.Hand hand, int x, int y) {
+        if (!isHovering()) {
+            return false;
+        }
+        requestFocus(this);
+        updateSlider(x, y);
+        return true;
+    }
+
+    @Override
+    public boolean onDrag(Player.Hand hand, int mouseX, int mouseY) {
+        if (!isDragging && !isHovering()) {
+            return false;
+        }
+        updateSlider(mouseX, mouseY);
+        return true;
+    }
+
+    @Override
+    public boolean onRelease(Player.Hand hand, int mouseX, int mouseY) {
+        if (isDragging) {
+            freeFocus();
+            setValue(value);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isFocusing() {
+        return this.isDragging;
+    }
+
+    @Override
+    public void onFocusGained() {
+        this.isDragging = true;
+    }
+
+    @Override
+    public void onFocusLost() {
+        this.isDragging = false;
+    }
+
+    @Override
+    public void postRender() {
+        if (this.isDragging) {
+            updateSlider(GuiUtils.getMouseX(), GuiUtils.getMouseY());
+        }
+    }
+
+    protected void updateSlider(int mouseX, int mouseY) {
+        double ratio;
+
+        if (isHorizontal) {
+            double relX = mouseX - x() - handleSize / 2.0;
+            ratio = relX / (width() - handleSize);
+        } else {
+            double relY = mouseY - y() - handleSize / 2.0;
+            ratio = relY / (height() - handleSize);
+        }
+
+        ratio = Math.max(0.0, Math.min(1.0, ratio));
+
+        double rawValue = min + ratio * (max - min);
+        setValue(Math.max(min, Math.min(max, rawValue)));
+    }
+
+    private void formatName() {
+        String text = this.getName().internal.getFormattedText();
+        formatted = text.replace("slidValue", "%."+displayPrecision+"f");
+    }
+
+    public void setVanillaFacade() {
+        this.setBackgroundRenderFunc((gui, slid) -> {
+            //Render track
+            gui.drawVanillaButton(slid.x(), slid.y(), slid.width(), slid.height(), 0);
+
+            double ratio = (slid.value - slid.min) / (slid.max - slid.min);
+            ratio = Math.max(0.0, Math.min(1.0, ratio));
+
+            //Render slider handle
+            if (slid.isHorizontal) {
+                int trackWidth = slid.width() - handleSize;
+                int handleX = slid.x() + (int) (ratio * trackWidth);
+                int handleY = slid.y();
+                gui.drawVanillaButton(handleX, handleY, handleSize, slid.height(), 1);
+            } else {
+                int trackHeight = slid.height() - handleSize;
+                int handleX = slid.x();
+                int handleY = slid.y() + (int) (ratio * trackHeight);
+                gui.drawVanillaButton(handleX, handleY, slid.width(), handleSize, 1);
+            }
+        });
+        this.setRenderFunc((gui, slid) -> {
+            int j = slid.getNameColor() != 0 ? slid.getNameColor() :
+                      slid.isHovering() ? 0xFFFFA0 : 0xE0E0E0;
+
+            gui.drawCenteredString(String.format(formatted, value),
+                                   slid.x() + slid.width() / 2, slid.y() + (slid.height() - GuiRenderer.TEXT_HEIGHT) / 2, j);
+        });
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/control/widget/TextField.java b/src/main/java/cam72cam/mod/gui_v2/control/widget/TextField.java
new file mode 100644
index 000000000..ae177f839
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/control/widget/TextField.java
@@ -0,0 +1,403 @@
+package cam72cam.mod.gui_v2.control.widget;
+
+import cam72cam.mod.entity.Player;
+import cam72cam.mod.gui_v2.GuiUtils;
+import cam72cam.mod.gui_v2.control.AbstractWidget;
+import cam72cam.mod.gui_v2.core.actions.*;
+import cam72cam.mod.gui_v2.rendering.GuiRenderer;
+import cam72cam.mod.input.Clipboard;
+import cam72cam.mod.input.Keyboard;
+import com.google.common.base.Predicates;
+
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+//TODO Multiline support
+public class TextField extends AbstractWidget<TextField>
+        implements IClickable, IFocusable, IDraggable, IKeyboardListener, IUpdatable {
+    private static final int SPAN = GuiRenderer.TEXT_HEIGHT / 2;
+
+    private String text;
+    private final Consumer<String> callback;
+    private Predicate<String> validator = Predicates.alwaysTrue();
+    private int cursorPos = 0;
+    private int textOffsetX = 0;
+
+    private boolean hasSelection = false;
+    private int selectionStart = 0;
+
+    private int cursorBlinkTimer = 0;
+
+    private boolean focusing;
+
+    public TextField(int width, int height, Consumer<String> callback) {
+        this(width, height, "", callback);
+    }
+
+    public TextField(int width, int height, String original, Consumer<String> callback) {
+        this.setWidth(width);
+        this.setHeight(height);
+        this.text = original;
+        this.callback = callback;
+
+        this.setVanillaFacade();
+    }
+
+    public String getText() {
+        return text;
+    }
+
+    public void setText(String newText) {
+        if (canApplyText(newText)) {
+            this.text = newText;
+            this.callback.accept(newText);
+        }
+    }
+
+    public void setValidator(Predicate<String> validator) {
+        this.validator = validator;
+    }
+
+    public void setCursorPos(int newPos) {
+        cursorPos = Math.max(0, Math.min(text.length(), newPos));
+        cursorBlinkTimer = 0; //Reset blinker
+
+        //Refine text offset to display in bounds
+        int visibleWidth = this.width() - 2 * SPAN;
+        int totalTextWidth = GuiUtils.getTextWidth(text);
+        int cursorPixelX = GuiUtils.getTextWidth(text.substring(0, cursorPos));
+
+        int newOffset = this.textOffsetX;
+        if (totalTextWidth > visibleWidth) {
+            if (cursorPixelX < newOffset) {
+                newOffset = cursorPixelX;
+            } else if (cursorPixelX > newOffset + visibleWidth) {
+                newOffset = cursorPixelX - visibleWidth;
+            }
+            newOffset = Math.min(newOffset, totalTextWidth - visibleWidth);
+            newOffset = Math.max(newOffset, 0);
+        } else {
+            newOffset = 0;
+        }
+        this.textOffsetX = newOffset;
+    }
+
+    public boolean hasSelection() {
+        return hasSelection;
+    }
+
+    public String getSelectedText() {
+        if (!hasSelection) return "";
+        int start = Math.min(selectionStart, cursorPos);
+        int end = Math.max(selectionStart, cursorPos);
+        return text.substring(start, end);
+    }
+
+    @Override
+    public void layout(int x, int y) {
+        setX(x);
+        setY(y);
+    }
+
+    @Override
+    public boolean isFocusing() {
+        return focusing;
+    }
+
+    @Override
+    public void onFocusGained() {
+        focusing = true;
+        cursorBlinkTimer = 0;
+    }
+
+    @Override
+    public void onFocusLost() {
+        focusing = false;
+    }
+
+    @Override
+    public boolean onClick(Player.Hand hand, int mouseX, int mouseY) {
+        if (!isHovering()) {
+            return false;
+        }
+
+        if(!focusing) {
+            requestFocus(this);
+        }
+
+        int relativeX = mouseX - x() + textOffsetX;
+        int bestPos = 0;
+        int bestDist = Integer.MAX_VALUE;
+        int currX = SPAN;
+        for (int i = 0; i <= text.length(); i++) {
+            int dist = Math.abs(relativeX - currX);
+            if (dist < bestDist) {
+                bestDist = dist;
+                bestPos = i;
+            }
+            if (i < text.length()) {
+                currX += GuiUtils.getTextWidth(String.valueOf(text.charAt(i)));
+            }
+        }
+
+        if (Keyboard.isPressingShift()) {
+            if (!hasSelection) {
+                hasSelection = true;
+                selectionStart = cursorPos;
+            }
+        } else {
+            clearSelection();
+        }
+        setCursorPos(bestPos);
+        return true;
+    }
+
+    @Override
+    public boolean onDrag(Player.Hand hand, int mouseX, int mouseY) {
+        if (!focusing) return false;
+
+        //Start dragging
+        if (!hasSelection) {
+            hasSelection = true;
+            selectionStart = cursorPos;
+        }
+
+        int relativeX = mouseX - x() + textOffsetX;
+        int bestPos = 0;
+        int bestDist = Integer.MAX_VALUE;
+        int currX = SPAN;
+        for (int i = 0; i <= text.length(); i++) {
+            int dist = Math.abs(relativeX - currX);
+            if (dist < bestDist) {
+                bestDist = dist;
+                bestPos = i;
+            }
+            if (i < text.length()) {
+                currX += GuiUtils.getTextWidth(String.valueOf(text.charAt(i)));
+            }
+        }
+        setCursorPos(bestPos);
+
+        //If cursor moves beyond then scroll the text to fit
+        int localX = mouseX - x();
+        int scrollThreshold = 10;
+        if (localX < -scrollThreshold) {
+            setCursorPos(cursorPos - 1);
+        } else if (localX > width() + scrollThreshold) {
+            setCursorPos(cursorPos + 1);
+        }
+
+        return true;
+    }
+
+    @Override
+    public boolean onRelease(Player.Hand hand, int mouseX, int mouseY) {
+        return false;
+    }
+
+    @Override
+    public boolean onKeyPressed(Keyboard.KeyCode key) {
+        if (!focusing) return false;
+
+        switch (key) {
+            case LEFT:
+                if (Keyboard.isPressingShift()) {
+                    if (!hasSelection) {
+                        hasSelection = true;
+                        selectionStart = cursorPos;
+                    }
+                } else {
+                    clearSelection();
+                }
+                setCursorPos(cursorPos - 1);
+                return true;
+            case RIGHT:
+                if (Keyboard.isPressingShift()) {
+                    if (!hasSelection) {
+                        hasSelection = true;
+                        selectionStart = cursorPos;
+                    }
+                } else {
+                    clearSelection();
+                }
+                setCursorPos(cursorPos + 1);
+                return true;
+            case HOME:
+                if (Keyboard.isPressingShift()) {
+                    if (!hasSelection) {
+                        hasSelection = true;
+                        selectionStart = cursorPos;
+                    }
+                } else {
+                    clearSelection();
+                }
+                setCursorPos(0);
+                return true;
+            case END:
+                if (Keyboard.isPressingShift()) {
+                    if (!hasSelection) {
+                        hasSelection = true;
+                        selectionStart = cursorPos;
+                    }
+                } else {
+                    clearSelection();
+                }
+                setCursorPos(text.length());
+                return true;
+            case BACK:
+                if (hasSelection()) {
+                    deleteSelection();
+                } else if (cursorPos > 0) {
+                    String newText = text.substring(0, cursorPos - 1) + text.substring(cursorPos);
+                    if (canApplyText(newText)) {
+                        if (cursorPos == newText.length()) {
+                            //Already at tail, don't move
+                            setCursorPos(cursorPos);
+                        } else {
+                            //Move front
+                            setCursorPos(cursorPos - 1);
+                        }
+                    }
+                }
+                return true;
+            case DELETE:
+                if (hasSelection()) {
+                    deleteSelection();
+                } else if (cursorPos < text.length()) {
+                    String newText = text.substring(0, cursorPos) + text.substring(cursorPos + 1);
+                    canApplyText(newText);
+                    setCursorPos(cursorPos); //Trigger updates
+                }
+                return true;
+            case A:
+                if (Keyboard.isPressingCtrl()) {
+                    hasSelection = true;
+                    selectionStart = 0;
+                    setCursorPos(text.length());
+                    return true;
+                }
+                break;
+            case C:
+                if (Keyboard.isPressingCtrl()) {
+                    if (hasSelection()) {
+                        Clipboard.setClipboard(getSelectedText());
+                    }
+                    return true;
+                }
+                break;
+            case X:
+                if (Keyboard.isPressingCtrl()) {
+                    if (hasSelection()) {
+                        Clipboard.setClipboard(getSelectedText());
+                        deleteSelection();
+                    }
+                    return true;
+                }
+                break;
+            case V:
+                if (Keyboard.isPressingCtrl()) {
+                    String clipboard = Clipboard.getClipboard();
+                    if (!clipboard.isEmpty()) {
+                        insert(clipboard);
+                    }
+                    return true;
+                }
+                break;
+        }
+        return false;
+    }
+
+    @Override
+    public void onTick() {
+        cursorBlinkTimer ++;
+    }
+
+    @Override
+    public boolean onCharTyped(char ch) {
+        if (!focusing) return false;
+        insert(ch);
+        return true;
+    }
+
+    @Override
+    public void setVisible(boolean visible) {
+        super.setVisible(visible);
+        this.clearSelection();
+    }
+
+    @Override
+    public void setEnabled(boolean enabled) {
+        super.setEnabled(enabled);
+        this.clearSelection();
+    }
+
+    private boolean canApplyText(String newText) {
+        if (!validator.test(newText)) {
+            return false;
+        }
+        this.text = newText;
+        setCursorPos(cursorPos); //Trigger updates
+        if (callback != null) {
+            callback.accept(text);
+        }
+        return true;
+    }
+
+    private void clearSelection() {
+        hasSelection = false;
+        selectionStart = 0;
+    }
+
+    private void deleteSelection() {
+        if (!hasSelection) return;
+        int start = Math.min(selectionStart, cursorPos);
+        int end = Math.max(selectionStart, cursorPos);
+        String newText = text.substring(0, start) + text.substring(end);
+        if (canApplyText(newText)) {
+            setCursorPos(start);
+            clearSelection();
+        }
+    }
+
+    private void insert(char c) {
+        insert(String.valueOf(c));
+    }
+
+    private void insert(String str) {
+        deleteSelection();
+        String newText = text.substring(0, cursorPos) + str + text.substring(cursorPos);
+        if (canApplyText(newText)) {
+            setCursorPos(cursorPos + str.length());
+        }
+    }
+
+    public void setVanillaFacade() {
+        this.setBackgroundRenderFunc((gui, txt) -> {
+            int bgColor = 0xFF101010;
+            int borderColor = txt.focusing ? 0xFFA0A0A0 : 0xFF808080;
+            gui.drawRect(txt.x(), txt.y(), txt.width(), txt.height(), borderColor);
+            gui.drawRect(txt.x()+1, txt.y()+1, txt.width()-2, txt.height()-2, bgColor);
+        });
+        this.setRenderFunc((gui, txt) -> {
+            int xOff = txt.x() + SPAN - txt.textOffsetX;
+            int yOff = txt.y() + (txt.height() - GuiRenderer.TEXT_HEIGHT) / 2;
+
+            //Selection box
+            if (txt.hasSelection()) {
+                int start = Math.min(txt.selectionStart, txt.cursorPos);
+                int end = Math.max(txt.selectionStart, txt.cursorPos);
+                int selX1 = xOff + GuiUtils.getTextWidth(txt.text.substring(0, start));
+                int selX2 = xOff + GuiUtils.getTextWidth(txt.text.substring(0, end));
+                gui.drawRect(selX1, yOff, selX2 - selX1, GuiRenderer.TEXT_HEIGHT, 0xFF0080FF);
+            }
+
+            gui.drawString(txt.text, xOff, yOff, 0xFFFFFF);
+
+            //Cursor
+            if (txt.focusing && txt.cursorBlinkTimer % 20 < 10) {
+                int cursorX = xOff + GuiUtils.getTextWidth(txt.text.substring(0, txt.cursorPos));
+                gui.drawRect(cursorX, yOff - 2 , 1, GuiRenderer.TEXT_HEIGHT + 4, 0xFFEEEEEE);
+            }
+        });
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/cam72cam/mod/gui_v2/core/ClientScreen.java b/src/main/java/cam72cam/mod/gui_v2/core/ClientScreen.java
new file mode 100644
index 000000000..987b8bb4a
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/core/ClientScreen.java
@@ -0,0 +1,22 @@
+package cam72cam.mod.gui_v2.core;
+
+import cam72cam.mod.gui_v2.control.panel.AnchorPane;
+
+public abstract class ClientScreen {
+    private ScreenWrapper internal;
+
+    public abstract void init(AnchorPane root);
+
+    public void onClose() {}
+
+    public void onGuiResize(int newWidth, int newHeight) {}
+
+    public final void requestClose() {
+        internal.onGuiClosed();
+    }
+
+    void bootstrap(ScreenWrapper internal) {
+        this.internal = internal;
+        init(this.internal.root);
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/core/GuiManager.java b/src/main/java/cam72cam/mod/gui_v2/core/GuiManager.java
new file mode 100644
index 000000000..0382c7159
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/core/GuiManager.java
@@ -0,0 +1,19 @@
+package cam72cam.mod.gui_v2.core;
+
+import net.minecraft.client.Minecraft;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+//TODO Container
+public class GuiManager {
+    @SideOnly(Side.CLIENT)
+    public static void openScreen(ClientScreen screen) {
+        openScreen(screen, false);
+    }
+
+    @SideOnly(Side.CLIENT)
+    public static void openScreen(ClientScreen screen, boolean pausesGame) {
+        ScreenWrapper sa = new ScreenWrapper(screen, pausesGame);
+        Minecraft.getMinecraft().displayGuiScreen(sa);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/cam72cam/mod/gui_v2/core/ScissorStack.java b/src/main/java/cam72cam/mod/gui_v2/core/ScissorStack.java
new file mode 100644
index 000000000..79a6af3a3
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/core/ScissorStack.java
@@ -0,0 +1,56 @@
+package cam72cam.mod.gui_v2.core;
+
+import cam72cam.mod.gui_v2.control.AbstractPanel;
+import cam72cam.mod.gui_v2.core.layout.ILayoutable;
+import cam72cam.mod.render.opengl.RenderContext;
+import cam72cam.mod.render.opengl.RenderState;
+import cam72cam.mod.util.With;
+
+import java.awt.*;
+import java.awt.geom.Rectangle2D;
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+public class ScissorStack {
+    private static final Rectangle2D EMPTY = new Rectangle(0, 0, 0, 0);
+
+    private final Deque<Rectangle2D> stack;
+
+    public ScissorStack() {
+        stack = new ArrayDeque<>();
+    }
+
+    public void push(ILayoutable<?> widget) {
+        push(new Rectangle(widget.x(), widget.y(), widget.width(), widget.height() + 1));
+    }
+
+    public void pushPanel(AbstractPanel<?> panel) {
+        push(new Rectangle(panel.panelX(), panel.panelY(), panel.panelWidth(), panel.panelHeight() + 1));
+    }
+
+    public void push(int x, int y, int width, int height) {
+        push(new Rectangle(x, y, width, height));
+    }
+
+    public void push(Rectangle2D r) {
+        if (!stack.isEmpty()) {
+            if (r.intersects(stack.peek())) {
+                r = r.createIntersection(stack.peek());
+            } else {
+                r = EMPTY;
+            }
+        }
+        stack.push(r);
+    }
+
+    public void pop() {
+        stack.pop();
+    }
+
+    public With applyScissor() {
+        if (!stack.isEmpty()) {
+            return RenderContext.apply(new RenderState().scissor(true, stack.peek()));
+        }
+        return () -> {};
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/core/ScreenWrapper.java b/src/main/java/cam72cam/mod/gui_v2/core/ScreenWrapper.java
new file mode 100644
index 000000000..ced9eeba6
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/core/ScreenWrapper.java
@@ -0,0 +1,128 @@
+package cam72cam.mod.gui_v2.core;
+
+import cam72cam.mod.entity.Player;
+import cam72cam.mod.event.ClientEvents;
+import cam72cam.mod.gui_v2.GuiUtils;
+import cam72cam.mod.gui_v2.control.panel.AnchorPane;
+import cam72cam.mod.gui_v2.rendering.GuiRenderer;
+import cam72cam.mod.input.Keyboard;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiScreen;
+import org.lwjgl.input.Mouse;
+
+import java.io.IOException;
+
+public class ScreenWrapper extends GuiScreen {
+    static ScreenWrapper instance;
+
+    final ClientScreen clientScreen;
+    final AnchorPane root;
+    final boolean pausesGame;
+
+    static {
+        ClientEvents.TICK.subscribe(() -> {
+            if (instance != null) {
+                instance.onTick();
+            } else if (Minecraft.getMinecraft().currentScreen instanceof ScreenWrapper) {
+                instance = ((ScreenWrapper) Minecraft.getMinecraft().currentScreen);
+            }
+        });
+    }
+
+    public ScreenWrapper(ClientScreen screen, boolean pausesGame) {
+        this.root = AnchorPane.fullScreen();
+        this.clientScreen = screen;
+        this.pausesGame = pausesGame;
+        screen.bootstrap(this);
+        instance = this;
+    }
+
+    public void layout() {
+        this.root.layout(0, 0);
+    }
+
+    @Override
+    public void drawScreen(int mouseX, int mouseY, float partialTicks) {
+        GuiUtils.mouseX = mouseX;
+        GuiUtils.mouseY = mouseY;
+        GuiRenderer renderer = new GuiRenderer(this);
+        ScissorStack stack = new ScissorStack();
+        root.renderPanel(renderer, stack);
+    }
+
+    @Override
+    protected void mouseClicked(int mouseX, int mouseY, int mouseButton) {
+        //TODO Mouse key detection
+        if (!root.onClick(Player.Hand.PRIMARY, mouseX, mouseY)) {
+            //If clicked nothing we should free current one
+            root.freeFocus();
+        }
+    }
+
+    @Override
+    protected void mouseClickMove(int mouseX, int mouseY, int mouseButton, long deltaTicks) {
+        root.onDrag(Player.Hand.PRIMARY, mouseX, mouseY);
+    }
+
+    @Override
+    protected void mouseReleased(int mouseX, int mouseY, int mouseButton) {
+        root.onRelease(Player.Hand.PRIMARY, mouseX, mouseY);
+    }
+
+    protected void mouseScrolled(int mouseX, int mouseY, double delta) {
+        root.onScroll(mouseX, mouseY, delta);
+    }
+
+    @Override
+    public void handleMouseInput() throws IOException {
+        super.handleMouseInput();
+
+        int i = Mouse.getEventX() * this.width / this.mc.displayWidth;
+        int j = this.height - Mouse.getEventY() * this.height / this.mc.displayHeight - 1;
+
+        double scroll = Math.signum(org.lwjgl.input.Mouse.getEventDWheel());
+        if (scroll != 0) {
+            this.mouseScrolled(i, j, scroll);
+        }
+    }
+
+    @Override
+    protected void keyTyped(char typedChar, int keyCode) throws IOException {
+        super.keyTyped(typedChar, keyCode);
+        Keyboard.KeyCode key = Keyboard.KeyCode.of(keyCode);
+        boolean consumed = false;
+        if (key != null) {
+            consumed = root.onKeyPressed(key);
+        }
+        if (!consumed && GuiUtils.isPrintable(typedChar)) {
+            root.onCharTyped(typedChar);
+        }
+    }
+
+    @Override
+    public void onGuiClosed() {
+        super.onGuiClosed();
+        this.clientScreen.onClose();
+        instance = null;
+    }
+
+    @Override
+    public void onResize(Minecraft mcIn, int w, int h) {
+        super.onResize(mcIn, w, h);
+        this.root.setBound(0, 0, w, h);
+        this.root.layout(0, 0);
+    }
+
+    private void onTick() {
+        this.root.onTick();
+    }
+
+    @Override
+    public boolean doesGuiPauseGame() {
+        return this.pausesGame;
+    }
+
+    public static ScreenWrapper getInstance() {
+        return instance;
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/core/actions/IClickable.java b/src/main/java/cam72cam/mod/gui_v2/core/actions/IClickable.java
new file mode 100644
index 000000000..22ad2c8c5
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/core/actions/IClickable.java
@@ -0,0 +1,13 @@
+package cam72cam.mod.gui_v2.core.actions;
+
+import cam72cam.mod.entity.Player;
+
+/**
+ * Represents
+ */
+public interface IClickable {
+    /**
+     * PRIMARY for left click, otherwise SECONDARY
+     */
+    boolean onClick(Player.Hand hand, int x, int y);
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/core/actions/IDraggable.java b/src/main/java/cam72cam/mod/gui_v2/core/actions/IDraggable.java
new file mode 100644
index 000000000..1a00de73d
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/core/actions/IDraggable.java
@@ -0,0 +1,8 @@
+package cam72cam.mod.gui_v2.core.actions;
+
+import cam72cam.mod.entity.Player;
+
+public interface IDraggable {
+    boolean onDrag(Player.Hand hand, int mouseX, int mouseY);
+    boolean onRelease(Player.Hand hand, int mouseX, int mouseY);
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/core/actions/IFocusable.java b/src/main/java/cam72cam/mod/gui_v2/core/actions/IFocusable.java
new file mode 100644
index 000000000..55f4a1ead
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/core/actions/IFocusable.java
@@ -0,0 +1,7 @@
+package cam72cam.mod.gui_v2.core.actions;
+
+public interface IFocusable {
+    boolean isFocusing();
+    void onFocusGained();
+    void onFocusLost();
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/core/actions/IKeyboardListener.java b/src/main/java/cam72cam/mod/gui_v2/core/actions/IKeyboardListener.java
new file mode 100644
index 000000000..5bebe8f46
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/core/actions/IKeyboardListener.java
@@ -0,0 +1,8 @@
+package cam72cam.mod.gui_v2.core.actions;
+
+import cam72cam.mod.input.Keyboard;
+
+public interface IKeyboardListener {
+    boolean onKeyPressed(Keyboard.KeyCode key);
+    boolean onCharTyped(char ch);
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/core/actions/IScrollable.java b/src/main/java/cam72cam/mod/gui_v2/core/actions/IScrollable.java
new file mode 100644
index 000000000..6bb14595a
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/core/actions/IScrollable.java
@@ -0,0 +1,5 @@
+package cam72cam.mod.gui_v2.core.actions;
+
+public interface IScrollable {
+    boolean onScroll(int mouseX, int mouseY, double deltaScroll);
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/core/actions/ITooltipper.java b/src/main/java/cam72cam/mod/gui_v2/core/actions/ITooltipper.java
new file mode 100644
index 000000000..1c676b682
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/core/actions/ITooltipper.java
@@ -0,0 +1,10 @@
+package cam72cam.mod.gui_v2.core.actions;
+
+import cam72cam.mod.text.PlayerMessage;
+
+import java.util.List;
+
+public interface ITooltipper {
+    List<PlayerMessage> getTooltips();
+    void setTooltip(List<PlayerMessage> text);
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/core/actions/IUpdatable.java b/src/main/java/cam72cam/mod/gui_v2/core/actions/IUpdatable.java
new file mode 100644
index 000000000..2354ccfac
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/core/actions/IUpdatable.java
@@ -0,0 +1,7 @@
+package cam72cam.mod.gui_v2.core.actions;
+
+public interface IUpdatable {
+    default void preRender() {}
+    default void postRender() {}
+    default void onTick() {}
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/core/layout/HorizontalAlign.java b/src/main/java/cam72cam/mod/gui_v2/core/layout/HorizontalAlign.java
new file mode 100644
index 000000000..1aa00f55b
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/core/layout/HorizontalAlign.java
@@ -0,0 +1,22 @@
+package cam72cam.mod.gui_v2.core.layout;
+
+import javax.annotation.Nullable;
+
+public enum HorizontalAlign {
+    LEFT,
+    MIDDLE,
+    RIGHT;
+
+    public static @Nullable HorizontalAlign parse(String s) {
+        switch (s.toUpperCase()) {
+            case "LEFT":
+                return LEFT;
+            case "MIDDLE":
+            case "CENTER":
+                return MIDDLE;
+            case "RIGHT":
+                return RIGHT;
+        }
+        return null;
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/core/layout/ILayoutable.java b/src/main/java/cam72cam/mod/gui_v2/core/layout/ILayoutable.java
new file mode 100644
index 000000000..0043629af
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/core/layout/ILayoutable.java
@@ -0,0 +1,33 @@
+package cam72cam.mod.gui_v2.core.layout;
+
+import cam72cam.mod.gui_v2.core.ScissorStack;
+import cam72cam.mod.gui_v2.rendering.GuiRenderFunc;
+import cam72cam.mod.gui_v2.rendering.GuiRenderer;
+
+public interface ILayoutable<T> {
+    //Position & Size
+    int x();
+    int y();
+    int width();
+    int height();
+    void setX(int x);
+    void setY(int y);
+    void setWidth(int width);
+    void setHeight(int height);
+    void setBound(int x, int y, int width, int height);
+
+    //Rendering
+    boolean isVisible();
+    void setVisible(boolean visible);
+
+    void renderBackground(GuiRenderer renderer, ScissorStack stack);
+    void render(GuiRenderer renderer, ScissorStack stack);
+    void renderForeground(GuiRenderer renderer, ScissorStack stack);
+
+    void setBackgroundRenderFunc(GuiRenderFunc<T> handler);
+    void setRenderFunc(GuiRenderFunc<T> handler);
+    void setForegroundRenderFunc(GuiRenderFunc<T> handler);
+
+    //Layout
+    void layout(int x, int y);
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/core/layout/VerticalAlign.java b/src/main/java/cam72cam/mod/gui_v2/core/layout/VerticalAlign.java
new file mode 100644
index 000000000..35b38ef3a
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/core/layout/VerticalAlign.java
@@ -0,0 +1,22 @@
+package cam72cam.mod.gui_v2.core.layout;
+
+import javax.annotation.Nullable;
+
+public enum VerticalAlign {
+    TOP,
+    MIDDLE,
+    BOTTOM;
+
+    public static @Nullable VerticalAlign parse(String s) {
+        switch (s.toUpperCase()) {
+            case "TOP":
+                return TOP;
+            case "MIDDLE":
+            case "CENTER":
+                return MIDDLE;
+            case "BOTTOM":
+                return BOTTOM;
+        }
+        return null;
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/rendering/GuiRenderFunc.java b/src/main/java/cam72cam/mod/gui_v2/rendering/GuiRenderFunc.java
new file mode 100644
index 000000000..00024456f
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/rendering/GuiRenderFunc.java
@@ -0,0 +1,6 @@
+package cam72cam.mod.gui_v2.rendering;
+
+@FunctionalInterface
+public interface GuiRenderFunc<T> {
+    void draw(GuiRenderer renderer, T widget);
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/rendering/GuiRenderer.java b/src/main/java/cam72cam/mod/gui_v2/rendering/GuiRenderer.java
new file mode 100644
index 000000000..c14b7894e
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/rendering/GuiRenderer.java
@@ -0,0 +1,283 @@
+package cam72cam.mod.gui_v2.rendering;
+
+import cam72cam.mod.fluid.Fluid;
+import cam72cam.mod.item.ItemStack;
+import cam72cam.mod.render.opengl.BlendMode;
+import cam72cam.mod.render.opengl.RenderContext;
+import cam72cam.mod.render.opengl.RenderState;
+import cam72cam.mod.render.opengl.Texture;
+import cam72cam.mod.resource.Identifier;
+import cam72cam.mod.util.With;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Gui;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.RenderHelper;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import org.lwjgl.opengl.GL11;
+import util.Matrix4;
+
+public class GuiRenderer {
+    public static final Texture VANILLA_BUTTON = Texture.wrap(new Identifier("textures/gui/widgets.png"));
+    public static int TEXT_HEIGHT = 8;
+    public static final int ITEM_SIZE = 16;
+
+    private final GuiScreen instance;
+
+    public GuiRenderer(GuiScreen gui) {
+        this.instance = gui;
+    }
+
+    /**
+     * Draw a solid color block
+     */
+    public void drawRect(int x, int y, int width, int height, int color) {
+        try (With ctx = RenderContext.apply(
+                new RenderState().color(1, 1, 1, 1)
+                                 .blend(new BlendMode(BlendMode.GL_SRC_ALPHA, BlendMode.GL_ONE_MINUS_SRC_ALPHA))
+        )) {
+            Gui.drawRect(x, y, x + width, y + height, color);
+        }
+    }
+
+    /**
+     * Draw a full image (tex) at coords with given width/height
+     */
+    public void drawTexturedRect(Identifier tex, int x, int y, int width, int height) {
+        this.drawTexturedRect(tex, x, y, 0, 0, width, height);
+    }
+
+    /**
+     * Draw a full image (tex) at coords with given width/height
+     */
+    public void drawTexturedRect(Identifier tex, int x, int y, int startU, int startV, int width, int height) {
+        try (With ctx = RenderContext.apply(new RenderState().texture(Texture.wrap(tex)))) {
+            instance.drawTexturedModalRect(x, y, startU, startV, width, height);
+        }
+    }
+
+    public void drawTexturedUvRect(Identifier tex, int x, int y, int width, int height, float startU, float startV, float endU, float endV) {
+        try (With ctx = RenderContext.apply(new RenderState().texture(Texture.wrap(tex)))) {
+            Tessellator tessellator = Tessellator.getInstance();
+            BufferBuilder builder = tessellator.getBuffer();
+            builder.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX);
+            builder.pos(x, y + height, 0.0).tex(startU, endV).endVertex();
+            builder.pos(x + width, y + height, 0.0).tex(endU, endV).endVertex();
+            builder.pos(x + width, y, 0.0).tex(endU, startV).endVertex();
+            builder.pos(x, y, 0.0).tex(startU, startV).endVertex();
+            tessellator.draw();
+        }
+    }
+
+    //0 - disabled, 1 - normal, 2 - hovering
+    public void drawVanillaButton(int x, int y, int width, int height, int btnState) {
+        if (width < 6 || height < 6) {
+            //Don't handle
+            return;
+        }
+
+        RenderState state = new RenderState().texture(VANILLA_BUTTON)
+                                             .color(1, 1, 1, 1)
+                                             .blend(new BlendMode(BlendMode.GL_SRC_ALPHA, BlendMode.GL_ONE_MINUS_SRC_ALPHA,
+                                                                  BlendMode.GL_ONE, BlendMode.GL_ZERO));
+        try (With ctx = RenderContext.apply(state)) {
+            //Sprite info
+            int uBase = 0;
+            int vBase = 46 + btnState * 20;
+            int border = 3;
+            int texTotalW = 200;
+            int texTotalH = 20;
+
+            int uLeft = uBase;
+            int uCenter = uBase + border;
+            int uRight = uBase + texTotalW - border;
+            int vTop = vBase;
+            int vMiddle = vBase + border;
+            int vBottom = vBase + texTotalH - border;
+
+            int centerTexW = texTotalW - 2 * border;
+            int centerTexH = texTotalH - 2 * border;
+
+            // Corners
+            instance.drawTexturedModalRect(x, y, uLeft, vTop, border, border);
+            instance.drawTexturedModalRect(x + width - border, y, uRight, vTop, border, border);
+            instance.drawTexturedModalRect(x, y + height - border, uLeft, vBottom, border, border);
+            instance.drawTexturedModalRect(x + width - border, y + height - border, uRight, vBottom, border, border);
+
+            int innerW = width - 2 * border;
+            int innerH = height - 2 * border;
+
+            // Upper/Lower edge
+            if (innerW > 0) {
+                int upperY = y;
+                int lowerY = y + height - border;
+                int startX = x + border;
+                int remaining = innerW;
+                while (remaining > 0) {
+                    int w = Math.min(remaining, centerTexW);
+                    instance.drawTexturedModalRect(startX, upperY, uCenter, vTop, w, border);
+                    instance.drawTexturedModalRect(startX, lowerY, uCenter, vBottom, w, border);
+                    startX += w;
+                    remaining -= w;
+                }
+            }
+
+            // Left/Right Edge
+            if (innerH > 0) {
+                int leftX = x;
+                int rightX = x + width - border;
+                int startY = y + border;
+                int remaining = innerH;
+                while (remaining > 0) {
+                    int h = Math.min(remaining, centerTexH);
+                    instance.drawTexturedModalRect(leftX, startY, uLeft, vMiddle, border, h);
+                    instance.drawTexturedModalRect(rightX, startY, uRight, vMiddle, border, h);
+                    startY += h;
+                    remaining -= h;
+                }
+            }
+
+            // Internal
+            if (innerW > 0 && innerH > 0) {
+                int startY = y + border;
+                int remainingH = innerH;
+                while (remainingH > 0) {
+                    int h = Math.min(remainingH, centerTexH);
+                    int startX = x + border;
+                    int remainingW = innerW;
+                    while (remainingW > 0) {
+                        int w = Math.min(remainingW, centerTexW);
+                        instance.drawTexturedModalRect(startX, startY, uCenter, vMiddle, w, h);
+                        startX += w;
+                        remainingW -= w;
+                    }
+                    startY += h;
+                    remainingH -= h;
+                }
+            }
+        }
+    }
+
+    /**
+     * Draw fluid block at coords
+     */
+    public void drawFluid(Fluid fluid, int x, int y, int width, int height) {
+        TextureAtlasSprite sprite = Minecraft.getMinecraft().getTextureMapBlocks().getAtlasSprite(
+                fluid.internal.getStill().toString());
+        drawSprite(sprite, fluid.internal.getColor(), x, y, width, height);
+    }
+
+    /**
+     * This is kinda fun, we want to use the standard sprite drawer with a partial sprite!
+     */
+    private static class HackedSprite extends TextureAtlasSprite {
+        HackedSprite() {
+            super("unknown");
+        }
+
+        void setup(TextureAtlasSprite other, int width, int height) {
+            this.copyFrom(other);
+            this.width = width;
+            this.height = height;
+            int inX = (int) (originX / getMinU());
+            int inY = (int) (originY / getMinV());
+            this.initSprite(inX, inY, originX, originY, rotated);
+        }
+    }
+
+    private final HackedSprite sprite = new HackedSprite();
+
+    /**
+     * Draw a texture sprite at coords, tinted with col
+     */
+    private void drawSprite(TextureAtlasSprite sprite, int col, int x, int y, int width, int height) {
+        try (With ctx = RenderContext.apply(
+                new RenderState()
+                        .texture(Texture.wrap(new Identifier(TextureMap.LOCATION_BLOCKS_TEXTURE)))
+                        .color((col >> 16 & 255) / 255.0f, (col >> 8 & 255) / 255.0f, (col & 255) / 255.0f, 1)
+                        .stage(RenderContext.Stage.GUI)
+        )) {
+            int iW = sprite.getIconWidth();
+            int iH = sprite.getIconHeight();
+
+            for (int offY = 0; offY < height; offY += iH) {
+                double curHeight = Math.min(iH, height - offY);
+                for (int offX = 0; offX < width; offX += iW) {
+                    double curWidth = Math.min(iW, width - offX);
+                    this.sprite.setup(sprite, (int) curWidth, (int) curHeight);
+                    instance.drawTexturedModalRect(x + offX, y + offY, this.sprite, (int) curWidth, (int) curHeight);
+                }
+            }
+        }
+    }
+
+    /**
+     * Draw the fluid in a tank with a black background at % full
+     */
+    public void drawTankBlock(int x, int y, int width, int height, Fluid fluid, float percentFull) {
+        drawTankBlock(x, y, width, height, fluid, percentFull, true, 0x00000000);
+    }
+
+    /**
+     * Draw the fluid in a tank with a colored background at % full
+     */
+    public void drawTankBlock(int x, int y, int width, int height, Fluid fluid, float percentFull, boolean drawBackground, int color) {
+        if (drawBackground) {
+            drawRect(x, y, width, height, 0xFF000000);
+        }
+
+        if (percentFull > 0 && fluid != null) {
+            int fullHeight = Math.max(1, (int) (height * percentFull));
+            drawFluid(fluid, x, y + height - fullHeight, width, fullHeight);
+            drawRect(x, y + height - fullHeight, width, fullHeight, color);
+        }
+    }
+
+    /**
+     * Draw a shadowed string offset from the center of coords
+     */
+    public void drawCenteredString(String text, int x, int y, int color /*ARGB*/) {
+        drawCenteredString(text, x, y, color, new Matrix4());
+    }
+
+    public void drawCenteredString(String text, int x, int y, int color, Matrix4 matrix) {
+        drawString(text, (int) (x - Minecraft.getMinecraft().fontRenderer.getStringWidth(text) / 2f), y, color, matrix);
+    }
+
+    /**
+     * Draw a left-aligned shadowed string
+     */
+    public void drawString(String text, int x, int y, int color) {
+        drawString(text, x, y, color, new Matrix4());
+    }
+
+    public void drawString(String text, int x, int y, int color, Matrix4 matrix) {
+        RenderState state = new RenderState().color(1, 1, 1, 1).alpha_test(true);
+        state.model_view().multiply(matrix);
+        state.stage(RenderContext.Stage.GUI);
+        state.color(1, 1, 1, 1);
+        try (With ctx = RenderContext.apply(state)) {
+            Minecraft.getMinecraft().fontRenderer.drawStringWithShadow(text, x, y, color);
+        }
+    }
+
+    /**
+     * Draw a Item at the given coords
+     */
+    public void drawItem(ItemStack stack, int x, int y) {
+        drawItem(stack, x, y, new Matrix4());
+    }
+
+    public void drawItem(ItemStack stack, int x, int y, Matrix4 matrix) {
+        RenderState state = new RenderState();
+        state.model_view().multiply(matrix);
+        RenderHelper.enableGUIStandardItemLighting();
+        try (With ctx = RenderContext.apply(state)) {
+            Minecraft.getMinecraft().getRenderItem().renderItemIntoGUI(stack.internal, x, y);
+        }
+        RenderHelper.disableStandardItemLighting();
+    }
+}
diff --git a/src/main/java/cam72cam/mod/gui_v2/test/TestScreen.java b/src/main/java/cam72cam/mod/gui_v2/test/TestScreen.java
new file mode 100644
index 000000000..a6114137c
--- /dev/null
+++ b/src/main/java/cam72cam/mod/gui_v2/test/TestScreen.java
@@ -0,0 +1,52 @@
+package cam72cam.mod.gui_v2.test;
+
+import cam72cam.mod.entity.Player;
+import cam72cam.mod.gui_v2.control.composed.ItemPicker;
+import cam72cam.mod.gui_v2.control.composed.NumberField;
+import cam72cam.mod.gui_v2.control.panel.AnchorPane;
+import cam72cam.mod.gui_v2.control.panel.ScrollPane;
+import cam72cam.mod.gui_v2.control.panel.VBox;
+import cam72cam.mod.gui_v2.control.widget.*;
+import cam72cam.mod.gui_v2.core.ClientScreen;
+import cam72cam.mod.gui_v2.core.layout.HorizontalAlign;
+import cam72cam.mod.gui_v2.core.layout.VerticalAlign;
+import cam72cam.mod.item.Fuzzy;
+import cam72cam.mod.resource.Identifier;
+import cam72cam.mod.text.PlayerMessage;
+
+import java.util.function.BiConsumer;
+
+public class TestScreen extends ClientScreen {
+    @Override
+    public void init(AnchorPane root) {
+        //Test
+        VBox vBox = new VBox(5, HorizontalAlign.MIDDLE);
+        BiConsumer<Player.Hand, Button> btnTest = (hand, btn) -> System.out.println(btn.hashCode());
+        Label lab = Label.direct("label1");
+        Button button1 = Button.vanilla(150, 20, PlayerMessage.direct("clicker"), btnTest);
+        Label lab2 = Label.direct("label2");
+        Button button3 = Button.textured(150, 20, PlayerMessage.direct("clicker3"), btnTest, new Identifier("textures/blocks/bedrock.png"));
+        NumberField numberField = new NumberField(150, 20, PlayerMessage.direct("Val: slidValue"), 0, 1, 0, true, d -> System.out.println("Val: " + d));
+        NumberField numberField1 = new NumberField(150, 20, PlayerMessage.direct("Val: slidValue"), 10, 100, 0, false, d -> System.out.println("Val: " + d));
+        Slider horizontal = Slider.horizontal(150, 20, PlayerMessage.direct("slider"), 0, 1, 0, 0,
+                                              slider -> System.out.println(slider.getValue()));
+        Slider vertical = Slider.vertical(20, 150, PlayerMessage.direct("slider"), 0, 1, 0, 0,
+                                          slider -> {
+                                              System.out.println(slider.getValue());
+                                              numberField1.setWidth((int) (50 + slider.getValue() * 100));
+                                          });
+
+        ItemPicker picker = new ItemPicker(140, 200, itemStack -> System.out.println(itemStack.getDisplayName()));
+        picker.addItems(Fuzzy.BRICK_BLOCK.enumerate());
+        picker.addItems(Fuzzy.WOOL_BLOCK.enumerate());
+        picker.addItems(Fuzzy.LOG_WOOD.enumerate());
+        root.addChildren(picker, HorizontalAlign.LEFT, 0, VerticalAlign.MIDDLE, 0);
+        CheckBox checkBox = new CheckBox(PlayerMessage.direct("cb"), cb -> System.out.println(cb.isChecked()));
+        TextField textField = new TextField(150, 20, txt -> System.out.println("Text: " + txt));
+        ScrollPane pane = ScrollPane.vertical(160, 200);
+        Button button2 = Button.vanilla(150, 20, PlayerMessage.direct("clicker2"), (hand, b) -> picker.setVisible(!picker.isVisible()));
+        vBox.addChildren(lab, button1, button2, lab2, button3, horizontal, checkBox, textField, numberField, numberField1, vertical);
+        pane.addChildren(vBox);
+        root.addChildren(pane, HorizontalAlign.RIGHT, 0, VerticalAlign.BOTTOM, 0);
+    }
+}
diff --git a/src/main/java/cam72cam/mod/input/Clipboard.java b/src/main/java/cam72cam/mod/input/Clipboard.java
new file mode 100644
index 000000000..15274fc48
--- /dev/null
+++ b/src/main/java/cam72cam/mod/input/Clipboard.java
@@ -0,0 +1,19 @@
+package cam72cam.mod.input;
+
+import net.minecraft.client.gui.GuiScreen;
+
+public class Clipboard {
+    /**
+     * Get text from system clipboard
+     */
+    public static String getClipboard() {
+        return GuiScreen.getClipboardString();
+    }
+
+    /**
+     * Set text of system clipboard
+     */
+    public static void setClipboard(String text) {
+        GuiScreen.setClipboardString(text);
+    }
+}
diff --git a/src/main/java/cam72cam/mod/input/Keyboard.java b/src/main/java/cam72cam/mod/input/Keyboard.java
index 8ecda2ef1..9fb78a49b 100644
--- a/src/main/java/cam72cam/mod/input/Keyboard.java
+++ b/src/main/java/cam72cam/mod/input/Keyboard.java
@@ -2,6 +2,7 @@
 
 import cam72cam.mod.event.ClientEvents;
 import it.unimi.dsi.fastutil.ints.Int2ObjectArrayMap;
+import net.minecraft.client.gui.GuiScreen;
 import net.minecraft.client.settings.KeyBinding;
 import net.minecraftforge.fml.client.registry.ClientRegistry;
 import net.minecraftforge.fml.relauncher.Side;
@@ -145,4 +146,24 @@ public static void registerKey(String name, KeyCode keyCode, String category, Ru
             }
         });
     }
+
+    @SideOnly(Side.CLIENT)
+    public static boolean isPressing(KeyCode keyCode) {
+        return org.lwjgl.input.Keyboard.isKeyDown(keyCode.code);
+    }
+
+    @SideOnly(Side.CLIENT)
+    public static boolean isPressingCtrl() {
+        return GuiScreen.isCtrlKeyDown();
+    }
+
+    @SideOnly(Side.CLIENT)
+    public static boolean isPressingShift() {
+        return GuiScreen.isShiftKeyDown();
+    }
+
+    @SideOnly(Side.CLIENT)
+    public static boolean isPressingAlt() {
+        return GuiScreen.isAltKeyDown();
+    }
 }