diff --git a/RELEASE-NOTES b/RELEASE-NOTES
index 45cc825f..0f839a7c 100644
--- a/RELEASE-NOTES
+++ b/RELEASE-NOTES
@@ -1,3 +1,8 @@
+DATE:   2015-08-09
+CHANGE: Rename product_* config options to release_* for consistency with productmd.
+ACTION: Rename product_name, product_short, product_version, product_is_layered to release_* in config files.
+        Rename //variant/product to //variant/release in variants XML.
+
 DATE:   2015-08-09
 CHANGE: pkgset_koji_url and pkgset_koji_path_prefix config options replaced with koji_profile.
 ACTION: Add 'koji_profile = "<profile_name>"' (use "koji" for Fedora) to config files.
diff --git a/bin/pungi-koji b/bin/pungi-koji
index cc1426e7..fca349e8 100755
--- a/bin/pungi-koji
+++ b/bin/pungi-koji
@@ -302,8 +302,8 @@ def run_compose(compose):
 
     # create a latest symlink
     compose_dir = os.path.basename(compose.topdir)
-    symlink_name = "latest-%s-%s" % (compose.conf["product_short"], ".".join(compose.conf["product_version"].split(".")[:-1]))
-    if compose.conf["product_is_layered"]:
+    symlink_name = "latest-%s-%s" % (compose.conf["release_short"], ".".join(compose.conf["release_version"].split(".")[:-1]))
+    if compose.conf["release_is_layered"]:
         symlink_name += "-%s-%s" % (compose.conf["base_product_short"], compose.conf["base_product_version"])
     symlink = os.path.join(compose.topdir, "..", symlink_name)
 
