diff --git a/providers/openflow/group/pom.xml b/providers/openflow/group/pom.xml
new file mode 100644
index 0000000..32ca37f
--- /dev/null
+++ b/providers/openflow/group/pom.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ Copyright 2015 Open Networking Laboratory
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~     http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.onosproject</groupId>
+        <artifactId>onos-of-providers</artifactId>
+        <version>1.1.0-SNAPSHOT</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+
+    <artifactId>onos-of-provider-group</artifactId>
+    <packaging>bundle</packaging>
+
+    <description>ONOS OpenFlow protocol group provider</description>
+
+</project>
\ No newline at end of file
diff --git a/providers/openflow/group/src/main/java/org/onosproject/provider/of/group/impl/GroupBucketEntryBuilder.java b/providers/openflow/group/src/main/java/org/onosproject/provider/of/group/impl/GroupBucketEntryBuilder.java
new file mode 100644
index 0000000..8ff8e70
--- /dev/null
+++ b/providers/openflow/group/src/main/java/org/onosproject/provider/of/group/impl/GroupBucketEntryBuilder.java
@@ -0,0 +1,325 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onosproject.provider.of.group.impl;
+
+import com.google.common.collect.Lists;
+import org.onlab.packet.Ip4Address;
+import org.onlab.packet.MacAddress;
+import org.onlab.packet.VlanId;
+import org.onosproject.core.DefaultGroupId;
+import org.onosproject.core.GroupId;
+import org.onosproject.net.PortNumber;
+import org.onosproject.net.flow.DefaultTrafficTreatment;
+import org.onosproject.net.flow.TrafficTreatment;
+import org.onosproject.net.group.DefaultGroupBucket;
+import org.onosproject.net.group.GroupBucket;
+import org.onosproject.net.group.GroupBuckets;
+import org.projectfloodlight.openflow.protocol.OFBucket;
+import org.projectfloodlight.openflow.protocol.OFGroupType;
+import org.projectfloodlight.openflow.protocol.action.OFAction;
+import org.projectfloodlight.openflow.protocol.action.OFActionCircuit;
+import org.projectfloodlight.openflow.protocol.action.OFActionCopyTtlIn;
+import org.projectfloodlight.openflow.protocol.action.OFActionCopyTtlOut;
+import org.projectfloodlight.openflow.protocol.action.OFActionDecMplsTtl;
+import org.projectfloodlight.openflow.protocol.action.OFActionDecNwTtl;
+import org.projectfloodlight.openflow.protocol.action.OFActionExperimenter;
+import org.projectfloodlight.openflow.protocol.action.OFActionOutput;
+import org.projectfloodlight.openflow.protocol.action.OFActionPopMpls;
+import org.projectfloodlight.openflow.protocol.action.OFActionPushMpls;
+import org.projectfloodlight.openflow.protocol.action.OFActionSetDlDst;
+import org.projectfloodlight.openflow.protocol.action.OFActionSetDlSrc;
+import org.projectfloodlight.openflow.protocol.action.OFActionSetField;
+import org.projectfloodlight.openflow.protocol.action.OFActionSetNwDst;
+import org.projectfloodlight.openflow.protocol.action.OFActionSetNwSrc;
+import org.projectfloodlight.openflow.protocol.action.OFActionSetVlanPcp;
+import org.projectfloodlight.openflow.protocol.action.OFActionSetVlanVid;
+import org.projectfloodlight.openflow.protocol.oxm.OFOxm;
+import org.projectfloodlight.openflow.protocol.oxm.OFOxmOchSigidBasic;
+import org.projectfloodlight.openflow.types.IPv4Address;
+import org.projectfloodlight.openflow.types.OFVlanVidMatch;
+import org.projectfloodlight.openflow.types.U32;
+import org.projectfloodlight.openflow.types.VlanPcp;
+import org.slf4j.Logger;
+
+import java.util.List;
+
+import static org.slf4j.LoggerFactory.getLogger;
+
+/*
+ * Builder for GroupBucketEntry.
+ */
+public class GroupBucketEntryBuilder {
+
+    private List<OFBucket> ofBuckets;
+    private OFGroupType type;
+
+    private final Logger log = getLogger(getClass());
+
+    /**
+     * Creates a builder.
+     *
+     * @param ofBuckets list of OFBucket
+     * @param type Group type
+     */
+    public GroupBucketEntryBuilder(List<OFBucket> ofBuckets, OFGroupType type) {
+        this.ofBuckets = ofBuckets;
+        this.type = type;
+    }
+
+    /**
+     * Builds a GroupBuckets.
+     *
+     * @return GroupBuckets object, a list of GroupBuck
+     */
+    public GroupBuckets build() {
+        List<GroupBucket> bucketList = Lists.newArrayList();
+
+        for (OFBucket bucket: ofBuckets) {
+            TrafficTreatment treatment = buildTreatment(bucket.getActions());
+            // TODO: Use GroupBucketEntry
+            GroupBucket groupBucket = null;
+            switch (type) {
+                case INDIRECT:
+                    groupBucket =
+                            DefaultGroupBucket.createIndirectGroupBucket(treatment);
+                    break;
+                case SELECT:
+                    groupBucket =
+                            DefaultGroupBucket.createSelectGroupBucket(treatment);
+                    break;
+                case FF:
+                    PortNumber port =
+                            PortNumber.portNumber(bucket.getWatchPort().getPortNumber());
+                    GroupId groupId =
+                            new DefaultGroupId(bucket.getWatchGroup().getGroupNumber());
+                    groupBucket =
+                            DefaultGroupBucket.createFailoverGroupBucket(treatment,
+                                    port, groupId);
+                    break;
+                default:
+                    log.error("Unsupported Group type : {}", type);
+            }
+            if (groupBucket != null) {
+                bucketList.add(groupBucket);
+            }
+        }
+        return new GroupBuckets(bucketList);
+    }
+
+
+    private TrafficTreatment buildTreatment(List<OFAction> actions) {
+        TrafficTreatment.Builder builder = DefaultTrafficTreatment.builder();
+        // If this is a drop rule
+        if (actions.size() == 0) {
+            builder.drop();
+            return builder.build();
+        }
+        for (OFAction act : actions) {
+            switch (act.getType()) {
+                case OUTPUT:
+                    OFActionOutput out = (OFActionOutput) act;
+                    builder.setOutput(
+                            PortNumber.portNumber(out.getPort().getPortNumber()));
+                    break;
+                case SET_VLAN_VID:
+                    OFActionSetVlanVid vlan = (OFActionSetVlanVid) act;
+                    builder.setVlanId(VlanId.vlanId(vlan.getVlanVid().getVlan()));
+                    break;
+                case SET_VLAN_PCP:
+                    OFActionSetVlanPcp pcp = (OFActionSetVlanPcp) act;
+                    builder.setVlanPcp(pcp.getVlanPcp().getValue());
+                    break;
+                case SET_DL_DST:
+                    OFActionSetDlDst dldst = (OFActionSetDlDst) act;
+                    builder.setEthDst(
+                            MacAddress.valueOf(dldst.getDlAddr().getLong()));
+                    break;
+                case SET_DL_SRC:
+                    OFActionSetDlSrc dlsrc = (OFActionSetDlSrc) act;
+                    builder.setEthSrc(
+                            MacAddress.valueOf(dlsrc.getDlAddr().getLong()));
+
+                    break;
+                case SET_NW_DST:
+                    OFActionSetNwDst nwdst = (OFActionSetNwDst) act;
+                    IPv4Address di = nwdst.getNwAddr();
+                    builder.setIpDst(Ip4Address.valueOf(di.getInt()));
+                    break;
+                case SET_NW_SRC:
+                    OFActionSetNwSrc nwsrc = (OFActionSetNwSrc) act;
+                    IPv4Address si = nwsrc.getNwAddr();
+                    builder.setIpSrc(Ip4Address.valueOf(si.getInt()));
+                    break;
+                case EXPERIMENTER:
+                    OFActionExperimenter exp = (OFActionExperimenter) act;
+                    if (exp.getExperimenter() == 0x80005A06 ||
+                            exp.getExperimenter() == 0x748771) {
+                        OFActionCircuit ct = (OFActionCircuit) exp;
+                        builder.setLambda(((OFOxmOchSigidBasic) ct.getField()).getValue().getChannelNumber());
+                    } else {
+                        log.warn("Unsupported OFActionExperimenter {}", exp.getExperimenter());
+                    }
+                    break;
+                case SET_FIELD:
+                    OFActionSetField setField = (OFActionSetField) act;
+                    handleSetField(builder, setField.getField());
+                    break;
+                case POP_MPLS:
+                    OFActionPopMpls popMpls = (OFActionPopMpls) act;
+                    builder.popMpls((short) popMpls.getEthertype().getValue());
+                    break;
+                case PUSH_MPLS:
+                    OFActionPushMpls pushMpls = (OFActionPushMpls) act;
+                    builder.pushMpls();
+                    break;
+                case COPY_TTL_IN:
+                    OFActionCopyTtlIn copyTtlIn = (OFActionCopyTtlIn) act;
+                    builder.copyTtlIn();
+                    break;
+                case COPY_TTL_OUT:
+                    OFActionCopyTtlOut copyTtlOut = (OFActionCopyTtlOut) act;
+                    builder.copyTtlOut();
+                    break;
+                case DEC_MPLS_TTL:
+                    OFActionDecMplsTtl decMplsTtl = (OFActionDecMplsTtl) act;
+                    builder.decMplsTtl();
+                    break;
+                case DEC_NW_TTL:
+                    OFActionDecNwTtl decNwTtl = (OFActionDecNwTtl) act;
+                    builder.decNwTtl();
+                    break;
+                case SET_TP_DST:
+                case SET_TP_SRC:
+                case POP_PBB:
+                case POP_VLAN:
+                case PUSH_PBB:
+                case PUSH_VLAN:
+                case SET_MPLS_LABEL:
+                case SET_MPLS_TC:
+                case SET_MPLS_TTL:
+                case SET_NW_ECN:
+                case SET_NW_TOS:
+                case SET_NW_TTL:
+                case SET_QUEUE:
+                case STRIP_VLAN:
+                case ENQUEUE:
+
+                case GROUP:
+                default:
+                    log.warn("Action type {} not yet implemented.", act.getType());
+            }
+        }
+
+        return builder.build();
+    }
+
+    private void handleSetField(TrafficTreatment.Builder builder, OFOxm<?> oxm) {
+        switch (oxm.getMatchField().id) {
+            case VLAN_PCP:
+                @SuppressWarnings("unchecked")
+                OFOxm<VlanPcp> vlanpcp = (OFOxm<VlanPcp>) oxm;
+                builder.setVlanPcp(vlanpcp.getValue().getValue());
+                break;
+            case VLAN_VID:
+                @SuppressWarnings("unchecked")
+                OFOxm<OFVlanVidMatch> vlanvid = (OFOxm<OFVlanVidMatch>) oxm;
+                builder.setVlanId(VlanId.vlanId(vlanvid.getValue().getVlan()));
+                break;
+            case ETH_DST:
+                @SuppressWarnings("unchecked")
+                OFOxm<org.projectfloodlight.openflow.types.MacAddress> ethdst =
+                        (OFOxm<org.projectfloodlight.openflow.types.MacAddress>) oxm;
+                builder.setEthDst(MacAddress.valueOf(ethdst.getValue().getLong()));
+                break;
+            case ETH_SRC:
+                @SuppressWarnings("unchecked")
+                OFOxm<org.projectfloodlight.openflow.types.MacAddress> ethsrc =
+                        (OFOxm<org.projectfloodlight.openflow.types.MacAddress>) oxm;
+                builder.setEthSrc(MacAddress.valueOf(ethsrc.getValue().getLong()));
+                break;
+            case IPV4_DST:
+                @SuppressWarnings("unchecked")
+                OFOxm<IPv4Address> ip4dst = (OFOxm<IPv4Address>) oxm;
+                builder.setIpDst(Ip4Address.valueOf(ip4dst.getValue().getInt()));
+                break;
+            case IPV4_SRC:
+                @SuppressWarnings("unchecked")
+                OFOxm<IPv4Address> ip4src = (OFOxm<IPv4Address>) oxm;
+                builder.setIpSrc(Ip4Address.valueOf(ip4src.getValue().getInt()));
+                break;
+            case MPLS_LABEL:
+                @SuppressWarnings("unchecked")
+                OFOxm<U32> labelId = (OFOxm<U32>) oxm;
+                builder.setMpls((int) labelId.getValue().getValue());
+                break;
+            case ARP_OP:
+            case ARP_SHA:
+            case ARP_SPA:
+            case ARP_THA:
+            case ARP_TPA:
+            case BSN_EGR_PORT_GROUP_ID:
+            case BSN_GLOBAL_VRF_ALLOWED:
+            case BSN_IN_PORTS_128:
+            case BSN_L3_DST_CLASS_ID:
+            case BSN_L3_INTERFACE_CLASS_ID:
+            case BSN_L3_SRC_CLASS_ID:
+            case BSN_LAG_ID:
+            case BSN_TCP_FLAGS:
+            case BSN_UDF0:
+            case BSN_UDF1:
+            case BSN_UDF2:
+            case BSN_UDF3:
+            case BSN_UDF4:
+            case BSN_UDF5:
+            case BSN_UDF6:
+            case BSN_UDF7:
+            case BSN_VLAN_XLATE_PORT_GROUP_ID:
+            case BSN_VRF:
+            case ETH_TYPE:
+            case ICMPV4_CODE:
+            case ICMPV4_TYPE:
+            case ICMPV6_CODE:
+            case ICMPV6_TYPE:
+            case IN_PHY_PORT:
+            case IN_PORT:
+            case IPV6_DST:
+            case IPV6_FLABEL:
+            case IPV6_ND_SLL:
+            case IPV6_ND_TARGET:
+            case IPV6_ND_TLL:
+            case IPV6_SRC:
+            case IP_DSCP:
+            case IP_ECN:
+            case IP_PROTO:
+            case METADATA:
+            case MPLS_TC:
+            case OCH_SIGID:
+            case OCH_SIGID_BASIC:
+            case OCH_SIGTYPE:
+            case OCH_SIGTYPE_BASIC:
+            case SCTP_DST:
+            case SCTP_SRC:
+            case TCP_DST:
+            case TCP_SRC:
+            case TUNNEL_ID:
+            case UDP_DST:
+            case UDP_SRC:
+            default:
+                log.warn("Set field type {} not yet implemented.", oxm.getMatchField().id);
+                break;
+        }
+    }
+}
diff --git a/providers/openflow/group/src/main/java/org/onosproject/provider/of/group/impl/GroupModBuilder.java b/providers/openflow/group/src/main/java/org/onosproject/provider/of/group/impl/GroupModBuilder.java
new file mode 100644
index 0000000..eac5f26
--- /dev/null
+++ b/providers/openflow/group/src/main/java/org/onosproject/provider/of/group/impl/GroupModBuilder.java
@@ -0,0 +1,333 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onosproject.provider.of.group.impl;
+
+import org.onlab.packet.Ip4Address;
+import org.onosproject.core.GroupId;
+import org.onosproject.net.PortNumber;
+import org.onosproject.net.flow.TrafficTreatment;
+import org.onosproject.net.flow.instructions.Instruction;
+import org.onosproject.net.flow.instructions.Instructions;
+import org.onosproject.net.flow.instructions.L0ModificationInstruction;
+import org.onosproject.net.flow.instructions.L2ModificationInstruction;
+import org.onosproject.net.flow.instructions.L3ModificationInstruction;
+import org.onosproject.net.group.GroupBucket;
+import org.onosproject.net.group.GroupBuckets;
+import org.onosproject.net.group.GroupDescription;
+import org.projectfloodlight.openflow.protocol.OFBucket;
+import org.projectfloodlight.openflow.protocol.OFFactory;
+import org.projectfloodlight.openflow.protocol.OFGroupAdd;
+import org.projectfloodlight.openflow.protocol.OFGroupDelete;
+import org.projectfloodlight.openflow.protocol.OFGroupMod;
+import org.projectfloodlight.openflow.protocol.OFGroupType;
+import org.projectfloodlight.openflow.protocol.action.OFAction;
+import org.projectfloodlight.openflow.protocol.action.OFActionOutput;
+import org.projectfloodlight.openflow.protocol.oxm.OFOxm;
+import org.projectfloodlight.openflow.types.CircuitSignalID;
+import org.projectfloodlight.openflow.types.EthType;
+import org.projectfloodlight.openflow.types.IPv4Address;
+import org.projectfloodlight.openflow.types.MacAddress;
+import org.projectfloodlight.openflow.types.OFGroup;
+import org.projectfloodlight.openflow.types.OFPort;
+import org.projectfloodlight.openflow.types.OFVlanVidMatch;
+import org.projectfloodlight.openflow.types.U32;
+import org.projectfloodlight.openflow.types.VlanPcp;
+import org.slf4j.Logger;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Optional;
+
+import static org.slf4j.LoggerFactory.getLogger;
+
+/*
+ * Builder for GroupMod.
+ */
+public final class GroupModBuilder {
+
+    private GroupBuckets buckets;
+    private GroupId groupId;
+    private GroupDescription.Type type;
+    private OFFactory factory;
+    private Long xid;
+
+    private final Logger log = getLogger(getClass());
+
+    private static final int OFPCML_NO_BUFFER = 0xffff;
+
+    private GroupModBuilder(GroupBuckets buckets, GroupId groupId,
+                             GroupDescription.Type type, OFFactory factory,
+                             Optional<Long> xid) {
+        this.buckets = buckets;
+        this.groupId = groupId;
+        this.type = type;
+        this.factory = factory;
+        this.xid = xid.orElse((long) 0);
+    }
+
+    /**
+     * Creates a builder for GroupMod.
+     *
+     * @param buckets GroupBuckets object
+     * @param groupId Group Id to create
+     * @param type Group type
+     * @param factory OFFactory object
+     * @param xid transaction ID
+     * @return GroupModBuilder object
+     */
+    public static GroupModBuilder builder(GroupBuckets buckets, GroupId groupId,
+                                          GroupDescription.Type type, OFFactory factory,
+                                          Optional<Long> xid) {
+
+        return new GroupModBuilder(buckets, groupId, type, factory, xid);
+    }
+
+    /**
+     * Builds the GroupAdd OF message.
+     *
+     * @return GroupAdd OF message
+     */
+    public OFGroupAdd buildGroupAdd() {
+
+        List<OFBucket> ofBuckets = new ArrayList<OFBucket>();
+        for (GroupBucket bucket: buckets.buckets()) {
+            List<OFAction> actions = buildActions(bucket.treatment());
+
+            OFBucket.Builder bucketBuilder = factory.buildBucket();
+            bucketBuilder.setActions(actions);
+            if (type == GroupDescription.Type.SELECT) {
+                bucketBuilder.setWeight(1);
+            }
+            bucketBuilder.setWatchGroup(OFGroup.ANY);
+            bucketBuilder.setWatchPort(OFPort.ANY);
+            OFBucket ofBucket = bucketBuilder.build();
+            ofBuckets.add(ofBucket);
+        }
+
+        OFGroupAdd groupMsg = factory.buildGroupAdd()
+                .setGroup(OFGroup.of(groupId.id()))
+                .setBuckets(ofBuckets)
+                .setGroupType(getOFGroupType(type))
+                .setXid(xid)
+                .build();
+
+        return groupMsg;
+    }
+
+    /**
+     * Builds the GroupMod OF message.
+     *
+     * @return GroupMod OF message
+     */
+    public OFGroupMod buildGroupMod() {
+        List<OFBucket> ofBuckets = new ArrayList<OFBucket>();
+        for (GroupBucket bucket: buckets.buckets()) {
+            List<OFAction> actions = buildActions(bucket.treatment());
+
+            OFBucket.Builder bucketBuilder = factory.buildBucket();
+            bucketBuilder.setActions(actions);
+            if (type == GroupDescription.Type.SELECT) {
+                bucketBuilder.setWeight(1);
+            }
+            bucketBuilder.setWatchGroup(OFGroup.ANY);
+            bucketBuilder.setWatchPort(OFPort.ANY);
+            OFBucket ofBucket = bucketBuilder.build();
+            ofBuckets.add(ofBucket);
+        }
+
+        OFGroupMod groupMsg = factory.buildGroupModify()
+                .setGroup(OFGroup.of(groupId.id()))
+                .setBuckets(ofBuckets)
+                .setGroupType(getOFGroupType(type))
+                .setXid(xid)
+                .build();
+
+        return groupMsg;
+    }
+
+    /**
+     * Builds the GroupDel OF message.
+     *
+     * @return GroupDel OF message
+     */
+    public OFGroupDelete buildGroupDel() {
+
+        OFGroupDelete groupMsg = factory.buildGroupDelete()
+                .setGroup(OFGroup.of(groupId.id()))
+                .setGroupType(OFGroupType.SELECT)
+                .setXid(xid)
+                .build();
+
+        return groupMsg;
+    }
+
+    private List<OFAction> buildActions(TrafficTreatment treatment) {
+        List<OFAction> actions = new LinkedList<>();
+        if (treatment == null) {
+            return actions;
+        }
+        for (Instruction i : treatment.instructions()) {
+            switch (i.type()) {
+                case DROP:
+                    log.warn("Saw drop action; assigning drop action");
+                    return new LinkedList<>();
+                case L0MODIFICATION:
+                    actions.add(buildL0Modification(i));
+                    break;
+                case L2MODIFICATION:
+                    actions.add(buildL2Modification(i));
+                    break;
+                case L3MODIFICATION:
+                    actions.add(buildL3Modification(i));
+                    break;
+                case OUTPUT:
+                    Instructions.OutputInstruction out =
+                            (Instructions.OutputInstruction) i;
+                    OFActionOutput.Builder action = factory.actions().buildOutput()
+                            .setPort(OFPort.of((int) out.port().toLong()));
+                    if (out.port().equals(PortNumber.CONTROLLER)) {
+                        action.setMaxLen(OFPCML_NO_BUFFER);
+                    }
+                    actions.add(action.build());
+                    break;
+                case GROUP:
+                default:
+                    log.warn("Instruction type {} not yet implemented.", i.type());
+            }
+        }
+
+        return actions;
+    }
+
+    private OFAction buildL0Modification(Instruction i) {
+        L0ModificationInstruction l0m = (L0ModificationInstruction) i;
+        switch (l0m.subtype()) {
+            case LAMBDA:
+                L0ModificationInstruction.ModLambdaInstruction ml =
+                        (L0ModificationInstruction.ModLambdaInstruction) i;
+                return factory.actions().circuit(factory.oxms().ochSigidBasic(
+                        new CircuitSignalID((byte) 1, (byte) 2, ml.lambda(), (short) 1)));
+            default:
+                log.warn("Unimplemented action type {}.", l0m.subtype());
+                break;
+        }
+        return null;
+    }
+
+    private OFAction buildL2Modification(Instruction i) {
+        L2ModificationInstruction l2m = (L2ModificationInstruction) i;
+        L2ModificationInstruction.ModEtherInstruction eth;
+        OFOxm<?> oxm = null;
+        switch (l2m.subtype()) {
+            case ETH_DST:
+                eth = (L2ModificationInstruction.ModEtherInstruction) l2m;
+                oxm = factory.oxms().ethDst(MacAddress.of(eth.mac().toLong()));
+                break;
+            case ETH_SRC:
+                eth = (L2ModificationInstruction.ModEtherInstruction) l2m;
+                oxm = factory.oxms().ethSrc(MacAddress.of(eth.mac().toLong()));
+                break;
+            case VLAN_ID:
+                L2ModificationInstruction.ModVlanIdInstruction vlanId =
+                        (L2ModificationInstruction.ModVlanIdInstruction) l2m;
+                oxm = factory.oxms().vlanVid(OFVlanVidMatch.ofVlan(vlanId.vlanId().toShort()));
+                break;
+            case VLAN_PCP:
+                L2ModificationInstruction.ModVlanPcpInstruction vlanPcp =
+                        (L2ModificationInstruction.ModVlanPcpInstruction) l2m;
+                oxm = factory.oxms().vlanPcp(VlanPcp.of(vlanPcp.vlanPcp()));
+                break;
+            case MPLS_PUSH:
+                L2ModificationInstruction.PushHeaderInstructions pushHeaderInstructions =
+                        (L2ModificationInstruction.PushHeaderInstructions) l2m;
+                return factory.actions().pushMpls(EthType.of(pushHeaderInstructions
+                        .ethernetType().getEtherType()));
+            case MPLS_POP:
+                L2ModificationInstruction.PushHeaderInstructions popHeaderInstructions =
+                        (L2ModificationInstruction.PushHeaderInstructions) l2m;
+                return factory.actions().popMpls(EthType.of(popHeaderInstructions
+                        .ethernetType().getEtherType()));
+            case MPLS_LABEL:
+                L2ModificationInstruction.ModMplsLabelInstruction mplsLabel =
+                        (L2ModificationInstruction.ModMplsLabelInstruction) l2m;
+                oxm = factory.oxms().mplsLabel(U32.of(mplsLabel.label()
+                        .longValue()));
+                break;
+            case DEC_MPLS_TTL:
+                return factory.actions().decMplsTtl();
+            default:
+                log.warn("Unimplemented action type {}.", l2m.subtype());
+                break;
+        }
+
+        if (oxm != null) {
+            return factory.actions().buildSetField().setField(oxm).build();
+        }
+        return null;
+    }
+
+    private OFAction buildL3Modification(Instruction i) {
+        L3ModificationInstruction l3m = (L3ModificationInstruction) i;
+        L3ModificationInstruction.ModIPInstruction ip;
+        Ip4Address ip4;
+        OFOxm<?> oxm = null;
+        switch (l3m.subtype()) {
+            case IP_DST:
+                ip = (L3ModificationInstruction.ModIPInstruction) i;
+                ip4 = ip.ip().getIp4Address();
+                oxm = factory.oxms().ipv4Dst(IPv4Address.of(ip4.toInt()));
+                break;
+            case IP_SRC:
+                ip = (L3ModificationInstruction.ModIPInstruction) i;
+                ip4 = ip.ip().getIp4Address();
+                oxm = factory.oxms().ipv4Src(IPv4Address.of(ip4.toInt()));
+                break;
+            case DEC_TTL:
+                return factory.actions().decNwTtl();
+            case TTL_IN:
+                return factory.actions().copyTtlIn();
+            case TTL_OUT:
+                return factory.actions().copyTtlOut();
+            default:
+                log.warn("Unimplemented action type {}.", l3m.subtype());
+                break;
+        }
+
+        if (oxm != null) {
+            return factory.actions().buildSetField().setField(oxm).build();
+        }
+        return null;
+    }
+
+    private OFGroupType getOFGroupType(GroupDescription.Type groupType) {
+        switch (groupType) {
+            case INDIRECT:
+                return OFGroupType.INDIRECT;
+            case SELECT:
+                return OFGroupType.SELECT;
+            case FAILOVER:
+                return OFGroupType.FF;
+            case ALL:
+                return OFGroupType.ALL;
+            default:
+                log.error("Unsupported group type : {}", groupType);
+                break;
+        }
+        return null;
+    }
+}
+
diff --git a/providers/openflow/group/src/main/java/org/onosproject/provider/of/group/impl/GroupStatsCollector.java b/providers/openflow/group/src/main/java/org/onosproject/provider/of/group/impl/GroupStatsCollector.java
new file mode 100644
index 0000000..90c700e
--- /dev/null
+++ b/providers/openflow/group/src/main/java/org/onosproject/provider/of/group/impl/GroupStatsCollector.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.provider.of.group.impl;
+
+import org.jboss.netty.util.HashedWheelTimer;
+import org.jboss.netty.util.Timeout;
+import org.jboss.netty.util.TimerTask;
+import org.onlab.util.Timer;
+import org.onosproject.openflow.controller.OpenFlowSwitch;
+import org.onosproject.openflow.controller.RoleState;
+import org.projectfloodlight.openflow.protocol.OFGroupDescStatsRequest;
+import org.projectfloodlight.openflow.protocol.OFGroupStatsRequest;
+import org.projectfloodlight.openflow.types.OFGroup;
+import org.slf4j.Logger;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+
+import static org.slf4j.LoggerFactory.getLogger;
+
+/*
+ * Sends Group Stats Request and collect the group statistics with a time interval.
+ */
+public class GroupStatsCollector implements TimerTask {
+
+    private final HashedWheelTimer timer = Timer.getTimer();
+    private final OpenFlowSwitch sw;
+    private final Logger log = getLogger(getClass());
+    private final int refreshInterval;
+
+    private Timeout timeout;
+    private final AtomicLong xidCounter = new AtomicLong(1);
+
+    private boolean stopTimer = false;
+
+    /**
+     * Creates a GroupStatsCollector object.
+     *
+     * @param sw Open Flow switch
+     * @param interval time interval for collecting group statistic
+     */
+    public GroupStatsCollector(OpenFlowSwitch sw, int interval) {
+        this.sw = sw;
+        this.refreshInterval = interval;
+    }
+
+    @Override
+    public void run(Timeout timeout) throws Exception {
+        log.trace("Collecting stats for {}", sw.getStringId());
+
+        sendGroupStatistic();
+
+        if (!this.stopTimer) {
+            log.trace("Scheduling stats collection in {} seconds for {}",
+                    this.refreshInterval, this.sw.getStringId());
+            timeout.getTimer().newTimeout(this, refreshInterval,
+                    TimeUnit.SECONDS);
+        }
+    }
+
+    private void sendGroupStatistic() {
+        if (log.isTraceEnabled()) {
+            log.trace("sendGroupStatistics {}:{}", sw.getStringId(), sw.getRole());
+        }
+        if (sw.getRole() != RoleState.MASTER) {
+            return;
+        }
+        Long statsXid = xidCounter.getAndAdd(2);
+        OFGroupStatsRequest statsRequest = sw.factory().buildGroupStatsRequest()
+                .setGroup(OFGroup.ALL)
+                .setXid(statsXid)
+                .build();
+        sw.sendMsg(statsRequest);
+
+        Long descXid = statsXid + 1;
+        OFGroupDescStatsRequest descStatsRequest =
+                sw.factory().buildGroupDescStatsRequest()
+                        .setXid(descXid)
+                        .build();
+        sw.sendMsg(descStatsRequest);
+    }
+
+    /**
+     * Starts the collector.
+     */
+    public void start() {
+        log.info("Staring Group Stats collection thread for {}", sw.getStringId());
+        timeout = timer.newTimeout(this, 1, TimeUnit.SECONDS);
+    }
+
+    /**
+     * Stops the collector.
+     */
+    public void stop() {
+        log.info("Stopping Group Stats collection thread for {}", sw.getStringId());
+        this.stopTimer = true;
+        timeout.cancel();
+    }
+}
diff --git a/providers/openflow/group/src/main/java/org/onosproject/provider/of/group/impl/OpenFlowGroupProvider.java b/providers/openflow/group/src/main/java/org/onosproject/provider/of/group/impl/OpenFlowGroupProvider.java
new file mode 100644
index 0000000..a477c39
--- /dev/null
+++ b/providers/openflow/group/src/main/java/org/onosproject/provider/of/group/impl/OpenFlowGroupProvider.java
@@ -0,0 +1,295 @@
+/*
+ * Copyright 2015 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onosproject.provider.of.group.impl;
+
+import com.google.common.collect.Maps;
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.felix.scr.annotations.ReferenceCardinality;
+import org.onosproject.core.DefaultGroupId;
+import org.onosproject.core.GroupId;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.group.DefaultGroup;
+import org.onosproject.net.group.Group;
+import org.onosproject.net.group.GroupBuckets;
+import org.onosproject.net.group.GroupDescription;
+import org.onosproject.net.group.GroupOperation;
+import org.onosproject.net.group.GroupOperations;
+import org.onosproject.net.group.GroupProvider;
+import org.onosproject.net.group.GroupProviderRegistry;
+import org.onosproject.net.group.GroupProviderService;
+import org.onosproject.net.provider.AbstractProvider;
+import org.onosproject.net.provider.ProviderId;
+import org.onosproject.openflow.controller.Dpid;
+import org.onosproject.openflow.controller.OpenFlowController;
+import org.onosproject.openflow.controller.OpenFlowEventListener;
+import org.onosproject.openflow.controller.OpenFlowSwitch;
+import org.onosproject.openflow.controller.OpenFlowSwitchListener;
+import org.onosproject.openflow.controller.RoleState;
+import org.projectfloodlight.openflow.protocol.OFErrorMsg;
+import org.projectfloodlight.openflow.protocol.OFErrorType;
+import org.projectfloodlight.openflow.protocol.OFGroupDescStatsEntry;
+import org.projectfloodlight.openflow.protocol.OFGroupDescStatsReply;
+import org.projectfloodlight.openflow.protocol.OFGroupMod;
+import org.projectfloodlight.openflow.protocol.OFGroupStatsEntry;
+import org.projectfloodlight.openflow.protocol.OFGroupStatsReply;
+import org.projectfloodlight.openflow.protocol.OFGroupType;
+import org.projectfloodlight.openflow.protocol.OFMessage;
+import org.projectfloodlight.openflow.protocol.OFPortStatus;
+import org.projectfloodlight.openflow.protocol.OFStatsReply;
+import org.projectfloodlight.openflow.protocol.OFStatsType;
+import org.slf4j.Logger;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicLong;
+
+import static org.slf4j.LoggerFactory.getLogger;
+
+/**
+ * Provider which uses an OpenFlow controller to handle Group.
+ */
+@Component(immediate = true)
+public class OpenFlowGroupProvider extends AbstractProvider implements GroupProvider {
+
+    private final Logger log = getLogger(getClass());
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected OpenFlowController controller;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected GroupProviderRegistry providerRegistry;
+
+    private GroupProviderService providerService;
+
+    static final int POLL_INTERVAL = 10;
+
+    private final InternalGroupProvider listener = new InternalGroupProvider();
+
+    private final AtomicLong xidCounter = new AtomicLong(1);
+    private final Map<Dpid, GroupStatsCollector> collectors = Maps.newHashMap();
+    private final Map<Long, OFStatsReply> groupStats = Maps.newHashMap();
+    private final Map<Long, GroupOperation> pendingGroupOperations =
+            Maps.newConcurrentMap();
+
+    /**
+     * Creates a OpenFlow group provider.
+     */
+    public OpenFlowGroupProvider() {
+        super(new ProviderId("of", "org.onosproject.provider.group"));
+    }
+
+    @Activate
+    public void activate() {
+        providerService = providerRegistry.register(this);
+        controller.addListener(listener);
+        controller.addEventListener(listener);
+
+        for (OpenFlowSwitch sw : controller.getSwitches()) {
+            GroupStatsCollector gsc = new GroupStatsCollector(sw, POLL_INTERVAL);
+            gsc.start();
+            collectors.put(new Dpid(sw.getId()), gsc);
+        }
+
+        log.info("Started");
+    }
+
+    @Deactivate
+    public void deactivate() {
+        providerRegistry.unregister(this);
+        providerService = null;
+
+        log.info("Stopped");
+    }
+
+    @Override
+    public void performGroupOperation(DeviceId deviceId, GroupOperations groupOps) {
+        Map<OFGroupMod, OpenFlowSwitch> mods = Maps.newIdentityHashMap();
+        final Dpid dpid = Dpid.dpid(deviceId.uri());
+        OpenFlowSwitch sw = controller.getSwitch(dpid);
+        for (GroupOperation groupOperation: groupOps.operations()) {
+            if (sw == null) {
+                log.error("SW {} is not found", sw.getStringId());
+                return;
+            }
+            final Long groupModXid = xidCounter.getAndIncrement();
+            GroupModBuilder builder =
+                    GroupModBuilder.builder(groupOperation.buckets(),
+                            groupOperation.groupId(),
+                            groupOperation.groupType(),
+                            sw.factory(),
+                            Optional.of(groupModXid));
+            OFGroupMod groupMod = null;
+            switch (groupOperation.opType()) {
+                case ADD:
+                    groupMod = builder.buildGroupAdd();
+                    break;
+                case MODIFY:
+                    groupMod = builder.buildGroupMod();
+                    break;
+                case DELETE:
+                    groupMod = builder.buildGroupDel();
+                    break;
+                default:
+                    log.error("Unsupported Group operation");
+            }
+            sw.sendMsg(groupMod);
+            pendingGroupOperations.put(groupModXid, groupOperation);
+        }
+     }
+
+    private void pushGroupMetrics(Dpid dpid, OFStatsReply statsReply) {
+        DeviceId deviceId = DeviceId.deviceId(Dpid.uri(dpid));
+
+        OFGroupStatsReply groupStatsReply = null;
+        OFGroupDescStatsReply groupDescStatsReply = null;
+
+        if (statsReply.getStatsType() == OFStatsType.GROUP) {
+            OFStatsReply reply = groupStats.get(statsReply.getXid() + 1);
+            if (reply != null) {
+                groupStatsReply = (OFGroupStatsReply) statsReply;
+                groupDescStatsReply = (OFGroupDescStatsReply) reply;
+                groupStats.remove(statsReply.getXid() + 1);
+            } else {
+                groupStats.put(statsReply.getXid(), statsReply);
+            }
+        } else if (statsReply.getStatsType() == OFStatsType.GROUP_DESC) {
+            OFStatsReply reply = groupStats.get(statsReply.getXid() - 1);
+            if (reply != null) {
+                groupStatsReply = (OFGroupStatsReply) reply;
+                groupDescStatsReply = (OFGroupDescStatsReply) statsReply;
+                groupStats.remove(statsReply.getXid() - 1);
+            } else {
+                groupStats.put(statsReply.getXid(), statsReply);
+            }
+        }
+
+        if (groupStatsReply != null && groupDescStatsReply != null) {
+            Collection<Group> groups = buildGroupMetrics(deviceId,
+                    groupStatsReply, groupDescStatsReply);
+            providerService.pushGroupMetrics(deviceId, groups);
+            for (Group group: groups) {
+                pendingGroupOperations.remove(group.id());
+            }
+        }
+    }
+
+    private Collection<Group> buildGroupMetrics(DeviceId deviceId,
+                                   OFGroupStatsReply groupStatsReply,
+                                   OFGroupDescStatsReply groupDescStatsReply) {
+
+        Map<Integer, Group> groups = Maps.newHashMap();
+
+        for (OFGroupDescStatsEntry entry: groupDescStatsReply.getEntries()) {
+            int id = entry.getGroup().getGroupNumber();
+            GroupId groupId = new DefaultGroupId(id);
+            GroupDescription.Type type = getGroupType(entry.getGroupType());
+            GroupBuckets buckets = new GroupBucketEntryBuilder(entry.getBuckets(),
+                    entry.getGroupType()).build();
+            DefaultGroup group = new DefaultGroup(groupId, deviceId, type, buckets);
+            groups.put(id, group);
+        }
+
+        for (OFGroupStatsEntry entry: groupStatsReply.getEntries()) {
+            int groupId = entry.getGroup().getGroupNumber();
+            DefaultGroup group = (DefaultGroup) groups.get(groupId);
+            if (group != null) {
+                group.setBytes(entry.getByteCount().getValue());
+                group.setLife(entry.getDurationSec());
+                group.setPackets(entry.getPacketCount().getValue());
+                group.setReferenceCount(entry.getRefCount());
+            }
+        }
+
+        return groups.values();
+    }
+
+    private GroupDescription.Type getGroupType(OFGroupType type) {
+        switch (type) {
+            case ALL:
+                return  GroupDescription.Type.ALL;
+            case INDIRECT:
+                return GroupDescription.Type.INDIRECT;
+            case SELECT:
+                return GroupDescription.Type.SELECT;
+            case FF:
+                return GroupDescription.Type.FAILOVER;
+            default:
+                log.error("Unsupported OF group type : {}", type);
+                break;
+        }
+        return null;
+    }
+
+    private class InternalGroupProvider
+            implements OpenFlowSwitchListener, OpenFlowEventListener {
+
+        @Override
+        public void handleMessage(Dpid dpid, OFMessage msg) {
+            switch (msg.getType()) {
+                case STATS_REPLY:
+                    pushGroupMetrics(dpid, (OFStatsReply) msg);
+                    break;
+                case ERROR:
+                    OFErrorMsg errorMsg = (OFErrorMsg) msg;
+                    if (errorMsg.getErrType() == OFErrorType.GROUP_MOD_FAILED) {
+                        GroupOperation operation =
+                                pendingGroupOperations.get(errorMsg.getXid());
+                        if (operation != null) {
+                            providerService.groupOperationFailed(operation);
+                            log.warn("received Error message {} from {}", msg, dpid);
+                        }
+                        break;
+                    }
+                default:
+                    log.debug("Unhandled message type: {}", msg.getType());
+            }
+        }
+
+        @Override
+        public void switchAdded(Dpid dpid) {
+            GroupStatsCollector gsc = new GroupStatsCollector(
+                    controller.getSwitch(dpid), POLL_INTERVAL);
+            gsc.start();
+            collectors.put(dpid, gsc);
+        }
+
+        @Override
+        public void switchRemoved(Dpid dpid) {
+            GroupStatsCollector collector = collectors.remove(dpid);
+            if (collector != null) {
+                collector.stop();
+            }
+        }
+
+        @Override
+        public void switchChanged(Dpid dpid) {
+        }
+
+        @Override
+        public void portChanged(Dpid dpid, OFPortStatus status) {
+        }
+
+        @Override
+        public void receivedRoleReply(Dpid dpid, RoleState requested, RoleState response) {
+        }
+    }
+
+}
diff --git a/providers/openflow/pom.xml b/providers/openflow/pom.xml
index 48ce6fe..4a733fd 100644
--- a/providers/openflow/pom.xml
+++ b/providers/openflow/pom.xml
@@ -37,6 +37,7 @@
         <module>host</module>
         <module>packet</module>
         <module>flow</module>
+        <module>group</module>
     </modules>
 
     <dependencies>