diff --git a/pungi/compose.py b/pungi/compose.py
index c0d7951f..bb6b77ab 100644
--- a/pungi/compose.py
+++ b/pungi/compose.py
@@ -42,14 +42,11 @@ def get_compose_dir(topdir, conf, compose_type="production", compose_date=None,
 
     # create an incomplete composeinfo to generate compose ID
     ci = ComposeInfo()
-    ci.compose.name = conf["product_name"]
-    ci.release.name = conf["product_name"]
-    ci.compose.short = conf["product_short"]
-    ci.release.short = conf["product_short"]
-    ci.compose.version = conf["product_version"]
-    ci.release.version = conf["product_version"]
-    ci.compose.is_layered = bool(conf.get("product_is_layered", False))
-    if ci.compose.is_layered:
+    ci.release.name = conf["release_name"]
+    ci.release.short = conf["release_short"]
+    ci.release.version = conf["release_version"]
+    ci.release.is_layered = bool(conf.get("release_is_layered", False))
+    if ci.release.is_layered:
         ci.base_product.name = conf["base_product_name"]
         ci.base_product.short = conf["base_product_short"]
         ci.base_product.version = conf["base_product_version"]
diff --git a/pungi/metadata.py b/pungi/metadata.py
index f6043515..e2891801 100644
--- a/pungi/metadata.py
+++ b/pungi/metadata.py
@@ -28,14 +28,14 @@ from pungi.compose_metadata.discinfo import write_media_repo as create_media_rep
 
 
 def get_description(compose, variant, arch):
-    if "product_discinfo_description" in compose.conf:
-        result = compose.conf["product_discinfo_description"]
+    if "release_discinfo_description" in compose.conf:
+        result = compose.conf["release_discinfo_description"]
     elif variant.type == "layered-product":
         # we need to make sure the layered product behaves as it was composed separately
-        result = "%s %s for %s %s" % (variant.product_name, variant.product_version, compose.conf["product_name"], get_major_version(compose.conf["product_version"]))
+        result = "%s %s for %s %s" % (variant.release_name, variant.release_version, compose.conf["release_name"], get_major_version(compose.conf["release_version"]))
     else:
-        result = "%s %s" % (compose.conf["product_name"], compose.conf["product_version"])
-        if compose.conf.get("product_is_layered", False):
+        result = "%s %s" % (compose.conf["release_name"], compose.conf["release_version"])
+        if compose.conf.get("release_is_layered", False):
             result += "for %s %s" % (compose.conf["base_product_name"], compose.conf["base_product_version"])
 
     result = result % {"variant_name": variant.name, "arch": arch}
@@ -73,10 +73,10 @@ def compose_to_composeinfo(compose):
     ci.compose.label = compose.compose_label
 
     # product
-    ci.release.name = compose.conf["product_name"]
-    ci.release.version = compose.conf["product_version"]
-    ci.release.short = compose.conf["product_short"]
-    ci.release.is_layered = compose.conf.get("product_is_layered", False)
+    ci.release.name = compose.conf["release_name"]
+    ci.release.version = compose.conf["release_version"]
+    ci.release.short = compose.conf["release_short"]
+    ci.release.is_layered = compose.conf.get("release_is_layered", False)
 
     # base product
     if ci.release.is_layered:
@@ -99,9 +99,9 @@ def compose_to_composeinfo(compose):
         var.arches = set(variant.arches)
 
         if var.type == "layered-product":
-            var.release.name = variant.product_name
-            var.release.short = variant.product_short
-            var.release.version = variant.product_version
+            var.release.name = variant.release_name
+            var.release.short = variant.release_short
+            var.release.version = variant.release_version
             var.release.is_layered = True
 
         for arch in variant.arches:
@@ -184,27 +184,27 @@ def write_tree_info(compose, arch, variant, timestamp=None):
     if variant.type == "layered-product":
         # we need to make sure the layered product behaves as it was composed separately
 
-        # product
+        # release
         # TODO: read from variants.xml
-        ti.release.name = variant.product_name
-        ti.release.version = variant.product_version
-        ti.release.short = variant.product_short
+        ti.release.name = variant.release_name
+        ti.release.version = variant.release_version
+        ti.release.short = variant.release_short
         ti.release.is_layered = True
 
         # base product
-        ti.base_product.name = compose.conf["product_name"]
-        if "." in compose.conf["product_version"]:
+        ti.base_product.name = compose.conf["release_name"]
+        if "." in compose.conf["release_version"]:
             # remove minor version if present
-            ti.base_product.version = get_major_version(compose.conf["product_version"])
+            ti.base_product.version = get_major_version(compose.conf["release_version"])
         else:
-            ti.base_product.version = compose.conf["product_version"]
-        ti.base_product.short = compose.conf["product_short"]
+            ti.base_product.version = compose.conf["release_version"]
+        ti.base_product.short = compose.conf["release_short"]
     else:
-        # product
-        ti.release.name = compose.conf["product_name"]
-        ti.release.version = compose.conf["product_version"]
-        ti.release.short = compose.conf["product_short"]
-        ti.release.is_layered = compose.conf.get("product_is_layered", False)
+        # release
+        ti.release.name = compose.conf["release_name"]
+        ti.release.version = compose.conf["release_version"]
+        ti.release.short = compose.conf["release_short"]
+        ti.release.is_layered = compose.conf.get("release_is_layered", False)
 
         # base product
         if ti.release.is_layered:
@@ -257,7 +257,7 @@ def write_tree_info(compose, arch, variant, timestamp=None):
         def _check_short(self):
             # HACK: set self.short so .treeinfo produced by lorax can be read
             if not self.short:
-                self.short = compose.conf["product_short"]
+                self.short = compose.conf["release_short"]
 
     class LoraxTreeInfo(productmd.treeinfo.TreeInfo):
         def clear(self):
diff --git a/pungi/phases/buildinstall.py b/pungi/phases/buildinstall.py
index 5dbeaee3..d7c79ad2 100644
--- a/pungi/phases/buildinstall.py
+++ b/pungi/phases/buildinstall.py
@@ -80,9 +80,9 @@ class BuildinstallPhase(PhaseBase):
 
     def run(self):
         lorax = LoraxWrapper()
-        product = self.compose.conf["product_name"]
-        version = self.compose.conf["product_version"]
-        release = self.compose.conf["product_version"]
+        product = self.compose.conf["release_name"]
+        version = self.compose.conf["release_version"]
+        release = self.compose.conf["release_version"]
         noupgrade = not self.compose.conf.get("buildinstall_upgrade_image", False)
         buildinstall_method = self.compose.conf["buildinstall_method"]
 
diff --git a/pungi/phases/gather/__init__.py b/pungi/phases/gather/__init__.py
index 5677ec46..e14d0de1 100644
--- a/pungi/phases/gather/__init__.py
+++ b/pungi/phases/gather/__init__.py
@@ -105,7 +105,7 @@ class GatherPhase(PhaseBase):
 
     def check_config(self):
         errors = []
-        for i in ["product_name", "product_short", "product_version"]:
+        for i in ["release_name", "release_short", "release_version"]:
             errors.append(self.conf_assert_str(i))
 
     def run(self):
diff --git a/pungi/phases/init.py b/pungi/phases/init.py
index 16b20ce1..b9ea0d55 100644
--- a/pungi/phases/init.py
+++ b/pungi/phases/init.py
@@ -35,25 +35,25 @@ class InitPhase(PhaseBase):
     config_options = (
         # PRODUCT INFO
         {
-            "name": "product_name",
+            "name": "release_name",
             "expected_types": [str],
         },
         {
-            "name": "product_short",
+            "name": "release_short",
             "expected_types": [str],
         },
         {
-            "name": "product_version",
+            "name": "release_version",
             "expected_types": [str],
         },
         {
             # override description in .discinfo; accepts %(variant_name)s and %(arch)s variables
-            "name": "product_discinfo_description",
+            "name": "release_discinfo_description",
             "expected_types": [str],
             "optional": True,
         },
         {
-            "name": "product_is_layered",
+            "name": "release_is_layered",
             "expected_types": [bool],
             "requires": (
                 (lambda x: bool(x), ["base_product_name", "base_product_short", "base_product_version"]),
diff --git a/pungi/phases/pkgset/common.py b/pungi/phases/pkgset/common.py
index 975c8c86..7ca3fb01 100644
--- a/pungi/phases/pkgset/common.py
+++ b/pungi/phases/pkgset/common.py
@@ -55,7 +55,7 @@ def create_global_repo(compose, path_prefix):
     old_compose_path = None
     update_md_path = None
     if compose.old_composes:
-        old_compose_path = find_old_compose(compose.old_composes, compose.conf["product_short"], compose.conf["product_version"], compose.conf.get("base_product_short", None), compose.conf.get("base_product_version", None))
+        old_compose_path = find_old_compose(compose.old_composes, compose.conf["release_short"], compose.conf["release_version"], compose.conf.get("base_product_short", None), compose.conf.get("base_product_version", None))
         if old_compose_path is None:
             compose.log_info("No suitable old compose found in: %s" % compose.old_composes)
         else:
@@ -93,7 +93,7 @@ def create_arch_repos(compose, arch, path_prefix):
     compose.log_info("[DONE ] %s" % msg)
 
 
-def find_old_compose(old_compose_dirs, product_short, product_version, base_product_short=None, base_product_version=None):
+def find_old_compose(old_compose_dirs, release_short, release_version, base_product_short=None, base_product_version=None):
     composes = []
 
     for compose_dir in force_list(old_compose_dirs):
@@ -104,7 +104,7 @@ def find_old_compose(old_compose_dirs, product_short, product_version, base_prod
         for i in os.listdir(compose_dir):
             # TODO: read .composeinfo
 
-            pattern = "%s-%s" % (product_short, product_version)
+            pattern = "%s-%s" % (release_short, release_version)
             if base_product_short:
                 pattern += "-%s" % base_product_short
             if base_product_version:
diff --git a/pungi/phases/test.py b/pungi/phases/test.py
index f8a2eee9..d55fedee 100644
--- a/pungi/phases/test.py
+++ b/pungi/phases/test.py
@@ -60,7 +60,7 @@ def run_repoclosure(compose):
             repo_dir = compose.paths.compose.repository(arch=arch, variant=variant)
             repos[repo_id] = repo_dir
 
-            if compose.conf.get("product_is_layered", False):
+            if compose.conf.get("release_is_layered", False):
                 for i, lookaside_url in enumerate(get_lookaside_repos(compose, arch, variant)):
                     lookaside["lookaside-%s.%s-%s" % (variant.uid, arch, i)] = lookaside_url
 
diff --git a/pungi/util.py b/pungi/util.py
index 7271898f..54f43e16 100644
--- a/pungi/util.py
+++ b/pungi/util.py
@@ -262,31 +262,31 @@ def get_volid(compose, arch, variant=None, escape_spaces=False):
         return None
 
     if variant and variant.type == "layered-product":
-        product_short = variant.product_short
-        product_version = variant.product_version
-        product_is_layered = True
-        base_product_short = compose.conf["product_short"]
-        base_product_version = get_major_version(compose.conf["product_version"])
+        release_short = variant.release_short
+        release_version = variant.release_version
+        release_is_layered = True
+        base_product_short = compose.conf["release_short"]
+        base_product_version = get_major_version(compose.conf["release_version"])
         variant_uid = variant.parent.uid
     else:
-        product_short = compose.conf["product_short"]
-        product_version = compose.conf["product_version"]
-        product_is_layered = compose.conf["product_is_layered"]
+        release_short = compose.conf["release_short"]
+        release_version = compose.conf["release_version"]
+        release_is_layered = compose.conf["release_is_layered"]
         base_product_short = compose.conf.get("base_product_short", "")
         base_product_version = compose.conf.get("base_product_version", "")
         variant_uid = variant and variant.uid or None
 
     products = [
-        "%(product_short)s-%(product_version)s %(variant_uid)s.%(arch)s",
-        "%(product_short)s-%(product_version)s %(arch)s",
+        "%(release_short)s-%(release_version)s %(variant_uid)s.%(arch)s",
+        "%(release_short)s-%(release_version)s %(arch)s",
     ]
     layered_products = [
-        "%(product_short)s-%(product_version)s %(base_product_short)s-%(base_product_version)s %(variant_uid)s.%(arch)s",
-        "%(product_short)s-%(product_version)s %(base_product_short)s-%(base_product_version)s %(arch)s",
+        "%(release_short)s-%(release_version)s %(base_product_short)s-%(base_product_version)s %(variant_uid)s.%(arch)s",
+        "%(release_short)s-%(release_version)s %(base_product_short)s-%(base_product_version)s %(arch)s",
     ]
 
     volid = None
-    if product_is_layered:
+    if release_is_layered:
         all_products = layered_products + products
     else:
         all_products = products
diff --git a/pungi/wrappers/variants.py b/pungi/wrappers/variants.py
index ff18bcc3..646ec39c 100755
--- a/pungi/wrappers/variants.py
+++ b/pungi/wrappers/variants.py
@@ -109,10 +109,10 @@ class VariantsXmlParser(object):
 
         variant = Variant(**variant_dict)
         if variant.type == "layered-product":
-            product_node = variant_node.xpath("product")[0]
-            variant.product_name = str(product_node.attrib["name"])
-            variant.product_version = str(product_node.attrib["version"])
-            variant.product_short = str(product_node.attrib["short"])
+            release_node = variant_node.xpath("release")[0]
+            variant.release_name = str(release_node.attrib["name"])
+            variant.release_version = str(release_node.attrib["version"])
+            variant.release_short = str(release_node.attrib["short"])
 
         contains_optional = False
         for child_node in variant_node.xpath("variants/variant"):
diff --git a/share/variants.dtd b/share/variants.dtd
index 40236ffc..718510d1 100644
--- a/share/variants.dtd
+++ b/share/variants.dtd
@@ -1,6 +1,6 @@
 <!ELEMENT variants (ref*,variant*)>
 
-<!ELEMENT variant (product?,arches,groups,environments*,variants*)?>
+<!ELEMENT variant (release?,arches,groups,environments*,variants*)?>
 <!ATTLIST variant
     id ID #REQUIRED
     name CDATA #REQUIRED
@@ -8,8 +8,8 @@
     has_optional (true|false) #IMPLIED
 >
 
-<!ELEMENT product (#PCDATA)>
-<!ATTLIST product
+<!ELEMENT release (#PCDATA)>
+<!ATTLIST release
     name CDATA #IMPLIED
     short CDATA #IMPLIED
     version CDATA #IMPLIED
diff --git a/tests/data/dummy-pungi.conf b/tests/data/dummy-pungi.conf
index 53572e45..018ad01c 100644
--- a/tests/data/dummy-pungi.conf
+++ b/tests/data/dummy-pungi.conf
@@ -1,40 +1,23 @@
-# PRODUCT (RELEASE) INFO
-product_name = "Dummy Product"
-product_short = "DP"
-product_version = "1.0"
-product_is_layered = False
-product_type = "ga"
+# RELEASE
+release_name = "Dummy Product"
+release_short = "DP"
+release_version = "1.0"
+release_is_layered = False
+release_type = "ga"
 
 
 # GENERAL SETTINGS
-bootable = False
 comps_file = "dummy-comps.xml"
 variants_file = "dummy-variants.xml"
-sigkeys = [None] # None = unsigned
-
-# limit tree architectures
-# if undefined, all architectures from variants.xml will be included
-atree_arches = ["x86_64"]
-
-# limit tree variants
-# if undefined, all variants from variants.xml will be included
-#tree_variants = ["Server"]
-
-multilib_arches = ["ppc64", "x86_64", "s390x"]
-multilib_methods = ["devel", "runtime"] # devel (recommended), all, base, file, kernel, none, runtime
 
 
-# RUNROOT settings
+# KOJI SETTINGS
 runroot = False
-#runroot_channel = ""
-#runroot_tag = ""
 
 
 # PKGSET
-pkgset_source = "repos" # koji, repos
-
-# PKGSET - REPOS
-# pkgset_repos format: {arch: [repo1_url, repo2_url, ...]}
+sigkeys = [None]
+pkgset_source = "repos"
 pkgset_repos = {
     "i386": [
         "repo",
@@ -47,45 +30,23 @@ pkgset_repos = {
     ],
 }
 
-# PKGSET - KOJI
-#pkgset_koji_path_prefix = "/mnt/koji"
-#pkgset_koji_url = ""
-#pkgset_koji_tag = ""
-
-
-# GATHER
-gather_source = "comps"
-gather_method = "deps"
-check_deps = False
-greedy_method = "build"
-
-# fomat: [(variant_uid_regex, {arch|*: [repos]})]
-# gather_lookaside_repos = []
-
-# GATHER - JSON
-# format: {variant_uid: {arch: package: [arch1, arch2, None (for any arch)]}}
-#gather_source_mapping = "/path/to/mapping.json"
-
 
 # CREATEREPO
 createrepo_checksum = "sha256"
 
 
-# BUILDINSTALL
+# GATHER
+gather_source = "comps"
+gather_method = "deps"
+greedy_method = "build"
+check_deps = False
 
+multilib_arches = ["ppc64", "x86_64", "s390x"]
+multilib_methods = ["devel", "runtime"]
 
-# PRODUCTIMG
-
-
-# CREATEISO
-symlink_isos_to = None
-
-
-# fomat: [(variant_uid_regex, {arch|*: [packages]})]
 additional_packages = [
     ('^Server$', {
         '*': [
-#            'dummy-lvm2-devel',
              'dummy-libtool',
         ],
     }),
@@ -119,14 +80,10 @@ filter_packages = [
     }),
 ]
 
-
-# format: {arch|*: [packages]}
 multilib_blacklist = {
     "*": [
         "kernel-devel",
         "httpd-devel",
-        "*",
-#        "dummy-glibc",
     ],
 }
 
@@ -135,3 +92,7 @@ multilib_whitelist = {
         "dummy-glibc",
     ],
 }
+
+
+# BUILDINSTALL
+bootable = False
diff --git a/tests/data/dummy-variants.xml b/tests/data/dummy-variants.xml
index 49974038..871ced2a 100644
--- a/tests/data/dummy-variants.xml
+++ b/tests/data/dummy-variants.xml
@@ -12,7 +12,7 @@
   </variant>
 
   <variant id="Gluster" name="Gluster Layered Product" type="layered-product">
-    <product name="Gluster" version="2.3" short="Gluster" />
+    <release name="Gluster" version="2.3" short="Gluster" />
     <arches>
       <arch>x86_64</arch>
     </arches>