diff --git a/app-admin/eselect-ctags/metadata.xml b/app-admin/eselect-ctags/metadata.xml
new file mode 100644
index 0000000..bc306fe
--- /dev/null
+++ b/app-admin/eselect-ctags/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>emacs</herd>
+</pkgmetadata>
diff --git a/app-admin/eselect-emacs/metadata.xml b/app-admin/eselect-emacs/metadata.xml
new file mode 100644
index 0000000..bc306fe
--- /dev/null
+++ b/app-admin/eselect-emacs/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>emacs</herd>
+</pkgmetadata>
diff --git a/app-admin/eselect-fontconfig/metadata.xml b/app-admin/eselect-fontconfig/metadata.xml
new file mode 100644
index 0000000..64cc0b6
--- /dev/null
+++ b/app-admin/eselect-fontconfig/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>fonts</herd>
+</pkgmetadata>
diff --git a/app-admin/eselect-opencl/metadata.xml b/app-admin/eselect-opencl/metadata.xml
new file mode 100644
index 0000000..0d69e85
--- /dev/null
+++ b/app-admin/eselect-opencl/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>xarthisius@gentoo.org</email>
+		<name>Kacper Kowalik</name>
+	</maintainer>
+	<longdescription>
+		Utility to switch OpenCL implementations between various providers.
+	</longdescription>
+</pkgmetadata>
diff --git a/app-admin/eselect-opengl/metadata.xml b/app-admin/eselect-opengl/metadata.xml
new file mode 100644
index 0000000..6b9cda0
--- /dev/null
+++ b/app-admin/eselect-opengl/metadata.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+<longdescription>Utility to switch opengl implementations between various providers.</longdescription>
+</pkgmetadata>
diff --git a/app-admin/eselect-ruby/metadata.xml b/app-admin/eselect-ruby/metadata.xml
new file mode 100644
index 0000000..8521361
--- /dev/null
+++ b/app-admin/eselect-ruby/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>ruby</herd>
+</pkgmetadata>
diff --git a/app-admin/eselect-vi/metadata.xml b/app-admin/eselect-vi/metadata.xml
new file mode 100644
index 0000000..c7b901f
--- /dev/null
+++ b/app-admin/eselect-vi/metadata.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>vim</herd>
+</pkgmetadata>
+
diff --git a/app-admin/eselect/metadata.xml b/app-admin/eselect/metadata.xml
new file mode 100644
index 0000000..4c9cb19
--- /dev/null
+++ b/app-admin/eselect/metadata.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+  <email>eselect@gentoo.org</email>
+</maintainer>
+</pkgmetadata>
diff --git a/app-admin/metadata.xml b/app-admin/metadata.xml
new file mode 100644
index 0000000..b15417f
--- /dev/null
+++ b/app-admin/metadata.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The app-admin category contains non-core applications which relate to
+		system administration.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría app-admin contiene aplicaciones para la administración
+		del sistema.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie app-admin enthält Applikationen zur Systemadministration,
+		die nicht Bestandteil des Basissystems sind.
+	</longdescription>
+	<longdescription lang="ja">
+		app-adminカテゴリにはnon-corシステム管理に関連したアプリケーションが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De app-admin categorie bevat applicaties met betrekking tot systeem
+		administratie.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm app-admin category chứa các ứng dụng liên quan
+		đến quản trị hệ thống (không tính các ứng dụng lõi).
+	</longdescription>
+	<longdescription lang="it">
+		La categoria app-admin contiene applicazioni per l'amministrazione del sistema.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria app-admin contém aplicações para a administração
+		do sistema.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria app-admin zawiera aplikacje dla administratorów systemu.
+	</longdescription>
+</catmetadata>
+
diff --git a/app-admin/python-updater/metadata.xml b/app-admin/python-updater/metadata.xml
new file mode 100644
index 0000000..de483c5
--- /dev/null
+++ b/app-admin/python-updater/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>python</herd>
+</pkgmetadata>
diff --git a/app-admin/rsyslog/metadata.xml b/app-admin/rsyslog/metadata.xml
new file mode 100644
index 0000000..828e59e
--- /dev/null
+++ b/app-admin/rsyslog/metadata.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <maintainer>
+    <email>ultrabug@gentoo.org</email>
+    <name>Alexys Jacob</name>
+    <description>Primary Maintainer</description>
+  </maintainer>
+  <use>
+    <flag name="extras">Add support for the UDP spoofing module (omudpspoof) using <pkg>net-libs/libnet</pkg></flag>
+    <flag name="relp">Add support for the Reliable Event Logging Protocol using <pkg>dev-libs/librelp</pkg></flag>
+    <flag name="zeromq">Add support for the ZeroMQ input and output plugins using <pkg>net-libs/zeromq</pkg></flag>
+  </use>
+</pkgmetadata>
diff --git a/app-admin/sudo/metadata.xml b/app-admin/sudo/metadata.xml
new file mode 100644
index 0000000..ecd156e
--- /dev/null
+++ b/app-admin/sudo/metadata.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>base-system</herd>
+  <longdescription lang="en">
+    Sudo (superuser do) allows a system administrator to give certain
+    users (or groups of users) the ability to run some (or all)
+    commands as root or another user while logging the commands and
+    arguments.
+  </longdescription>
+  <use>
+    <flag name='offensive'>
+      Let sudo print insults when the user types the wrong password.
+    </flag>
+  </use>
+</pkgmetadata>
diff --git a/app-admin/webapp-config/metadata.xml b/app-admin/webapp-config/metadata.xml
new file mode 100644
index 0000000..e53ef9e
--- /dev/null
+++ b/app-admin/webapp-config/metadata.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>web-apps</herd>
+	<herd>proxy-maintainers</herd>
+	<maintainer>
+		<email>blueness@gentoo.org</email>
+		<name>Anthony G. Basile</name>
+	</maintainer>
+	<maintainer>
+		<email>twitch153@hotmail.com</email>
+		<name>Devan Franchini</name>
+	</maintainer>
+</pkgmetadata>
diff --git a/app-arch/bzip2/metadata.xml b/app-arch/bzip2/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/app-arch/bzip2/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/app-arch/cabextract/metadata.xml b/app-arch/cabextract/metadata.xml
new file mode 100644
index 0000000..1acfbec
--- /dev/null
+++ b/app-arch/cabextract/metadata.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>fonts</herd>
+<use>
+	<flag name="extra-tools">Install experimental tools: wince_info and
+	wince_rename for examining and processing Windows CE installation cabinet
+	header files; cabinfo for examining the structure of a cab file.</flag>
+</use>
+</pkgmetadata>
diff --git a/app-arch/cpio/metadata.xml b/app-arch/cpio/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/app-arch/cpio/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/app-arch/gzip/metadata.xml b/app-arch/gzip/metadata.xml
new file mode 100644
index 0000000..f8ea417
--- /dev/null
+++ b/app-arch/gzip/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<use>
+<flag name='pic'>disable optimized assembly code that is not PIC friendly</flag>
+</use>
+</pkgmetadata>
diff --git a/app-arch/libarchive/metadata.xml b/app-arch/libarchive/metadata.xml
new file mode 100644
index 0000000..56bc518
--- /dev/null
+++ b/app-arch/libarchive/metadata.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>bsd</herd>
+  <maintainer>
+    <email>ferringb@gentoo.org</email>
+    <name>Brian Harring</name>
+  </maintainer>
+  <maintainer>
+    <email>ssuominen@gentoo.org</email>
+    <name>Samuli Suominen</name>
+  </maintainer>
+  <longdescription lang='en'>
+    The bsdtar program creates and manipulates streaming archive files.
+    It has a number of advantages over previous tar implementations.
+  </longdescription>
+  <use>
+    <flag name='zlib'>
+      Allow accessing gzip-compressed archives through
+      <pkg>sys-libs/zlib</pkg>. This only affects libarchive's native
+      support: bsdtar will keep using gunzip as a filter if that's not
+      built-in. It's also needed for supporting extraction of ZIP
+      files.
+    </flag>
+    <flag name='bzip2'>
+      Allow accessing bzip2-compressed archives through libbz2 (which
+      comes with <pkg>app-arch/bzip2</pkg>). This only affects
+      libarchive's native support: bsdtar will keep using bunzip2 as a
+      filter if that's not built-in.
+    </flag>
+    <flag name='nettle'>
+      Use <pkg>dev-libs/nettle</pkg> as crypto backend
+    </flag>
+    <flag name='e2fsprogs'>
+      Use file flags from <pkg>sys-fs/e2fsprogs</pkg> headers instead of <pkg>virtual/os-headers</pkg> headers
+    </flag>
+  </use>
+</pkgmetadata>
diff --git a/app-arch/lzop/metadata.xml b/app-arch/lzop/metadata.xml
new file mode 100644
index 0000000..caaa4ac
--- /dev/null
+++ b/app-arch/lzop/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+    <email>binki@gentoo.org</email>
+    <name>Nathan Phillip Brink</name>
+</maintainer>
+<longdescription></longdescription>
+</pkgmetadata>
diff --git a/app-arch/metadata.xml b/app-arch/metadata.xml
new file mode 100644
index 0000000..72ecbb9
--- /dev/null
+++ b/app-arch/metadata.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The app-arch category contains tools for archiving, compressing and
+		uncompressing files or groups of files.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie app-arch enthält Werkzeuge für das Archivieren, Packen und
+		Entpacken von Dateien oder Gruppen von Dateien.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría app-arch contiene herramientas para archivar, comprimir
+		y descomprimir archivos ó grupos de archivos.
+	</longdescription>
+	<longdescription lang="ja">
+		app-archカテゴリにはファイルをアーカイブする、圧縮する、解凍する
+		ツールが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		The app-arch categorie bevat applicaties met betrekking tot het
+		archiveren en comprimeren van bestanden.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm app-arch chứa những công cụ để lưu trữ, nén và
+		giải nén các tập tin hoặc nhóm các tập tin.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria app-arch contiene strumenti di archiviazione, compressione e decompressione di file o gruppi di files.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria app-arch contém ferramentas para arquivar, comprimir
+		e descomprimir arquivos ou grupos de arquivos.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria app-arch zawiera narzędzia służące do archiwizowania,
+		kompresji i dekompresji zarówno pojedynczych plików jak i ich grup.
+	</longdescription>
+</catmetadata>
+
diff --git a/app-arch/p7zip/metadata.xml b/app-arch/p7zip/metadata.xml
new file mode 100644
index 0000000..e71e752
--- /dev/null
+++ b/app-arch/p7zip/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>jlec@gentoo.org</email>
+		<description>maintainer</description>
+	</maintainer>
+	<use>
+		<flag name="rar">Enable support for non-free rar decoder</flag>
+	</use>
+</pkgmetadata>
diff --git a/app-arch/pbzip2/metadata.xml b/app-arch/pbzip2/metadata.xml
new file mode 100644
index 0000000..e7f1246
--- /dev/null
+++ b/app-arch/pbzip2/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>radhermit@gentoo.org</email>
+		<name>Tim Harder</name>
+	</maintainer>
+	<use>
+		<flag name="symlink">Install symlinks which override <pkg>app-arch/bzip2</pkg> implementation</flag>
+	</use>
+</pkgmetadata>
diff --git a/app-arch/pigz/metadata.xml b/app-arch/pigz/metadata.xml
new file mode 100644
index 0000000..8246c88
--- /dev/null
+++ b/app-arch/pigz/metadata.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>radhermit@gentoo.org</email>
+		<name>Tim Harder</name>
+	</maintainer>
+	<longdescription lang="en">
+		A parallel implementation of gzip for modern
+		multi-processor, multi-core machines.
+	</longdescription>
+</pkgmetadata>
diff --git a/app-arch/rpm2targz/metadata.xml b/app-arch/rpm2targz/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/app-arch/rpm2targz/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/app-arch/sharutils/metadata.xml b/app-arch/sharutils/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/app-arch/sharutils/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/app-arch/snappy/metadata.xml b/app-arch/snappy/metadata.xml
new file mode 100644
index 0000000..35d868e
--- /dev/null
+++ b/app-arch/snappy/metadata.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>nirbheek@gentoo.org</email>
+		<name>Nirbheek Chauhan</name>
+	</maintainer>
+	<longdescription lang="en">Snappy is a compression/decompression library. It does not aim for
+		maximum compression, or compatibility with any other compression
+		library; instead, it aims for very high speeds and reasonable
+		compression.</longdescription>
+	<upstream>
+		<remote-id type="google-code">snappy</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/app-arch/tar/metadata.xml b/app-arch/tar/metadata.xml
new file mode 100644
index 0000000..455b61e
--- /dev/null
+++ b/app-arch/tar/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<use>
+	<flag name='minimal'>just install `tar`</flag>
+</use>
+</pkgmetadata>
diff --git a/app-arch/unrar/metadata.xml b/app-arch/unrar/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/app-arch/unrar/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/app-arch/unzip/metadata.xml b/app-arch/unzip/metadata.xml
new file mode 100644
index 0000000..af80d5d
--- /dev/null
+++ b/app-arch/unzip/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<use>
+<flag name='natspec'>Use <pkg>dev-libs/libnatspec</pkg> to correctly decode non-ascii file names archived in Windows.</flag>
+</use>
+</pkgmetadata>
diff --git a/app-arch/xz-utils/metadata.xml b/app-arch/xz-utils/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/app-arch/xz-utils/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/app-arch/zip/metadata.xml b/app-arch/zip/metadata.xml
new file mode 100644
index 0000000..841173e
--- /dev/null
+++ b/app-arch/zip/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<longdescription>Application that supports the Info Zip series of encryption.</longdescription>
+<use>
+<flag name='natspec'>Use <pkg>dev-libs/libnatspec</pkg> to correctly decode non-ascii file names archived in Windows.</flag>
+</use>
+</pkgmetadata>
diff --git a/app-benchmarks/i7z/metadata.xml b/app-benchmarks/i7z/metadata.xml
new file mode 100644
index 0000000..00ecf9d
--- /dev/null
+++ b/app-benchmarks/i7z/metadata.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>jlec@gentoo.org</email>
+	</maintainer>
+	<upstream>
+		<remote-id type="google-code">i7z</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/app-benchmarks/metadata.xml b/app-benchmarks/metadata.xml
new file mode 100644
index 0000000..c7ff909
--- /dev/null
+++ b/app-benchmarks/metadata.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The app-benchmarks category contains benchmarking software.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría app-benchmarks contiene programas para pruebas.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie app-benchmarks enthält Benchmark-Software.
+	</longdescription>
+	<longdescription lang="ja">
+		app-benchmarksカテゴリにはベンチマークソフトウェアが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De app-benchmarks categorie bevat benchmarking applicaties.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm app-benchmarks chứa các ứng dụng benchmark.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria app-benchmarks contiene programmi per l'analisi delle prestazioni.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria app-benchmarks contém programas para benchmarking.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria app-benchmarks zawiera oprogramowanie służące do testowania
+		wydajności.
+	</longdescription>
+</catmetadata>
+
diff --git a/app-crypt/metadata.xml b/app-crypt/metadata.xml
new file mode 100644
index 0000000..d508e60
--- /dev/null
+++ b/app-crypt/metadata.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The app-crypt category contains cryptographic (encryption, decryption,
+		steganography and signing) software.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie app-crypt enhält kryptographische (Ver- und Entschlüsselung,
+		Steganographie, Signierung) Software.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría app-crypt contiene programas para criptografía
+		(cifrado, des-cifrado, estenografía y firmas). 
+	</longdescription>
+	<longdescription lang="ja">
+		app-cryptカテゴリには暗号手法ソフトウェア
+		(暗証化と復号化と電子透かしと電子署名)が含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De app-crypt categorie bevat cryptografische applicaties (encryptie,
+		decryptie, steganografie,...).
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm app-crypto chứa các ứng dụng về mật mã (mã hóa,
+		giải mã, kỷ tên và steganography).
+	</longdescription>
+	<longdescription lang="it">
+		La categoria app-crypt contiene programmi di crittografia (cifratura, decifratura, steganografia e firma).
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria app-crypt contém programas criptográficos (cifradores,
+		descifradores, esteganografia e assinaturas).
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria app-crypt zawiera programy kryptograficzne związane z
+		szyfrowaniem, deszyfrowaniem, stenografią oraz podpisywaniem danych.
+	</longdescription>
+</catmetadata>
+
diff --git a/app-crypt/mit-krb5/metadata.xml b/app-crypt/mit-krb5/metadata.xml
new file mode 100644
index 0000000..2609e96
--- /dev/null
+++ b/app-crypt/mit-krb5/metadata.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>kerberos</herd>
+<longdescription>Kerberos 5 reference implementation from MIT</longdescription>
+<use>
+  <flag name="doc">
+    Creates and installs the API and implementation
+    documentation. This is only useful if you want to develop software
+    which depends on kerberos.
+  </flag>
+  <flag name="keyutils">Enable for the keyring ccache using keyutils.</flag>
+  <flag name="pkinit">Enable pkinit support for the initial ticket.</flag>
+  <flag name="openldap">Enable support for ldap as a database backend.</flag>
+</use>
+</pkgmetadata>
diff --git a/app-crypt/tpm-tools/metadata.xml b/app-crypt/tpm-tools/metadata.xml
new file mode 100644
index 0000000..b4a02b3
--- /dev/null
+++ b/app-crypt/tpm-tools/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>crypto</herd>
+  <use>
+    <flag name='pkcs11'>
+      Build Token data management utilities based on OpenCryptoki's
+      (<pkg>dev-libs/opencryptoki</pkg>) PKCS#11 implementation.
+    </flag>
+  </use>
+</pkgmetadata>
diff --git a/app-editors/emacs/metadata.xml b/app-editors/emacs/metadata.xml
new file mode 100644
index 0000000..4981aad
--- /dev/null
+++ b/app-editors/emacs/metadata.xml
@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>emacs</herd>
+<longdescription>
+  GNU Emacs is an extensible, customizable text editor - and more. At its core
+  is an interpreter for Emacs Lisp, a dialect of the Lisp programming language
+  with extensions to support text editing. The features of GNU Emacs include:
+   * Content-sensitive editing modes, including syntax coloring, for a variety
+     of file types including plain text, source code, and HTML.
+   * Complete built-in documentation, including a tutorial for new users.
+   * Full Unicode support for nearly all human languages and their scripts.
+   * Highly customizable, using Emacs Lisp code or a graphical interface.
+   * A large number of extensions that add other functionality, including a
+     project planner, mail and news reader, debugger interface, calendar, and
+     more. Many of these extensions are distributed with GNU Emacs; others are
+     available separately.
+</longdescription>
+<use>
+  <flag name='athena'>Enable the MIT Athena widget set
+    (<pkg>x11-libs/libXaw</pkg>)</flag>
+  <flag name='games'>Support shared score files for games</flag>
+  <flag name='gconf'>Use <pkg>gnome-base/gconf</pkg> to read the system
+    font name</flag>
+  <flag name='gsettings'>Use gsettings (<pkg>dev-libs/glib</pkg>) to read the
+    system font name</flag>
+  <flag name='gtk3'>Link against version 3 of the GIMP Toolkit instead of
+    version 2 (<pkg>x11-libs/gtk+</pkg>)</flag>
+  <flag name='gzip-el'>Compress bundled Emacs Lisp source</flag>
+  <flag name='hesiod'>Enable support for <pkg>net-dns/hesiod</pkg></flag>
+  <flag name='imagemagick'>Use <pkg>media-gfx/imagemagick</pkg> for image
+    processing</flag>
+  <flag name='leim'>Add support for Emacs input methods</flag>
+  <flag name='libxml2'>Use <pkg>dev-libs/libxml2</pkg> to parse XML instead
+    of the internal Lisp implementations</flag>
+  <flag name='pax_kernel'>Enable building under a PaX enabled kernel
+    (<pkg>sys-apps/paxctl</pkg>)</flag>
+  <flag name='sendmail'>Build Emacs with MTA support</flag>
+  <flag name='source'>Install C source files and make them available for
+    find-function</flag>
+  <flag name='toolkit-scroll-bars'>Use the selected toolkit's scrollbars in
+    preference to Emacs' own scrollbars</flag>
+  <flag name='wide-int'>Prefer wide Emacs integers (typically 62-bit).
+    This option has an effect only on architectures where "long" and
+    "long long" types have different size.</flag>
+</use>
+</pkgmetadata>
diff --git a/app-editors/metadata.xml b/app-editors/metadata.xml
new file mode 100644
index 0000000..195f875
--- /dev/null
+++ b/app-editors/metadata.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The app-editors category contains text editors.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie app-editors enthält Texteditoren.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría app-editors contiene editores de textos.
+	</longdescription>
+	<longdescription lang="ja">
+		app-editorsカテゴリにはテキストエディタが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De app-editors categorie bevat text editors.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm app-editors chứa các trình soạn thảo văn bản.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria app-editors contiene editor di testo.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria app-editors contém editores de texto.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria app-editors zawiera edytory tekstu.
+	</longdescription>
+</catmetadata>
+
diff --git a/app-editors/nano/metadata.xml b/app-editors/nano/metadata.xml
new file mode 100644
index 0000000..98a4895
--- /dev/null
+++ b/app-editors/nano/metadata.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+ <email>vapier@gentoo.org</email>
+</maintainer>
+<longdescription>
+GNU nano - an enhanced clone of the Pico text editor.
+
+The nano project was started because of a few "problems" with the
+wonderfully easy-to-use and friendly Pico text editor.
+
+First and foremost is its license: the Pine suite does not use the
+GPL or a GPL-friendly license, and has unclear restrictions on
+redistribution.  Because of this, Pine and Pico are not included with
+many GNU/Linux distributions.  Also, other features (like goto line
+number or search and replace) were unavailable until recently or
+require a command line flag.  Yuck.
+
+nano aims to solve these problems by emulating the functionality of
+Pico as closely as possible while addressing the problems above and
+perhaps providing other extra functionality.
+</longdescription>
+<use>
+ <flag name='justify'>Enable justify/unjustify functions for text formatting.</flag>
+ <flag name='debug'>
+  Enable debug messages and assert warnings.  Note that these will all be sent
+  straight to stderr rather than some logging facility.
+ </flag>
+ <flag name='magic'>
+  Add magic file support (sys-apps/file) to automatically detect appropriate syntax highlighting
+ </flag>
+ <flag name='minimal'>
+  Disable all fancy features, including ones that otherwise have a dedicated
+  USE flag (such as spelling).
+ </flag>
+</use>
+</pkgmetadata>
diff --git a/app-editors/vim-core/metadata.xml b/app-editors/vim-core/metadata.xml
new file mode 100644
index 0000000..5fcb673
--- /dev/null
+++ b/app-editors/vim-core/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>vim</herd>
+</pkgmetadata>
diff --git a/app-editors/vim/metadata.xml b/app-editors/vim/metadata.xml
new file mode 100644
index 0000000..46400a3
--- /dev/null
+++ b/app-editors/vim/metadata.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>vim</herd>
+<use>
+  <flag name='vim-pager'>Install vimpager and vimmanpager links</flag>
+  <flag name='X'>Link console vim against X11 libraries to enable title and
+	  clipboard features in xterm</flag>
+</use>
+</pkgmetadata>
diff --git a/app-emacs/emacs-common-gentoo/metadata.xml b/app-emacs/emacs-common-gentoo/metadata.xml
new file mode 100644
index 0000000..dce5920
--- /dev/null
+++ b/app-emacs/emacs-common-gentoo/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>emacs</herd>
+<use>
+  <flag name='games'>Support shared score files for games</flag>
+</use>
+</pkgmetadata>
diff --git a/app-emacs/metadata.xml b/app-emacs/metadata.xml
new file mode 100644
index 0000000..f19199d
--- /dev/null
+++ b/app-emacs/metadata.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The app-emacs category contains extension packages for the Emacs text
+		editor.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie app-emacs enthält Pakete für den Texteditor Emacs.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría app-emacs contiene paquetes de extensión para el editor
+		de texto Emacs.
+	</longdescription>
+	<longdescription lang="ja">
+		app-emacsカテゴリにはEmacsテキストエディタに関連した
+		拡張パッケージが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De app-emacs categorie bevat extensies voor Emacs.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm app-emacs chứa các gói mở rộng cho trình soạn
+		thảo văn bản Emacs.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria app-emacs contiene pacchetti di estensioni per l'editor di testo Emacs.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria app-emacs contém pacotes de extensão para o editor de
+		texto Emacs.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria app-emacs zawiera pakiety związane z edytorem tekstu Emacs.
+	</longdescription>
+</catmetadata>
diff --git a/app-i18n/metadata.xml b/app-i18n/metadata.xml
new file mode 100644
index 0000000..44756a0
--- /dev/null
+++ b/app-i18n/metadata.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The app-i18n category contains internationalisation-related packages.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie app-i18n enthält Programme im Zusammenhang mit Internationalisierung.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría app-i18n contiene paquetes para Internacionalización.
+	</longdescription>
+	<longdescription lang="ja">
+		app-i18nカテゴリには国際化関連パッケージが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De app-i18n categorie bevat applicaties om te internationaliseren (vertalen).
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm app-i18n chứa các gói liên quan đến
+		quốc tế hoá (i18n).
+	</longdescription>
+	<longdescription lang="it">
+		La categoria app-i18n contiene pacchetti per l'internazionalizzazione.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria app-i18n contém pacotes para internacionalização.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria app-i18n zawiera pakiety zawierające tłumaczenia różnych
+		składników systemu na różne języki.
+	</longdescription>
+</catmetadata>
+
diff --git a/app-i18n/zinnia/metadata.xml b/app-i18n/zinnia/metadata.xml
new file mode 100644
index 0000000..51689f0
--- /dev/null
+++ b/app-i18n/zinnia/metadata.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>cjk</herd>
+</pkgmetadata>
+
diff --git a/app-misc/ddccontrol-db/metadata.xml b/app-misc/ddccontrol-db/metadata.xml
new file mode 100644
index 0000000..9bf0b3b
--- /dev/null
+++ b/app-misc/ddccontrol-db/metadata.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>proxy-maintainers</herd>
+<maintainer>
+  <email>robbat2@gentoo.org</email>
+</maintainer>
+<maintainer>
+	<email>nicolas@boichat.ch</email>
+	<description>
+		Upstream developer. Please CC on all bugs involving ddccontrol
+		and ddccontrol-db.
+	</description>
+</maintainer>
+</pkgmetadata>
diff --git a/app-misc/editor-wrapper/metadata.xml b/app-misc/editor-wrapper/metadata.xml
new file mode 100644
index 0000000..83d3350
--- /dev/null
+++ b/app-misc/editor-wrapper/metadata.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<herd>emacs</herd>
+</pkgmetadata>
diff --git a/app-misc/evtest/metadata.xml b/app-misc/evtest/metadata.xml
new file mode 100644
index 0000000..7123fa8
--- /dev/null
+++ b/app-misc/evtest/metadata.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+ <email>vapier@gentoo.org</email>
+</maintainer>
+</pkgmetadata>
diff --git a/app-misc/metadata.xml b/app-misc/metadata.xml
new file mode 100644
index 0000000..98bcf3d
--- /dev/null
+++ b/app-misc/metadata.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The app-misc category contains various miscellaneous application
+		packages which don't belong anywhere else.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie app-misc enthält verschiedenste Applikationen welche
+		keiner anderen Kategorie zugeordnet werden konnten.
+	</longdescription>
+	<longdescription lang="nl">
+		De app-misc categorie bevat applicaties die niet in een specifieke
+		categorie geplaatst konden worden.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm app-misc chứa các ứng dụng linh tinh, không thuộc
+		về nhóm nào cả.
+	</longdescription>
+	<longdescription lang="it">
+		La cateogria app-misc contiene varie applicazioni che non ricadono nelle altre categorie.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria app-misc contém vários pacotes de aplicações mistas
+		que não pertencem a outros lugares.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria app-misc zawiera wiele rozmaitych programów, które nie
+		pasowały do żadnej innej kategorii.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría app-misc contiene varios paquetes de aplicaciones
+		misceláneas que no pertenecen a ninguna otra categoría.
+	</longdescription>
+</catmetadata>
+
diff --git a/app-misc/mime-types/metadata.xml b/app-misc/mime-types/metadata.xml
new file mode 100644
index 0000000..f93bc00
--- /dev/null
+++ b/app-misc/mime-types/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>net-mail</herd>
+<maintainer>
+  <email>djc@gentoo.org</email>
+  <name>Dirkjan Ochtman</name>
+</maintainer>
+</pkgmetadata>
diff --git a/app-misc/pax-utils/metadata.xml b/app-misc/pax-utils/metadata.xml
new file mode 100644
index 0000000..448899f
--- /dev/null
+++ b/app-misc/pax-utils/metadata.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <maintainer>
+    <email>solar@gentoo.org</email>
+    <description>Maintainer</description>
+  </maintainer>
+  <maintainer>
+    <email>vapier@gentoo.org</email>
+    <description>Maintainer</description>
+  </maintainer>
+  <longdescription>A suite of ELF tools to aid auditing systems. Contains various ELF related utils for ELF32, ELF64 binaries useful for displaying PaX and security info on a large groups of binary files.</longdescription>
+  <use>
+    <flag name='python'>Install a more powerful/faster version of lddtree</flag>
+  </use>
+</pkgmetadata>
diff --git a/app-misc/screen/metadata.xml b/app-misc/screen/metadata.xml
new file mode 100644
index 0000000..87bfb0b
--- /dev/null
+++ b/app-misc/screen/metadata.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>shell-tools</herd>
+  <maintainer>
+    <email>swegener@gentoo.org</email>
+    <description>Primary Maintainer</description>
+  </maintainer>
+  <longdescription>
+Screen is a full-screen window manager that multiplexes a physical terminal
+between several processes, typically interactive shells. Each virtual terminal
+provides the functions of the DEC VT100 terminal and, in addition, several
+control functions from the ANSI X3.64 (ISO 6429) and ISO 2022 standards (e.g.,
+insert/delete line and support for multiple character sets). There is a
+scrollback history buffer for each virtual terminal and a copy-and-paste
+mechanism that allows the user to move text regions between windows. When screen
+is called, it creates a single window with a shell in it (or the specified
+command) and then gets out of your way so that you can use the program as you
+normally would. Then, at any time, you can create new (full-screen) windows with
+other programs in them (including more shells), kill the current window, view a
+list of the active windows, turn output logging on and off, copy text between
+windows, view the scrollback history, switch between windows, etc. All windows
+run their programs completely independent of each other. Programs continue to
+run when their window is currently not visible and even when the whole screen
+session is detached from the users terminal.
+</longdescription>
+  <use>
+    <flag name="multiuser">Enable multiuser support (by setting correct
+    permissions)</flag>
+    <flag name="nethack">Express error messages in nethack style</flag>
+  </use>
+</pkgmetadata>
diff --git a/app-misc/tmux/metadata.xml b/app-misc/tmux/metadata.xml
new file mode 100644
index 0000000..a88ed84
--- /dev/null
+++ b/app-misc/tmux/metadata.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>shell-tools</herd>
+  <maintainer>
+    <email>wired@gentoo.org</email>
+    <name>Alex Alexander</name>
+  </maintainer>
+  <longdescription>
+		tmux is a "terminal multiplexer", it enables a number of terminals
+		(or windows) to be accessed and controlled from a single terminal.
+		tmux is intended to be a simple, modern, BSD-licensed alternative to
+		programs such as <pkg>app-misc/screen</pkg>.
+	</longdescription>
+</pkgmetadata>
diff --git a/app-office/dia/metadata.xml b/app-office/dia/metadata.xml
new file mode 100644
index 0000000..a257c23
--- /dev/null
+++ b/app-office/dia/metadata.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>gnome-office</herd>
+<longdescription>
+  Dia is a gtk+ based diagram creation program. It can be used to
+  draw many different kinds of diagrams. It currently has special
+  objects to help draw entity relationship diagrams, UML diagrams,
+  flowcharts, network diagrams, and simple circuits. It is also
+  possible to add support for new shapes by writing simple XML
+  files, using a subset of SVG to draw the shape.
+</longdescription>
+</pkgmetadata>
diff --git a/app-office/metadata.xml b/app-office/metadata.xml
new file mode 100644
index 0000000..93999ec
--- /dev/null
+++ b/app-office/metadata.xml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The app-office category contains 'office' (word processing,
+		spreadsheets, presentation) software packages.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie app-office enthält Bürosoftware (Textverarbeitung,
+		Tabellenkalkulation, Präsentation).
+	</longdescription>
+	<longdescription lang="es">
+		La categoría app-office contiene paquetes de oficina 
+		(procesadores de palabras, hojas de balance, presentación).
+	</longdescription>
+	<longdescription lang="ja">
+		app-officeカテゴリには「オフィス」(ワープロや表計算やプレゼンテーション)
+		と言うソフトウェアパッケージが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De app-office categorie bevat applicaties voor kantoorwerk, zoals text-
+		verwerkers, spreadsheets, presentatiehulpmiddelen enz.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm app-office chứa các ứng dụng 'văn phòng' (soạn
+		thảo văn bản, bảng tính, trình diễn).
+	</longdescription>
+	<longdescription lang="it">
+		La categoria app-office contiene pacchetti per ufficio
+		(videoscrittura, fogli elettronici, presentazioni).
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria app-office contém pacotes de software para
+		escritório (processadores de textos, planilhas, apresentações).
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria app-office zawiera programy biurowe takie jak edytory tekstu,
+		arkuszy kalkulacyjnych i prezentacji.
+	</longdescription>
+</catmetadata>
+
diff --git a/app-portage/esearch/metadata.xml b/app-portage/esearch/metadata.xml
new file mode 100644
index 0000000..d29ef56
--- /dev/null
+++ b/app-portage/esearch/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>tools-portage</herd>
+</pkgmetadata>
diff --git a/app-portage/gentoolkit-dev/metadata.xml b/app-portage/gentoolkit-dev/metadata.xml
new file mode 100644
index 0000000..fa4d725
--- /dev/null
+++ b/app-portage/gentoolkit-dev/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>tools-portage</herd>
+	<longdescription>
+		Gentoolkit-dev is a collection of developer tools for the Gentoo distribution.
+	</longdescription>
+</pkgmetadata>
diff --git a/app-portage/gentoolkit/metadata.xml b/app-portage/gentoolkit/metadata.xml
new file mode 100644
index 0000000..24c8ea0
--- /dev/null
+++ b/app-portage/gentoolkit/metadata.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>tools-portage</herd>
+
+<longdescription>
+Gentoolkit is a collection of useful adminstration scripts particular to
+the Gentoo Linux distribution. It contains rough drafts and
+implementations of features that may in time make it into Portage, or
+into full-fledged tools in their own right.
+</longdescription>
+</pkgmetadata>
diff --git a/app-portage/metadata.xml b/app-portage/metadata.xml
new file mode 100644
index 0000000..3872164
--- /dev/null
+++ b/app-portage/metadata.xml
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The app-portage category contains software which works with portage or
+		ebuilds.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie app-portage enthält Programme für das Arbeiten mit Portage
+		oder Ebuilds.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría app-portage contiene programas para trabajar con portage
+		o con ebuilds.
+	</longdescription>
+	<longdescription lang="ja">
+		app-portageカテゴリにはportageかebuildと使うソフトウェアが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De app-portage categorie bevat applicaties die samenwerken met portage of
+		direct met ebuilds te maken hebben.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm app-portage chứa các ứng dụng liên quan đến
+		portage.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria app-portage contiene programmi per portage o per le ebuilds.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria app-portage contém programas que funcionam com o portage
+		ou ebuilds.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria app-portage zawiera dodatkowe programy do pracy z systemem
+		Portage oraz ebuildami.
+	</longdescription>
+</catmetadata>
+
diff --git a/app-portage/portage-utils/metadata.xml b/app-portage/portage-utils/metadata.xml
new file mode 100644
index 0000000..5480650
--- /dev/null
+++ b/app-portage/portage-utils/metadata.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+	<email>portage-utils@gentoo.org</email>
+</maintainer>
+</pkgmetadata>
diff --git a/app-shells/bash/metadata.xml b/app-shells/bash/metadata.xml
new file mode 100644
index 0000000..23e4a90
--- /dev/null
+++ b/app-shells/bash/metadata.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<use>
+  <flag name='bashlogger'>Log ALL commands typed into bash; should ONLY be
+    used in restricted environments such as honeypots</flag>
+  <flag name='mem-scramble'>Build with custom malloc/free overwriting allocated/freed memory</flag>
+  <flag name='net'>Enable /dev/tcp/host/port redirection</flag>
+  <flag name='plugins'>Add support for loading builtins at runtime via
+    'enable'</flag>
+</use>
+</pkgmetadata>
diff --git a/app-shells/dash/metadata.xml b/app-shells/dash/metadata.xml
new file mode 100644
index 0000000..659da0c
--- /dev/null
+++ b/app-shells/dash/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>base-system</herd>
+</pkgmetadata>
diff --git a/app-shells/gentoo-bashcomp/metadata.xml b/app-shells/gentoo-bashcomp/metadata.xml
new file mode 100644
index 0000000..40149c9
--- /dev/null
+++ b/app-shells/gentoo-bashcomp/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>shell-tools</herd>
+</pkgmetadata>
diff --git a/app-shells/metadata.xml b/app-shells/metadata.xml
new file mode 100644
index 0000000..f70a049
--- /dev/null
+++ b/app-shells/metadata.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The app-shells category contains shells and their extensions.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie app-shells enthält Kommandozeileninterpreter (Shells)
+		sowie deren Erweiterungen.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría app-shells contiene shells y sus extensiones.
+	</longdescription>
+	<longdescription lang="nl">
+		De app-shells categorie bevat opdrachtverwerkers (shells) en hun uitbreidingen.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm app-shells chứa các loại shell và các phần mở
+		rộng của shell.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria app-shells contiene shells e loro estensioni.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria app-shells contém shells e suas extensões.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria app-shells zawiera interpretery poleceń (powłoki) oraz ich
+		rozszerzenia.
+	</longdescription>
+</catmetadata>
+
diff --git a/app-text/asciidoc/metadata.xml b/app-text/asciidoc/metadata.xml
new file mode 100644
index 0000000..9f88199
--- /dev/null
+++ b/app-text/asciidoc/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>sgml</herd>
+  <use>
+    <flag name="highlight">Enable source code highlighting</flag>
+  </use>
+</pkgmetadata>
diff --git a/app-text/build-docbook-catalog/metadata.xml b/app-text/build-docbook-catalog/metadata.xml
new file mode 100644
index 0000000..904857b
--- /dev/null
+++ b/app-text/build-docbook-catalog/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>sgml</herd>
+</pkgmetadata>
diff --git a/app-text/docbook-dsssl-stylesheets/metadata.xml b/app-text/docbook-dsssl-stylesheets/metadata.xml
new file mode 100644
index 0000000..e960864
--- /dev/null
+++ b/app-text/docbook-dsssl-stylesheets/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>sgml</herd>
+</pkgmetadata>
diff --git a/app-text/docbook-sgml-dtd/metadata.xml b/app-text/docbook-sgml-dtd/metadata.xml
new file mode 100644
index 0000000..e960864
--- /dev/null
+++ b/app-text/docbook-sgml-dtd/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>sgml</herd>
+</pkgmetadata>
diff --git a/app-text/docbook-xml-dtd/metadata.xml b/app-text/docbook-xml-dtd/metadata.xml
new file mode 100644
index 0000000..e960864
--- /dev/null
+++ b/app-text/docbook-xml-dtd/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>sgml</herd>
+</pkgmetadata>
diff --git a/app-text/docbook-xsl-stylesheets/metadata.xml b/app-text/docbook-xsl-stylesheets/metadata.xml
new file mode 100644
index 0000000..c63d5ad
--- /dev/null
+++ b/app-text/docbook-xsl-stylesheets/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>sgml</herd>
+  <use>
+    <flag name="ruby">
+      Install the Ruby-based dbtoepub script; requires an interpreter
+      compatible with <pkg>app-admin/eselect-ruby</pkg>.
+    </flag>
+  </use>
+</pkgmetadata>
diff --git a/app-text/dos2unix/metadata.xml b/app-text/dos2unix/metadata.xml
new file mode 100644
index 0000000..f23b9ca
--- /dev/null
+++ b/app-text/dos2unix/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>shell-tools</herd>
+</pkgmetadata>
diff --git a/app-text/ghostscript-gpl/metadata.xml b/app-text/ghostscript-gpl/metadata.xml
new file mode 100644
index 0000000..115b76c
--- /dev/null
+++ b/app-text/ghostscript-gpl/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>printing</herd>
+	<use>
+		<flag name="bindist">Disable dejavu support for binary distribution because of licensing issue</flag>
+	</use>
+</pkgmetadata>
diff --git a/app-text/gnome-doc-utils/metadata.xml b/app-text/gnome-doc-utils/metadata.xml
new file mode 100644
index 0000000..6e0e2ec
--- /dev/null
+++ b/app-text/gnome-doc-utils/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>gnome</herd>
+</pkgmetadata>
diff --git a/app-text/htmltidy/metadata.xml b/app-text/htmltidy/metadata.xml
new file mode 100644
index 0000000..e960864
--- /dev/null
+++ b/app-text/htmltidy/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>sgml</herd>
+</pkgmetadata>
diff --git a/app-text/libpaper/metadata.xml b/app-text/libpaper/metadata.xml
new file mode 100644
index 0000000..1fa0ca5
--- /dev/null
+++ b/app-text/libpaper/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>printing</herd>
+</pkgmetadata>
diff --git a/app-text/metadata.xml b/app-text/metadata.xml
new file mode 100644
index 0000000..fcbc7cd
--- /dev/null
+++ b/app-text/metadata.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The app-text category contains tools for working with human-language
+		text files.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie app-text enhält Werkzeuge für das Arbeiten mit menschenlesbaren
+		Textdokumenten.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría app-text contiene herramientas para trabajar con archivos
+		de texto en lenguaje humano.
+	</longdescription>
+	<longdescription lang="nl">
+		De app-text categorie bevat applicaties voor het werken met door mensen geschreven teksten.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm app-text chứa các công cụ để làm việc với các tập
+		tin văn bản có thể đọc hiểu.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria app-text contiene utilità per lavorare con file di testo.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria app-text contém ferramentas para trabalhar com
+		arquivos de texto em linguagens humanas.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria app-text zawiera narzędzia do pracy ze zwykłymi plikami tekstowymi.
+	</longdescription>
+</catmetadata>
+
diff --git a/app-text/openjade/metadata.xml b/app-text/openjade/metadata.xml
new file mode 100644
index 0000000..e960864
--- /dev/null
+++ b/app-text/openjade/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>sgml</herd>
+</pkgmetadata>
diff --git a/app-text/opensp/metadata.xml b/app-text/opensp/metadata.xml
new file mode 100644
index 0000000..e960864
--- /dev/null
+++ b/app-text/opensp/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>sgml</herd>
+</pkgmetadata>
diff --git a/app-text/poppler-data/metadata.xml b/app-text/poppler-data/metadata.xml
new file mode 100644
index 0000000..1fa0ca5
--- /dev/null
+++ b/app-text/poppler-data/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>printing</herd>
+</pkgmetadata>
diff --git a/app-text/rarian/metadata.xml b/app-text/rarian/metadata.xml
new file mode 100644
index 0000000..da6fd63
--- /dev/null
+++ b/app-text/rarian/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>gnome</herd>
+</pkgmetadata>
diff --git a/app-text/scrollkeeper-dtd/metadata.xml b/app-text/scrollkeeper-dtd/metadata.xml
new file mode 100644
index 0000000..48a8d92
--- /dev/null
+++ b/app-text/scrollkeeper-dtd/metadata.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>gnome</herd>
+</pkgmetadata>
+
diff --git a/app-text/scrollkeeper/metadata.xml b/app-text/scrollkeeper/metadata.xml
new file mode 100644
index 0000000..da6fd63
--- /dev/null
+++ b/app-text/scrollkeeper/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>gnome</herd>
+</pkgmetadata>
diff --git a/app-text/sgml-common/metadata.xml b/app-text/sgml-common/metadata.xml
new file mode 100644
index 0000000..e960864
--- /dev/null
+++ b/app-text/sgml-common/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>sgml</herd>
+</pkgmetadata>
diff --git a/app-text/texi2html/metadata.xml b/app-text/texi2html/metadata.xml
new file mode 100644
index 0000000..ba6a8a8
--- /dev/null
+++ b/app-text/texi2html/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>tex</herd>
+</pkgmetadata>
diff --git a/app-text/tree/metadata.xml b/app-text/tree/metadata.xml
new file mode 100644
index 0000000..3e22333
--- /dev/null
+++ b/app-text/tree/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <maintainer>
+    <email>mr_bones_@gentoo.org</email>
+    <name>Michael Sterrett</name>
+  </maintainer>
+</pkgmetadata>
diff --git a/app-text/xmlto/metadata.xml b/app-text/xmlto/metadata.xml
new file mode 100644
index 0000000..e960864
--- /dev/null
+++ b/app-text/xmlto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>sgml</herd>
+</pkgmetadata>
diff --git a/app-vim/gentoo-syntax/metadata.xml b/app-vim/gentoo-syntax/metadata.xml
new file mode 100644
index 0000000..9515a7c
--- /dev/null
+++ b/app-vim/gentoo-syntax/metadata.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>vim</herd>
+  <maintainer>
+    <email>yngwin@gentoo.org</email>
+    <name>Ben de Groot</name>
+  </maintainer>
+  <use>
+    <flag name='ignore-glep31'>Remove GLEP 31 (UTF-8 file encodings) settings</flag>
+  </use>
+</pkgmetadata>
diff --git a/app-vim/metadata.xml b/app-vim/metadata.xml
new file mode 100644
index 0000000..df7f603
--- /dev/null
+++ b/app-vim/metadata.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The app-vim category contains plugins, syntax file and spelling
+		packages for the Vim text editor.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie app-vim enthält Plugins und
+		Syntax-Pakete für den Vim Texteditor.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría app-vim contiene extensiones y paquetes
+		de syntaxis para el editor de texto Vim.
+	</longdescription>
+	<longdescription lang="nl">
+		De app-vim categorie bevat plugins en syntax-bestanden
+		voor de vim text editor.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm app-vim chứa các plugin và các gói syntax cho
+		trình soạn thảo văn bản Vim.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria app-vim contiene estensioni e pacchetti di sintassi
+		per l'editor di testo Vim.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria app-vim contém plugins e pacotes de sintaxe e grafia
+		para o editor de texto Vim.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria app-vim zawiera rozszerzenia, schematy podświetlania składni
+		oraz dodatki służące do sprawdzania pisowni dla edytora tekstu Vim.
+	</longdescription>
+</catmetadata>
+
diff --git a/dev-cpp/ctemplate/metadata.xml b/dev-cpp/ctemplate/metadata.xml
new file mode 100644
index 0000000..e3f7acb
--- /dev/null
+++ b/dev-cpp/ctemplate/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>cpp</herd>
+	<upstream>
+		<remote-id type="google-code">google-ctemplate</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-cpp/gflags/metadata.xml b/dev-cpp/gflags/metadata.xml
new file mode 100644
index 0000000..59aa0bb
--- /dev/null
+++ b/dev-cpp/gflags/metadata.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+	<email>maintainer-needed@gentoo.org</email>
+	</maintainer>
+	<upstream>
+		<remote-id type="google-code">gflags</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-cpp/glog/metadata.xml b/dev-cpp/glog/metadata.xml
new file mode 100644
index 0000000..f537538
--- /dev/null
+++ b/dev-cpp/glog/metadata.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>vapier@gentoo.org</email>
+	</maintainer>
+	<herd>cpp</herd>
+	<use>
+		<flag name="gflags">Use <pkg>dev-cpp/gflags</pkg> for flag parsing</flag>
+		<flag name="unwind">Use <pkg>sys-libs/libunwind</pkg> for stack unwinding instead of glibc/gcc (may be more reliable on x86_64)</flag>
+	</use>
+	<upstream>
+		<remote-id type="google-code">google-glog</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-cpp/gmock/metadata.xml b/dev-cpp/gmock/metadata.xml
new file mode 100644
index 0000000..541e716
--- /dev/null
+++ b/dev-cpp/gmock/metadata.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>vapier@gentoo.org</email>
+	</maintainer>
+	<upstream>
+		<remote-id type="google-code">googlemock</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-cpp/gtest/metadata.xml b/dev-cpp/gtest/metadata.xml
new file mode 100644
index 0000000..0027097
--- /dev/null
+++ b/dev-cpp/gtest/metadata.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+	<email>tomka@gentoo.org</email>
+	<name>Thomas Kahle</name>
+	</maintainer>
+	<upstream>
+		<doc lang="en">http://code.google.com/p/googletest/w/list</doc>
+		<remote-id type="google-code">googletest</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-cpp/metadata.xml b/dev-cpp/metadata.xml
new file mode 100644
index 0000000..643f761
--- /dev/null
+++ b/dev-cpp/metadata.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The dev-cpp category contains libraries and utilities relevant to the
+		c++ programming language.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie dev-cpp enthält Bibliotheken und Werkzeuge für die 
+		Programmiersprache C++.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría dev-cpp contiene librerias y utilidades referentes al
+		lenguaje de programación C++.
+	</longdescription>
+	<longdescription lang="ja">
+		dev-cpp カテゴリーにはC++プログラミング言語に関連したライブラリーと
+		ユーティリティが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De dev-cpp categorie bevat bibliotheken en hulpmiddelen voor het gebruik
+		van de programmeertaal C++.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm dev-cpp chứa các thư viện và tiện ích liên quan
+		đến ngôn ngữ lập trình C++.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria dev-cpp contiene librerie e utilità per illinguaggio C++.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria dev-cpp contém bibliotecas e utilitários para a
+		linguagem de programação C++.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria dev-cpp zawiera biblioteki i narzędzia związane z językiem
+		programowania c++.
+	</longdescription>
+</catmetadata>
+
diff --git a/dev-db/freetds/metadata.xml b/dev-db/freetds/metadata.xml
new file mode 100644
index 0000000..746c693
--- /dev/null
+++ b/dev-db/freetds/metadata.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>olemarkus@gentoo.org</email>
+	</maintainer>
+</pkgmetadata>
diff --git a/dev-db/m17n-contrib/metadata.xml b/dev-db/m17n-contrib/metadata.xml
new file mode 100644
index 0000000..2896f95
--- /dev/null
+++ b/dev-db/m17n-contrib/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>cjk</herd>
+<longdescription lang="en">
+The m17n-contrib is a collection of contributed works to be used with the m17n library.
+</longdescription>
+</pkgmetadata>
+
diff --git a/dev-db/m17n-db/metadata.xml b/dev-db/m17n-db/metadata.xml
new file mode 100644
index 0000000..2d5852c
--- /dev/null
+++ b/dev-db/m17n-db/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>cjk</herd>
+</pkgmetadata>
diff --git a/dev-db/metadata.xml b/dev-db/metadata.xml
new file mode 100644
index 0000000..7ef0dd9
--- /dev/null
+++ b/dev-db/metadata.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The dev-db category contains libraries and utilities for database
+		related programming.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie dev-db enhält Bibliotheken und Werkzeuge für die
+		Datenbank-Programmierung.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría dev-db contiene librerias y utilidades para programación
+		referente a bases de datos.
+	</longdescription>
+	<longdescription lang="ja">
+		dev-dbカテゴリーにはデータベース・プログラミングに関連したライブラリーと
+		ユーティリティが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De dev-db categorie bevat bibliotheken en hulpmiddelen voor het gebruik
+		van verschillende database-programmeertalen.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm dev-db chứa các thư viện và tiện ích liên quan
+		đến Cơ sở dữ liệu.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria dev-db contiene librerie ed utilità per la programmazione di basi di dati.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria dev-db contém bibliotecas e utilitários para a
+		programação relacionada a bancos de dados.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria dev-db zawiera biblioteki i narzędzia związane z
+		programowaniem związanym z bazami danych.
+	</longdescription>
+</catmetadata>
+
diff --git a/dev-db/sqlite/metadata.xml b/dev-db/sqlite/metadata.xml
new file mode 100644
index 0000000..21bf785
--- /dev/null
+++ b/dev-db/sqlite/metadata.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>proxy-maintainers</herd>
+<maintainer>
+	<email>arfrever.fta@gmail.com</email>
+	<description>Proxy maintainer</description>
+</maintainer>
+<use>
+  <flag name='extensions'>Enable support for dynamic loading of extensions</flag>
+  <flag name='fts3'>Full text search using the fts3 module</flag>
+  <flag name='secure-delete'>Overwrite deleted information with zeros in addition to marking the space as available for reuse. This causes a performance penalty.</flag>
+  <flag name='soundex'>Enable the soundex function to compute soundex
+    encodings of strings</flag>
+  <flag name='threadsafe'>Enable thread safe operation of sqlite</flag>
+  <flag name='unlock-notify'>Adds API for notifications when a database is 
+    unlocked in shared-cache mode</flag>
+</use>
+</pkgmetadata>
diff --git a/dev-embedded/libftdi/metadata.xml b/dev-embedded/libftdi/metadata.xml
new file mode 100644
index 0000000..3f860e4
--- /dev/null
+++ b/dev-embedded/libftdi/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>dev-embedded</herd>
+<use>
+ <flag name='tools'>build ftdi_eeprom helper tool</flag>
+</use>
+</pkgmetadata>
diff --git a/dev-embedded/metadata.xml b/dev-embedded/metadata.xml
new file mode 100644
index 0000000..e2e461a
--- /dev/null
+++ b/dev-embedded/metadata.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The dev-embedded category contains libraries and utilities relevant to
+		embedded programming.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie dev-embedded enhält Bibliotheken und Werkzeuge für die
+		Embedded-Programmierung.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría dev-embedded contiene librerias y utilidades referentes a
+		embedded-programming.
+	</longdescription>
+	<longdescription lang="ja">
+		dev-embeddedカテゴリーには組み込みプログラミングに関連したライブラリーと
+		ユーティリティが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De dev-embedded categorie bevat bibliotheken en hulpmiddelen voor het
+		programmeren in een "embedded" omgeving.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm dev-embedded chứa các thư viện và tiện ích liên quan
+		đến lập trình nhúng.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria dev-embedded contiene librerie ed utilità per la programmazione di sistemi embedded.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria dev-embedded contém bibliotecas e utilitários
+		referentes a programação de dispositivos embedded.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria dev-embedded zawiera biblioteki i narzędzia związane z
+		programowaniem dla urządzeń osadzonych.
+	</longdescription>
+</catmetadata>
+
diff --git a/dev-embedded/openocd/metadata.xml b/dev-embedded/openocd/metadata.xml
new file mode 100644
index 0000000..05669d6
--- /dev/null
+++ b/dev-embedded/openocd/metadata.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>dev-embedded</herd>
+<use>
+  <flag name='blaster'>Enable support for Altera USE-Blaster</flag>
+  <flag name="dummy">Build the dummy port driver</flag>
+  <flag name="minidriver">Build the dummy minidriver</flag>
+  <flag name='ftd2xx'>Enable support for USB FTDI chips via <pkg>dev-embedded/libftd2xx</pkg></flag>
+  <flag name='ftdi'>Enable support for USB FTDI chips via <pkg>dev-embedded/libftdi</pkg></flag>
+  <flag name='parport'>Enable support for parport JTAG devices</flag>
+  <flag name='presto'>Enable support for AXIS PRESTO devices</flag>
+  <flag name='segger'>Enable support for the Segger J-Link JTAG</flag>
+  <flag name='versaloon'>Enable building support for the Versallon-lInk JTAG</flag>
+</use>
+</pkgmetadata>
diff --git a/dev-embedded/smdk-dltool/metadata.xml b/dev-embedded/smdk-dltool/metadata.xml
new file mode 100644
index 0000000..9211408
--- /dev/null
+++ b/dev-embedded/smdk-dltool/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>dev-embedded</herd>
+</pkgmetadata>
diff --git a/dev-embedded/u-boot-tools/metadata.xml b/dev-embedded/u-boot-tools/metadata.xml
new file mode 100644
index 0000000..9211408
--- /dev/null
+++ b/dev-embedded/u-boot-tools/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>dev-embedded</herd>
+</pkgmetadata>
diff --git a/dev-java/java-config-wrapper/metadata.xml b/dev-java/java-config-wrapper/metadata.xml
new file mode 100644
index 0000000..7303cef
--- /dev/null
+++ b/dev-java/java-config-wrapper/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>java</herd>
+</pkgmetadata>
diff --git a/dev-java/java-config/metadata.xml b/dev-java/java-config/metadata.xml
new file mode 100644
index 0000000..7e8e003
--- /dev/null
+++ b/dev-java/java-config/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>java</herd>
+	<longdescription>
+		java-config is used to configure the Java subsystem on your Gentoo
+		installation. In particular, it can be used to configure system-wide and
+		per-user default JVMs, construct classpath env vars from installed java
+		packages and be used to query for the path to various JDK tools.
+	</longdescription>
+</pkgmetadata>
diff --git a/dev-java/metadata.xml b/dev-java/metadata.xml
new file mode 100644
index 0000000..878473a
--- /dev/null
+++ b/dev-java/metadata.xml
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The dev-java category contains libraries and utilities relevant to the
+		Java programming language.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie dev-java enthält Bibliotheken und Werkzeuge für die
+		Programmiersprache Java.
+	</longdescription>
+	<longdescription lang="fi">
+		Kategoria dev-java sisältää kirjastoja ja työkaluja
+		Java-ohjelmointikielen hyödyntämiseen.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría dev-java contiene librerias y utilidades para el lenguaje
+		de programación Java.
+	</longdescription>
+	<longdescription lang="ja">
+		dev-java カテゴリーにはJavaプログラミング言語に関連したライブラリーと
+		ユーティリティが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De dev-java categorie bevat bibliotheken en hulpmiddelen voor het gebruik
+		van de programmeertaal Java.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm dev-java chứa các thư viện và tiện ích liên quan
+		đến ngôn ngữ lập trình Java.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria dev-java contiene librerie ed utilità per il linguaggio Java.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria dev-java contém bibliotecas e utilitários para a
+		linguagem de programação Java.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria dev-java zawiera biblioteki i narzędzia związane z
+		z językiem programowania Java.
+	</longdescription>
+</catmetadata>
+
diff --git a/dev-lang/closure-compiler-bin/metadata.xml b/dev-lang/closure-compiler-bin/metadata.xml
new file mode 100644
index 0000000..f587472
--- /dev/null
+++ b/dev-lang/closure-compiler-bin/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>python</herd>
+<maintainer>
+ <email>vapier@gentoo.org</email>
+ <description>make whatever changes you want except for removal -- i need a compiler that avoids installing a jdk</description>
+</maintainer>
+</pkgmetadata>
diff --git a/dev-lang/jimtcl/metadata.xml b/dev-lang/jimtcl/metadata.xml
new file mode 100644
index 0000000..5e3a61a
--- /dev/null
+++ b/dev-lang/jimtcl/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+<email>hwoarang@gentoo.org</email>
+<name>Markos Chandras</name>
+</maintainer>
+<longdescription lang="en">
+</longdescription>
+</pkgmetadata>
+
diff --git a/dev-lang/metadata.xml b/dev-lang/metadata.xml
new file mode 100644
index 0000000..e19c9e9
--- /dev/null
+++ b/dev-lang/metadata.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The dev-lang category contains various programming language
+		implementations and related tools.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie dev-lang enthält verschiedene Programmiersprachen
+		und die damit verbundenen Werkzeuge.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría dev-lang contiene varias implementaciones de lenguajes de
+		programación y sus respectivas herramientas.
+	</longdescription>
+	<longdescription lang="ja">
+		dev-langカテゴリーには様々なプログラミング言語の実行環境とそれに関連した
+		ツールが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De dev-lang categorie bevat implementaties van verschillende programmeertalen
+		en gerelateerde hulpmiddelen.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm dev-lang chứa các phiên bản cài đặt các ngôn ngữ
+		lập trình khác nhau và các công cụ liên quan.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria dev-lang contiene varie implementazioni di linguaggi di programmazione e utilità correlate.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria dev-lang contém várias implementações de linguagens
+		de programação e ferramentas relacionadas.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria dev-lang zawiera różne implementacje języków programowania i
+		związane z nimi narzędzia.
+	</longdescription>
+</catmetadata>
+
diff --git a/dev-lang/nasm/metadata.xml b/dev-lang/nasm/metadata.xml
new file mode 100644
index 0000000..a648b4a
--- /dev/null
+++ b/dev-lang/nasm/metadata.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+  <email>mr_bones_@gentoo.org</email>
+  <name>Michael Sterrett</name>
+</maintainer>
+<longdescription>
+The Netwide Assembler, NASM, is an 80x86 assembler designed for portability
+and modularity. It supports a range of object file formats, including Linux
+and NetBSD/FreeBSD a.out, ELF, COFF, Microsoft 16-bit OBJ and Win32. It
+will also output plain binary files. Its syntax is designed to be simple
+and easy to understand, similar to Intel's but less complex. It supports
+Pentium, P6, MMX, 3DNow!, SSE and SSE2 opcodes, and has macro capability.
+</longdescription>
+</pkgmetadata>
diff --git a/dev-lang/perl/metadata.xml b/dev-lang/perl/metadata.xml
new file mode 100644
index 0000000..1db3180
--- /dev/null
+++ b/dev-lang/perl/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>perl</herd>
+	<use>
+		<flag name='ithreads'>Enable Perl threads, has some compatibility problems</flag>
+		<flag name='perlsuid'>Enable Perl SUID install. Has some risks associated.</flag>
+	</use>
+</pkgmetadata>
diff --git a/dev-lang/ruby/metadata.xml b/dev-lang/ruby/metadata.xml
new file mode 100644
index 0000000..963d76e
--- /dev/null
+++ b/dev-lang/ruby/metadata.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>ruby</herd>
+  <use>
+    <flag name='rubytests'>
+      Install ruby tests that can only be run after ruby is installed
+    </flag>
+
+    <flag name='libedit'>
+      Use the <pkg>dev-libs/libedit</pkg> library to provide the
+      readline extension, used for instance by the irb tool. This flag
+      will take precedence over the readline USE flag.
+
+      If neither libedit nor readline USE flags are enabled, the
+      readline extension will not be built (and irb will lose line
+      editing functionality).
+    </flag>
+
+    <flag name='readline'>
+      Use the <pkg>sys-libs/readline</pkg> library to provide the
+      readline extension, used for instance by the irb tool. This flag
+      is meaningful only if the libedit USE flag is disabled.
+
+      If neither libedit nor readline USE flags are enabled, the
+      readline extension will not be built (and irb will lose line
+      editing functionality).
+    </flag>
+
+    <flag name='yaml'>
+      Use the <pkg>dev-libs/libyaml</pkg> library to build the psych
+      extension, available since Ruby 1.9.2_rc2, in alternative to the
+      bundled syck-based parser.
+    </flag>
+
+    <flag name='rdoc'>
+      Install <pkg>dev-ruby/rdoc</pkg> after installing Ruby.
+    </flag>
+  </use>
+</pkgmetadata>
diff --git a/dev-lang/swig/metadata.xml b/dev-lang/swig/metadata.xml
new file mode 100644
index 0000000..3161255
--- /dev/null
+++ b/dev-lang/swig/metadata.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>scheme</herd>
+	<maintainer>
+		<email>pchrist@gentoo.org</email>
+		<name>Panagiotis Christopoulos</name>
+	</maintainer>
+	<maintainer>
+		<email>hkBst@gentoo.org</email>
+	</maintainer>
+	<maintainer>
+		<email>radhermit@gentoo.org</email>
+		<name>Tim Harder</name>
+	</maintainer>
+	<longdescription lang="en">
+SWIG is a software development tool that connects programs written in C and C++ with a variety of high-level programming languages. SWIG is used with different	types of languages including common scripting languages such as Perl, Python, Tcl/Tk and Ruby. The list of supported languages also includes non-scripting languages such as C#, Common Lisp (Allegro CL), Java, Modula-3 and OCAML. Also several interpreted and compiled Scheme implementations (Chicken, Guile, MzScheme) are supported.
+	</longdescription>
+	<use>
+		<flag name='ccache'>build ccache-swig(a fast compiler cache)</flag>
+	</use>
+</pkgmetadata>
diff --git a/dev-lang/tcl/metadata.xml b/dev-lang/tcl/metadata.xml
new file mode 100644
index 0000000..3745454
--- /dev/null
+++ b/dev-lang/tcl/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>tcltk</herd>
+  <maintainer>
+    <email>tcltk@gentoo.org</email>
+    <description>TCL/TK Herd.</description>
+  </maintainer>
+</pkgmetadata>
diff --git a/dev-lang/yasm/metadata.xml b/dev-lang/yasm/metadata.xml
new file mode 100644
index 0000000..e9e6c9b
--- /dev/null
+++ b/dev-lang/yasm/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>base-system</herd>
+	<maintainer>
+		<email>ssuominen@gentoo.org</email>
+		<name>Samuli Suominen</name>
+	</maintainer>
+</pkgmetadata>
diff --git a/dev-libs/apr-util/metadata.xml b/dev-libs/apr-util/metadata.xml
new file mode 100644
index 0000000..4a3f337
--- /dev/null
+++ b/dev-libs/apr-util/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>maintainer-needed@gentoo.org</email>
+	</maintainer>
+	<use>
+		<flag name="nss">Install apr_crypto_nss module</flag>
+		<flag name="openssl">Install apr_crypto_openssl module</flag>
+	</use>
+</pkgmetadata>
diff --git a/dev-libs/apr/metadata.xml b/dev-libs/apr/metadata.xml
new file mode 100644
index 0000000..acee4d4
--- /dev/null
+++ b/dev-libs/apr/metadata.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>maintainer-needed@gentoo.org</email>
+	</maintainer>
+	<use>
+		<flag name="older-kernels-compatibility">Enable binary compatibility with older kernels</flag>
+		<flag name="urandom">Use /dev/urandom instead of /dev/random</flag>
+		<flag name="uuid">Enable UUID support</flag>
+	</use>
+</pkgmetadata>
diff --git a/dev-libs/atk/metadata.xml b/dev-libs/atk/metadata.xml
new file mode 100644
index 0000000..d9f21e6
--- /dev/null
+++ b/dev-libs/atk/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>gnome-accessibility</herd>
+</pkgmetadata>
diff --git a/dev-libs/check/metadata.xml b/dev-libs/check/metadata.xml
new file mode 100644
index 0000000..a0468c0
--- /dev/null
+++ b/dev-libs/check/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>binki@gentoo.org</email>
+		<name>Nathan Phillip Brink</name>
+	</maintainer>
+	<use>
+		<flag name="subunit">Enable support for the subunit unit test protocol</flag>
+	</use>
+</pkgmetadata>
diff --git a/dev-libs/crypto++/metadata.xml b/dev-libs/crypto++/metadata.xml
new file mode 100644
index 0000000..b02ffbb
--- /dev/null
+++ b/dev-libs/crypto++/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>crypto</herd>
+</pkgmetadata>
diff --git a/dev-libs/dbus-glib/metadata.xml b/dev-libs/dbus-glib/metadata.xml
new file mode 100644
index 0000000..9879e83
--- /dev/null
+++ b/dev-libs/dbus-glib/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>freedesktop</herd>
+  <maintainer>
+    <email>freedesktop-bugs@gentoo.org</email>
+  </maintainer>
+</pkgmetadata>
diff --git a/dev-libs/elfutils/metadata.xml b/dev-libs/elfutils/metadata.xml
new file mode 100644
index 0000000..6d5bc38
--- /dev/null
+++ b/dev-libs/elfutils/metadata.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>toolchain</herd>
+	<use>
+		<flag name="lzma">Support automatic decompression of LZMA-compressed files and kernel images</flag>
+		<flag name="threads">Build the libraries with thread safe support</flag>
+		<flag name="utils">Install command-line utilities (all the eu-* programs)</flag>
+	</use>
+</pkgmetadata>
diff --git a/dev-libs/engine_pkcs11/metadata.xml b/dev-libs/engine_pkcs11/metadata.xml
new file mode 100644
index 0000000..9682e47
--- /dev/null
+++ b/dev-libs/engine_pkcs11/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>crypto</herd>
+	<longdescription>
+		engine_pkcs11 is an implementation of an engine for OpenSSL.
+	</longdescription>
+</pkgmetadata>
diff --git a/dev-libs/expat/metadata.xml b/dev-libs/expat/metadata.xml
new file mode 100644
index 0000000..2953eb8
--- /dev/null
+++ b/dev-libs/expat/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>freedesktop</herd>
+</pkgmetadata>
diff --git a/dev-libs/fribidi/metadata.xml b/dev-libs/fribidi/metadata.xml
new file mode 100644
index 0000000..d9cd2ca
--- /dev/null
+++ b/dev-libs/fribidi/metadata.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+<email>maintainer-needed@gentoo.org</email>
+</maintainer>
+</pkgmetadata>
diff --git a/dev-libs/glib/metadata.xml b/dev-libs/glib/metadata.xml
new file mode 100644
index 0000000..7224311
--- /dev/null
+++ b/dev-libs/glib/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>gnome</herd>
+  <use>
+	<flag name="systemtap">Build support for profiling and tracing using 
+		<pkg>dev-util/systemtap</pkg></flag>
+	<flag name="utils">Install gtester-report utility to generate test
+		report files for your software.</flag>
+  </use>
+</pkgmetadata>
diff --git a/dev-libs/gmp/metadata.xml b/dev-libs/gmp/metadata.xml
new file mode 100644
index 0000000..b419bd1
--- /dev/null
+++ b/dev-libs/gmp/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>toolchain</herd>
+<use>
+ <flag name='pgo'>after building gmp, run some tests against to produce faster libraries -- this option will double the compile time</flag>
+</use>
+</pkgmetadata>
diff --git a/dev-libs/iniparser/metadata.xml b/dev-libs/iniparser/metadata.xml
new file mode 100644
index 0000000..714b385
--- /dev/null
+++ b/dev-libs/iniparser/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>samba</herd>
+<maintainer>
+	<email>samba@gentoo.org</email>
+	<name>Samba Team</name>
+</maintainer>
+</pkgmetadata>
diff --git a/dev-libs/libaio/metadata.xml b/dev-libs/libaio/metadata.xml
new file mode 100644
index 0000000..a5a7a60
--- /dev/null
+++ b/dev-libs/libaio/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+  <email>maintainer-needed@gentoo.org</email>
+</maintainer>
+<longdescription>Library to provide user-level kernel Asynchronous I/O (AIO)
+ support for Linux (needs kernel patches as of 2.6.12)</longdescription>
+</pkgmetadata>
diff --git a/dev-libs/libatomic_ops/metadata.xml b/dev-libs/libatomic_ops/metadata.xml
new file mode 100644
index 0000000..e1774e3
--- /dev/null
+++ b/dev-libs/libatomic_ops/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>sound</herd>
+</pkgmetadata>
diff --git a/dev-libs/libchewing/metadata.xml b/dev-libs/libchewing/metadata.xml
new file mode 100644
index 0000000..2d5852c
--- /dev/null
+++ b/dev-libs/libchewing/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>cjk</herd>
+</pkgmetadata>
diff --git a/dev-libs/libdaemon/metadata.xml b/dev-libs/libdaemon/metadata.xml
new file mode 100644
index 0000000..2b43b61
--- /dev/null
+++ b/dev-libs/libdaemon/metadata.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>eva@gentoo.org</email>
+	</maintainer>
+</pkgmetadata>
diff --git a/dev-libs/libevent/metadata.xml b/dev-libs/libevent/metadata.xml
new file mode 100644
index 0000000..52363bf
--- /dev/null
+++ b/dev-libs/libevent/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>jer@gentoo.org</email>
+		<name>Jeroen Roovers</name>
+	</maintainer>
+</pkgmetadata>
diff --git a/dev-libs/libgpg-error/metadata.xml b/dev-libs/libgpg-error/metadata.xml
new file mode 100644
index 0000000..780611b
--- /dev/null
+++ b/dev-libs/libgpg-error/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>crypto</herd>
+	<use>
+		<flag name="common-lisp">Install common-lisp files</flag>
+	</use>
+</pkgmetadata>
diff --git a/dev-libs/libnl/metadata.xml b/dev-libs/libnl/metadata.xml
new file mode 100644
index 0000000..d9379a5
--- /dev/null
+++ b/dev-libs/libnl/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>netmon</herd>
+<use>
+<flag name="utils">Install command line interface utils</flag>
+<flag name="doc">Install development documentation</flag>
+</use>
+</pkgmetadata>
diff --git a/dev-libs/libotf/metadata.xml b/dev-libs/libotf/metadata.xml
new file mode 100644
index 0000000..cdee253
--- /dev/null
+++ b/dev-libs/libotf/metadata.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>cjk</herd>
+<herd>fonts</herd>
+</pkgmetadata>
diff --git a/dev-libs/libp11/metadata.xml b/dev-libs/libp11/metadata.xml
new file mode 100644
index 0000000..831aab7
--- /dev/null
+++ b/dev-libs/libp11/metadata.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>crypto</herd>
+  <longdescription>
+    Library implementing a small layer on top of PKCS#11 API to make
+    using PKCS#11 implementations easier.
+  </longdescription>
+
+  <use>
+    <flag name='doc'>
+      Generate and install API documentation for the package.
+    </flag>
+  </use>
+</pkgmetadata>
diff --git a/dev-libs/libpcre/metadata.xml b/dev-libs/libpcre/metadata.xml
new file mode 100644
index 0000000..56495e4
--- /dev/null
+++ b/dev-libs/libpcre/metadata.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>base-system</herd>
+  <use>
+    <flag name='bzip2'>
+      Add support for pcregrep command to search within
+      bzip2-compressed files, through <pkg>sys-libs/zlib</pkg>.
+    </flag>
+
+    <flag name='pcre16'>
+      Build 16 bit PCRE library.
+    </flag>
+
+    <flag name='readline'>
+      Add support for command line editing to pcretest, through
+      <pkg>sys-libs/readline</pkg>.
+    </flag>
+
+    <flag name='recursion-limit'>
+      Limit match recursion to 8192; if disabled, the default limit is
+      used, which is the same as the match limit.
+    </flag>
+
+    <flag name='zlib'>
+      Add support for pcregrep command to search within
+      gzip-compressed files, through <pkg>app-arch/gzip</pkg>.
+    </flag>
+  </use>
+</pkgmetadata>
diff --git a/dev-libs/libpthread-stubs/metadata.xml b/dev-libs/libpthread-stubs/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/dev-libs/libpthread-stubs/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/dev-libs/libtasn1/metadata.xml b/dev-libs/libtasn1/metadata.xml
new file mode 100644
index 0000000..b02ffbb
--- /dev/null
+++ b/dev-libs/libtasn1/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>crypto</herd>
+</pkgmetadata>
diff --git a/dev-libs/libusb/metadata.xml b/dev-libs/libusb/metadata.xml
new file mode 100644
index 0000000..659da0c
--- /dev/null
+++ b/dev-libs/libusb/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>base-system</herd>
+</pkgmetadata>
diff --git a/dev-libs/libxslt/metadata.xml b/dev-libs/libxslt/metadata.xml
new file mode 100644
index 0000000..da6fd63
--- /dev/null
+++ b/dev-libs/libxslt/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>gnome</herd>
+</pkgmetadata>
diff --git a/dev-libs/libyaml/metadata.xml b/dev-libs/libyaml/metadata.xml
new file mode 100644
index 0000000..15dcec1
--- /dev/null
+++ b/dev-libs/libyaml/metadata.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>sbriesen@gentoo.org</email>
+		<name>Stefan Briesenick</name>
+	</maintainer>
+	<longdescription lang="en">
+		LibYAML is a YAML 1.1 parser and emitter written in C.
+		It's in an early stage of development.
+	</longdescription>
+</pkgmetadata>
diff --git a/dev-libs/lzo/metadata.xml b/dev-libs/lzo/metadata.xml
new file mode 100644
index 0000000..caaa4ac
--- /dev/null
+++ b/dev-libs/lzo/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+    <email>binki@gentoo.org</email>
+    <name>Nathan Phillip Brink</name>
+</maintainer>
+<longdescription></longdescription>
+</pkgmetadata>
diff --git a/dev-libs/m17n-lib/metadata.xml b/dev-libs/m17n-lib/metadata.xml
new file mode 100644
index 0000000..8c2cd4b
--- /dev/null
+++ b/dev-libs/m17n-lib/metadata.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>cjk</herd>
+  <use>
+    <flag name='X'>
+      Builds the Graphical User Interface API and utilities for the
+      package.
+    </flag>
+    <flag name='anthy'>Enable support for <pkg>app-i18n/anthy</pkg>
+    input method.</flag>
+    <flag name='athena'>Enable the MIT Athena widget set
+    (<pkg>x11-libs/libXaw</pkg>)</flag>
+    <flag name='gd'>
+      Build API and utilities based on <pkg>media-libs/gd</pkg>. This
+      flag is only meaningful if the X USE flag is also enabled.
+    </flag>
+    <flag name='libotf'>Use <pkg>dev-libs/libotf</pkg> to handle OpenType fonts</flag>
+    <flag name='libxml2'>Use <pkg>dev-libs/libxml2</pkg> to parse XML</flag>
+  </use>
+</pkgmetadata>
diff --git a/dev-libs/metadata.xml b/dev-libs/metadata.xml
new file mode 100644
index 0000000..e85537c
--- /dev/null
+++ b/dev-libs/metadata.xml
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The dev-libs category contains various miscellaneous programming
+		libraries.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie dev-libs enthält verschiedenste Programmierbibliotheken.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría dev-libs contiene varias librerías mixtas
+		para programación.
+	</longdescription>
+	<longdescription lang="ja">
+		dev-libsカテゴリーには多種多様なプログラミング・ライブラリが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De dev-libs categorie bevat verschillende bibliotheken die het
+		programmeren ondersteunen.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm dev-libs chứa các thư viện lập trình khác nhau.
+	</longdescription>
+	<longdescription lang="sk">
+		Kategória dev-libs obsahuje rôzne programovacie knižnice.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria dev-libs contiene varie librerie per la programmazione.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria dev-libs contém várias bibliotecas mistas para
+		programação.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria dev-libs zawiera różne dodatkowe biblioteki związane z programowaniem.
+	</longdescription>
+</catmetadata>
+
diff --git a/dev-libs/mpc/metadata.xml b/dev-libs/mpc/metadata.xml
new file mode 100644
index 0000000..5961aa2
--- /dev/null
+++ b/dev-libs/mpc/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>toolchain</herd>
+</pkgmetadata>
diff --git a/dev-libs/mpfr/metadata.xml b/dev-libs/mpfr/metadata.xml
new file mode 100644
index 0000000..fb4199e
--- /dev/null
+++ b/dev-libs/mpfr/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>toolchain</herd>
+</pkgmetadata>
diff --git a/dev-libs/newt/metadata.xml b/dev-libs/newt/metadata.xml
new file mode 100644
index 0000000..8a0d67b
--- /dev/null
+++ b/dev-libs/newt/metadata.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>naota@gentoo.org</email>
+	</maintainer>
+</pkgmetadata>
diff --git a/dev-libs/opensc/metadata.xml b/dev-libs/opensc/metadata.xml
new file mode 100644
index 0000000..9f7c01f
--- /dev/null
+++ b/dev-libs/opensc/metadata.xml
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>crypto</herd>
+  <longdescription>
+    OpenSC is a library for accessing SmartCard devices. It is also
+    the core library of the OpenSC project.
+
+    Basic functionality (e.g. SELECT FILE, READ BINARY) should work on
+    any ISO 7816-4 compatible SmartCard.  Encryption and decryption
+    using private keys on the SmartCard is possible with PKCS #15
+    compatible cards, such as the FINEID (Finnish Electronic IDentity)
+    card.
+  </longdescription>
+  <use>
+    <flag name='libtool'>
+      Use <pkg>sys-devel/libtool</pkg> for dynamically loading libraries
+      rather than the host libdl/dlopen helpers.
+    </flag>
+
+    <flag name='openct'>
+      Use <pkg>dev-libs/openct</pkg> (and CT-API) for accessing
+      Smartcard hardware.
+    </flag>
+
+    <flag name='ctapi'>
+      Use CT-API for accessing Smartcard hardware.
+    </flag>
+
+    <flag name='pcsc-lite'>
+      Use <pkg>sys-apps/pcsc-lite</pkg> (and PC/SC API) for accessing
+      Smartcard hardware.
+    </flag>
+
+    <flag name='secure-messaging'>
+      Enable secure messaging.
+    </flag>
+  </use>
+</pkgmetadata>
diff --git a/dev-libs/openssl/metadata.xml b/dev-libs/openssl/metadata.xml
new file mode 100644
index 0000000..c3a9997
--- /dev/null
+++ b/dev-libs/openssl/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<use>
+ <flag name='bindist'>Disable EC/RC5 algorithms (as they seem to be patented)</flag>
+ <flag name='rfc3779'>Enable support for RFC 3779 (X.509 Extensions for IP Addresses and AS Identifiers)</flag>
+</use>
+</pkgmetadata>
diff --git a/dev-libs/pkcs11-helper/metadata.xml b/dev-libs/pkcs11-helper/metadata.xml
new file mode 100644
index 0000000..57a9ee6
--- /dev/null
+++ b/dev-libs/pkcs11-helper/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>crypto</herd>
+<use>
+  <flag name='nss'>Enable NSS crypto engine</flag>
+</use>
+</pkgmetadata>
diff --git a/dev-libs/popt/metadata.xml b/dev-libs/popt/metadata.xml
new file mode 100644
index 0000000..bee9f9a
--- /dev/null
+++ b/dev-libs/popt/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>base-system</herd>
+</pkgmetadata>
diff --git a/dev-libs/udis86/metadata.xml b/dev-libs/udis86/metadata.xml
new file mode 100644
index 0000000..64da8c6
--- /dev/null
+++ b/dev-libs/udis86/metadata.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>chithanh@gentoo.org</email>
+		<name>Chí-Thanh Christopher Nguyễn</name>
+	</maintainer>
+	<use>
+		<flag name="pic">Force shared libraries to be built as PIC</flag>
+	</use>
+</pkgmetadata>
+
diff --git a/dev-libs/xmlrpc-c/metadata.xml b/dev-libs/xmlrpc-c/metadata.xml
new file mode 100644
index 0000000..86b1e0a
--- /dev/null
+++ b/dev-libs/xmlrpc-c/metadata.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>proxy-maintainers</herd>
+	<maintainer>
+		<email>andreis.vinogradovs@gmail.com</email>
+		<name>Andreis Vinogradovs</name>
+	</maintainer>
+	<use>
+		<flag name='abyss'>Build the Abyss mini web-server.</flag>
+		<flag name='libxml2'>Use dev-libs/libxml2 to parse XML instead of the internal expat library.</flag>
+		<flag name='threads'>Controls whether to build the Abyss web-server with pthreads or fork 'threading'.</flag>
+		<flag name='tools'>Build the xmlrpc* tools.</flag>
+	</use>
+</pkgmetadata>
diff --git a/dev-perl/Crypt-PasswdMD5/metadata.xml b/dev-perl/Crypt-PasswdMD5/metadata.xml
new file mode 100644
index 0000000..a873327
--- /dev/null
+++ b/dev-perl/Crypt-PasswdMD5/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>perl</herd>
+  <upstream>
+    <remote-id type="cpan">Crypt-PasswdMD5</remote-id>
+    <remote-id type="cpan-module">Crypt::PasswdMD5</remote-id>
+  </upstream>
+</pkgmetadata>
diff --git a/dev-perl/Digest-SHA1/metadata.xml b/dev-perl/Digest-SHA1/metadata.xml
new file mode 100644
index 0000000..8565ca2
--- /dev/null
+++ b/dev-perl/Digest-SHA1/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>perl</herd>
+  <upstream>
+    <remote-id type="cpan">Digest-SHA1</remote-id>
+    <remote-id type="cpan-module">Digest::SHA1</remote-id>
+  </upstream>
+</pkgmetadata>
diff --git a/dev-perl/GD/metadata.xml b/dev-perl/GD/metadata.xml
new file mode 100644
index 0000000..ee4d212
--- /dev/null
+++ b/dev-perl/GD/metadata.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>perl</herd>
+  <use>
+    <flag name="animgif">Enable animated gif support</flag>
+  </use>
+  <upstream>
+    <remote-id type="cpan">GD</remote-id>
+    <remote-id type="cpan-module">GD</remote-id>
+    <remote-id type="cpan-module">GD::Group</remote-id>
+    <remote-id type="cpan-module">GD::Polygon</remote-id>
+    <remote-id type="cpan-module">GD::Polyline</remote-id>
+    <remote-id type="cpan-module">GD::Simple</remote-id>
+  </upstream>
+</pkgmetadata>
diff --git a/dev-perl/Locale-gettext/metadata.xml b/dev-perl/Locale-gettext/metadata.xml
new file mode 100644
index 0000000..e780592
--- /dev/null
+++ b/dev-perl/Locale-gettext/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>perl</herd>
+  <upstream>
+    <remote-id type="cpan">gettext</remote-id>
+    <remote-id type="cpan-module">Locale::gettext</remote-id>
+  </upstream>
+</pkgmetadata>
diff --git a/dev-perl/Text-Unidecode/metadata.xml b/dev-perl/Text-Unidecode/metadata.xml
new file mode 100644
index 0000000..c9be3ad
--- /dev/null
+++ b/dev-perl/Text-Unidecode/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>perl</herd>
+  <upstream>
+    <remote-id type="cpan">Text-Unidecode</remote-id>
+    <remote-id type="cpan-module">Text::Unidecode</remote-id>
+  </upstream>
+</pkgmetadata>
diff --git a/dev-perl/URI/metadata.xml b/dev-perl/URI/metadata.xml
index 6f997c1..d1083f8 100644
--- a/dev-perl/URI/metadata.xml
+++ b/dev-perl/URI/metadata.xml
@@ -4,5 +4,57 @@
   <herd>perl</herd>
   <upstream>
     <remote-id type="cpan">URI</remote-id>
+    <remote-id type="cpan-module">URI</remote-id>
+    <remote-id type="cpan-module">URI::Escape</remote-id>
+    <remote-id type="cpan-module">URI::Heuristic</remote-id>
+    <remote-id type="cpan-module">URI::IRI</remote-id>
+    <remote-id type="cpan-module">URI::QueryParam</remote-id>
+    <remote-id type="cpan-module">URI::Split</remote-id>
+    <remote-id type="cpan-module">URI::URL</remote-id>
+    <remote-id type="cpan-module">URI::WithBase</remote-id>
+    <remote-id type="cpan-module">URI::_foreign</remote-id>
+    <remote-id type="cpan-module">URI::_generic</remote-id>
+    <remote-id type="cpan-module">URI::_idna</remote-id>
+    <remote-id type="cpan-module">URI::_ldap</remote-id>
+    <remote-id type="cpan-module">URI::_login</remote-id>
+    <remote-id type="cpan-module">URI::_punycode</remote-id>
+    <remote-id type="cpan-module">URI::_query</remote-id>
+    <remote-id type="cpan-module">URI::_segment</remote-id>
+    <remote-id type="cpan-module">URI::_server</remote-id>
+    <remote-id type="cpan-module">URI::_userpass</remote-id>
+    <remote-id type="cpan-module">URI::data</remote-id>
+    <remote-id type="cpan-module">URI::file</remote-id>
+    <remote-id type="cpan-module">URI::file::Base</remote-id>
+    <remote-id type="cpan-module">URI::file::FAT</remote-id>
+    <remote-id type="cpan-module">URI::file::Mac</remote-id>
+    <remote-id type="cpan-module">URI::file::OS2</remote-id>
+    <remote-id type="cpan-module">URI::file::QNX</remote-id>
+    <remote-id type="cpan-module">URI::file::Unix</remote-id>
+    <remote-id type="cpan-module">URI::file::Win32</remote-id>
+    <remote-id type="cpan-module">URI::ftp</remote-id>
+    <remote-id type="cpan-module">URI::gopher</remote-id>
+    <remote-id type="cpan-module">URI::http</remote-id>
+    <remote-id type="cpan-module">URI::https</remote-id>
+    <remote-id type="cpan-module">URI::ldap</remote-id>
+    <remote-id type="cpan-module">URI::ldapi</remote-id>
+    <remote-id type="cpan-module">URI::ldaps</remote-id>
+    <remote-id type="cpan-module">URI::mailto</remote-id>
+    <remote-id type="cpan-module">URI::mms</remote-id>
+    <remote-id type="cpan-module">URI::news</remote-id>
+    <remote-id type="cpan-module">URI::nntp</remote-id>
+    <remote-id type="cpan-module">URI::pop</remote-id>
+    <remote-id type="cpan-module">URI::rlogin</remote-id>
+    <remote-id type="cpan-module">URI::rsync</remote-id>
+    <remote-id type="cpan-module">URI::rtsp</remote-id>
+    <remote-id type="cpan-module">URI::rtspu</remote-id>
+    <remote-id type="cpan-module">URI::sip</remote-id>
+    <remote-id type="cpan-module">URI::sips</remote-id>
+    <remote-id type="cpan-module">URI::snews</remote-id>
+    <remote-id type="cpan-module">URI::ssh</remote-id>
+    <remote-id type="cpan-module">URI::telnet</remote-id>
+    <remote-id type="cpan-module">URI::tn3270</remote-id>
+    <remote-id type="cpan-module">URI::urn</remote-id>
+    <remote-id type="cpan-module">URI::urn::isbn</remote-id>
+    <remote-id type="cpan-module">URI::urn::oid</remote-id>
   </upstream>
 </pkgmetadata>
diff --git a/dev-perl/XML-Parser/metadata.xml b/dev-perl/XML-Parser/metadata.xml
new file mode 100644
index 0000000..c867a87
--- /dev/null
+++ b/dev-perl/XML-Parser/metadata.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>perl</herd>
+  <upstream>
+    <remote-id type="cpan">XML-Parser</remote-id>
+    <remote-id type="cpan-module">XML::Parser</remote-id>
+    <remote-id type="cpan-module">XML::Parser::Expat</remote-id>
+    <remote-id type="cpan-module">XML::Parser::Style::Debug</remote-id>
+    <remote-id type="cpan-module">XML::Parser::Style::Objects</remote-id>
+    <remote-id type="cpan-module">XML::Parser::Style::Stream</remote-id>
+    <remote-id type="cpan-module">XML::Parser::Style::Subs</remote-id>
+    <remote-id type="cpan-module">XML::Parser::Style::Tree</remote-id>
+  </upstream>
+</pkgmetadata>
diff --git a/dev-perl/YAML-Tiny/metadata.xml b/dev-perl/YAML-Tiny/metadata.xml
index 8c560b3..377bdd3 100644
--- a/dev-perl/YAML-Tiny/metadata.xml
+++ b/dev-perl/YAML-Tiny/metadata.xml
@@ -2,10 +2,8 @@
 <!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
 <pkgmetadata>
   <herd>perl</herd>
-  <maintainer>
-    <email>robbat2@gentoo.org</email>
-  </maintainer>
   <upstream>
     <remote-id type="cpan">YAML-Tiny</remote-id>
+    <remote-id type="cpan-module">YAML::Tiny</remote-id>
   </upstream>
 </pkgmetadata>
diff --git a/dev-perl/libintl-perl/metadata.xml b/dev-perl/libintl-perl/metadata.xml
new file mode 100644
index 0000000..3c5fc2b
--- /dev/null
+++ b/dev-perl/libintl-perl/metadata.xml
@@ -0,0 +1,158 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>perl</herd>
+  <upstream>
+    <remote-id type="cpan">libintl-perl</remote-id>
+    <remote-id type="cpan-module">Locale::Messages</remote-id>
+    <remote-id type="cpan-module">Locale::Recode</remote-id>
+    <remote-id type="cpan-module">Locale::Recode::_Aliases</remote-id>
+    <remote-id type="cpan-module">Locale::Recode::_Conversions</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ASMO_449</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ATARI_ST</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ATARI_ST_EURO</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::CP10007</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::CP1250</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::CP1251</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::CP1252</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::CP1253</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::CP1254</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::CP1256</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::CP1257</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::CSN_369103</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::CWI</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::DEC_MCS</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::EBCDIC_AT_DE</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::EBCDIC_AT_DE_A</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::EBCDIC_CA_FR</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::EBCDIC_DK_NO</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::EBCDIC_DK_NO_A</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::EBCDIC_ES</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::EBCDIC_ES_A</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::EBCDIC_ES_S</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::EBCDIC_FI_SE</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::EBCDIC_FI_SE_A</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::EBCDIC_FR</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::EBCDIC_IS_FRISS</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::EBCDIC_IT</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::EBCDIC_PT</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::EBCDIC_UK</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::EBCDIC_US</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ECMA_CYRILLIC</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::GEORGIAN_ACADEMY</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::GEORGIAN_PS</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::GOST_19768_74</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::GREEK7</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::GREEK7_OLD</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::GREEK_CCITT</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::HP_ROMAN8</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM037</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM038</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM1004</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM1026</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM1047</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM256</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM273</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM274</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM275</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM277</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM278</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM280</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM281</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM284</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM285</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM290</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM297</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM420</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM423</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM424</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM437</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM500</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM850</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM851</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM852</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM855</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM857</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM860</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM861</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM862</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM863</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM864</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM865</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM866</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM868</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM869</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM870</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM871</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM874</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM875</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM880</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM891</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM903</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM904</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM905</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IBM918</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::IEC_P27_1</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::INIS</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::INIS_8</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::INIS_CYRILLIC</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_10367_BOX</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_2033_1983</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_5427</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_5427_EXT</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_5428</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_8859_1</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_8859_10</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_8859_11</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_8859_13</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_8859_14</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_8859_15</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_8859_16</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_8859_2</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_8859_3</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_8859_4</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_8859_5</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_8859_6</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_8859_7</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_8859_8</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::ISO_8859_9</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::KOI8_R</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::KOI8_RU</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::KOI8_T</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::KOI8_U</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::KOI_8</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::LATIN_GREEK</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::LATIN_GREEK_1</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::MACARABIC</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::MACCROATIAN</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::MACCYRILLIC</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::MACGREEK</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::MACHEBREW</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::MACICELAND</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::MACINTOSH</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::MACROMANIA</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::MACTHAI</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::MACTURKISH</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::MACUKRAINE</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::MAC_IS</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::MAC_SAMI</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::MAC_UK</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::NATS_DANO</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::NATS_SEFI</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::NEXTSTEP</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::SAMI_WS2</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::TIS_620</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::US_ASCII</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::UTF_8</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::VISCII</remote-id>
+    <remote-id type="cpan-module">Locale::RecodeData::_Encode</remote-id>
+    <remote-id type="cpan-module">Locale::TextDomain</remote-id>
+    <remote-id type="cpan-module">Locale::Util</remote-id>
+    <remote-id type="cpan-module">Locale::gettext_pp</remote-id>
+    <remote-id type="cpan-module">Locale::gettext_xs</remote-id>
+    <remote-id type="cpan-module">MyInstall</remote-id>
+    <remote-id type="cpan-module">SimpleCal</remote-id>
+    <remote-id type="cpan-module">__TiedTextDomain</remote-id>
+  </upstream>
+</pkgmetadata>
diff --git a/dev-perl/metadata.xml b/dev-perl/metadata.xml
new file mode 100644
index 0000000..707e230
--- /dev/null
+++ b/dev-perl/metadata.xml
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The dev-perl category contains libraries and utilities relevant to the
+		Perl programming language.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie dev-perl enthält Bibliotheken und Werkzeuge für die 
+		Programmiersprache Perl.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría dev-perl contiene librerías y utilidades referentes
+		al lenguaje de programación Perl.
+	</longdescription>
+	<longdescription lang="ja">
+		dev-perlカテゴリーにはPerlプログラミング言語に関連したライブラリーと
+		ユーティリティが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De dev-perl categorie bevat bibliotheken en hulpmiddelen voor het gebruik
+		van de programmeertaal Perl.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm dev-perl chứa các thư viện và tiện ích liên quan
+		đến ngôn ngữ lập trình Perl.
+	</longdescription>
+	<longdescription lang="sk">
+		Kategória dev-perl obsahuje knižnice a utility pre programovací jazyk
+		Perl.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria dev-perl contiene librerie ed utilità per il linguaggio di programmazione Perl.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria dev-perl contém bibliotecas e utilitários referentes
+		à linguagem de programação Perl.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria dev-perl zawiera biblioteki i narzędzia związane z
+		językiem programowania Perl.
+	</longdescription>
+</catmetadata>
+
diff --git a/dev-perl/yaml/metadata.xml b/dev-perl/yaml/metadata.xml
index 83e1276..9e1dc75 100644
--- a/dev-perl/yaml/metadata.xml
+++ b/dev-perl/yaml/metadata.xml
@@ -4,5 +4,29 @@
   <herd>perl</herd>
   <upstream>
     <remote-id type="cpan">YAML</remote-id>
+    <remote-id type="cpan-module">Test::YAML</remote-id>
+    <remote-id type="cpan-module">Test::YAML::Filter</remote-id>
+    <remote-id type="cpan-module">YAML</remote-id>
+    <remote-id type="cpan-module">YAML::Any</remote-id>
+    <remote-id type="cpan-module">YAML::Dumper</remote-id>
+    <remote-id type="cpan-module">YAML::Dumper::Base</remote-id>
+    <remote-id type="cpan-module">YAML::Error</remote-id>
+    <remote-id type="cpan-module">YAML::Loader</remote-id>
+    <remote-id type="cpan-module">YAML::Loader::Base</remote-id>
+    <remote-id type="cpan-module">YAML::Marshall</remote-id>
+    <remote-id type="cpan-module">YAML::Mo</remote-id>
+    <remote-id type="cpan-module">YAML::Node</remote-id>
+    <remote-id type="cpan-module">YAML::Tag</remote-id>
+    <remote-id type="cpan-module">YAML::Type::blessed</remote-id>
+    <remote-id type="cpan-module">YAML::Type::code</remote-id>
+    <remote-id type="cpan-module">YAML::Type::glob</remote-id>
+    <remote-id type="cpan-module">YAML::Type::ref</remote-id>
+    <remote-id type="cpan-module">YAML::Type::regexp</remote-id>
+    <remote-id type="cpan-module">YAML::Type::undef</remote-id>
+    <remote-id type="cpan-module">YAML::Types</remote-id>
+    <remote-id type="cpan-module">YAML::Warning</remote-id>
+    <remote-id type="cpan-module">yaml_mapping</remote-id>
+    <remote-id type="cpan-module">yaml_scalar</remote-id>
+    <remote-id type="cpan-module">yaml_sequence</remote-id>
   </upstream>
 </pkgmetadata>
diff --git a/dev-python/argparse/metadata.xml b/dev-python/argparse/metadata.xml
new file mode 100644
index 0000000..2c67fa7
--- /dev/null
+++ b/dev-python/argparse/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="google-code">argparse</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/astng/metadata.xml b/dev-python/astng/metadata.xml
new file mode 100644
index 0000000..1b13630
--- /dev/null
+++ b/dev-python/astng/metadata.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>python</herd>
+  <longdescription lang="en">The aim of this module is to provide a common base representation of
+  python source code for projects such as pychecker, pyreverse,
+  pylint... Well, actually the development of this library is
+  essentially governed by pylint's needs.
+  It provides a compatible representation which comes from the _ast
+  module. It rebuilds the tree generated by the builtin _ast module by
+  recursively walking down the AST and building an extended ast (let's
+  call it astng ;). The new node classes have additional methods and
+  attributes for different usages. They include some support for static
+  inference and local name scopes. Furthermore, astng builds partial
+  trees by inspecting living objects.</longdescription>
+  <upstream>
+    <remote-id type="pypi">logilab-astng</remote-id>
+  </upstream>
+</pkgmetadata>
diff --git a/dev-python/beaker/metadata.xml b/dev-python/beaker/metadata.xml
new file mode 100644
index 0000000..cee3bb6
--- /dev/null
+++ b/dev-python/beaker/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="pypi">Beaker</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/boto/metadata.xml b/dev-python/boto/metadata.xml
new file mode 100644
index 0000000..1548fc6
--- /dev/null
+++ b/dev-python/boto/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<maintainer>
+		<email>vapier@gentoo.org</email>
+	</maintainer>
+	<upstream>
+		<remote-id type="google-code">boto</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/certifi/metadata.xml b/dev-python/certifi/metadata.xml
new file mode 100644
index 0000000..0942d52
--- /dev/null
+++ b/dev-python/certifi/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="pypi">certifi</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/chardet/metadata.xml b/dev-python/chardet/metadata.xml
new file mode 100644
index 0000000..de483c5
--- /dev/null
+++ b/dev-python/chardet/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>python</herd>
+</pkgmetadata>
diff --git a/dev-python/cherrypy/metadata.xml b/dev-python/cherrypy/metadata.xml
new file mode 100644
index 0000000..301d220
--- /dev/null
+++ b/dev-python/cherrypy/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+</pkgmetadata>
diff --git a/dev-python/ctypesgen/metadata.xml b/dev-python/ctypesgen/metadata.xml
new file mode 100644
index 0000000..301d220
--- /dev/null
+++ b/dev-python/ctypesgen/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+</pkgmetadata>
diff --git a/dev-python/dbus-python/metadata.xml b/dev-python/dbus-python/metadata.xml
new file mode 100644
index 0000000..1f701e5
--- /dev/null
+++ b/dev-python/dbus-python/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>python</herd>
+  <herd>freedesktop</herd>
+  <maintainer>
+    <email>freedesktop-bugs@gentoo.org</email>
+  </maintainer>
+</pkgmetadata>
diff --git a/dev-python/django/metadata.xml b/dev-python/django/metadata.xml
new file mode 100644
index 0000000..301d220
--- /dev/null
+++ b/dev-python/django/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+</pkgmetadata>
diff --git a/dev-python/dnspython/metadata.xml b/dev-python/dnspython/metadata.xml
new file mode 100644
index 0000000..e593ae8
--- /dev/null
+++ b/dev-python/dnspython/metadata.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>python</herd>
+<longdescription>
+dnspython is a DNS toolkit for Python. It supports almost all of the record
+types. It can be used for queries, zone transfers, and dynamic updates. It
+supports TSIG authenticated messages and EDNS0.  dnspython provides both high
+and low level access to DNS. The high level classes perform queries for data
+of a given name, type, and class, and return an answer set. The low level
+classes allow direct manipulation of DNS zones, messages, names, and records.
+</longdescription>
+<longdescription lang="ja">
+DNSPythonはPython言語用のDNSツールキットです。ほとんどのレコード・タイプをサポー
+トします。クエリー、ゾーン・トランスファー、ダイナミック・アップデートができます
+。TSTGメッセージ認証とEDNS0をサポートします。DNSPythonは高水準でのアクセスと低水
+準でのアクセスの両方を提供します。高水準ではネーム、タイプ、クラスでクエリーを行
+い、その戻り値を使います。低水準はゾーン、メッセージ、ネーム、レコードを直接操作
+します。
+</longdescription>
+</pkgmetadata>
diff --git a/dev-python/flup/metadata.xml b/dev-python/flup/metadata.xml
new file mode 100644
index 0000000..de483c5
--- /dev/null
+++ b/dev-python/flup/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>python</herd>
+</pkgmetadata>
diff --git a/dev-python/imaging/metadata.xml b/dev-python/imaging/metadata.xml
new file mode 100644
index 0000000..de483c5
--- /dev/null
+++ b/dev-python/imaging/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>python</herd>
+</pkgmetadata>
diff --git a/dev-python/ipython/metadata.xml b/dev-python/ipython/metadata.xml
new file mode 100644
index 0000000..ce50223
--- /dev/null
+++ b/dev-python/ipython/metadata.xml
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<longdescription>
+IPython provides a replacement for the interactive Python interpreter with
+extra functionality.
+
+Main features:
+* Comprehensive object introspection.
+* Input history, persistent across sessions.
+* Caching of output results during a session with automatically generated
+  references.
+* Readline based name completion.
+* Extensible system of 'magic' commands for controlling the environment and
+  performing many tasks related either to IPython or the operating system.
+* Configuration system with easy switching between different setups (simpler
+  than changing $PYTHONSTARTUP environment variables every time).
+* Session logging and reloading.
+* Extensible syntax processing for special purpose situations.
+* Access to the system shell with user-extensible alias system.
+* Easily embeddable in other Python programs.
+* Integrated access to the pdb debugger and the Python profiler.
+</longdescription>
+	<longdescription lang="ja">
+対話的に利用する場合にPythonインタープリタから、より機能が豊富なIPythonへ置き換&gt;える事ができます。
+
+主機能：
+* 内包的オブジェクトの分析。
+* 入力ヒストリーはセッションを越えて記憶し続けます。
+* 出力は自動作成されるリファレンスのセッション間はキャッシュします。
+* Readlineを利用した名前補完。
+* 環境管理とIPythonまたはOSのどちらかに関係するタスク実行のためのmagic
+  コマンドを拡張可能なシステム。
+* 異なるセットアップを簡単に交換できるコンフィグレーション・システム。
+  (毎回起動時に、$PYTHONSTARTUP環境変数を指定するよりも簡単です。)
+* セッション・ロギングとセッション・リローディング。
+* 特別な状況時のための拡張可能な構文解析。
+* ユーザー定義できるエイリアス・システムでシステム・シェルにアクセス。
+* 他のPython言語プログラムを組み込むのが簡単。
+* pdbデバッガとprofilerへの統合アクセス。
+</longdescription>
+<use>
+  <flag name="matplotlib">Add support for <pkg>dev-python/matplotlib</pkg></flag>
+  <flag name="mongodb">Enable support for MongoDB via <pkg>dev-python/pymongo</pkg></flag>
+  <flag name="notebook">Install requirements for the web notebook based on <pkg>www-servers/tornado</pkg></flag>
+  <flag name="octave">Enable octave bridge via <pkg>dev-python/oct2py</pkg></flag>
+</use>
+</pkgmetadata>
diff --git a/dev-python/jsonrpclib/metadata.xml b/dev-python/jsonrpclib/metadata.xml
new file mode 100644
index 0000000..80f2c02
--- /dev/null
+++ b/dev-python/jsonrpclib/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>python</herd>
+<maintainer>
+ <email>vapier@gentoo.org</email>
+ <description>make whatever changes you want</description>
+</maintainer>
+</pkgmetadata>
diff --git a/dev-python/lockfile/metadata.xml b/dev-python/lockfile/metadata.xml
new file mode 100644
index 0000000..90c5f8c
--- /dev/null
+++ b/dev-python/lockfile/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="google-code">pylockfile</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/logilab-common/metadata.xml b/dev-python/logilab-common/metadata.xml
new file mode 100644
index 0000000..2c6b0c6
--- /dev/null
+++ b/dev-python/logilab-common/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="pypi">logilab-common</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/m2crypto/metadata.xml b/dev-python/m2crypto/metadata.xml
new file mode 100644
index 0000000..001dc58
--- /dev/null
+++ b/dev-python/m2crypto/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="pypi">M2Crypto</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/mako/metadata.xml b/dev-python/mako/metadata.xml
new file mode 100644
index 0000000..301d220
--- /dev/null
+++ b/dev-python/mako/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+</pkgmetadata>
diff --git a/dev-python/markupsafe/metadata.xml b/dev-python/markupsafe/metadata.xml
new file mode 100644
index 0000000..5eb521f
--- /dev/null
+++ b/dev-python/markupsafe/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="pypi">MarkupSafe</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/metadata.xml b/dev-python/metadata.xml
new file mode 100644
index 0000000..cbb601a
--- /dev/null
+++ b/dev-python/metadata.xml
@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The dev-python category contains libraries, utilities or
+		bindings written in or for the Python programming language. 
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie dev-python enthält Bibliotheken und Werkzeuge für die
+		Programmiersprache Python.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría dev-python contiene librerias y utilidades referentes al
+		lenguaje de programación Python.
+	</longdescription>
+	<longdescription lang="ja">
+		dev-pythonカテゴリーにはPythonプログラミング言語で記述された/のために
+		記述されたライブラリーと>ユーティリティとバインディングが含まれます。
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria dev-python zawiera biblioteki oraz narzędzia związane
+		z językiem programowania Python.
+	</longdescription>
+	<longdescription lang="nl">
+		De dev-python categorie bevat bibliotheken en hulpmiddelen voor het gebruik
+		van de programmeertaal Python.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm dev-python chứa các thư viện và tiện ích liên quan
+		đến ngôn ngữ lập trình Python.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria dev-python contiene librerie ed utilità per il linguaggio di programmazione Python.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria dev-python contém bibliotecas, utilitários e
+		bindings escritos em ou para a linguagem de programação Python.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria dev-python zawiera biblioteki, narzędzia i powiązania
+		(bindings) napisane w lub stworzone do pisania w języku programowania
+		Python.
+	</longdescription>
+</catmetadata>
+
diff --git a/dev-python/mock/metadata.xml b/dev-python/mock/metadata.xml
new file mode 100644
index 0000000..41d2ade
--- /dev/null
+++ b/dev-python/mock/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="pypi">mock</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/mox/metadata.xml b/dev-python/mox/metadata.xml
new file mode 100644
index 0000000..5cc9764
--- /dev/null
+++ b/dev-python/mox/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="google-code">pymox</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/netifaces/metadata.xml b/dev-python/netifaces/metadata.xml
new file mode 100644
index 0000000..01874fb
--- /dev/null
+++ b/dev-python/netifaces/metadata.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>python</herd>
+<maintainer>
+<email>xmw@gentoo.org</email>
+<name>Michael Weber</name>
+</maintainer>
+</pkgmetadata>
+
diff --git a/dev-python/numpy/metadata.xml b/dev-python/numpy/metadata.xml
new file mode 100644
index 0000000..0bfafa1
--- /dev/null
+++ b/dev-python/numpy/metadata.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>sci</herd>
+  <herd>python</herd>
+  <longdescription lang="en">
+  NumPy is a general-purpose array-processing Python package designed to
+  efficiently manipulate large multi-dimensional arrays of arbitrary
+  records without sacrificing too much speed for small multi-dimensional
+  arrays. There are also basic facilities for discrete fourier transform,
+  basic linear algebra and random number generation.
+  It is the successor of Numeric and numarray.
+</longdescription>
+  <upstream>
+    <remote-id type="pypi">numpy</remote-id>
+  </upstream>
+</pkgmetadata>
diff --git a/dev-python/pexpect/metadata.xml b/dev-python/pexpect/metadata.xml
new file mode 100644
index 0000000..cb9b36f
--- /dev/null
+++ b/dev-python/pexpect/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="pypi">pexpect</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/pycairo/metadata.xml b/dev-python/pycairo/metadata.xml
new file mode 100644
index 0000000..301d220
--- /dev/null
+++ b/dev-python/pycairo/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+</pkgmetadata>
diff --git a/dev-python/pyinotify/metadata.xml b/dev-python/pyinotify/metadata.xml
new file mode 100644
index 0000000..de483c5
--- /dev/null
+++ b/dev-python/pyinotify/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>python</herd>
+</pkgmetadata>
diff --git a/dev-python/pylint/metadata.xml b/dev-python/pylint/metadata.xml
new file mode 100644
index 0000000..f9fbc27
--- /dev/null
+++ b/dev-python/pylint/metadata.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<longdescription lang="en">Pylint is a Python source code analyzer which looks for programming
+		errors, helps enforcing a coding standard and sniffs for some code
+		smells (as defined in Martin Fowler's Refactoring book).
+		Pylint can be seen as another PyChecker since nearly all tests you can
+		do with PyChecker can also be done with Pylint. However, Pylint offers
+		some more features, like checking length of lines of code, checking if
+		variable names are well-formed according to your coding standard, or
+		checking if declared interfaces are truly implemented, and much more.
+		Additionally, it is possible to write plugins to add your own checks.</longdescription>
+	<upstream>
+		<remote-id type="pypi">pylint</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/pyopenssl/metadata.xml b/dev-python/pyopenssl/metadata.xml
new file mode 100644
index 0000000..ab2a1fc
--- /dev/null
+++ b/dev-python/pyopenssl/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="pypi">pyOpenSSL</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/pyserial/metadata.xml b/dev-python/pyserial/metadata.xml
new file mode 100644
index 0000000..b52569e
--- /dev/null
+++ b/dev-python/pyserial/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="pypi">pyserial</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/python-daemon/metadata.xml b/dev-python/python-daemon/metadata.xml
new file mode 100644
index 0000000..96d6967
--- /dev/null
+++ b/dev-python/python-daemon/metadata.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<maintainer>
+		<email>djc@gentoo.org</email>
+		<name>Dirkjan Ochtman</name>
+	</maintainer>
+	<upstream>
+		<remote-id type="pypi">python-daemon</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/python-xlib/metadata.xml b/dev-python/python-xlib/metadata.xml
new file mode 100644
index 0000000..de483c5
--- /dev/null
+++ b/dev-python/python-xlib/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>python</herd>
+</pkgmetadata>
diff --git a/dev-python/pyudev/metadata.xml b/dev-python/pyudev/metadata.xml
new file mode 100644
index 0000000..e870cbb
--- /dev/null
+++ b/dev-python/pyudev/metadata.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<maintainer>
+		<email>sbriesen@gentoo.org</email>
+		<name>Stefan Briesenick</name>
+	</maintainer>
+	<longdescription lang="en">pyudev is a Python binding to libudev, the hardware management
+		library and service found in modern linux systems.</longdescription>
+	<use>
+		<flag name="pygobject">Install PyGobject binding</flag>
+		<flag name="pyqt4">Install PyQt4 binding</flag>
+		<flag name="pyside">Install PySide binding</flag>
+	</use>
+	<upstream>
+		<remote-id type="pypi">pyudev</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/pyusb/metadata.xml b/dev-python/pyusb/metadata.xml
index e1fa957..70519d0 100644
--- a/dev-python/pyusb/metadata.xml
+++ b/dev-python/pyusb/metadata.xml
@@ -6,4 +6,7 @@
 		pyusb is a python wrapper for the libusb user space USB device library.
 	</longdescription>
 	<maintainer><email>josejx@gentoo.org</email><name>Joseph Jezak</name></maintainer>
+	<upstream>
+		<remote-id type="pypi">pyusb</remote-id>
+	</upstream>
 </pkgmetadata>
diff --git a/dev-python/pyxdg/metadata.xml b/dev-python/pyxdg/metadata.xml
new file mode 100644
index 0000000..de483c5
--- /dev/null
+++ b/dev-python/pyxdg/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>python</herd>
+</pkgmetadata>
diff --git a/dev-python/pyyaml/metadata.xml b/dev-python/pyyaml/metadata.xml
new file mode 100644
index 0000000..7899d63
--- /dev/null
+++ b/dev-python/pyyaml/metadata.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>sbriesen@gentoo.org</email>
+		<name>Stefan Briesenick</name>
+	</maintainer>
+	<use>
+		<flag name='libyaml'>enable libyaml support</flag>
+	</use>
+	<longdescription lang="en">
+		PyYAML is a YAML parser and emitter for the Python programming language.
+	</longdescription>
+</pkgmetadata>
diff --git a/dev-python/requests/metadata.xml b/dev-python/requests/metadata.xml
new file mode 100644
index 0000000..395b9e6
--- /dev/null
+++ b/dev-python/requests/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="pypi">requests</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/setproctitle/metadata.xml b/dev-python/setproctitle/metadata.xml
new file mode 100644
index 0000000..4f5a535
--- /dev/null
+++ b/dev-python/setproctitle/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="pypi">setproctitle</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/setuptools/metadata.xml b/dev-python/setuptools/metadata.xml
new file mode 100644
index 0000000..188a750
--- /dev/null
+++ b/dev-python/setuptools/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="pypi">distribute</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/simplejson/metadata.xml b/dev-python/simplejson/metadata.xml
new file mode 100644
index 0000000..f52cdf3
--- /dev/null
+++ b/dev-python/simplejson/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="pypi">simplejson</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/twisted/metadata.xml b/dev-python/twisted/metadata.xml
new file mode 100644
index 0000000..3215da1
--- /dev/null
+++ b/dev-python/twisted/metadata.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<use>
+		<flag name='serial'>include serial port support</flag>
+	</use>
+	<longdescription>
+		Twisted is an asynchronous networking framework written in Python,
+		supporting TCP, UDP, multicast, SSL/TLS, serial communication and
+		more. It is used by most of the servers, clients and protocols that
+		are part of other Twisted projects.
+	</longdescription>
+</pkgmetadata>
diff --git a/dev-python/unittest2/metadata.xml b/dev-python/unittest2/metadata.xml
new file mode 100644
index 0000000..d58233d
--- /dev/null
+++ b/dev-python/unittest2/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="pypi">unittest2</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-python/ws4py/metadata.xml b/dev-python/ws4py/metadata.xml
new file mode 100644
index 0000000..13bc2c4
--- /dev/null
+++ b/dev-python/ws4py/metadata.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>python</herd>
+<maintainer>
+ <email>vapier@gentoo.org</email>
+ <description>make whatever changes you want</description>
+</maintainer>
+<use>
+ <flag name='client'>Install client modules</flag>
+ <flag name='server'>Install server modules</flag>
+</use>
+</pkgmetadata>
diff --git a/dev-tcltk/expect/metadata.xml b/dev-tcltk/expect/metadata.xml
new file mode 100644
index 0000000..815cc91
--- /dev/null
+++ b/dev-tcltk/expect/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>tcltk</herd>
+</pkgmetadata>
diff --git a/dev-tcltk/metadata.xml b/dev-tcltk/metadata.xml
new file mode 100644
index 0000000..0fadf10
--- /dev/null
+++ b/dev-tcltk/metadata.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The dev-tcltk category contains Tcl- and Tk-related libraries and tools.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie dev-tcltk enthält Bibliotheken und Werkzeuge für Tcl und Tk.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría dev-tcltk contiene herramientas y librerías referentes
+		a Tcl y Tk.
+	</longdescription>
+	<longdescription lang="ja">
+		dev-tcltkカテゴリーにはTclとTkに関連したライブラリーとツールが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De dev-tcltk categorie bevat bibliotheken en hulpmiddelen voor het gebruik van de
+		programmeertalen Tcl en Tk.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm dev-tcltk chứa các thư viện và tiện ích liên quan
+		đến ngôn ngữ lập trình Tcl/Tk.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria dev-tcltk contiene utilità e librerie per Tcl e Tk.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria dev-tcltk contém bibliotecas e ferramentas
+		referentes a Tcl e Tk.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria dev-tcltk zawiera biblioteki i narzędzia związane z Tcl i Tk.
+	</longdescription>
+</catmetadata>
+
diff --git a/dev-util/boost-build/metadata.xml b/dev-util/boost-build/metadata.xml
new file mode 100644
index 0000000..f3682b7
--- /dev/null
+++ b/dev-util/boost-build/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>cpp</herd>
+</pkgmetadata>
diff --git a/dev-util/ccache/metadata.xml b/dev-util/ccache/metadata.xml
new file mode 100644
index 0000000..21bd770
--- /dev/null
+++ b/dev-util/ccache/metadata.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>toolchain</herd>
+	<maintainer>
+		<email>robbat2@gentoo.org</email>
+	</maintainer>
+	<longdescription lang="en">
+		ccache acts as a caching pre-processor to C/C++ compilers, improving
+		compilation time when recompiling previously compiled source.
+	</longdescription>
+</pkgmetadata>
diff --git a/dev-util/cmake/metadata.xml b/dev-util/cmake/metadata.xml
new file mode 100644
index 0000000..a23f444
--- /dev/null
+++ b/dev-util/cmake/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>kde</herd>
+</pkgmetadata>
diff --git a/dev-util/cscope/metadata.xml b/dev-util/cscope/metadata.xml
new file mode 100644
index 0000000..f2b9350
--- /dev/null
+++ b/dev-util/cscope/metadata.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>vim</herd>
+<herd>emacs</herd>
+<longdescription>
+Cscope is a developer's tool for browsing source code.  Cscope allows
+searching code for:
+
+  * cross referenced symbols
+  * global definitions
+  * callees and callers
+  * text strings and regular expression patterns
+  * files and files including a file
+
+Other features:
+
+  * curses based (text screen)
+  * fast searches
+  * fuzzy parser supports C and is flexible enough to be useful for
+    C++, Java and other documents
+  * command line mode for inclusion in scripts or as a backend to GUIs
+
+Cscope is distributed with xcscope which provides tight integration
+with GNU Emacs.
+</longdescription>
+</pkgmetadata>
diff --git a/dev-util/ctags/metadata.xml b/dev-util/ctags/metadata.xml
new file mode 100644
index 0000000..80ac66c
--- /dev/null
+++ b/dev-util/ctags/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>vim</herd>
+  <use>
+    <flag name="ada">Enable Ada support</flag>
+  </use>
+</pkgmetadata>
diff --git a/dev-util/dejagnu/metadata.xml b/dev-util/dejagnu/metadata.xml
new file mode 100644
index 0000000..fb4199e
--- /dev/null
+++ b/dev-util/dejagnu/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>toolchain</herd>
+</pkgmetadata>
diff --git a/dev-util/dialog/metadata.xml b/dev-util/dialog/metadata.xml
new file mode 100644
index 0000000..a56bb3a
--- /dev/null
+++ b/dev-util/dialog/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>livecd</herd>
+<use>
+<flag name="minimal">Disable library, install command-line program only</flag>
+</use>
+</pkgmetadata>
diff --git a/dev-util/diffstat/metadata.xml b/dev-util/diffstat/metadata.xml
new file mode 100644
index 0000000..2d5b398
--- /dev/null
+++ b/dev-util/diffstat/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>shell-tools</herd>
+  <upstream>
+    <changelog>http://invisible-island.net/diffstat/CHANGES</changelog>
+  </upstream>
+</pkgmetadata>
diff --git a/dev-util/gdbus-codegen/metadata.xml b/dev-util/gdbus-codegen/metadata.xml
new file mode 100644
index 0000000..6e0e2ec
--- /dev/null
+++ b/dev-util/gdbus-codegen/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>gnome</herd>
+</pkgmetadata>
diff --git a/dev-util/gob/metadata.xml b/dev-util/gob/metadata.xml
new file mode 100644
index 0000000..da6fd63
--- /dev/null
+++ b/dev-util/gob/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>gnome</herd>
+</pkgmetadata>
diff --git a/dev-util/gperf/metadata.xml b/dev-util/gperf/metadata.xml
new file mode 100644
index 0000000..b6073e4
--- /dev/null
+++ b/dev-util/gperf/metadata.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>blueness@gentoo.org</email>
+	</maintainer>
+</pkgmetadata>
diff --git a/dev-util/gtk-doc-am/metadata.xml b/dev-util/gtk-doc-am/metadata.xml
new file mode 100644
index 0000000..da6fd63
--- /dev/null
+++ b/dev-util/gtk-doc-am/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>gnome</herd>
+</pkgmetadata>
diff --git a/dev-util/gtk-doc/metadata.xml b/dev-util/gtk-doc/metadata.xml
new file mode 100644
index 0000000..a562fd8
--- /dev/null
+++ b/dev-util/gtk-doc/metadata.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>gnome</herd>
+<use>
+	<flag name="highlight">Enable source code highlighting</flag>
+	<flag name="vim">Enable source code highlighting through
+	<pkg>app-editors/vim</pkg></flag>
+</use>
+<longdescription lang="en">
+	GTK-Doc is used to document C code.
+	It is typically used to document the public API of libraries,
+	such as the GTK+ and GNOME libraries, but it can also be used
+	to document application code.
+</longdescription>
+</pkgmetadata>
diff --git a/dev-util/intltool/metadata.xml b/dev-util/intltool/metadata.xml
new file mode 100644
index 0000000..c03b663
--- /dev/null
+++ b/dev-util/intltool/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>freedesktop</herd>
+	<maintainer>
+		<email>freedesktop-bugs@gentoo.org</email>
+	</maintainer>
+</pkgmetadata>
diff --git a/dev-util/lcov/metadata.xml b/dev-util/lcov/metadata.xml
new file mode 100644
index 0000000..e44eaf4
--- /dev/null
+++ b/dev-util/lcov/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>dev-tools</herd>
+</pkgmetadata>
diff --git a/dev-util/metadata.xml b/dev-util/metadata.xml
new file mode 100644
index 0000000..b57240b
--- /dev/null
+++ b/dev-util/metadata.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The dev-util category contains various miscellaneous development
+		utilities.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie dev-util enthält verschiedene Programmierwerkzeuge.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría dev-util contiene varias utilidades de desarrollo mixtas.
+	</longdescription>
+	<longdescription lang="ja">
+		dev-util カテゴリーには多種多様な開発ユーティリティが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De dev-util categorie bevat verschillende hulpmiddelen voor gebruik
+		bij het programmeren.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm dev-util chứa các tiện ích phát triển khác nhau.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria dev-util contiene varie utilità di sviluppo software.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria dev-util contém vários utilitários de
+		desenvolvimento mistos.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria dev-util zawiera różne dodatkowe narzędzia związane z
+		rozwijaniem programów.
+	</longdescription>
+	<longdescription lang="ru">
+		Категория dev-util содержит различные утилиты для разработки,
+		не попадающие в другие категории.
+	</longdescription>
+</catmetadata>
+
diff --git a/dev-util/pkgconfig/metadata.xml b/dev-util/pkgconfig/metadata.xml
new file mode 100644
index 0000000..572c23e
--- /dev/null
+++ b/dev-util/pkgconfig/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>freedesktop</herd>
+	<maintainer>
+		<email>freedesktop-bugs@gentoo.org</email>
+	</maintainer>
+	<use>
+		<flag name='internal-glib'>Use internal copy of <pkg>dev-libs/glib</pkg></flag>
+	</use>
+</pkgmetadata>
diff --git a/dev-util/scons/metadata.xml b/dev-util/scons/metadata.xml
new file mode 100644
index 0000000..29b5016
--- /dev/null
+++ b/dev-util/scons/metadata.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>python</herd>
+  <longdescription lang="en">
+    SCons is a make replacement providing a range of enhanced
+    features such as automated dependency generation and built in
+    compilation cache support. SCons rule sets are Python scripts so
+    as well as the features it provides itself SCons allows you to use
+    the full power of Python to control compilation.
+  </longdescription>
+</pkgmetadata>
diff --git a/dev-util/shflags/metadata.xml b/dev-util/shflags/metadata.xml
new file mode 100644
index 0000000..b314e39
--- /dev/null
+++ b/dev-util/shflags/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>shell-tools</herd>
+	<maintainer>
+		<email>vapier@gentoo.org</email>
+	</maintainer>
+	<upstream>
+		<remote-id type="google-code">shflags</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-util/strace/metadata.xml b/dev-util/strace/metadata.xml
new file mode 100644
index 0000000..3134acb
--- /dev/null
+++ b/dev-util/strace/metadata.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>base-system</herd>
+  <use>
+    <flag name="aio">
+      Enable <pkg>dev-libs/libaio</pkg> support for tracing Asynchronous I/O operations
+    </flag>
+  </use>
+</pkgmetadata>
diff --git a/dev-util/stressapptest/metadata.xml b/dev-util/stressapptest/metadata.xml
new file mode 100644
index 0000000..0947421
--- /dev/null
+++ b/dev-util/stressapptest/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+ <email>vapier@gentoo.org</email>
+ <description>do whatever</description>
+</maintainer>
+</pkgmetadata>
diff --git a/dev-util/valgrind/metadata.xml b/dev-util/valgrind/metadata.xml
new file mode 100644
index 0000000..e20d0c3
--- /dev/null
+++ b/dev-util/valgrind/metadata.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>blueness@gentoo.org</email>
+		<name>Anthony G. Basile</name>
+	</maintainer>
+	<longdescription>
+		Valgrind is a GPL'd tool to help you find memory-management problems
+		in your programs. When a program is run under Valgrind's supervision,
+		all reads and writes of memory are checked, and calls to
+		malloc/new/free/delete are intercepted. As a result, Valgrind can
+		detect problems such as
+
+		- Use of uninitialised memory
+		- Reading/writing memory after it has been free'd
+		- Reading/writing off the end of malloc'd blocks
+		- Reading/writing inappropriate areas on the stack
+		- Memory leaks -- where pointers to malloc'd blocks are lost forever
+		- Passing of uninitialised and/or unaddressible memory to system calls
+		- Mismatched use of malloc/new/new [] vs free/delete/delete []
+		- Some abuses of the POSIX Pthreads API
+	</longdescription>
+</pkgmetadata>
diff --git a/dev-vcs/cvs/metadata.xml b/dev-vcs/cvs/metadata.xml
new file mode 100644
index 0000000..4432750
--- /dev/null
+++ b/dev-vcs/cvs/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>cvs-utils</herd>
+  <use>
+    <flag name="server">Enable server support</flag>
+  </use>
+</pkgmetadata>
diff --git a/dev-vcs/cvsps/metadata.xml b/dev-vcs/cvsps/metadata.xml
new file mode 100644
index 0000000..e9a271c
--- /dev/null
+++ b/dev-vcs/cvsps/metadata.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>slyfox@gentoo.org</email>
+		<name>Sergei Trofimovich</name>
+	</maintainer>
+	<herd>cvs-utils</herd>
+	<upstream>
+		<remote-id type="freecode">cvsps</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/dev-vcs/git/metadata.xml b/dev-vcs/git/metadata.xml
new file mode 100644
index 0000000..1fa9edd
--- /dev/null
+++ b/dev-vcs/git/metadata.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <maintainer>
+    <email>robbat2@gentoo.org</email>
+    <name>Robin H. Johnson</name>
+  </maintainer>
+  <longdescription lang="en">
+    Git - Fast Version Control System. Official titled
+    "GIT - the stupid content tracker". 
+
+    Git is a popular version control system designed to handle very large
+    projects with speed and efficiency; it is used mainly for various open
+    source projects, most notably the Linux kernel.
+
+    Git falls in the category of distributed source code management tools,
+    similar to e.g. GNU Arch or Monotone (or BitKeeper in the proprietary
+    world). Every Git working directory is a full-fledged repository with full
+    revision tracking capabilities, not dependent on network access or a central
+    server.
+  </longdescription>
+  <use>
+    <flag name="blksha1">Use the new optimized SHA1 implementation</flag>
+    <flag name="cgi">Install gitweb too</flag>
+    <flag name="curl">Support fetching and pushing (requires webdav too) over http:// and https:// protocols</flag>
+    <flag name="gpg">Pull in gnupg for signing -- without gnupg, attempts at signing will fail at runtime!</flag>
+    <flag name="gtk">Include the gitview contrib tool</flag>
+    <flag name="highlight">GitWeb support for app-text/highlight</flag>
+    <flag name="mozsha1">Makes git use an optimized SHA1 routine from Mozilla that should be fast on non-x86 machines</flag>
+    <flag name="ppcsha1">Make use of a bundled routine that is optimized for the PPC arch</flag>
+    <flag name="subversion">Include git-svn for <pkg>dev-vcs/subversion</pkg> support</flag>
+    <flag name="webdav">Adds support for push'ing to HTTP/HTTPS repositories via DAV</flag>
+  </use>
+</pkgmetadata>
diff --git a/dev-vcs/metadata.xml b/dev-vcs/metadata.xml
new file mode 100644
index 0000000..9944321
--- /dev/null
+++ b/dev-vcs/metadata.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The dev-vcs category contains utilities focused on version control.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie dev-vcs enthält Programme, die sich mit Versionskontrolle beschäftigen.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría dev-vcs contiene programas para control de versiones.
+	</longdescription>
+</catmetadata>
diff --git a/dev-vcs/subversion/metadata.xml b/dev-vcs/subversion/metadata.xml
new file mode 100644
index 0000000..6f92b19
--- /dev/null
+++ b/dev-vcs/subversion/metadata.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>tommy@gentoo.org</email>
+		<name>Thomas Sachau</name>
+	</maintainer>
+	<use>
+		<flag name="ctypes-python">Build and install Ctypes Python bindings</flag>
+		<flag name="dso">Enable runtime module search</flag>
+		<flag name="extras">Install extra scripts (examples, tools, hooks)</flag>
+		<flag name="webdav-neon">Enable WebDAV support using <pkg>net-libs/neon</pkg></flag>
+		<flag name="webdav-serf">Enable WebDAV support using <pkg>net-libs/serf</pkg></flag>
+	</use>
+</pkgmetadata>
diff --git a/games-emulation/metadata.xml b/games-emulation/metadata.xml
new file mode 100644
index 0000000..5f57686
--- /dev/null
+++ b/games-emulation/metadata.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The games-emulation category contains game platform emulators.
+	</longdescription>
+	<longdescription lang="de">
+	    Die Kategorie games-emulation enthält Emulatoren für verschiedene
+	    Spieleplattformen.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría games-emulation contiene emuladores de juegos de plataforma.
+	</longdescription>
+	<longdescription lang="ja">
+		games-emulationカテゴリーにはプラットフォームをエミュレートしたゲームが
+		含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De games-emulation categorie bevat emulators voor verschillende spelcomputers.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm games-emulation chứa các bộ mô phỏng nền chơi game.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria games-emulation contiene emulatori di piattaforme di gioco.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria games-emulation contém emuladores de plataformas de
+		jogos.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria games-emulation zawiera emulatory rozmaitych platform dla gier.
+	</longdescription>
+</catmetadata>
+
diff --git a/games-emulation/snes9x/metadata.xml b/games-emulation/snes9x/metadata.xml
new file mode 100644
index 0000000..24e4956
--- /dev/null
+++ b/games-emulation/snes9x/metadata.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>games</herd>
+	<use>
+		<flag name="netplay">Enable playing ROMs over the network (not recommended)</flag>
+		<flag name="xrandr">Enable support for the X xrandr extension</flag>
+	</use>
+	<upstream>
+		<remote-id type="google-code">snes9x-gtk</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/games-emulation/zsnes/metadata.xml b/games-emulation/zsnes/metadata.xml
new file mode 100644
index 0000000..57d2372
--- /dev/null
+++ b/games-emulation/zsnes/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>games</herd>
+  <use>
+    <flag name='debug'>Enable the builtin debugger</flag>
+    <flag name='pax_kernel'>Triggers a paxmarking of the binary</flag>
+  </use>
+</pkgmetadata>
diff --git a/games-util/joystick/metadata.xml b/games-util/joystick/metadata.xml
new file mode 100644
index 0000000..d3c2cc9
--- /dev/null
+++ b/games-util/joystick/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>games</herd>
+</pkgmetadata>
diff --git a/games-util/metadata.xml b/games-util/metadata.xml
new file mode 100644
index 0000000..e3106a7
--- /dev/null
+++ b/games-util/metadata.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The games-util category contains various game-related utilities.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie games-util enthält verschiede Tools rund um Spiele.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría games-util contiene varias utilidades relacionadas con
+		juegos.
+	</longdescription>
+	<longdescription lang="ja">
+		games-utilカテゴリーにはゲームに関連した様々なユーティリティが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De games-util categorie bevat hulpmiddelen voor bepaalde spellen.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm games-util chứa các tiện ích linh tinh liên quan đến các trò chơi.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria games-util contiene varie utilità per i giochi.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria games-util contém vários utilitários relacionados a
+		jogos.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria games-util zawiera narządzia związane z grami.
+	</longdescription>
+</catmetadata>
+
diff --git a/gnome-base/libglade/metadata.xml b/gnome-base/libglade/metadata.xml
new file mode 100644
index 0000000..dad9001
--- /dev/null
+++ b/gnome-base/libglade/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>gnome</herd>
+</pkgmetadata>
diff --git a/gnome-base/metadata.xml b/gnome-base/metadata.xml
new file mode 100644
index 0000000..0fe9232
--- /dev/null
+++ b/gnome-base/metadata.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The gnome-base category contains core GNOME packages.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie gnome-base enthält die GNOME Basispakete.
+	</longdescription>
+	<longdescription lang="es">
+		La catagoría gnome-base contiene los paquetes principales de GNOME.
+	</longdescription>
+	<longdescription lang="ja">
+		gnome-baseカテゴリーにはGNOMEのコア・パッケージが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De gnome-base categorie bevat de basisonderdelen van de GNOME desktopomgeving.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm gnome-base chứa các gói GNOME cốt lõi.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria gnome-base contiene i pacchetti base di GNOME.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria gnome-base contém os pacotes principais de GNOME.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria gnome-base zawiera podstawowe pakiety środowiska GNOME.
+	</longdescription>
+</catmetadata>
+
diff --git a/media-fonts/corefonts/metadata.xml b/media-fonts/corefonts/metadata.xml
new file mode 100644
index 0000000..696065e
--- /dev/null
+++ b/media-fonts/corefonts/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>fonts</herd>
+</pkgmetadata>
diff --git a/media-fonts/dejavu/metadata.xml b/media-fonts/dejavu/metadata.xml
new file mode 100644
index 0000000..995272f
--- /dev/null
+++ b/media-fonts/dejavu/metadata.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>fonts</herd>
+<use>
+	<flag name='fontforge'>Use <pkg>media-gfx/fontforge</pkg> to build fonts from source</flag>
+</use>
+<longdescription>
+	The DejaVu fonts are a font family based on the Vera Fonts release 1.10. Its
+	purpose is to provide a wider range of characters while maintaining the
+	original look and feel through the process of collaborative development.
+	Available families (Sans = sans serif, Mono = monospaced): DejaVu Sans,
+	DejaVu Sans Mono, DejaVu Sans Condensed (experimental), DejaVu Serif, DejaVu
+	Serif Condensed
+</longdescription>
+</pkgmetadata>
diff --git a/media-fonts/encodings/metadata.xml b/media-fonts/encodings/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/media-fonts/encodings/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/media-fonts/font-util/metadata.xml b/media-fonts/font-util/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/media-fonts/font-util/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/media-fonts/liberation-fonts/metadata.xml b/media-fonts/liberation-fonts/metadata.xml
new file mode 100644
index 0000000..6412fa6
--- /dev/null
+++ b/media-fonts/liberation-fonts/metadata.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>fonts</herd>
+	<maintainer>
+		<email>je_fro@gentoo.org</email>
+	</maintainer>
+	<use>
+		<flag name='fontforge'>Use <pkg>media-gfx/fontforge</pkg> to build fonts from source</flag>
+	</use>
+	<longdescription lang="en">
+		A GPL-2 Helvetica/Times/Courier replacement TrueType font set, courtesy of Red Hat
+	</longdescription>
+</pkgmetadata>
diff --git a/media-fonts/metadata.xml b/media-fonts/metadata.xml
new file mode 100644
index 0000000..01248fc
--- /dev/null
+++ b/media-fonts/metadata.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The media-fonts category contains fonts.
+	</longdescription>
+	<longdescription lang="de">
+	        Die Kategorie media-fonts enthält verschiedene Font-Pakete.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría media-fonts contiene fuentes.
+	</longdescription>
+	<longdescription lang="ja">
+		media-fontsカテゴリーにはフォントが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De media-fonts categorie bevat lettertypes.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm media-fonts chứa các phông chữ.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria media-fonts contiene fonti tipografiche.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria media-fonts contém fontes.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria media-fonts zawiera czcionki.
+	</longdescription>
+</catmetadata>
+
diff --git a/media-fonts/sil-abyssinica/metadata.xml b/media-fonts/sil-abyssinica/metadata.xml
new file mode 100644
index 0000000..8df0e88
--- /dev/null
+++ b/media-fonts/sil-abyssinica/metadata.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>fonts</herd>
+  <longdescription lang="en">
+    The Ethiopic script is used for writing many of the languages of
+    Ethiopia and Eritrea.  Ethiopic (U+1200..U+137F) was added to
+    Unicode 3.0.  Ethiopic Supplement (U+1380..U+139F) and Ethiopic
+    Extended (U+2D80..U+2DDF) were added to Unicode 4.1. Abyssinica
+    SIL supports all Ethiopic characters which are in Unicode
+    including the Unicode 4.1 extensions. Some languages of Ethiopia
+    are not yet able to be fully represented in Unicode and, where
+    necessary, we have included non-Unicode characters in the Private
+    Use Area (see Private-use (PUA) characters supported by Abyssinica
+    SIL).
+
+    Abyssinica SIL is based on Ethiopic calligraphic traditions. This
+    release is a regular typeface, with no bold or italic version
+    available or planned.
+  </longdescription>
+</pkgmetadata>
diff --git a/media-fonts/urw-fonts/metadata.xml b/media-fonts/urw-fonts/metadata.xml
new file mode 100644
index 0000000..696065e
--- /dev/null
+++ b/media-fonts/urw-fonts/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>fonts</herd>
+</pkgmetadata>
diff --git a/media-gfx/imagemagick/metadata.xml b/media-gfx/imagemagick/metadata.xml
new file mode 100644
index 0000000..9ea268a
--- /dev/null
+++ b/media-gfx/imagemagick/metadata.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>graphics</herd>
+  <use>
+    <flag name='autotrace'>Use <pkg>media-gfx/autotrace</pkg> to convert bitmaps into vector graphics</flag>
+    <flag name='corefonts'>Use <pkg>media-fonts/corefonts</pkg> which is required by some commands</flag> 
+    <flag name='fpx'>Enable <pkg>media-libs/libfpx</pkg> support</flag>
+    <flag name='hdri'>enable High Dynamic Range Images formats</flag>
+    <flag name='lqr'>Enable experimental liquid rescale support using <pkg>media-libs/liblqr</pkg></flag>
+    <flag name='opencl'>Enable OpenCL support</flag>
+    <flag name='pango'>Enable Pango support using <pkg>x11-libs/pango</pkg></flag>
+    <flag name='q32'>Set quantum depth value to 32</flag>
+    <flag name='q64'>Set quantum depth value to 64</flag>
+    <flag name='q8'>Set quantum depth value to 8</flag>
+    <flag name='webp'>Enable webp image format support using <pkg>media-libs/libwebp</pkg></flag>
+  </use>
+</pkgmetadata>
diff --git a/media-gfx/metadata.xml b/media-gfx/metadata.xml
new file mode 100644
index 0000000..3e62cd8
--- /dev/null
+++ b/media-gfx/metadata.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The media-gfx category contains graphics-related packages.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie media-gfx enthält Programme rund um das Thema Grafik.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría media-gfx contiene paquetes relacionados con gráficos.
+	</longdescription>
+	<longdescription lang="ja">
+		media-gfxカテゴリーにはグラフィック関連のパッケージが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De media-gfx categorie bevat grafische applicaties.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm media-gfx chứa các gói liên quan đến đồ hoạ.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria media-gfx contiene pacchetti per la grafica.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria media-gfx contém pacotes relacionados com gráficos.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria media-gfx zawiera programy graficzne.
+	</longdescription>
+</catmetadata>
+
diff --git a/media-libs/alsa-lib/metadata.xml b/media-libs/alsa-lib/metadata.xml
new file mode 100644
index 0000000..9fbd294
--- /dev/null
+++ b/media-libs/alsa-lib/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>alsa</herd>
+  <maintainer>
+    <email>alsa-bugs@gentoo.org</email>
+  </maintainer>
+  <use>
+    <flag name="alisp">Enable support for ALISP (ALSA LISP) interpreter for advanced features.</flag>
+  </use>
+</pkgmetadata>
diff --git a/media-libs/audiofile/metadata.xml b/media-libs/audiofile/metadata.xml
new file mode 100644
index 0000000..b016c18
--- /dev/null
+++ b/media-libs/audiofile/metadata.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>gnome</herd>
+<herd>sound</herd>
+</pkgmetadata>
diff --git a/media-libs/flac/metadata.xml b/media-libs/flac/metadata.xml
new file mode 100644
index 0000000..e1774e3
--- /dev/null
+++ b/media-libs/flac/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>sound</herd>
+</pkgmetadata>
diff --git a/media-libs/freeglut/metadata.xml b/media-libs/freeglut/metadata.xml
new file mode 100644
index 0000000..ac6ab69
--- /dev/null
+++ b/media-libs/freeglut/metadata.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+<use>
+	<flag name="mpx">
+		Enable support for multi-pointer-X. One pointer for each pointer
+		device.
+	</flag>
+</use>
+<longdescription>
+	Freeglut provides an open-source alternative to the OpenGL Utility Toolkit
+	(GLUT) library. It is actively developed and maintained, while not being
+	restricted by its license.
+</longdescription>
+</pkgmetadata>
diff --git a/media-libs/gd/metadata.xml b/media-libs/gd/metadata.xml
new file mode 100644
index 0000000..ef35ed9
--- /dev/null
+++ b/media-libs/gd/metadata.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>graphics</herd>
+<maintainer>
+	<email>vapier@gentoo.org</email>
+</maintainer>
+<longdescription>
+gd is a graphics library. It allows your code to quickly draw images complete  
+with lines, arcs, text, multiple colors, cut and paste from other images, and
+flood fills, and write out the result as a PNG or JPEG file. This is particularly
+useful in World Wide Web applications, where PNG and JPEG are two of the formats
+accepted for inline images by most browsers.
+
+gd is not a paint program. If you are looking for a paint program, you are
+looking in the wrong place. If you are not a programmer, you are looking in the
+wrong place, unless you are installing a required library in order to run an
+application.
+
+gd does not provide for every possible desirable graphics operation. It is not
+necessary or desirable for gd to become a kitchen-sink graphics package, but
+version 2.0 does include most frequently requested features, including both  
+truecolor and palette images, resampling (smooth resizing of truecolor images)
+and so forth.
+</longdescription>
+</pkgmetadata>
diff --git a/media-libs/giflib/metadata.xml b/media-libs/giflib/metadata.xml
new file mode 100644
index 0000000..b1db677
--- /dev/null
+++ b/media-libs/giflib/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>graphics</herd>
+  <use>
+    <flag name="rle">Build converters for RLE format (utah raster toolkit)</flag>
+  </use>
+</pkgmetadata>
diff --git a/media-libs/glew/metadata.xml b/media-libs/glew/metadata.xml
new file mode 100644
index 0000000..157326a
--- /dev/null
+++ b/media-libs/glew/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>radhermit@gentoo.org</email>
+		<name>Tim Harder</name>
+	</maintainer>
+</pkgmetadata>
diff --git a/media-libs/jbig2dec/metadata.xml b/media-libs/jbig2dec/metadata.xml
new file mode 100644
index 0000000..75356f7
--- /dev/null
+++ b/media-libs/jbig2dec/metadata.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>graphics</herd>
+  <herd>printing</herd>
+</pkgmetadata>
diff --git a/media-libs/jpeg/metadata.xml b/media-libs/jpeg/metadata.xml
new file mode 100644
index 0000000..e770d1b
--- /dev/null
+++ b/media-libs/jpeg/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>graphics</herd>
+</pkgmetadata>
diff --git a/media-libs/ladspa-sdk/metadata.xml b/media-libs/ladspa-sdk/metadata.xml
new file mode 100644
index 0000000..0dc3775
--- /dev/null
+++ b/media-libs/ladspa-sdk/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>proaudio</herd>
+</pkgmetadata>
diff --git a/media-libs/lcms/metadata.xml b/media-libs/lcms/metadata.xml
new file mode 100644
index 0000000..1fa0ca5
--- /dev/null
+++ b/media-libs/lcms/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>printing</herd>
+</pkgmetadata>
diff --git a/media-libs/libao/metadata.xml b/media-libs/libao/metadata.xml
new file mode 100644
index 0000000..e1774e3
--- /dev/null
+++ b/media-libs/libao/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>sound</herd>
+</pkgmetadata>
diff --git a/media-libs/libart_lgpl/metadata.xml b/media-libs/libart_lgpl/metadata.xml
new file mode 100644
index 0000000..da6fd63
--- /dev/null
+++ b/media-libs/libart_lgpl/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>gnome</herd>
+</pkgmetadata>
diff --git a/media-libs/libdvdnav/metadata.xml b/media-libs/libdvdnav/metadata.xml
new file mode 100644
index 0000000..1cadc2e
--- /dev/null
+++ b/media-libs/libdvdnav/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>video</herd>
+<maintainer>
+  <email>media-video@gentoo.org</email>
+</maintainer>
+</pkgmetadata>
diff --git a/media-libs/libdvdread/metadata.xml b/media-libs/libdvdread/metadata.xml
new file mode 100644
index 0000000..1cadc2e
--- /dev/null
+++ b/media-libs/libdvdread/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>video</herd>
+<maintainer>
+  <email>media-video@gentoo.org</email>
+</maintainer>
+</pkgmetadata>
diff --git a/media-libs/libexif/metadata.xml b/media-libs/libexif/metadata.xml
new file mode 100644
index 0000000..e770d1b
--- /dev/null
+++ b/media-libs/libexif/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>graphics</herd>
+</pkgmetadata>
diff --git a/media-libs/libid3tag/metadata.xml b/media-libs/libid3tag/metadata.xml
new file mode 100644
index 0000000..e1774e3
--- /dev/null
+++ b/media-libs/libid3tag/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>sound</herd>
+</pkgmetadata>
diff --git a/media-libs/libjpeg-turbo/metadata.xml b/media-libs/libjpeg-turbo/metadata.xml
new file mode 100644
index 0000000..2df8087
--- /dev/null
+++ b/media-libs/libjpeg-turbo/metadata.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>graphics</herd>
+  <maintainer>
+    <email>ssuominen@gentoo.org</email>
+    <name>Samuli Suominen</name>
+  </maintainer>
+  <maintainer>
+    <email>anarchy@gentoo.org</email>
+    <name>Jory A. Pratt</name>
+  </maintainer>
+</pkgmetadata>
diff --git a/media-libs/libogg/metadata.xml b/media-libs/libogg/metadata.xml
new file mode 100644
index 0000000..e1774e3
--- /dev/null
+++ b/media-libs/libogg/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>sound</herd>
+</pkgmetadata>
diff --git a/media-libs/libsamplerate/metadata.xml b/media-libs/libsamplerate/metadata.xml
new file mode 100644
index 0000000..e1774e3
--- /dev/null
+++ b/media-libs/libsamplerate/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>sound</herd>
+</pkgmetadata>
diff --git a/media-libs/libsdl/metadata.xml b/media-libs/libsdl/metadata.xml
new file mode 100644
index 0000000..0ee2113
--- /dev/null
+++ b/media-libs/libsdl/metadata.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>games</herd>
+  <longdescription>
+Simple DirectMedia Layer is a cross-platform multimedia library designed 
+to provide low level access to audio, keyboard, mouse, joystick, 3D 
+hardware via OpenGL, and 2D video framebuffer. It is used by MPEG 
+playback software, emulators, and many popular games, including the 
+award winning Linux port of "Civilization: Call To Power."
+
+Simple DirectMedia Layer supports Linux, Windows, BeOS, MacOS Classic, 
+MacOS X, FreeBSD, OpenBSD, BSD/OS, Solaris, IRIX, and QNX. There is also 
+code, but no official support, for Windows CE, AmigaOS, Dreamcast, 
+Atari, NetBSD, AIX, OSF/Tru64, RISC OS, and SymbianOS.
+
+SDL is written in C, but works with C++ natively, and has bindings to 
+several other languages, including Ada, Eiffel, Java, Lua, ML, Perl, 
+PHP, Pike, Python, and Ruby.
+</longdescription>
+  <use>
+	<flag name="audio">Control audio support (disable at your own risk)</flag>
+	<flag name="joystick">Control joystick support (disable at your own risk)</flag>
+	<flag name="ps3">Build the PS3 video driver</flag>
+	<flag name="tslib">Build with tslib support for touchscreen devices</flag>
+	<flag name="video">Control video support (disable at your own risk)</flag>
+  </use>
+</pkgmetadata>
diff --git a/media-libs/libv4l/metadata.xml b/media-libs/libv4l/metadata.xml
new file mode 100644
index 0000000..1e04bfc
--- /dev/null
+++ b/media-libs/libv4l/metadata.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>media-tv</herd>
+	<maintainer>
+		<email>tetromino@gentoo.org</email>
+		<name>Alexandre Rostovtsev</name>
+	</maintainer>
+	<longdescription lang="en">
+	libv4l is a collection of libraries which adds a thin abstraction layer	on
+	top of video4linux2 devices. The purpose of this (thin) layer is to make it
+	easy for application writers to support a wide variety of devices without
+	having to write separate code for different devices in the same class.
+
+	libv4l consists of 3 different libraries: libv4lconvert, libv4l1 and libv4l2.
+
+	libv4lconvert offers functions to convert from any (known) pixelformat
+	to V4l2_PIX_FMT_BGR24 or V4l2_PIX_FMT_YUV420.
+
+	libv4l1 offers the (deprecated) v4l1 API on top of v4l2 devices, independent
+	of the drivers for those devices supporting v4l1 compatibility (which many
+	v4l2 drivers do not).
+
+	libv4l2 offers the v4l2 API on top of v4l2 devices, while adding for the
+	application transparent libv4lconvert conversion where necessary.
+	</longdescription>
+</pkgmetadata>
+
diff --git a/media-libs/libvorbis/metadata.xml b/media-libs/libvorbis/metadata.xml
new file mode 100644
index 0000000..e1774e3
--- /dev/null
+++ b/media-libs/libvorbis/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>sound</herd>
+</pkgmetadata>
diff --git a/media-libs/libvpx/metadata.xml b/media-libs/libvpx/metadata.xml
new file mode 100644
index 0000000..94a045d
--- /dev/null
+++ b/media-libs/libvpx/metadata.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>video</herd>
+	<maintainer>
+		<email>media-video@gentoo.org</email>
+	</maintainer>
+	<use>
+		<flag name="postproc">Enable additional post processing filters</flag>
+		<flag name="sse3">Enable optimization for SSE3 capable chips</flag>
+		<flag name="ssse3">faster floating point optimization for SSSE3 capable chips (Intel Core 2 and later chips)</flag>
+		<flag name="sse4_1">Enable optimization for SSE4_1 capable processors (Intel Core 2 Penryn and later chips)</flag>
+	</use>
+	<upstream>
+		<remote-id type="google-code">webm</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/media-libs/metadata.xml b/media-libs/metadata.xml
new file mode 100644
index 0000000..afd9185
--- /dev/null
+++ b/media-libs/metadata.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The media-libs category contains media-related libraries.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie media-libs enthält Multimedia-Bibliotheken.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría media-libs contiene librerías relacionadas con media.
+	</longdescription>
+	<longdescription lang="ja">
+		media-libsカテゴリーにはメディア関連のライブラリが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De media-libs categorie bevat bibliotheken voor multimedia.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm media-libs chứa các thư viện liên quan đến media.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria media-libs contiene librerie multimediali.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria media-libs contém bibliotecas relacionadas com mídia.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria media-libs zawiera biblioteki multimedialne.
+	</longdescription>
+</catmetadata>
+
diff --git a/media-libs/sbc/metadata.xml b/media-libs/sbc/metadata.xml
new file mode 100644
index 0000000..c9b0be6
--- /dev/null
+++ b/media-libs/sbc/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>sound</herd>
+	<maintainer>
+		<email>pacho@gentoo.org</email>
+		<name>Pacho Ramos</name>
+	</maintainer>
+</pkgmetadata>
diff --git a/media-libs/speex/metadata.xml b/media-libs/speex/metadata.xml
new file mode 100644
index 0000000..e1774e3
--- /dev/null
+++ b/media-libs/speex/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>sound</herd>
+</pkgmetadata>
diff --git a/media-libs/tiff/metadata.xml b/media-libs/tiff/metadata.xml
new file mode 100644
index 0000000..fee1dc1
--- /dev/null
+++ b/media-libs/tiff/metadata.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>graphics</herd>
+<longdescription>TIFF image library and tools, mostly for scanner and fax
+ support, but also used by GIS and other imaging tools.</longdescription>
+</pkgmetadata>
diff --git a/media-plugins/alsa-plugins/metadata.xml b/media-plugins/alsa-plugins/metadata.xml
new file mode 100644
index 0000000..8987e55
--- /dev/null
+++ b/media-plugins/alsa-plugins/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>alsa</herd>
+<maintainer>
+<email>alsa-bugs@gentoo.org</email>
+</maintainer>
+</pkgmetadata>
diff --git a/media-plugins/metadata.xml b/media-plugins/metadata.xml
new file mode 100644
index 0000000..06ee545
--- /dev/null
+++ b/media-plugins/metadata.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The media-plugins category contains plugin packages for various media
+		applications.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie media-plugins enthält Plugins für verschiedene 
+		Multimedia-Anwendungen.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría media-plugins contiene paquetes de extensión para varias
+		aplicaciones de media.
+	</longdescription>
+	<longdescription lang="ja">
+		media-pluginsカテゴリーには様々なメディアプラグイン・パッケージが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De media-plugins categorie bevat uitbreidingen voor multimedia-applicaties.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm media-plugins chứa các gói plugin cho các ứng dụng media khác nhau.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria media-plugins contiene pacchetti di estensione per vari pacchetti
+		delle categorie media-.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria media-plugins contém pacotes de extensão para várias
+		aplicações de mídia.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria media-plugins zawiera rozszerzenia multimedialne dla różnych
+		aplikacji.
+	</longdescription>
+</catmetadata>
+
diff --git a/media-sound/alsa-headers/metadata.xml b/media-sound/alsa-headers/metadata.xml
new file mode 100644
index 0000000..8987e55
--- /dev/null
+++ b/media-sound/alsa-headers/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>alsa</herd>
+<maintainer>
+<email>alsa-bugs@gentoo.org</email>
+</maintainer>
+</pkgmetadata>
diff --git a/media-sound/alsa-utils/metadata.xml b/media-sound/alsa-utils/metadata.xml
new file mode 100644
index 0000000..daf88ad
--- /dev/null
+++ b/media-sound/alsa-utils/metadata.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>alsa</herd>
+  <maintainer>
+    <email>alsa-bugs@gentoo.org</email>
+  </maintainer>
+  <use>
+    <flag name='libsamplerate'>install utils that use libsamplerate (e.g. alsaloop)</flag>
+    <flag name='minimal'>omit utils that rely on extra packages (e.g. alsaconf and alsa-info)</flag>
+    <flag name='ncurses'>install utils that use ncurses (e.g. alsamixer)</flag>
+  </use>
+</pkgmetadata>
diff --git a/media-sound/gsm/metadata.xml b/media-sound/gsm/metadata.xml
new file mode 100644
index 0000000..e1774e3
--- /dev/null
+++ b/media-sound/gsm/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>sound</herd>
+</pkgmetadata>
diff --git a/media-sound/metadata.xml b/media-sound/metadata.xml
new file mode 100644
index 0000000..84c7cb8
--- /dev/null
+++ b/media-sound/metadata.xml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The media-sound category contains sound, music and audio applications.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie media-sound enthält verschiedenste Audio-Applikationen.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría media-sound contiene aplicaciones de sonido, música y
+		audio.
+	</longdescription>
+	<longdescription lang="fr">
+		La catégorie media-sound contient des applications de son, de musique et d'audio.
+	</longdescription>
+	<longdescription lang="ja">
+		media-soundカテゴリーにはサウンドやミュージックやオーデイオの
+		アプリケーションが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De categorie media-sound bevat applicaties voor geluid en muziek.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm media-sound chứa các ứng dụng liên quan đến âm thanh, nhạc, tiếng nói.
+	</longdescription>
+	<longdescription lang="sk">
+		Kategória media-sound obsahuje aplikácie pre prácu so zvukom a hudbou.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria media-sound contiene applicazioni per suono, musica e
+		audio.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria media-sound contém aplicações de som, música e áudio.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria media-sound zawiera programy dźwiękowe i muzyczne.
+	</longdescription>
+</catmetadata>
+
diff --git a/media-sound/sox/metadata.xml b/media-sound/sox/metadata.xml
new file mode 100644
index 0000000..b50e87a
--- /dev/null
+++ b/media-sound/sox/metadata.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>sound</herd>
+  <use>
+    <flag name="amr">Enables Adaptive Multi-Rate Audio support</flag>
+    <flag name="id3tag">Enables ID3 tagging with id3tag library</flag>
+    <flag name="twolame">Enables twolame support (MPEG Audio Layer 2 encoder)</flag>
+  </use>
+</pkgmetadata>
diff --git a/media-video/ffmpeg/metadata.xml b/media-video/ffmpeg/metadata.xml
new file mode 100644
index 0000000..96d35d9
--- /dev/null
+++ b/media-video/ffmpeg/metadata.xml
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>video</herd>
+  <maintainer>
+    <email>media-video@gentoo.org</email>
+  </maintainer>
+  <use>
+    <flag name="3dnowext">
+      Enable manually-optimised routines using the AMD 3DNow!Ex SIMD
+      instruction set, present in modern AMD CPUs.  (Check for
+      3dnowext in /proc/cpuinfo to know whether your CPU supports it).
+    </flag>
+    <flag name="aacplus">AAC+ encoding via <pkg>media-libs/libaacplus</pkg>.</flag>
+    <flag name="amr">Enables Adaptive Multi-Rate Audio support</flag>
+    <flag name="avx">Adds support for Advanced Vector Extensions instructions (Intel Sandy Bridge, AMD Bulldozer and later chips)</flag>
+	<flag name="bindist">Enforces license compatibility constraints via REQUIRED_USE.</flag>
+	<flag name="bluray">Enable playback of Blu-ray filesystems</flag>
+    <flag name="cdio">Enables audio CD grabbing with <pkg>dev-libs/libcdio</pkg>.</flag>
+	<flag name="celt">Adds Xiph CELT audio decoding support via <pkg>media-libs/celt</pkg></flag>
+    <flag name="cpudetection">Enables runtime CPU detection (useful for bindist, compatibility on other CPUs)</flag>
+    <flag name="dirac">Enable Dirac video support (an advanced royalty-free video compression format) via the reference library: dirac.</flag>
+	<flag name="faac">Use external faac library for AAC encoding</flag>
+	<flag name="fdk">Use external fdk-aac library for AAC encoding</flag>
+	<flag name="flite">Adds a text-to-speech filter based on <pkg>app-accessibility/flite</pkg>.</flag>
+	<flag name="frei0r">Enable frei0r wrapping in libavfilter</flag>
+    <flag name="hardcoded-tables">Use pre-calculated tables rather than calculating them on the fly.</flag>
+	<flag name="iec61883"> Support for FireWire DV/HDV input device using <pkg>media-libs/libiec61883</pkg>.</flag>
+	<flag name="libsoxr">Enables audio resampling through <pkg>media-libs/soxr</pkg>.</flag>
+	<flag name="libv4l">Uses <pkg>media-libs/libv4l</pkg> for video4linux instead of direct calls. Adds support for more devices via the userspace library.</flag>
+    <flag name="mmxext">Enables mmx2 support</flag>
+    <flag name="network">Enables network streaming support</flag>
+	<flag name="openssl">Enables <pkg>dev-libs/openssl</pkg> support. Adds support for encrypted network protocols (TLS/HTTPS).</flag>
+	<flag name="opus">Adds (decoding) support for the Opus codec via <pkg>media-libs/opus</pkg>.</flag>
+    <flag name="pic">Force shared libraries to be built as PIC (this is slower)</flag>
+    <flag name="rtmp">Enable Real Time Messaging Protocol using librtmp</flag>
+    <flag name="schroedinger">Enable Dirac video support (an advanced royalty-free video compression format) via libschroedinger (high-speed implementation in C of the Dirac codec).</flag>
+    <flag name="ssse3">Faster floating point optimization for SSSE3 capable chips (Intel Core 2 and later chips)</flag>
+	<flag name="twolame">Enables MP2 encoding via <pkg>media-sound/twolame</pkg> as an alternative to the internal encoder.</flag>
+	<flag name="vaapi">Enables VAAPI (Video Acceleration API) for hardware decoding</flag>
+	<flag name="vis"> Adds support for SIMD optimizations for UltraSPARC processors.</flag>
+	<flag name="vpx">Enables vp8 codec support using libvpx: Decoding vp8 does not require this to be enabled but libvpx can also be used for decoding; encoding vp8 requires this useflag to be enabled though.</flag>
+  </use>
+</pkgmetadata>
diff --git a/media-video/metadata.xml b/media-video/metadata.xml
new file mode 100644
index 0000000..21e3aff
--- /dev/null
+++ b/media-video/metadata.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The media-video category contains video-related applications.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie media-video enthält Applikationen rund um das Thema Video.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría media-video contiene aplicaciones para video.
+	</longdescription>
+	<longdescription lang="ja">
+		media-videoカテゴリーにはビデオ関連のアプリケーションが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De media-video categorie bevat video-applicaties.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm media-video chứa các ứng dụng liên quan đến phim ảnh.
+	</longdescription>
+	<longdescription lang="sk">
+		Kategória media-video obsahuje aplikácie pre prácu s videomateriálom.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria media-video contiene applicazioni video.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria media-video contém aplicações de vídeo.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria media-video zawiera pakiety związane z odtwarzaniem i
+		przetwarzaniem filmów.
+	</longdescription>
+</catmetadata>
+
diff --git a/media-video/mplayer/metadata.xml b/media-video/mplayer/metadata.xml
new file mode 100644
index 0000000..ab025d9
--- /dev/null
+++ b/media-video/mplayer/metadata.xml
@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>video</herd>
+<maintainer>
+	<email>media-video@gentoo.org</email>
+</maintainer>
+<use>
+	<flag name="3dnowext">Enable 3dnowext cpu instructions</flag>
+	<flag name="bindist">Enforces license compatibility constraints via REQUIRED_USE.</flag>
+	<flag name="bl">Blinkenlights video output</flag>
+	<flag name="bluray">Enable playback of Blu-ray filesystems</flag>
+	<flag name="bs2b">Enable Bauer stereophonic-to-binaural headphone filter</flag>
+	<flag name="cdio">Use libcdio for CD support (instead of cdparanoia)</flag>
+	<flag name="cpudetection">Enables runtime CPU detection (useful for bindist, compatibility on other CPUs)</flag>
+	<flag name="dvdnav">Use forked libdvdnav, navigate menus in GUIs</flag>
+	<flag name="dxr3">Enable DXR3/H+ video output</flag>
+	<flag name="enca">Enables support for charset discovery and conversion</flag>
+	<flag name="faac">Use external faac library for AAC encoding</flag>
+	<flag name="faad">Use external faad library for AAC decoding</flag>
+	<flag name="libmpeg2">Build support for mpeg2 over media-libs/libmpeg2 rather than using ffmpeg.</flag>
+	<flag name="live">Enables live.com streaming media support</flag>
+	<flag name="md5sum">Enables md5sum video output</flag>
+	<flag name="mmxext">Enables mmx2 support</flag>
+	<flag name="mng">MNG input support</flag>
+	<flag name="network">Enables network streaming support</flag>
+	<flag name="nut">Enables support for the NUT container format</flag>
+	<flag name="osdmenu">Enables support for on-screen display (OSD) menus</flag>
+	<flag name="pnm">Add PNM video output option, to create PPM/PGM/PGMYUV images</flag>
+	<flag name="pvr">Enable Video4Linux2 MPEG PVR</flag>
+	<flag name="radio">Enable V4L2 radio interface and support</flag>
+	<flag name="rar">Enable Unique RAR File Library</flag>
+	<flag name="real">Adds Real audio/video support</flag>
+	<flag name="rtc">Enables usage of the linux real time clock. The alternative is software emulation of rtc</flag>
+	<flag name="rtmp">Enables RTMPDump Streaming Media support</flag>
+	<flag name="shm">Enable support for shm</flag>
+	<flag name="ssse3">faster floating point optimization for SSSE3 capable chips (Intel Core 2 and later chips)</flag>
+	<flag name="tga">Enables Targa video output</flag>
+	<flag name="toolame">Enable toolame MPEG-2 encoding</flag>
+	<flag name="tremor">Enable internal support for Vorbis</flag>
+	<flag name="twolame">Enable twolame MPEG-2 encoding</flag>
+	<flag name="vidix">Support for vidix video output</flag>
+	<flag name="xanim">Enables support for xanim based codecs</flag>
+	<flag name="xvmc">Enables X-Video Motion Compensation support</flag>
+	<flag name="zoran">Enables ZR360[56]7/ZR36060 video output</flag>
+</use>
+</pkgmetadata>
diff --git a/net-analyzer/metadata.xml b/net-analyzer/metadata.xml
new file mode 100644
index 0000000..58f5863
--- /dev/null
+++ b/net-analyzer/metadata.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The net-analyzer category contains network analysis software.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie net-analyzer enthält Software zur Netzwerkanalyse.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría net-analyzer contiene programas de análisis de redes.
+	</longdescription>
+	<longdescription lang="ja">
+		net-analyzerカテゴリーにはネットワーク・アナリシスのソフトウェアが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De net-analyzer categorie bevat applicaties voor netwerk-analyse.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm net-analyzer chứa các phần mềm phân tích mạng.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria net-analyzer contiene programmi per l'analisi della rete.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria net-analyzer contém programas de análise de rede.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria net-analyzer zawiera programy do analizowania sieci.
+	</longdescription>
+</catmetadata>
+
diff --git a/net-analyzer/netperf/metadata.xml b/net-analyzer/netperf/metadata.xml
new file mode 100644
index 0000000..9f51ead
--- /dev/null
+++ b/net-analyzer/netperf/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>netmon</herd>
+<use>
+<flag name='demo'>Emit interim results during the run. May affect results</flag>
+<flag name='sctp'>Include tests to measure SCTP performance</flag>
+</use>
+</pkgmetadata>
diff --git a/net-analyzer/tcpdump/metadata.xml b/net-analyzer/tcpdump/metadata.xml
new file mode 100644
index 0000000..a9759ef
--- /dev/null
+++ b/net-analyzer/tcpdump/metadata.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>netmon</herd>
+	<longdescription>A pcap based tool for network protocol monitoring and data acquisition.</longdescription>
+	<use>
+		<flag name='smi'>Build with <pkg>net-libs/libsmi</pkg> to load MIBs on the fly to decode SNMP packets</flag>
+		<flag name='chroot'>Chroot into /var/lib/tcpdump when dropping privileges</flag>
+	</use>
+</pkgmetadata>
diff --git a/net-dialup/lrzsz/metadata.xml b/net-dialup/lrzsz/metadata.xml
new file mode 100644
index 0000000..a46ef86
--- /dev/null
+++ b/net-dialup/lrzsz/metadata.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>net-dialup</herd>
+<longdescription>Communication package providing the X, Y, and ZMODEM file transfer protocols</longdescription>
+</pkgmetadata>
diff --git a/net-dialup/metadata.xml b/net-dialup/metadata.xml
new file mode 100644
index 0000000..313bfd5
--- /dev/null
+++ b/net-dialup/metadata.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The net-dialup category contains dialup-related networking software.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie net-dialup enthält Software für Dialup-Verbindungen.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría net-dialup contiene paquetes relacionados con conexiones
+		telefónicas.
+	</longdescription>
+	<longdescription lang="ja">
+		net-dialupカテゴリーにはダイアルアップに関連したネットワーキング・ソフトウェアが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De net-dialup categorie bevat applicaties voor inbelverbindingen.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm net-dialup chứa các phần mềm liên quan đến mạng quay số.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria net-dialup contiene pacchetti per la connessione telefonica dial-up.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria net-dialup contém programas relacionados com
+		conexões telefônicas.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria net-dialup zawiera programy sieciowe związane z połączeniami
+		telefonicznymi (dialup).
+	</longdescription>
+</catmetadata>
+
diff --git a/net-dialup/minicom/metadata.xml b/net-dialup/minicom/metadata.xml
new file mode 100644
index 0000000..860bc36
--- /dev/null
+++ b/net-dialup/minicom/metadata.xml
@@ -0,0 +1,13 @@
+<?xml version = '1.0' encoding = 'UTF-8'?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>net-dialup</herd>
+  <maintainer>
+    <email>radhermit@gentoo.org</email>
+    <name>Tim Harder</name>
+  </maintainer>
+  <longdescription lang="en">
+    Minicom is a menu driven communications program. It emulates ANSI and VT102
+    terminals. It has a dialing directory and auto zmodem download.
+  </longdescription>
+</pkgmetadata>
diff --git a/net-dns/avahi/metadata.xml b/net-dns/avahi/metadata.xml
new file mode 100644
index 0000000..7eaf27c
--- /dev/null
+++ b/net-dns/avahi/metadata.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+	<email>blueness@gentoo.org</email>
+	<name>Anthony G. Basile</name>
+</maintainer>
+<use>
+	<flag name='autoipd'>Build and install the IPv4LL (RFC3927) network address
+		configuration daemon</flag>
+	<flag name='bookmarks'>Install the avahi-bookmarks application (requires
+		<pkg>dev-python/twisted</pkg>)</flag>
+	<flag name='howl-compat'>Enable compat libraries for howl</flag>
+	<flag name="gtk3">Build the avahi-ui-gtk3 library, and use gtk3 for the
+		avahi utilities under USE=utils</flag>
+	<flag name="introspection">Use <pkg>dev-libs/gobject-introspection</pkg>
+		for introspection</flag>
+	<flag name='mdnsresponder-compat'>Enable compat libraries for
+		mDNSResponder</flag>
+	<flag name="utils">Install the avahi gtk+ utils avahi-discover, bssh, and
+		bvnc</flag>
+</use>
+</pkgmetadata>
diff --git a/net-dns/c-ares/metadata.xml b/net-dns/c-ares/metadata.xml
new file mode 100644
index 0000000..950fed5
--- /dev/null
+++ b/net-dns/c-ares/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+  <email>blueness@gentoo.org</email>
+  <name>Anthony G. Basile</name>
+</maintainer>
+<longdescription></longdescription>
+</pkgmetadata>
diff --git a/net-dns/dnsmasq/metadata.xml b/net-dns/dnsmasq/metadata.xml
new file mode 100644
index 0000000..74dc8ba
--- /dev/null
+++ b/net-dns/dnsmasq/metadata.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+<email>chutzpah@gentoo.org</email>
+<name>Patrick McLean</name>
+</maintainer>
+<use>
+	<flag name='auth-dns'>Add support for acting as an authorative DNS server.</flag>
+	<flag name='conntrack'>Add support for Linux conntrack connection marking.</flag>
+	<flag name='dhcp'>Enable support for reading ISC DHCPd lease files</flag>
+	<flag name='script'>Enable support for calling scripts when leases change</flag>
+	<flag name='tftp'>Enables built in TFTP server for netbooting</flag>
+	<flag name='dhcp-tools'>Install extra command line tools for manually managing DHCP leases</flag>
+</use>
+</pkgmetadata>
+
diff --git a/net-dns/metadata.xml b/net-dns/metadata.xml
new file mode 100644
index 0000000..18ee426
--- /dev/null
+++ b/net-dns/metadata.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The net-dns category contains DNS (Domain Name Service) related
+		software.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie net-dns enthült Software zum Thema DNS (Domain Name Service).
+	</longdescription>
+	<longdescription lang="es">
+		La categoría net-dns contiene programas relacionados con el DNS, el
+		sistema de resolución de nombres de dominio.
+	</longdescription>
+	<longdescription lang="ja">
+		net-dnsカテゴリーにはドメイン・ネーム・サービスに関連したソフトウェアが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De net-dns categorie bevat DNS (Domain Name Service) applicaties.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm net-dns chứa các phần mềm liên quan đến DNS.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria net-dns contiene programmi per DNS (Domain Name Service).
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria net-dns contém programas relacionados a DNS (Domain
+		Name Service).
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria net-dns zawiera pakiety związane z DNS (Domain Name Service).
+	</longdescription>
+</catmetadata>
+
diff --git a/net-ftp/metadata.xml b/net-ftp/metadata.xml
new file mode 100644
index 0000000..48d4281
--- /dev/null
+++ b/net-ftp/metadata.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The net-ftp contains FTP (File Transfer Protocol) software.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie net-ftp enthält Software für das File Transfer Protocol (FTP).
+	</longdescription>
+	<longdescription lang="es">
+		La categoría net-ftp contiene programas relacionados con FTP, el
+		protocolo de transferencia de ficheros.
+	</longdescription>
+	<longdescription lang="ja">
+		net-ftpカテゴリーにはファイル・トランスファー・プロトコルの
+		ソフトウェアが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De net-ftp categorie bevat software voor gebruik van FTP (File Transfer Protocol).
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria net-ftp contem programas relacionados com FTP (File Transfer
+		Protocol).
+	</longdescription>
+	<longdescription lang="sk">
+		Kategória net-ftp obsahuje aplikácie vzťahujúce sa k FTP (File Transfer Protocol).
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm net-ftp chứa các phần mềm FTP (File Transfer Protocol).
+	</longdescription>
+	<longdescription lang="it">
+		La categoria net-ftp contiene programmi per l'FTP (File Transfer Protocol).
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria net-ftp zawiera pakiety związane z FTP (File Transfer Protocol).
+	</longdescription>
+</catmetadata>
+
diff --git a/net-ftp/tftp-hpa/metadata.xml b/net-ftp/tftp-hpa/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/net-ftp/tftp-hpa/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/net-libs/gnutls/metadata.xml b/net-libs/gnutls/metadata.xml
new file mode 100644
index 0000000..f082e62
--- /dev/null
+++ b/net-libs/gnutls/metadata.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>crypto</herd>
+  <use>
+    <flag name="nettle" restrict="&lt;net-libs/gnutls-3">
+      Use <pkg>dev-libs/nettle</pkg> as crypto backend
+    </flag>
+    <flag name="pkcs11">
+      Add support for PKCS#11 through <pkg>app-crypt/p11-kit</pkg>
+    </flag>
+    <flag name="dane" restrict="&gt;=net-libs/gnutls-3.1.3">
+      Build libgnutls-dane, implementing DNS-based Authentication of
+      Named Entities. Requires <pkg>net-dns/unbound</pkg>.
+    </flag>
+    <flag name="bindist">
+      Disallow building LZO support, because of a license
+      incompatibility with <pkg>dev-libs/lzo</pkg>.
+    </flag>
+  </use>
+</pkgmetadata>
diff --git a/net-libs/liblockfile/metadata.xml b/net-libs/liblockfile/metadata.xml
new file mode 100644
index 0000000..51f94e3
--- /dev/null
+++ b/net-libs/liblockfile/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>net-mail</herd>
+</pkgmetadata>
diff --git a/net-libs/libmnl/metadata.xml b/net-libs/libmnl/metadata.xml
new file mode 100644
index 0000000..b301c63
--- /dev/null
+++ b/net-libs/libmnl/metadata.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>netmon</herd>
+<longdescription lang="en">
+	libmnl is a minimalistic user-space library oriented to Netlink developers.
+	There are a lot of common tasks in parsing, validating, constructing of both
+	the Netlink header and TLVs that are repetitive and easy to get wrong. This
+	library aims to provide simple helpers that allows you to re-use code and to
+	avoid re-inventing the wheel.
+</longdescription>
+</pkgmetadata>
+
diff --git a/net-libs/libnetfilter_queue/metadata.xml b/net-libs/libnetfilter_queue/metadata.xml
new file mode 100644
index 0000000..acb09b4
--- /dev/null
+++ b/net-libs/libnetfilter_queue/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>netmon</herd>
+<maintainer>
+  <email>cedk@gentoo.org</email>
+</maintainer>
+<longdescription>API to packets that have been queued by the kernel packet filter</longdescription>
+</pkgmetadata>
diff --git a/net-libs/libnfnetlink/metadata.xml b/net-libs/libnfnetlink/metadata.xml
new file mode 100644
index 0000000..851c899
--- /dev/null
+++ b/net-libs/libnfnetlink/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>netmon</herd>
+<maintainer>
+  <email>cedk@gentoo.org</email>
+</maintainer>
+<longdescription>the low-level library for netfilter related kernel/userspace communication</longdescription>
+</pkgmetadata>
diff --git a/net-libs/libnfsidmap/metadata.xml b/net-libs/libnfsidmap/metadata.xml
new file mode 100644
index 0000000..ca66751
--- /dev/null
+++ b/net-libs/libnfsidmap/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>net-fs</herd>
+</pkgmetadata>
diff --git a/net-libs/libpcap/metadata.xml b/net-libs/libpcap/metadata.xml
new file mode 100644
index 0000000..0d5a883
--- /dev/null
+++ b/net-libs/libpcap/metadata.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>netmon</herd>
+  <longdescription>A system-independent library for user-level network packet capture</longdescription>
+  <use>
+    <flag name='netlink'>
+      Use <pkg>dev-libs/libnl</pkg> to put wireless interfaces in monitor mode.
+    </flag>
+    <flag name='canusb'>
+      Use <pkg>virtual/libusb</pkg> to support Controller Area Network over USB (CAN USB)
+    </flag>
+  </use>
+</pkgmetadata>
diff --git a/net-libs/libsoup/metadata.xml b/net-libs/libsoup/metadata.xml
new file mode 100644
index 0000000..f96b3e3
--- /dev/null
+++ b/net-libs/libsoup/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>gnome</herd>
+	<use>
+		<flag name="samba">Use <pkg>net-fs/samba</pkg> for NTLM Single
+			Sign-On</flag>
+	</use>
+</pkgmetadata>
diff --git a/net-libs/libtirpc/metadata.xml b/net-libs/libtirpc/metadata.xml
new file mode 100644
index 0000000..ca66751
--- /dev/null
+++ b/net-libs/libtirpc/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>net-fs</herd>
+</pkgmetadata>
diff --git a/net-libs/metadata.xml b/net-libs/metadata.xml
new file mode 100644
index 0000000..80be98e
--- /dev/null
+++ b/net-libs/metadata.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The net-libs category contains libraries that are network-related.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie net-libs enthält Bibliotheken zur Netzwerkprogrammierung.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría net-libs contiene librerías relacionadas con las redes.
+	</longdescription>
+	<longdescription lang="ja">
+		net-libsカテゴリーにはネットワーク関連のライブラリが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De net-libs categorie bevat bibliotheken voor netwerk-gebruik.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm net-libs chứa các thư viện về mạng.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria net-libs contiene librerie per le reti.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria net-libs contém bibliotecas relacionadas a redes.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria net-libs zawiera związane z siecią biblioteki.
+	</longdescription>
+</catmetadata>
+
diff --git a/net-libs/neon/metadata.xml b/net-libs/neon/metadata.xml
new file mode 100644
index 0000000..25503b4
--- /dev/null
+++ b/net-libs/neon/metadata.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>proxy-maintainers</herd>
+  <maintainer>
+    <email>arfrever.fta@gmail.com</email>
+  </maintainer>
+  <longdescription>
+	Neon is an HTTP and WebDAV client library for Unix systems, with a C
+	language API. It provides high-level interfaces to HTTP/1.1 and WebDAV
+	methods, and a low-level interface to HTTP request/response handling,
+	allowing new methods to be easily implemented.
+	</longdescription>
+  <longdescription lang="ja">
+	neon は Unix システムにおける HTTP 及び WebDAV クライアント・ライブラリ
+	であり、C言語 API です。HTTP/1.1 及び WebDAV のメソッドという高い視点
+	でのインターフェイス、HTTP リクエスト/レスポンス のハンドリングという
+	低い視点でのインターフェイス、簡単に実装できるようにした新しいメソッド
+	といったものを提供します。
+	</longdescription>
+  <use>
+    <flag name="libproxy">Add support for <pkg>net-libs/libproxy</pkg></flag>
+    <flag name="pkcs11">Add support for PKCS#11 using <pkg>dev-libs/pakchois</pkg></flag>
+  </use>
+</pkgmetadata>
diff --git a/net-libs/serf/metadata.xml b/net-libs/serf/metadata.xml
new file mode 100644
index 0000000..d5a6167
--- /dev/null
+++ b/net-libs/serf/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>proxy-maintainers</herd>
+	<maintainer>
+		<email>arfrever.fta@gmail.com</email>
+	</maintainer>
+	<upstream>
+		<remote-id type="google-code">serf</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/net-misc/corkscrew/metadata.xml b/net-misc/corkscrew/metadata.xml
new file mode 100644
index 0000000..eb5fbf2
--- /dev/null
+++ b/net-misc/corkscrew/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>sysadmin</herd>
+<longdescription>
+Corkscrew is a tool for tunneling SSH through HTTP proxies.
+</longdescription>
+<longdescription lang="ja">
+Corkscrew は HTTP プロクシ経由の SSH トンネルを構築するツールです。
+</longdescription>
+</pkgmetadata>
diff --git a/net-misc/gsutil/metadata.xml b/net-misc/gsutil/metadata.xml
new file mode 100644
index 0000000..139f125
--- /dev/null
+++ b/net-misc/gsutil/metadata.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>vapier@gentoo.org</email>
+	</maintainer>
+	<upstream>
+		<remote-id type="google-code">gsutil</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/net-misc/metadata.xml b/net-misc/metadata.xml
new file mode 100644
index 0000000..0848d7a
--- /dev/null
+++ b/net-misc/metadata.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The net-misc category contains various miscellaneous networking tools
+		and utilities.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie net-misc enthält verschiedenste Programme und Werkzeuge
+		rund um Netzwerke.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría net-misc contiene varias herramientas y utilidades
+		relacionadas con las redes.
+	</longdescription>
+	<longdescription lang="ja">
+		net-miscカテゴリーには多種多様なネットワーキング・ツールと
+		ユーティリティが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De net-misc categorie bevat verschillende netwerkapplicaties.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm net-misc chứa các công cụ mạng khác nhau.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria net-misc contiene vari strumenti ed utilità per la gestione delle reti.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria net-misc contém várias ferramentas e utilitários
+		de rede.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria net-misc zawiera różne dodatkowe narzędzia i programy sieciowe.
+	</longdescription>
+</catmetadata>
+
diff --git a/net-misc/radvd/metadata.xml b/net-misc/radvd/metadata.xml
new file mode 100644
index 0000000..74f40b3
--- /dev/null
+++ b/net-misc/radvd/metadata.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>xmw@gentoo.org</email>
+		<name>Michael Weber</name>
+	</maintainer>
+	<maintainer>
+		<email>prometheanfire@gentoo.org</email>
+		<name>Matthew Thode</name>
+	</maintainer>
+</pkgmetadata>
diff --git a/net-misc/rsync/metadata.xml b/net-misc/rsync/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/net-misc/rsync/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/net-misc/socat/metadata.xml b/net-misc/socat/metadata.xml
new file mode 100644
index 0000000..7869263
--- /dev/null
+++ b/net-misc/socat/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>netmon</herd>
+</pkgmetadata>
diff --git a/net-misc/wget/metadata.xml b/net-misc/wget/metadata.xml
new file mode 100644
index 0000000..789a0be
--- /dev/null
+++ b/net-misc/wget/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+ <herd>base-system</herd>
+<use>
+ <flag name='ntlm'>Enable support for NTLM (Windows-based) authorization</flag>
+ <flag name='uuid'>Generate UUIDs for the WARC (Web ARChive file format) using libuuid; otherwise use a simple RNG (random number generator)</flag>
+</use>
+</pkgmetadata>
diff --git a/net-nds/metadata.xml b/net-nds/metadata.xml
new file mode 100644
index 0000000..e5113d1
--- /dev/null
+++ b/net-nds/metadata.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The net-nds category contains NDS (NetWare Directory Services) software.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie net-nds enthält Software für die NetWare Directory Services (NDS).
+	</longdescription>
+	<longdescription lang="es">
+		La categoría net-nds contiene programas NDS (NetWare Directory
+		Services).
+	</longdescription>
+	<longdescription lang="ja">
+		net-ndsカテゴリーにはNetWare・ディレクトリ・サービスの
+		ソフトウェアが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De net-nds categorie bevat applicaties voor NDS (NetWare Directory Service).
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm net-nds chứa phần mềm NDS (NetWare Directory Services).
+	</longdescription>
+	<longdescription lang="it">
+		La categoria net-nds contiene programmi NDS (NetWare Directory
+		Services).
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria net-nds contém programas de NDS (NetWare Directory
+		Services).
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria net-nds zawiera oprogramowanie NDS (NetWare Directory Services).
+	</longdescription>
+</catmetadata>
+
diff --git a/net-nds/rpcbind/metadata.xml b/net-nds/rpcbind/metadata.xml
new file mode 100644
index 0000000..ca66751
--- /dev/null
+++ b/net-nds/rpcbind/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>net-fs</herd>
+</pkgmetadata>
diff --git a/net-proxy/metadata.xml b/net-proxy/metadata.xml
new file mode 100644
index 0000000..3248860
--- /dev/null
+++ b/net-proxy/metadata.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The net-proxy category contains network proxy software.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie net-proxy enthält verschiedene Netzwerk-Proxies.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría net-proxy contiene proxies de red.
+	</longdescription>
+	<longdescription lang="ja">
+		net-proxyカテゴリーにはネットワーク・プロキシの
+		ソフトウェアが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De net-proxy categorie bevat verschillende netwerkproxy's.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm net-proxy chứa các phần mềm proxy mạng.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria net-proxy contiene software proxy come squid e privoxy.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria net-proxy contém softwares de proxy de rede.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria net-proxy zawiera oprogramowanie związane z serwerami proxy.
+	</longdescription>
+</catmetadata>
+
diff --git a/net-wireless/metadata.xml b/net-wireless/metadata.xml
new file mode 100644
index 0000000..e951a75
--- /dev/null
+++ b/net-wireless/metadata.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The net-wireless category contains wireless networking software and
+		utilities.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie net-wireless enthält Treiber und Programme für Wireless-Netzwerke.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría net-wireless contiene utilidades y programas relacionados
+		con las redes inalámbricas.
+	</longdescription>
+	<longdescription lang="ja">
+		net-wirelessカテゴリーにはワイヤレスネットワーキング・ソフトウェアと
+		ユーティリティが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De net-wireless categorie bevat applicaties en stuurprogramma's voor draadloze netwerken.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm net-wireless chứa các phần mềm mạng không dây.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria net-wireless contiene utilità e programmi per le reti wireless.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria net-wireless contém programas e utilitários para
+		redes sem fio (wireless).
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria net-wireless zawiera narzędzia do pracy w sieciach bezprzewodowych.
+	</longdescription>
+</catmetadata>
+
diff --git a/net-wireless/wireless-tools/metadata.xml b/net-wireless/wireless-tools/metadata.xml
new file mode 100644
index 0000000..338d98e
--- /dev/null
+++ b/net-wireless/wireless-tools/metadata.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>zerochaos@gentoo.org</email>
+		<name>Rick Farina</name>
+	</maintainer>
+	<longdescription lang="en">
+		This package provides all the command line tools for configuring
+		wireless networking devices with drivers that implement the Linux
+		Wireless Extensions (almost all recent IEEE 802.11a/b/g drivers).
+	</longdescription>
+	<use>
+		<flag name='multicall'>Build the most commonly used tools as one
+			binary</flag>
+	</use>
+</pkgmetadata>
diff --git a/net-zope/metadata.xml b/net-zope/metadata.xml
new file mode 100644
index 0000000..0bf4451
--- /dev/null
+++ b/net-zope/metadata.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The net-zope category contains all Zope (zope.org) related software including third party products and tools.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie net-zope enthält Software rund um Zope (zope.org), inklusive externerProdukte und Werkzeuge.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría net-zope contiene todo el software relacionado con Zope
+		(zope.org) incluyendo herramientas y módulos de terceros.
+	</longdescription>
+	<longdescription lang="ja">
+		net-zopeカテゴリーにはサードパーティ製プロダクトとツールも含めたZope全般の
+		ソフトウェアが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De net-zope categorie bevat alle Zope (zope.org) gerelateerde applicaties.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm net-zope chứa các phần mềm liên quan đến Zope (zope.org)
+		bao gồm các sản phẩm của bên thứ ba.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria net-zope contiene tutto il software relativo a Zope (zope.org)
+		compreso il software sviluppato da terze parti.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria net-zope contém todos os programas relacionados a
+		Zope (zope.org), incluindo produtos e ferramentas de terceiros.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria net-zope zawiera wszystkie pakiety związane bezpośrednio z
+		Zope (zope.org) jak i nieoficjalne narzędzia i produkty.
+	</longdescription>
+</catmetadata>
+
diff --git a/net-zope/zope-fixers/metadata.xml b/net-zope/zope-fixers/metadata.xml
new file mode 100644
index 0000000..2e1ba128
--- /dev/null
+++ b/net-zope/zope-fixers/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="pypi">zope.fixers</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/net-zope/zope-interface/metadata.xml b/net-zope/zope-interface/metadata.xml
new file mode 100644
index 0000000..71902eb
--- /dev/null
+++ b/net-zope/zope-interface/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+	<upstream>
+		<remote-id type="pypi">zope.interface</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/perl-core/Archive-Tar/metadata.xml b/perl-core/Archive-Tar/metadata.xml
index 9b129ee..e9c5768 100644
--- a/perl-core/Archive-Tar/metadata.xml
+++ b/perl-core/Archive-Tar/metadata.xml
@@ -4,5 +4,8 @@
   <herd>perl</herd>
   <upstream>
     <remote-id type="cpan">Archive-Tar</remote-id>
+    <remote-id type="cpan-module">Archive::Tar</remote-id>
+    <remote-id type="cpan-module">Archive::Tar::Constant</remote-id>
+    <remote-id type="cpan-module">Archive::Tar::File</remote-id>
   </upstream>
 </pkgmetadata>
diff --git a/perl-core/Compress-Raw-Bzip2/metadata.xml b/perl-core/Compress-Raw-Bzip2/metadata.xml
index 4170498..c887ffb 100644
--- a/perl-core/Compress-Raw-Bzip2/metadata.xml
+++ b/perl-core/Compress-Raw-Bzip2/metadata.xml
@@ -4,5 +4,6 @@
   <herd>perl</herd>
   <upstream>
     <remote-id type="cpan">Compress-Raw-Bzip2</remote-id>
+    <remote-id type="cpan-module">Compress::Raw::Bzip2</remote-id>
   </upstream>
 </pkgmetadata>
diff --git a/perl-core/Compress-Raw-Zlib/metadata.xml b/perl-core/Compress-Raw-Zlib/metadata.xml
index 84f04a6..1406265 100644
--- a/perl-core/Compress-Raw-Zlib/metadata.xml
+++ b/perl-core/Compress-Raw-Zlib/metadata.xml
@@ -4,5 +4,6 @@
   <herd>perl</herd>
   <upstream>
     <remote-id type="cpan">Compress-Raw-Zlib</remote-id>
+    <remote-id type="cpan-module">Compress::Raw::Zlib</remote-id>
   </upstream>
 </pkgmetadata>
diff --git a/perl-core/ExtUtils-CBuilder/metadata.xml b/perl-core/ExtUtils-CBuilder/metadata.xml
index ac839a3..f190af4 100644
--- a/perl-core/ExtUtils-CBuilder/metadata.xml
+++ b/perl-core/ExtUtils-CBuilder/metadata.xml
@@ -4,5 +4,18 @@
   <herd>perl</herd>
   <upstream>
     <remote-id type="cpan">ExtUtils-CBuilder</remote-id>
+    <remote-id type="cpan-module">ExtUtils::CBuilder</remote-id>
+    <remote-id type="cpan-module">ExtUtils::CBuilder::Base</remote-id>
+    <remote-id type="cpan-module">ExtUtils::CBuilder::Platform::Unix</remote-id>
+    <remote-id type="cpan-module">ExtUtils::CBuilder::Platform::VMS</remote-id>
+    <remote-id type="cpan-module">ExtUtils::CBuilder::Platform::Windows</remote-id>
+    <remote-id type="cpan-module">ExtUtils::CBuilder::Platform::Windows::BCC</remote-id>
+    <remote-id type="cpan-module">ExtUtils::CBuilder::Platform::Windows::GCC</remote-id>
+    <remote-id type="cpan-module">ExtUtils::CBuilder::Platform::Windows::MSVC</remote-id>
+    <remote-id type="cpan-module">ExtUtils::CBuilder::Platform::aix</remote-id>
+    <remote-id type="cpan-module">ExtUtils::CBuilder::Platform::cygwin</remote-id>
+    <remote-id type="cpan-module">ExtUtils::CBuilder::Platform::darwin</remote-id>
+    <remote-id type="cpan-module">ExtUtils::CBuilder::Platform::dec_osf</remote-id>
+    <remote-id type="cpan-module">ExtUtils::CBuilder::Platform::os2</remote-id>
   </upstream>
 </pkgmetadata>
diff --git a/perl-core/ExtUtils-ParseXS/metadata.xml b/perl-core/ExtUtils-ParseXS/metadata.xml
index 26740f8..a3eb673 100644
--- a/perl-core/ExtUtils-ParseXS/metadata.xml
+++ b/perl-core/ExtUtils-ParseXS/metadata.xml
@@ -4,5 +4,14 @@
   <herd>perl</herd>
   <upstream>
     <remote-id type="cpan">ExtUtils-ParseXS</remote-id>
+    <remote-id type="cpan-module">ExtUtils::ParseXS</remote-id>
+    <remote-id type="cpan-module">ExtUtils::ParseXS::Constants</remote-id>
+    <remote-id type="cpan-module">ExtUtils::ParseXS::CountLines</remote-id>
+    <remote-id type="cpan-module">ExtUtils::ParseXS::Utilities</remote-id>
+    <remote-id type="cpan-module">ExtUtils::Typemaps</remote-id>
+    <remote-id type="cpan-module">ExtUtils::Typemaps::Cmd</remote-id>
+    <remote-id type="cpan-module">ExtUtils::Typemaps::InputMap</remote-id>
+    <remote-id type="cpan-module">ExtUtils::Typemaps::OutputMap</remote-id>
+    <remote-id type="cpan-module">ExtUtils::Typemaps::Type</remote-id>
   </upstream>
 </pkgmetadata>
diff --git a/perl-core/File-Spec/metadata.xml b/perl-core/File-Spec/metadata.xml
index 4f3520e..b62bc1a 100644
--- a/perl-core/File-Spec/metadata.xml
+++ b/perl-core/File-Spec/metadata.xml
@@ -9,5 +9,15 @@
 	interim.</longdescription>
   <upstream>
     <remote-id type="cpan">PathTools</remote-id>
+    <remote-id type="cpan-module">Cwd</remote-id>
+    <remote-id type="cpan-module">File::Spec</remote-id>
+    <remote-id type="cpan-module">File::Spec::Cygwin</remote-id>
+    <remote-id type="cpan-module">File::Spec::Epoc</remote-id>
+    <remote-id type="cpan-module">File::Spec::Functions</remote-id>
+    <remote-id type="cpan-module">File::Spec::Mac</remote-id>
+    <remote-id type="cpan-module">File::Spec::OS2</remote-id>
+    <remote-id type="cpan-module">File::Spec::Unix</remote-id>
+    <remote-id type="cpan-module">File::Spec::VMS</remote-id>
+    <remote-id type="cpan-module">File::Spec::Win32</remote-id>
   </upstream>
 </pkgmetadata>
diff --git a/perl-core/IO-Compress/metadata.xml b/perl-core/IO-Compress/metadata.xml
index 5a09d5e..a85bae8 100644
--- a/perl-core/IO-Compress/metadata.xml
+++ b/perl-core/IO-Compress/metadata.xml
@@ -4,5 +4,35 @@
   <herd>perl</herd>
   <upstream>
     <remote-id type="cpan">IO-Compress</remote-id>
+    <remote-id type="cpan-module">Compress::Zlib</remote-id>
+    <remote-id type="cpan-module">File::GlobMapper</remote-id>
+    <remote-id type="cpan-module">IO::Compress::Adapter::Bzip2</remote-id>
+    <remote-id type="cpan-module">IO::Compress::Adapter::Deflate</remote-id>
+    <remote-id type="cpan-module">IO::Compress::Adapter::Identity</remote-id>
+    <remote-id type="cpan-module">IO::Compress::Base</remote-id>
+    <remote-id type="cpan-module">IO::Compress::Base::Common</remote-id>
+    <remote-id type="cpan-module">IO::Compress::Bzip2</remote-id>
+    <remote-id type="cpan-module">IO::Compress::Deflate</remote-id>
+    <remote-id type="cpan-module">IO::Compress::Gzip</remote-id>
+    <remote-id type="cpan-module">IO::Compress::Gzip::Constants</remote-id>
+    <remote-id type="cpan-module">IO::Compress::RawDeflate</remote-id>
+    <remote-id type="cpan-module">IO::Compress::Zip</remote-id>
+    <remote-id type="cpan-module">IO::Compress::Zip::Constants</remote-id>
+    <remote-id type="cpan-module">IO::Compress::Zlib::Constants</remote-id>
+    <remote-id type="cpan-module">IO::Compress::Zlib::Extra</remote-id>
+    <remote-id type="cpan-module">IO::Uncompress::Adapter::Bunzip2</remote-id>
+    <remote-id type="cpan-module">IO::Uncompress::Adapter::Identity</remote-id>
+    <remote-id type="cpan-module">IO::Uncompress::Adapter::Inflate</remote-id>
+    <remote-id type="cpan-module">IO::Uncompress::AnyInflate</remote-id>
+    <remote-id type="cpan-module">IO::Uncompress::AnyUncompress</remote-id>
+    <remote-id type="cpan-module">IO::Uncompress::Base</remote-id>
+    <remote-id type="cpan-module">IO::Uncompress::Bunzip2</remote-id>
+    <remote-id type="cpan-module">IO::Uncompress::Gunzip</remote-id>
+    <remote-id type="cpan-module">IO::Uncompress::Inflate</remote-id>
+    <remote-id type="cpan-module">IO::Uncompress::RawInflate</remote-id>
+    <remote-id type="cpan-module">IO::Uncompress::Unzip</remote-id>
+    <remote-id type="cpan-module">U64</remote-id>
+    <remote-id type="cpan-module">Zlib::OldDeflate</remote-id>
+    <remote-id type="cpan-module">Zlib::OldInflate</remote-id>
   </upstream>
 </pkgmetadata>
diff --git a/perl-core/IO-Zlib/metadata.xml b/perl-core/IO-Zlib/metadata.xml
index b7af084..bbac0ab 100644
--- a/perl-core/IO-Zlib/metadata.xml
+++ b/perl-core/IO-Zlib/metadata.xml
@@ -4,5 +4,6 @@
   <herd>perl</herd>
   <upstream>
     <remote-id type="cpan">IO-Zlib</remote-id>
+    <remote-id type="cpan-module">IO::Zlib</remote-id>
   </upstream>
 </pkgmetadata>
diff --git a/perl-core/Module-Build/metadata.xml b/perl-core/Module-Build/metadata.xml
index 1dd4bf6..526d387 100644
--- a/perl-core/Module-Build/metadata.xml
+++ b/perl-core/Module-Build/metadata.xml
@@ -4,5 +4,33 @@
   <herd>perl</herd>
   <upstream>
     <remote-id type="cpan">Module-Build</remote-id>
+    <remote-id type="cpan-module">Module::Build</remote-id>
+    <remote-id type="cpan-module">Module::Build::Base</remote-id>
+    <remote-id type="cpan-module">Module::Build::Compat</remote-id>
+    <remote-id type="cpan-module">Module::Build::Config</remote-id>
+    <remote-id type="cpan-module">Module::Build::Cookbook</remote-id>
+    <remote-id type="cpan-module">Module::Build::Dumper</remote-id>
+    <remote-id type="cpan-module">Module::Build::ModuleInfo</remote-id>
+    <remote-id type="cpan-module">Module::Build::Notes</remote-id>
+    <remote-id type="cpan-module">Module::Build::PPMMaker</remote-id>
+    <remote-id type="cpan-module">Module::Build::Platform::Amiga</remote-id>
+    <remote-id type="cpan-module">Module::Build::Platform::Default</remote-id>
+    <remote-id type="cpan-module">Module::Build::Platform::EBCDIC</remote-id>
+    <remote-id type="cpan-module">Module::Build::Platform::MPEiX</remote-id>
+    <remote-id type="cpan-module">Module::Build::Platform::MacOS</remote-id>
+    <remote-id type="cpan-module">Module::Build::Platform::RiscOS</remote-id>
+    <remote-id type="cpan-module">Module::Build::Platform::Unix</remote-id>
+    <remote-id type="cpan-module">Module::Build::Platform::VMS</remote-id>
+    <remote-id type="cpan-module">Module::Build::Platform::VOS</remote-id>
+    <remote-id type="cpan-module">Module::Build::Platform::Windows</remote-id>
+    <remote-id type="cpan-module">Module::Build::Platform::aix</remote-id>
+    <remote-id type="cpan-module">Module::Build::Platform::cygwin</remote-id>
+    <remote-id type="cpan-module">Module::Build::Platform::darwin</remote-id>
+    <remote-id type="cpan-module">Module::Build::Platform::os2</remote-id>
+    <remote-id type="cpan-module">Module::Build::PodParser</remote-id>
+    <remote-id type="cpan-module">Module::Build::Version</remote-id>
+    <remote-id type="cpan-module">Module::Build::YAML</remote-id>
+    <remote-id type="cpan-module">inc::latest</remote-id>
+    <remote-id type="cpan-module">inc::latest::private</remote-id>
   </upstream>
 </pkgmetadata>
diff --git a/perl-core/Package-Constants/metadata.xml b/perl-core/Package-Constants/metadata.xml
index d9208c1..7b82830 100644
--- a/perl-core/Package-Constants/metadata.xml
+++ b/perl-core/Package-Constants/metadata.xml
@@ -4,5 +4,6 @@
   <herd>perl</herd>
   <upstream>
     <remote-id type="cpan">Package-Constants</remote-id>
+    <remote-id type="cpan-module">Package::Constants</remote-id>
   </upstream>
 </pkgmetadata>
diff --git a/perl-core/Scalar-List-Utils/metadata.xml b/perl-core/Scalar-List-Utils/metadata.xml
index 9f9af3c..31f81fd 100644
--- a/perl-core/Scalar-List-Utils/metadata.xml
+++ b/perl-core/Scalar-List-Utils/metadata.xml
@@ -4,5 +4,8 @@
   <herd>perl</herd>
   <upstream>
     <remote-id type="cpan">Scalar-List-Utils</remote-id>
+    <remote-id type="cpan-module">List::Util</remote-id>
+    <remote-id type="cpan-module">List::Util::XS</remote-id>
+    <remote-id type="cpan-module">Scalar::Util</remote-id>
   </upstream>
 </pkgmetadata>
diff --git a/perl-core/Test-Harness/metadata.xml b/perl-core/Test-Harness/metadata.xml
index dd7c10e..6884ccf 100644
--- a/perl-core/Test-Harness/metadata.xml
+++ b/perl-core/Test-Harness/metadata.xml
@@ -4,5 +4,53 @@
   <herd>perl</herd>
   <upstream>
     <remote-id type="cpan">Test-Harness</remote-id>
+    <remote-id type="cpan-module">App::Prove</remote-id>
+    <remote-id type="cpan-module">App::Prove::State</remote-id>
+    <remote-id type="cpan-module">App::Prove::State::Result</remote-id>
+    <remote-id type="cpan-module">App::Prove::State::Result::Test</remote-id>
+    <remote-id type="cpan-module">TAP::Base</remote-id>
+    <remote-id type="cpan-module">TAP::Formatter::Base</remote-id>
+    <remote-id type="cpan-module">TAP::Formatter::Color</remote-id>
+    <remote-id type="cpan-module">TAP::Formatter::Console</remote-id>
+    <remote-id type="cpan-module">TAP::Formatter::Console::ParallelSession</remote-id>
+    <remote-id type="cpan-module">TAP::Formatter::Console::Session</remote-id>
+    <remote-id type="cpan-module">TAP::Formatter::File</remote-id>
+    <remote-id type="cpan-module">TAP::Formatter::File::Session</remote-id>
+    <remote-id type="cpan-module">TAP::Formatter::Session</remote-id>
+    <remote-id type="cpan-module">TAP::Harness</remote-id>
+    <remote-id type="cpan-module">TAP::Object</remote-id>
+    <remote-id type="cpan-module">TAP::Parser</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Aggregator</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Grammar</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Iterator</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Iterator::Array</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Iterator::Process</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Iterator::Stream</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::IteratorFactory</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Multiplexer</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Result</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Result::Bailout</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Result::Comment</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Result::Plan</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Result::Pragma</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Result::Test</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Result::Unknown</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Result::Version</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Result::YAML</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::ResultFactory</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Scheduler</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Scheduler::Job</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Scheduler::Spinner</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Source</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::SourceHandler</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::SourceHandler::Executable</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::SourceHandler::File</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::SourceHandler::Handle</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::SourceHandler::Perl</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::SourceHandler::RawTAP</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::Utils</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::YAMLish::Reader</remote-id>
+    <remote-id type="cpan-module">TAP::Parser::YAMLish::Writer</remote-id>
+    <remote-id type="cpan-module">Test::Harness</remote-id>
   </upstream>
 </pkgmetadata>
diff --git a/perl-core/Test-Simple/metadata.xml b/perl-core/Test-Simple/metadata.xml
index 91d153e..05212b0 100644
--- a/perl-core/Test-Simple/metadata.xml
+++ b/perl-core/Test-Simple/metadata.xml
@@ -4,5 +4,13 @@
   <herd>perl</herd>
   <upstream>
     <remote-id type="cpan">Test-Simple</remote-id>
+    <remote-id type="cpan-module">Test::Builder</remote-id>
+    <remote-id type="cpan-module">Test::Builder::IO::Scalar</remote-id>
+    <remote-id type="cpan-module">Test::Builder::Module</remote-id>
+    <remote-id type="cpan-module">Test::Builder::Tester</remote-id>
+    <remote-id type="cpan-module">Test::Builder::Tester::Color</remote-id>
+    <remote-id type="cpan-module">Test::Builder::Tester::Tie</remote-id>
+    <remote-id type="cpan-module">Test::More</remote-id>
+    <remote-id type="cpan-module">Test::Simple</remote-id>
   </upstream>
 </pkgmetadata>
diff --git a/perl-core/digest-base/metadata.xml b/perl-core/digest-base/metadata.xml
index 6d1229e..15d31f1 100644
--- a/perl-core/digest-base/metadata.xml
+++ b/perl-core/digest-base/metadata.xml
@@ -4,5 +4,8 @@
   <herd>perl</herd>
   <upstream>
     <remote-id type="cpan">Digest</remote-id>
+    <remote-id type="cpan-module">Digest</remote-id>
+    <remote-id type="cpan-module">Digest::base</remote-id>
+    <remote-id type="cpan-module">Digest::file</remote-id>
   </upstream>
 </pkgmetadata>
diff --git a/perl-core/metadata.xml b/perl-core/metadata.xml
new file mode 100644
index 0000000..e56fed0
--- /dev/null
+++ b/perl-core/metadata.xml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The perl-core category contains libraries and utilities relevant to the
+		Perl programming language.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie perl-core enthält Bibliotheken und Werkzeuge für die 
+		Programmiersprache Perl.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría perl-core contiene librerías y utilidades referentes
+		al lenguaje de programación Perl.
+	</longdescription>
+	<longdescription lang="ja">
+		perl-coreカテゴリーにはPerl プログラミング言語に関連にするライブラリと
+		ユーティリティが含まれて>います。
+	</longdescription>
+	<longdescription lang="nl">
+		De perl-core categorie bevat bibliotheken en hulpmiddelen voor het gebruik
+		van de programmeertaal Perl.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm perl-core chứa các thư viện và tiện ích liên quan
+		đến ngôn ngữ lập trình Perl.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria perl-core contiene librerie ed utilità per il linguaggio di
+		programmazione Perl.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria perl-core contém bibliotecas e utilitários
+		referentes à linguagem de programação Perl.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria perl-core zawiera biblioteki i narzędzia związane z językiem
+		programowania Perl.
+	</longdescription>
+</catmetadata>
+
diff --git a/sci-calculators/metadata.xml b/sci-calculators/metadata.xml
new file mode 100644
index 0000000..00a8c12
--- /dev/null
+++ b/sci-calculators/metadata.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The sci-calculators category contains scientific calculator packages.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie sci-calculators enthält wissenschaftliche Rechenprogramme.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría sci-calculators contiene calculadoras científicas.
+	</longdescription>
+	<longdescription lang="ja">
+		sci-calculatorsカテゴリーには科学計算機のパッケージが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De sci-calculators categorie bevat wetenschappelijke calculators.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm sci-calculators chứa các phần mềm tính toán khoa học.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria sci-calculators contiene calcolatori scientifici.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria sci-calculators zawiera kalkulatory naukowe.
+	</longdescription>
+</catmetadata>
+
diff --git a/sci-calculators/pcalc/metadata.xml b/sci-calculators/pcalc/metadata.xml
new file mode 100644
index 0000000..ccc6fa9
--- /dev/null
+++ b/sci-calculators/pcalc/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>sci</herd>
+<maintainer>
+ <email>vapier@gentoo.org</email>
+</maintainer>
+</pkgmetadata>
diff --git a/sci-geosciences/gpsd/metadata.xml b/sci-geosciences/gpsd/metadata.xml
new file mode 100644
index 0000000..2fb5da4
--- /dev/null
+++ b/sci-geosciences/gpsd/metadata.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>sci-geosciences</herd>
+<longdescription>Unbundled GPS daemon and library to support USB and serial
+ GPS devices and various GPS/mapping clients, such as GPSDrive, kismet, and
+ pygps.
+</longdescription>
+<use>
+  <flag name='dbus'>export gpsd data over dbus connections</flag>
+  <flag name='latency_timing'>support latency timing information</flag>
+  <flag name='ntp'>Enable <pkg>net-misc/ntp</pkg> shared memory interface
+    and PPS kernel support for GPS time</flag>
+  <flag name='sockets'>export gpsd over unix sockets</flag>
+  <flag name='shm'>export gpsd over shared memory</flag>
+</use>
+</pkgmetadata>
diff --git a/sci-geosciences/metadata.xml b/sci-geosciences/metadata.xml
new file mode 100644
index 0000000..ca00dbc
--- /dev/null
+++ b/sci-geosciences/metadata.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The sci-geosciences category contains geosciences-related software.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie sci-geosciences enthält Software aus dem Bereich der
+		Geowissenschaften.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría sci-geosciences contiene programas relacionados con la
+		geología.
+	</longdescription>
+	<longdescription lang="ja">
+		sci-geosciencesカテゴリーには地球科学関連のソフトウェアが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De sci-geosciences categorie bevat programma's voor gebruik in de geologie
+		en andere aardwetenschappen.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm sci-geosciences chứa các phần mềm liên quan đến địa-khoa học.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria sci-geosciences contiene programmi di geologia.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria sci-geosciences contém programas relacionados com
+		geologia.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria sci-geosciences zawiera programy naukowe związane z geologią.
+	</longdescription>
+</catmetadata>
+
diff --git a/sys-apps/acl/metadata.xml b/sys-apps/acl/metadata.xml
new file mode 100644
index 0000000..8eda6f1
--- /dev/null
+++ b/sys-apps/acl/metadata.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<use>
+	<flag name='nfs'>
+		add support for NFS acls
+	</flag>
+</use>
+</pkgmetadata>
diff --git a/sys-apps/attr/metadata.xml b/sys-apps/attr/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/attr/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/busybox/metadata.xml b/sys-apps/busybox/metadata.xml
new file mode 100644
index 0000000..72850fb
--- /dev/null
+++ b/sys-apps/busybox/metadata.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>embedded</herd>
+<use>
+<flag name="make-symlinks">Create all the appropriate symlinks in /bin and /sbin.</flag>
+<flag name="math">Enable math support in gawk (requires libm)</flag>
+<flag name="mdev">Create the appropriate symlink in /sbin and install mdev.conf and support files</flag>
+<flag name="sep-usr">Support a separate /usr without needing an initramfs by booting with init=/ginit</flag>
+<flag name="static">Make the system rescue shell (/bin/bb) static so you can recover even when glibc is broken</flag>
+<flag name="systemd">Support systemd</flag>
+</use>
+</pkgmetadata>
diff --git a/sys-apps/coreutils/metadata.xml b/sys-apps/coreutils/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/coreutils/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/debianutils/metadata.xml b/sys-apps/debianutils/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/debianutils/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/diffutils/metadata.xml b/sys-apps/diffutils/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/diffutils/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/ethtool/metadata.xml b/sys-apps/ethtool/metadata.xml
new file mode 100644
index 0000000..5977c7f
--- /dev/null
+++ b/sys-apps/ethtool/metadata.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<longdescription lang="en">
+	ethtool is a Linux utility for controlling network drivers and hardware,
+	particularly for wired Ethernet devices. It can be used to:
+		* Get identification and diagnostic information
+		* Get extended device statistics
+		* Control speed, duplex, autonegotiation and flow control for Ethernet devices
+		* Control checksum offload and other hardware offload features
+		* Control DMA ring sizes and interrupt moderation
+		* Control receive queue selection for multiqueue devices
+		* Upgrade firmware in flash memory
+</longdescription>
+</pkgmetadata>
diff --git a/sys-apps/fbset/metadata.xml b/sys-apps/fbset/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/fbset/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/file/metadata.xml b/sys-apps/file/metadata.xml
new file mode 100644
index 0000000..d05cbc0
--- /dev/null
+++ b/sys-apps/file/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<upstream>
+	<bugs-to>http://bugs.gw.com/</bugs-to>
+</upstream>
+</pkgmetadata>
diff --git a/sys-apps/findutils/metadata.xml b/sys-apps/findutils/metadata.xml
new file mode 100644
index 0000000..659da0c
--- /dev/null
+++ b/sys-apps/findutils/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/gawk/metadata.xml b/sys-apps/gawk/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/gawk/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/grep/metadata.xml b/sys-apps/grep/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/grep/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/groff/metadata.xml b/sys-apps/groff/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/groff/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/hdparm/metadata.xml b/sys-apps/hdparm/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/hdparm/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/help2man/metadata.xml b/sys-apps/help2man/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/help2man/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/hwids/metadata.xml b/sys-apps/hwids/metadata.xml
new file mode 100644
index 0000000..9247431
--- /dev/null
+++ b/sys-apps/hwids/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<maintainer>
+  <email>flameeyes@gentoo.org</email>
+</maintainer>
+<maintainer>
+  <email>gregkh@gentoo.org</email>
+</maintainer>
+</pkgmetadata>
diff --git a/sys-apps/i2c-tools/metadata.xml b/sys-apps/i2c-tools/metadata.xml
new file mode 100644
index 0000000..4538a68
--- /dev/null
+++ b/sys-apps/i2c-tools/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer><email>maintainer-needed@gentoo.org</email></maintainer>
+</pkgmetadata>
diff --git a/sys-apps/input-utils/metadata.xml b/sys-apps/input-utils/metadata.xml
new file mode 100644
index 0000000..5821467
--- /dev/null
+++ b/sys-apps/input-utils/metadata.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+<email>zzam@gentoo.org</email>
+<name>Matthias Schwarzott</name>
+</maintainer>
+<maintainer>
+<email>robbat2@gentoo.org</email>
+<name>Robin H. Johnson</name>
+</maintainer>
+<longdescription lang="en">
+This is a collection of utilities which are useful when working with the input
+layer of the Linux kernel (version 2.6 and later). Included are utilities to
+list the input devices known to the kernel, show the input events that are
+received by a device, and query or modify keyboard maps.
+</longdescription>
+</pkgmetadata>
+
diff --git a/sys-apps/iotools/metadata.xml b/sys-apps/iotools/metadata.xml
new file mode 100644
index 0000000..8c8fbb1
--- /dev/null
+++ b/sys-apps/iotools/metadata.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+ <email>vapier@gentoo.org</email>
+</maintainer>
+<use>
+ <flag name='make-symlinks'>Generate sub-command symlinks to iotools -- note that a lot are simple like "xor"</flag>
+</use>
+</pkgmetadata>
diff --git a/sys-apps/iproute2/metadata.xml b/sys-apps/iproute2/metadata.xml
new file mode 100644
index 0000000..eab1d3a
--- /dev/null
+++ b/sys-apps/iproute2/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<use>
+	<flag name='berkdb'>build programs that use berkdb (just arpd)</flag>
+	<flag name='iptables'>include support for iptables filtering</flag>
+</use>
+</pkgmetadata>
diff --git a/sys-apps/kbd/metadata.xml b/sys-apps/kbd/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/kbd/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/less/metadata.xml b/sys-apps/less/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/less/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/man-pages-posix/metadata.xml b/sys-apps/man-pages-posix/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/man-pages-posix/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/man-pages/metadata.xml b/sys-apps/man-pages/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/man-pages/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/man/metadata.xml b/sys-apps/man/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/man/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/mawk/metadata.xml b/sys-apps/mawk/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/mawk/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/memtester/metadata.xml b/sys-apps/memtester/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/memtester/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/metadata.xml b/sys-apps/metadata.xml
new file mode 100644
index 0000000..e780a89
--- /dev/null
+++ b/sys-apps/metadata.xml
@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The sys-apps category contains various core system applications, and
+		some non-core system applications which have not yet been moved out into
+		other sys- categories.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría sys-apps contiene varios paquetes esenciales del sistema, y
+		algunos paquetes no esenciales que aún no han sido movidos a otras
+		categorías sys-.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie sys-apps enthält sowohl Programme die Bestandteil des Basissystems sind,
+		als auch Applikationen die noch nicht in eine der anderen sys- Kategorien eingeordnet
+		wurden.
+	</longdescription>
+	<longdescription lang="ja">
+		sys-appsカテゴリには様々なコアシステムアプリケーションの他、まだ他のsys-カテゴリに
+		移動されていないシステムアプリケーションが含まれています。				
+	</longdescription>
+	<longdescription lang="nl">
+		De sys-apps categorie bevat kerenbestanddelen van het systeem, en bepaalde
+		niet-kern toepassingen die nog niet in andere categorien zijn geplaatst.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm sys-apps chứa các phần mềm hệ thống cốt lõi, và vài phần mềm
+		hệ thống không phải cốt lõi mà chưa được chuyển sang các nhóm sys- khác.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria sys-apps contiene vari pacchetti essenziali per il sistema, e alcuni pacchetti
+		non essenziali che non sono ancora stati spostati in altre categorie sys-.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria sys-apps contém vários pacotes essenciais do sistema, e
+		algumas aplicações não-centrais que ainda não foram colocadas em
+		outras categorias sys-.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria sys-apps zawiera programy systemowe oraz inne dodatkowe
+		programy, których jeszcze nie przeniesiono do kategorii sys-.
+	</longdescription>
+</catmetadata>
+
diff --git a/sys-apps/miscfiles/metadata.xml b/sys-apps/miscfiles/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/miscfiles/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/module-init-tools/metadata.xml b/sys-apps/module-init-tools/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/module-init-tools/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/net-tools/metadata.xml b/sys-apps/net-tools/metadata.xml
new file mode 100644
index 0000000..0c72e81
--- /dev/null
+++ b/sys-apps/net-tools/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<use>
+ <flag name='old-output'>use old ifconfig output style (useful for when new output breaks scripts)</flag>
+</use>
+</pkgmetadata>
diff --git a/sys-apps/pciutils/metadata.xml b/sys-apps/pciutils/metadata.xml
new file mode 100644
index 0000000..a1df75b
--- /dev/null
+++ b/sys-apps/pciutils/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<use>
+ <flag name='compress-db'>Compress pci.ids database by default</flag>
+ <flag name='kmod'>Enable <pkg>sys-apps/kmod</pkg> support for the -k switch in lspci command</flag>
+ <flag name='network-cron'>Monthly cronjob the update-pciids script</flag>
+ <flag name='zlib'>Support compressed pci.ids database</flag>
+</use>
+</pkgmetadata>
diff --git a/sys-apps/pv/metadata.xml b/sys-apps/pv/metadata.xml
new file mode 100644
index 0000000..e021cd5
--- /dev/null
+++ b/sys-apps/pv/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <maintainer>
+    <email>jer@gentoo.org</email>
+    <name>Jeroen Roovers</name>
+  </maintainer>
+  <upstream>
+    <remote-id type="google-code">pipeviewer</remote-id>
+  </upstream>
+</pkgmetadata>
diff --git a/sys-apps/sandbox/metadata.xml b/sys-apps/sandbox/metadata.xml
new file mode 100644
index 0000000..9e13eae
--- /dev/null
+++ b/sys-apps/sandbox/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+
+<!-- portage lacks a herd.  correct this when we have one. -->
+
+<maintainer>
+  <email>sandbox@gentoo.org</email>
+  <description>Sandbox Maintainers</description>
+</maintainer>
+</pkgmetadata>
diff --git a/sys-apps/sed/metadata.xml b/sys-apps/sed/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/sed/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/smartmontools/metadata.xml b/sys-apps/smartmontools/metadata.xml
new file mode 100644
index 0000000..29294b2
--- /dev/null
+++ b/sys-apps/smartmontools/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<use>
+<flag name='minimal'>Do not install the monitoring daemon and associated scripts.</flag>
+</use>
+</pkgmetadata>
diff --git a/sys-apps/texinfo/metadata.xml b/sys-apps/texinfo/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/texinfo/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-apps/usbutils/metadata.xml b/sys-apps/usbutils/metadata.xml
new file mode 100644
index 0000000..73512f4
--- /dev/null
+++ b/sys-apps/usbutils/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<use>
+	<flag name='network-cron'>Monthly cronjob the update-usbids script</flag>
+</use>
+</pkgmetadata>
diff --git a/sys-apps/util-linux/metadata.xml b/sys-apps/util-linux/metadata.xml
new file mode 100644
index 0000000..38a484a
--- /dev/null
+++ b/sys-apps/util-linux/metadata.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>base-system</herd>
+	<maintainer restrict="sys-apps/util-linux[loop-aes]">
+		<email>c1pher@gentoo.org</email>
+		<name>Dane Smith</name>
+	</maintainer>
+<use>
+	<flag name='cramfs'>build mkfs/fsck helpers for cramfs filesystems</flag>
+	<flag name='ddate'>build ddate helper (Discordian dates)</flag>
+	<flag name='loop-aes'>include support for Loop AES encryption</flag>
+	<flag name='perl'>install the chkdupexe helper script</flag>
+	<flag name='suid'>
+		install mount/umount as setuid so non-root users may mount/umount devices,
+		and wall/write as setgid so non-root users can notify other users
+	</flag>
+</use>
+</pkgmetadata>
diff --git a/sys-apps/which/metadata.xml b/sys-apps/which/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-apps/which/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-auth/metadata.xml b/sys-auth/metadata.xml
new file mode 100644
index 0000000..4b8897c
--- /dev/null
+++ b/sys-auth/metadata.xml
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The sys-auth category contains applications and libraries to support
+		authentication and authorization facilities.
+		Here belongs PAM modules, NSS modules and login apps.
+	</longdescription>
+	<longdescription lang="ja">
+		sys-authカテゴリには確認を採用するアプリケーションとライブラリが
+		含まれます。これはPAMとNSSモジュールとログインアプリケーションの場所です。
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm sys-auth chứa các ứng dụng và thư viện hỗ trợ xác thực và phân quyền.
+		Ở đây bao gồm các module PAM, NSS và các ứng dụng đăng nhập.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie sys-auth enthält Programme und Bibliotheken die Funktionen
+		zur Authentifizierung und Authorisierung zur Verfügung stellen. Module für PAM 
+		und NSS sowie Loginapplikationen finden sich hier.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria sys-auth contiene applicazioni e librerie di supporto per
+		gli strumenti di autenticazione e autorizzazione. Appartengono a questa categoria
+		i moduli PAM, i moduli NSS e le applicazioni di login.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria sys-auth contém aplicações e bibliotecas para
+		suportar instrumentos de autenticação e autorização.
+		Nesta categoria pertencem módulos de PAM, módulos de NSS e
+		aplicações de login.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria sys-auth zawiera biblioteki oraz programy związane z
+		autoryzacją i uwierzytelnianiem. Znajdują się tu moduły PAM, NSS oraz
+		aplikacje służące do logowania.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría sys-auth contiene aplicaciones y librerías para dar
+		soporte a los servicios de autenticación y autorización.
+		A esta categoría pertenecen los módulos PAM, NSS y las aplicaciones
+		para ingresar en el sistema.
+	</longdescription>
+</catmetadata>
diff --git a/sys-block/metadata.xml b/sys-block/metadata.xml
new file mode 100644
index 0000000..d54bebd
--- /dev/null
+++ b/sys-block/metadata.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The sys-block category contains packages which work with block devices.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría sys-block contiene paquetes que trabajan con dispositivos
+		de bloque.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie sys-block enthält Pakete für die Arbeit mit Blockgeräten
+		(Festplatten, Disketten, CD-ROMs etc.).
+	</longdescription>
+	<longdescription lang="ja">
+		sys-blockカテゴリにはブロックデバイスと使用パッケージが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De sys-block categorie bevat gereedschappen voor het omgaan met blok-apparaten
+		zoals harde schijven, diskettes en CD-ROM's.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm sys-block chứa các gói hoạt động với thiết bị khối (block device).
+	</longdescription>
+	<longdescription lang="it">
+		La categoria sys-block contiene pacchetti per la gestione dei dispositivi a blocchi.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria sys-block contém pacotes que funcionam com
+		dispositivos de bloco.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria sys-block zawiera programy do pracy na urządzeniach blokowych.
+	</longdescription>
+</catmetadata>
+
diff --git a/sys-block/parted/metadata.xml b/sys-block/parted/metadata.xml
new file mode 100644
index 0000000..57a6769
--- /dev/null
+++ b/sys-block/parted/metadata.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>livecd</herd>
+<use>
+	<flag name='device-mapper'>
+	Enable device-mapper support from <pkg>sys-fs/lvm2</pkg> in parted
+	</flag>
+	<flag name="debug">
+	Enable debugging as encouraged by upstream: [The default configuration]
+	includes --enable-debug (by default), which contains many assertions.
+	Obviously, these "waste" space, but in the past, they have caught
+	potentially dangerous bugs before they would have done damage, so we think
+	it's worth it.  Also, it means we get more bug reports ;)
+	</flag>
+</use>
+</pkgmetadata>
diff --git a/sys-boot/gnu-efi/metadata.xml b/sys-boot/gnu-efi/metadata.xml
new file mode 100644
index 0000000..fe15722
--- /dev/null
+++ b/sys-boot/gnu-efi/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>ia64</herd>
+</pkgmetadata>
diff --git a/sys-boot/grub/metadata.xml b/sys-boot/grub/metadata.xml
new file mode 100644
index 0000000..86409b5
--- /dev/null
+++ b/sys-boot/grub/metadata.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<maintainer>
+	<email>base-system@gentoo.org</email>
+</maintainer>
+<maintainer restrict="&gt;=sys-boot/grub-2">
+	<email>floppym@gentoo.org</email>
+	<name>Mike Gilbert</name>
+</maintainer>
+<use>
+	<flag name='device-mapper'>
+		Enable support for device-mapper from <pkg>sys-fs/lvm2</pkg>
+	</flag>
+	<flag name='efiemu'>
+		Build and install the efiemu runtimes
+	</flag>
+	<flag name='mount'>
+		Build and install the grub-mount utility
+	</flag>
+	<flag name='libzfs'>
+		Enable support for <pkg>sys-fs/zfs</pkg>
+	</flag>
+</use>
+</pkgmetadata>
diff --git a/sys-boot/metadata.xml b/sys-boot/metadata.xml
new file mode 100644
index 0000000..2d91fb2
--- /dev/null
+++ b/sys-boot/metadata.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The sys-boot category contains bootloaders and related tools.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría sys-boot contiene algunos cargadores de arranque y
+		herramientas relacionadas.
+	</longdescription>
+	<longdescription lang="ja">
+		sys-bootカテゴリにはブートとブート関連ツールが含まれます。
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie sys-boot enthält Bootloader sowie damit in 
+		Zusammenhang stehende Programme.
+	</longdescription>
+	<longdescription lang="nl">
+		De sys-boot categorie bevat bootloaders en bijbehorende gereedschappen. 
+	</longdescription>
+	<longdescription lang="vi">
+			Nhóm sys-boot chứa các bootloader và công cụ liên quan.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria sys-boot contiene bootloaders e strumenti correlati al boot del sistema.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria sys-boot contém gerenciadores de inicialização e
+		ferramentas relacionadas.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria sys-boot zawiera programy ładujące (bootloadery) i związane z
+		nimi pakiety.
+	</longdescription>
+</catmetadata>
+
diff --git a/sys-devel/autoconf-wrapper/metadata.xml b/sys-devel/autoconf-wrapper/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-devel/autoconf-wrapper/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-devel/autoconf/metadata.xml b/sys-devel/autoconf/metadata.xml
new file mode 100644
index 0000000..f9d3cbf
--- /dev/null
+++ b/sys-devel/autoconf/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<use>
+<flag name='multislot'>Allow for multiple versions to be installed at once</flag>
+</use>
+</pkgmetadata>
diff --git a/sys-devel/automake-wrapper/metadata.xml b/sys-devel/automake-wrapper/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-devel/automake-wrapper/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-devel/automake/metadata.xml b/sys-devel/automake/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-devel/automake/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-devel/bc/metadata.xml b/sys-devel/bc/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-devel/bc/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-devel/bin86/metadata.xml b/sys-devel/bin86/metadata.xml
new file mode 100644
index 0000000..746b4d9
--- /dev/null
+++ b/sys-devel/bin86/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>base-system</herd>
+	<!--
+		If anyone from base-system wants to be secondary, by all means just add
+		yourself, and send me (boo) a mail telling me that you've done so.
+	-->
+</pkgmetadata>
diff --git a/sys-devel/binutils-config/metadata.xml b/sys-devel/binutils-config/metadata.xml
new file mode 100644
index 0000000..fb4199e
--- /dev/null
+++ b/sys-devel/binutils-config/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>toolchain</herd>
+</pkgmetadata>
diff --git a/sys-devel/bison/metadata.xml b/sys-devel/bison/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-devel/bison/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-devel/crossdev/metadata.xml b/sys-devel/crossdev/metadata.xml
new file mode 100644
index 0000000..33d7123
--- /dev/null
+++ b/sys-devel/crossdev/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>embedded</herd>
+<herd>toolchain</herd>
+<maintainer>
+<email>vapier@gentoo.org</email>
+</maintainer>
+</pkgmetadata>
diff --git a/sys-devel/dev86/metadata.xml b/sys-devel/dev86/metadata.xml
new file mode 100644
index 0000000..756af1a
--- /dev/null
+++ b/sys-devel/dev86/metadata.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>maintainer-needed@gentoo.org</email>
+	</maintainer>
+	<longdescription>
+		Bruce's C compiler - Simple C compiler to generate 8086 code
+	</longdescription>
+</pkgmetadata>
diff --git a/sys-devel/flex/metadata.xml b/sys-devel/flex/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-devel/flex/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-devel/gcc-config/metadata.xml b/sys-devel/gcc-config/metadata.xml
new file mode 100644
index 0000000..fb4199e
--- /dev/null
+++ b/sys-devel/gcc-config/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>toolchain</herd>
+</pkgmetadata>
diff --git a/sys-devel/gettext/metadata.xml b/sys-devel/gettext/metadata.xml
new file mode 100644
index 0000000..757fc75
--- /dev/null
+++ b/sys-devel/gettext/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<use>
+ <flag name="cvs">When running `autopoint`, use cvs to store the internal development files;
+                  this requires cvs at runtime, but will be faster/smaller than raw archives</flag>
+ <flag name="git">When running `autopoint`, use git to store the internal development files;
+                  this requires git at runtime, but will be faster/smaller than raw archives</flag>
+</use>
+</pkgmetadata>
diff --git a/sys-devel/gnuconfig/metadata.xml b/sys-devel/gnuconfig/metadata.xml
new file mode 100644
index 0000000..59c5b7b
--- /dev/null
+++ b/sys-devel/gnuconfig/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<longdescription>
+Updated config.{sub,guess} files from upstream cvs to properly detect various system types.
+</longdescription>
+</pkgmetadata>
diff --git a/sys-devel/libperl/metadata.xml b/sys-devel/libperl/metadata.xml
index 30a8721..80eacdc 100644
--- a/sys-devel/libperl/metadata.xml
+++ b/sys-devel/libperl/metadata.xml
@@ -2,11 +2,6 @@
 <!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
 <pkgmetadata>
 	<herd>perl</herd>
-	<maintainer>
-		<email>perl@gentoo.org</email>
-		<description>Primary Maintainer</description>
-	</maintainer>
-	<longdescription></longdescription>
 	<use>
 	<flag name='ithreads'>Enable Perl threads, has some compatibility problems</flag>
 	</use>
diff --git a/sys-devel/libtool/metadata.xml b/sys-devel/libtool/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-devel/libtool/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-devel/m4/metadata.xml b/sys-devel/m4/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-devel/m4/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-devel/make/metadata.xml b/sys-devel/make/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-devel/make/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-devel/metadata.xml b/sys-devel/metadata.xml
new file mode 100644
index 0000000..dd5a911
--- /dev/null
+++ b/sys-devel/metadata.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The sys-devel category contains various core system development tools
+		and libraries.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría sys-devel contiene paquetes esenciales para el desarrollo
+		de software.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie sys-devel enthält essentielle Entwicklungswerkzeuge und
+		Bibliotheken.
+	</longdescription>
+	<longdescription lang="ja">
+		sys-develカテゴリにはコアシステム開発ツールとライブラリが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De sys-devel categorie bevat essentiele ontwikkelgereedschappen en
+		bibliotheken.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm sys-devel chứa các phần mềm và thư viện phát triển hệ thống cốt lõi.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria sys-devel contiene gli strumenti e le librerie essenziali per lo sviluppo del software e la compilazione del sistema.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria sys-devel contém várias ferramentas e bibliotecas
+		de desenvolvimento essenciais para o sistema.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria sys-devel zawiera programy i biblioteki służące do rozwijania
+		systemu.
+	</longdescription>
+</catmetadata>
+
diff --git a/sys-devel/patch/metadata.xml b/sys-devel/patch/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-devel/patch/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-devel/smatch/metadata.xml b/sys-devel/smatch/metadata.xml
new file mode 100644
index 0000000..f8824b4
--- /dev/null
+++ b/sys-devel/smatch/metadata.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+ <herd>kernel-misc</herd>
+ <herd>toolchain</herd>
+</pkgmetadata>
diff --git a/sys-fs/avfs/metadata.xml b/sys-fs/avfs/metadata.xml
new file mode 100644
index 0000000..bf87603
--- /dev/null
+++ b/sys-fs/avfs/metadata.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>kernel-misc</herd>
+  <herd>proxy-maintainers</herd>
+  <maintainer>
+    <email>pete4abw@comcast.net</email>
+    <name>Peter Hyman</name>
+  </maintainer>
+</pkgmetadata>
diff --git a/sys-fs/dd-rescue/metadata.xml b/sys-fs/dd-rescue/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-fs/dd-rescue/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-fs/dosfstools/metadata.xml b/sys-fs/dosfstools/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-fs/dosfstools/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-fs/e2fsprogs/metadata.xml b/sys-fs/e2fsprogs/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-fs/e2fsprogs/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-fs/ecryptfs-utils/metadata.xml b/sys-fs/ecryptfs-utils/metadata.xml
new file mode 100644
index 0000000..99766b9
--- /dev/null
+++ b/sys-fs/ecryptfs-utils/metadata.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>kernel-misc</herd>
+	<herd>crypto</herd>
+	<use>
+		<flag name='gpg'>Enable <pkg>app-crypt/gnupg</pkg> key module</flag>
+		<flag name='openssl'>Enable <pkg>dev-libs/openssl</pkg> key
+			module</flag>
+		<flag name='pkcs11'>Enable PKCS#11 (Smartcards) key module</flag>
+		<flag name='tpm'>Enable support for Trusted Platform Module (TPM) using <pkg>app-crypt/trousers</pkg></flag>
+	</use>
+</pkgmetadata>
diff --git a/sys-fs/exfat-utils/metadata.xml b/sys-fs/exfat-utils/metadata.xml
new file mode 100644
index 0000000..7b05b18
--- /dev/null
+++ b/sys-fs/exfat-utils/metadata.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>base-system</herd>
+	<maintainer>
+		<email>ssuominen@gentoo.org</email>
+		<name>Samuli Suominen</name>
+	</maintainer>
+	<upstream>
+		<remote-id type="google-code">exfat</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/sys-fs/fuse-exfat/metadata.xml b/sys-fs/fuse-exfat/metadata.xml
new file mode 100644
index 0000000..7b05b18
--- /dev/null
+++ b/sys-fs/fuse-exfat/metadata.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>base-system</herd>
+	<maintainer>
+		<email>ssuominen@gentoo.org</email>
+		<name>Samuli Suominen</name>
+	</maintainer>
+	<upstream>
+		<remote-id type="google-code">exfat</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/sys-fs/libfat/metadata.xml b/sys-fs/libfat/metadata.xml
new file mode 100644
index 0000000..f9fc195
--- /dev/null
+++ b/sys-fs/libfat/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+ <email>vapier@gentoo.org</email>
+ <description>make whatever changes you want</description>
+</maintainer>
+</pkgmetadata>
diff --git a/sys-fs/lvm2/metadata.xml b/sys-fs/lvm2/metadata.xml
new file mode 100644
index 0000000..62eb343
--- /dev/null
+++ b/sys-fs/lvm2/metadata.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>robbat2@gentoo.org</email>
+		<name>Robin H. Johnson</name>
+	</maintainer>
+	<maintainer>
+		<email>cardoe@gentoo.org</email>
+		<name>Doug Goldstein</name>
+	</maintainer>
+	<maintainer>
+		<email>agk@redhat.com</email>
+		<name>Alasdair Kergon</name>
+		<description>Upstream Maintainer (please CC on bugs)</description>
+	</maintainer>
+	<use>
+		<flag name='clvm'>Allow users to build clustered lvm2</flag>
+		<flag name='cman'>Cman support for clustered lvm</flag>
+		<flag name='lvm1'>Allow users to build lvm2 with lvm1 support</flag>
+		<flag name='thin'>Support for thin volumes</flag>
+	</use>
+</pkgmetadata>
diff --git a/sys-fs/metadata.xml b/sys-fs/metadata.xml
new file mode 100644
index 0000000..0760ba1
--- /dev/null
+++ b/sys-fs/metadata.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The sys-fs category contains filesystem tools and utilities.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría sys-fs contiene herramientas y utilidades de sistemas de
+		ficheros.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie sys-fs enthält Programme für die Arbeit mit Dateisystemen.
+	</longdescription>
+	<longdescription lang="nl">
+		De sys-fs categorie bevat hulpmiddelen om met bestandssystemen te werken.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm sys-fs chứa các công cụ và tiện ích về hệ tập tin.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria sys-fs contiene gli strumenti e le utilità di supporto per i vari file systems.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria sys-fs contém certos utilitários e ferramentas para
+		sistemas de arquivos.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria sys-fs zawiera programy i narzędzia związane z różnymi
+		systemami plików.
+	</longdescription>
+</catmetadata>
+
diff --git a/sys-fs/mtd-utils/metadata.xml b/sys-fs/mtd-utils/metadata.xml
new file mode 100644
index 0000000..125f41e
--- /dev/null
+++ b/sys-fs/mtd-utils/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>embedded</herd>
+<maintainer>
+	<email>robbat2@gentoo.org</email>
+</maintainer>
+</pkgmetadata>
+
diff --git a/sys-fs/mtools/metadata.xml b/sys-fs/mtools/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-fs/mtools/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-fs/squashfs-tools/metadata.xml b/sys-fs/squashfs-tools/metadata.xml
new file mode 100644
index 0000000..8a76920
--- /dev/null
+++ b/sys-fs/squashfs-tools/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>livecd</herd>
+	<use>
+		<flag name="xz">Enable support for XZ ("LZMA2") compression using <pkg>app-arch/xz-utils</pkg></flag>
+	</use>
+</pkgmetadata>
diff --git a/sys-fs/sshfs-fuse/metadata.xml b/sys-fs/sshfs-fuse/metadata.xml
new file mode 100644
index 0000000..f7740ac
--- /dev/null
+++ b/sys-fs/sshfs-fuse/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>kernel-misc</herd>
+</pkgmetadata>
diff --git a/sys-fs/udev/metadata.xml b/sys-fs/udev/metadata.xml
new file mode 100644
index 0000000..1c496c5
--- /dev/null
+++ b/sys-fs/udev/metadata.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+  <email>udev-bugs@gentoo.org</email>
+</maintainer>
+<use>
+  <flag name='firmware-loader'>Enable userspace firmware loader (DEPRECATED, replaced by in-kernel loader in 3.8+)</flag>
+  <flag name='gudev'>Build the gobject interface library</flag>
+  <flag name='hwdb'>Read vendor/device string database and add it to udev database</flag>
+  <flag name='keymap'>Map custom hardware's multimedia keys</flag>
+  <flag name='kmod'>Enable kernel module loading/unloading support using <pkg>sys-apps/kmod</pkg></flag>
+  <flag name='openrc'>Install the OpenRC init scripts</flag>
+</use>
+</pkgmetadata>
diff --git a/sys-kernel/linux-headers/metadata.xml b/sys-kernel/linux-headers/metadata.xml
new file mode 100644
index 0000000..fb4199e
--- /dev/null
+++ b/sys-kernel/linux-headers/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>toolchain</herd>
+</pkgmetadata>
diff --git a/sys-kernel/metadata.xml b/sys-kernel/metadata.xml
new file mode 100644
index 0000000..16c8a6d
--- /dev/null
+++ b/sys-kernel/metadata.xml
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The sys-kernel category contains kernel source ebuilds and
+		kernel-related tools.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría sys-kernel contiene las fuentes del núcleo y herramientas
+		relacionadas con este.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie sys-kernel enthält Ebuilds für Kernelquellen
+		sowie damit in Zusammenhang stehende Pakete.
+	</longdescription>
+	<longdescription lang="ja">
+		sys-kernelカテゴリにはカーネルソースebuildとカーネル関連ツールが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De sys-kernel categorie bevat ebuilds voor kernelbroncode en gerelateerde
+		hulpmiddelen.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm sys-kernel chứa ebuild mã nguồn kernel và các công cụ
+		liên quan đến kernel.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria sys-kernel contiene i sorgenti del kernel e alcuni programmi
+		per la sua gestione come genkernel.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria sys-kernel contém ebuilds de fonte de kernel e
+		ferramentas relacionadas a kernel.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria sys-kernel zawiera źródła jądra oraz związane z nimi narzędzia.
+	</longdescription>
+</catmetadata>
+
diff --git a/sys-libs/cracklib/metadata.xml b/sys-libs/cracklib/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-libs/cracklib/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-libs/e2fsprogs-libs/metadata.xml b/sys-libs/e2fsprogs-libs/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-libs/e2fsprogs-libs/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-libs/gdbm/metadata.xml b/sys-libs/gdbm/metadata.xml
new file mode 100644
index 0000000..07b3785
--- /dev/null
+++ b/sys-libs/gdbm/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<use>
+ <flag name='berkdb'>enable compatibility layer for UNIX-like dbm and ndbm interfaces</flag>
+ <flag name='exporter'>enable gdbmexport binary for exporting data from gdbm-1.8 databases into gdbm-1.9</flag>
+</use>
+</pkgmetadata>
diff --git a/sys-libs/libcap-ng/metadata.xml b/sys-libs/libcap-ng/metadata.xml
new file mode 100644
index 0000000..703c252
--- /dev/null
+++ b/sys-libs/libcap-ng/metadata.xml
@@ -0,0 +1,10 @@
+<?xml version = '1.0' encoding = 'UTF-8'?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>base-system</herd>
+  <longdescription>The libcap-ng library is intended to make programming with
+  POSIX capabilities much easier than the traditional libcap library. It
+  includes utilities that can analyse all currently running applications and
+  print out any capabilities and whether or not it has an open ended bounding
+  set.</longdescription>
+</pkgmetadata>
diff --git a/sys-libs/libcap/metadata.xml b/sys-libs/libcap/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-libs/libcap/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-libs/libnih/metadata.xml b/sys-libs/libnih/metadata.xml
new file mode 100644
index 0000000..7940d76
--- /dev/null
+++ b/sys-libs/libnih/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+ <email>vapier@gentoo.org</email>
+ <description>feel free to update however you like</description>
+</maintainer>
+</pkgmetadata>
diff --git a/sys-libs/metadata.xml b/sys-libs/metadata.xml
new file mode 100644
index 0000000..bb3bb99
--- /dev/null
+++ b/sys-libs/metadata.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The sys-libs category contains various system-level libraries.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría sys-libs contiene varias librerías del sistema.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie sys-libs enthält verschiedene Systembibliotheken.
+	</longdescription>
+	<longdescription lang="ja">
+		sys-libsカテゴリには様々なシステムレベルライブラリが含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De sys-libs categorie bevat verschillende systeembibliotheken.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm sys-libs chứa các thư viện cấp hệ thống.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria sys-libs contiene varie librerie di sistema.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria sys-libs contém várias bibliotecas de sistema.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria sys-libs zawiera biblioteki systemowe.
+	</longdescription>
+</catmetadata>
+
diff --git a/sys-libs/mtdev/metadata.xml b/sys-libs/mtdev/metadata.xml
new file mode 100644
index 0000000..1e98470
--- /dev/null
+++ b/sys-libs/mtdev/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+<maintainer>
+  <email>naota@gentoo.org</email>
+</maintainer>
+</pkgmetadata>
diff --git a/sys-libs/ncurses/metadata.xml b/sys-libs/ncurses/metadata.xml
new file mode 100644
index 0000000..7856364
--- /dev/null
+++ b/sys-libs/ncurses/metadata.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<use>
+	<flag name='ada'>Add bindings for the ADA programming language</flag>
+	<flag name='tinfo'>
+		Build curses library (libncurses) sep from the low-level terminfo
+		library (libtinfo) -- usually needed only for binary packages -- but
+		it is binary compatible in either mode
+	</flag>
+	<flag name='trace'>Enable test trace() support in ncurses calls</flag>
+</use>
+</pkgmetadata>
diff --git a/sys-libs/newlib/metadata.xml b/sys-libs/newlib/metadata.xml
new file mode 100644
index 0000000..c302942
--- /dev/null
+++ b/sys-libs/newlib/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>toolchain</herd>
+<maintainer>
+<email>lu_zero@gentoo.org</email>
+</maintainer>
+</pkgmetadata>
diff --git a/sys-libs/pam/metadata.xml b/sys-libs/pam/metadata.xml
new file mode 100644
index 0000000..e5b58f5
--- /dev/null
+++ b/sys-libs/pam/metadata.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>pam</herd>
+  <maintainer>
+    <email>pam-bugs@gentoo.org</email>
+  </maintainer>
+  <use>
+    <flag name='audit'>Enable support for <pkg>sys-process/audit</pkg></flag>
+
+    <flag name="berkdb">
+      Build the pam_userdb module, that allows to authenticate users
+      against a Berkeley DB file. Please note that enabling this USE
+      flag will create a PAM module that links to the Berkeley DB (as
+      provided by <pkg>sys-libs/db</pkg>) installed in /usr/lib and
+      will thus not work for boot-critical services authentication.
+    </flag>
+
+    <flag name="cracklib">
+      Build the pam_cracklib module, that allows to verify the chosen
+      passwords' strength through the use of
+      <pkg>sys-libs/cracklib</pkg>. Please note that simply enabling
+      the USE flag on this package will not make use of pam_cracklib
+      by default, you should also enable it in
+      <pkg>sys-auth/pambase</pkg> as well as update your configuration
+      files.
+    </flag>
+  </use>
+</pkgmetadata>
diff --git a/sys-libs/readline/metadata.xml b/sys-libs/readline/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-libs/readline/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-libs/slang/metadata.xml b/sys-libs/slang/metadata.xml
new file mode 100644
index 0000000..aef01fc
--- /dev/null
+++ b/sys-libs/slang/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>cjk</herd>
+</pkgmetadata>
diff --git a/sys-libs/timezone-data/metadata.xml b/sys-libs/timezone-data/metadata.xml
new file mode 100644
index 0000000..fb4199e
--- /dev/null
+++ b/sys-libs/timezone-data/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>toolchain</herd>
+</pkgmetadata>
diff --git a/sys-libs/zlib/metadata.xml b/sys-libs/zlib/metadata.xml
new file mode 100644
index 0000000..600525c
--- /dev/null
+++ b/sys-libs/zlib/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>base-system</herd>
+	<use>
+		<flag name="minizip">include the minizip library for quick and dirty zip extraction</flag>
+	</use>
+</pkgmetadata>
diff --git a/sys-power/iasl/metadata.xml b/sys-power/iasl/metadata.xml
new file mode 100644
index 0000000..c6d8628
--- /dev/null
+++ b/sys-power/iasl/metadata.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+  <email>robbat2@gentoo.org</email>
+</maintainer>
+</pkgmetadata>
diff --git a/sys-power/metadata.xml b/sys-power/metadata.xml
new file mode 100644
index 0000000..c486331
--- /dev/null
+++ b/sys-power/metadata.xml
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The sys-power category contains software which handles power management,
+		including CPU frequency scaling tools.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría sys-power contiene programas que manejan el control del
+		rendimiento incluyendo herramientas para cambio de frecuencia de algunos
+		microprocesadores.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie sys-power enthält Software für das Powermanagement, wie 
+		beispielsweise Programme zur Änderung der CPU-Frequenz.
+	</longdescription>
+	<longdescription lang="ja">
+		sys-powerカテゴリには電源管理を管理する(例えば、CPU基準化)が含まれます。
+	</longdescription>
+	<longdescription lang="nl">
+		De sys-power categorie bevat programma's voor energiebeheer, bijvoorbeeld
+		voor het aanpassen van de CPU-kloksnelheid.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm sys-power chứa các phần mềm quản lý năng lượng,
+		bao gồm các công cụ quản lý tần số CPU.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria sys-power contiene programmi per la gestione del risparmio energetico,
+		incluso il software per la variazione della frequenza della CPU.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria sys-power contém programas que lidam com
+		gerenciamento de energia, incluindo ferramentas de variação de
+		freqüência de microprocessadores.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria sys-power zawiera oprogramowanie związane z zarządzaniem
+		energią, włączając w to programy służące do skalowania częstotliwości
+		procesora.
+	</longdescription>
+</catmetadata>
+
diff --git a/sys-power/pm-quirks/metadata.xml b/sys-power/pm-quirks/metadata.xml
new file mode 100644
index 0000000..8542880
--- /dev/null
+++ b/sys-power/pm-quirks/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>freedesktop</herd>
+</pkgmetadata>
diff --git a/sys-power/powertop/metadata.xml b/sys-power/powertop/metadata.xml
new file mode 100644
index 0000000..9cca7a8
--- /dev/null
+++ b/sys-power/powertop/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <maintainer>
+    <email>zerochaos@gentoo.org</email>
+    <name>Rick Farina</name>
+  </maintainer>
+</pkgmetadata>
diff --git a/sys-process/audit/metadata.xml b/sys-process/audit/metadata.xml
new file mode 100644
index 0000000..4f84c85
--- /dev/null
+++ b/sys-process/audit/metadata.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <maintainer>
+    <email>robbat2@gentoo.org</email>
+  </maintainer>
+</pkgmetadata>
diff --git a/sys-process/lsof/metadata.xml b/sys-process/lsof/metadata.xml
new file mode 100644
index 0000000..49fb858
--- /dev/null
+++ b/sys-process/lsof/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<use>
+ <flag name='rpc'>support looking up RPC service info</flag>
+</use>
+</pkgmetadata>
diff --git a/sys-process/metadata.xml b/sys-process/metadata.xml
new file mode 100644
index 0000000..9509672
--- /dev/null
+++ b/sys-process/metadata.xml
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The sys-process category contains packages which query or manipulate
+		processes. The 'cron' daemons are included in this.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría sys-proccess contiene paquetes que manipulan y obtienen
+		información de los procesos. Los paquetes de 'cron' también están
+		incluidos en esta categoría.
+	</longdescription>
+	<longdescription lang="ja">
+		sys-processカテゴリにはプロセスを照会と操作パッケージが含まれます。
+		cronデーモンはここに含まれます。
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie sys-process enthält Pakete für das Arbeiten mit Prozessen.
+		Auch die Cron-Daemons sind in dieser Kategorie enthalten.
+	</longdescription>
+	<longdescription lang="nl">
+		De sys-process categorie bevat pakketten voor de omgang met processen. Ook
+		de verschillende cron-daemons behoren tot deze categorie.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm sys-process chứa các phần mềm truy vấn và xử lý tiến trình.
+		Các 'cron' daemon cũng nằm trong đây.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria sys-process contiene pacchetti per la manipolazione e l'analisi dei processi.
+		I demoni 'cron' appartengono a questa categoria.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria sys-process contém pacotes que manipulam e captam
+		informações dos processos. Os daemons de 'cron' estão incluídos
+		aqui.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria sys-process zawiera programy do przeszukiwania listy procesów
+		oraz do manipulowania nimi. Znajdują się tu również demony cron.
+	</longdescription>
+</catmetadata>
+
diff --git a/sys-process/procps/metadata.xml b/sys-process/procps/metadata.xml
new file mode 100644
index 0000000..16e9fa3
--- /dev/null
+++ b/sys-process/procps/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<use>
+ <flag name='ncurses'>Build programs that use ncurses: top, slabtop, watch</flag>
+</use>
+</pkgmetadata>
diff --git a/sys-process/psmisc/metadata.xml b/sys-process/psmisc/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-process/psmisc/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/sys-process/time/metadata.xml b/sys-process/time/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/sys-process/time/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/virtual/acl/metadata.xml b/virtual/acl/metadata.xml
new file mode 100644
index 0000000..c6e0a01
--- /dev/null
+++ b/virtual/acl/metadata.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>bsd</herd>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/virtual/editor/metadata.xml b/virtual/editor/metadata.xml
new file mode 100644
index 0000000..472bbac
--- /dev/null
+++ b/virtual/editor/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>emacs</herd>
+<herd>xemacs</herd>
+<herd>vim</herd>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/virtual/emacs/metadata.xml b/virtual/emacs/metadata.xml
new file mode 100644
index 0000000..bc306fe
--- /dev/null
+++ b/virtual/emacs/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>emacs</herd>
+</pkgmetadata>
diff --git a/virtual/ffmpeg/metadata.xml b/virtual/ffmpeg/metadata.xml
new file mode 100644
index 0000000..4c63c77
--- /dev/null
+++ b/virtual/ffmpeg/metadata.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>video</herd>
+<maintainer>
+	<email>media-video@gentoo.org</email>
+</maintainer>
+<use>
+	<flag name="opus">Use the external opus library for encoding and decoding.</flag>
+	<flag name="vaapi">Enables VAAPI (Video Acceleration API) for hardware decoding</flag>
+</use>
+</pkgmetadata>
diff --git a/virtual/glu/metadata.xml b/virtual/glu/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/virtual/glu/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/virtual/jdk/metadata.xml b/virtual/jdk/metadata.xml
new file mode 100644
index 0000000..7303cef
--- /dev/null
+++ b/virtual/jdk/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>java</herd>
+</pkgmetadata>
diff --git a/virtual/jpeg/metadata.xml b/virtual/jpeg/metadata.xml
new file mode 100644
index 0000000..9be90a2
--- /dev/null
+++ b/virtual/jpeg/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>graphics</herd>
+</pkgmetadata>
diff --git a/virtual/jre/metadata.xml b/virtual/jre/metadata.xml
new file mode 100644
index 0000000..7303cef
--- /dev/null
+++ b/virtual/jre/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>java</herd>
+</pkgmetadata>
diff --git a/virtual/krb5/metadata.xml b/virtual/krb5/metadata.xml
new file mode 100644
index 0000000..9cc2325
--- /dev/null
+++ b/virtual/krb5/metadata.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>kerberos</herd>
+</pkgmetadata>
+
diff --git a/virtual/libc/metadata.xml b/virtual/libc/metadata.xml
new file mode 100644
index 0000000..7b307f7
--- /dev/null
+++ b/virtual/libc/metadata.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>toolchain</herd>
+<herd>embedded</herd>
+<herd>bsd</herd>
+</pkgmetadata>
diff --git a/virtual/libffi/metadata.xml b/virtual/libffi/metadata.xml
new file mode 100644
index 0000000..686dc81
--- /dev/null
+++ b/virtual/libffi/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>toolchain</herd>
+</pkgmetadata>
diff --git a/virtual/libiconv/metadata.xml b/virtual/libiconv/metadata.xml
new file mode 100644
index 0000000..3519b5e
--- /dev/null
+++ b/virtual/libiconv/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+	<email>alt@gentoo.org</email>
+	<name>Gentoo Alt</name>
+</maintainer>
+</pkgmetadata>
diff --git a/virtual/libintl/metadata.xml b/virtual/libintl/metadata.xml
new file mode 100644
index 0000000..3519b5e
--- /dev/null
+++ b/virtual/libintl/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+	<email>alt@gentoo.org</email>
+	<name>Gentoo Alt</name>
+</maintainer>
+</pkgmetadata>
diff --git a/virtual/libusb/metadata.xml b/virtual/libusb/metadata.xml
index e135c6e..659da0c 100644
--- a/virtual/libusb/metadata.xml
+++ b/virtual/libusb/metadata.xml
@@ -1,8 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
 <pkgmetadata>
-	<herd>no-herd</herd>
-	<maintainer>
-		<email>robbat2@gentoo.org</email>
-	</maintainer>
+	<herd>base-system</herd>
 </pkgmetadata>
diff --git a/virtual/logger/metadata.xml b/virtual/logger/metadata.xml
new file mode 100644
index 0000000..e31cecb
--- /dev/null
+++ b/virtual/logger/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+<maintainer>
+    <email>ultrabug@gentoo.org</email>
+    <name>Alexys Jacob</name>
+</maintainer>
+</pkgmetadata>
diff --git a/virtual/man/metadata.xml b/virtual/man/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/virtual/man/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/virtual/metadata.xml b/virtual/metadata.xml
new file mode 100644
index 0000000..27e4dd2
--- /dev/null
+++ b/virtual/metadata.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The virtual category contains packages which satisfy virtual dependencies.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría virtual contiene paquetes para satisfacer las
+		dependencias virtuales.
+	</longdescription>
+</catmetadata>
+
diff --git a/virtual/modutils/metadata.xml b/virtual/modutils/metadata.xml
new file mode 100644
index 0000000..14f8165
--- /dev/null
+++ b/virtual/modutils/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>udev-bugs@gentoo.org</email>
+	</maintainer>
+	<herd>base-system</herd>
+</pkgmetadata>
diff --git a/virtual/mta/metadata.xml b/virtual/mta/metadata.xml
new file mode 100644
index 0000000..c508d21
--- /dev/null
+++ b/virtual/mta/metadata.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>net-mail</herd>
+<herd>qmail</herd>
+</pkgmetadata>
+
diff --git a/virtual/opengl/metadata.xml b/virtual/opengl/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/virtual/opengl/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/virtual/os-headers/metadata.xml b/virtual/os-headers/metadata.xml
new file mode 100644
index 0000000..73b7451
--- /dev/null
+++ b/virtual/os-headers/metadata.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>toolchain</herd>
+<herd>bsd</herd>
+</pkgmetadata>
diff --git a/virtual/pager/metadata.xml b/virtual/pager/metadata.xml
new file mode 100644
index 0000000..2811ade
--- /dev/null
+++ b/virtual/pager/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<maintainer>
+    <email>fauli@gentoo.org</email>
+    <name>Christian Faulhammer</name>
+</maintainer>
+</pkgmetadata>
diff --git a/virtual/pam/metadata.xml b/virtual/pam/metadata.xml
new file mode 100644
index 0000000..f8e763f
--- /dev/null
+++ b/virtual/pam/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>pam</herd>
+<maintainer>
+  <email>pam-bugs@gentoo.org</email>
+</maintainer>
+</pkgmetadata>
diff --git a/virtual/pkgconfig/metadata.xml b/virtual/pkgconfig/metadata.xml
new file mode 100644
index 0000000..08b7896
--- /dev/null
+++ b/virtual/pkgconfig/metadata.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>freedesktop</herd>
+<herd>embedded</herd>
+</pkgmetadata>
diff --git a/virtual/python-argparse/metadata.xml b/virtual/python-argparse/metadata.xml
new file mode 100644
index 0000000..301d220
--- /dev/null
+++ b/virtual/python-argparse/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>python</herd>
+</pkgmetadata>
diff --git a/virtual/ttf-fonts/metadata.xml b/virtual/ttf-fonts/metadata.xml
new file mode 100644
index 0000000..64cc0b6
--- /dev/null
+++ b/virtual/ttf-fonts/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>fonts</herd>
+</pkgmetadata>
diff --git a/virtual/yacc/metadata.xml b/virtual/yacc/metadata.xml
new file mode 100644
index 0000000..96a2d58
--- /dev/null
+++ b/virtual/yacc/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>base-system</herd>
+</pkgmetadata>
diff --git a/x11-apps/iceauth/metadata.xml b/x11-apps/iceauth/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/iceauth/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/mesa-progs/metadata.xml b/x11-apps/mesa-progs/metadata.xml
new file mode 100644
index 0000000..f9f35a8
--- /dev/null
+++ b/x11-apps/mesa-progs/metadata.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+<use>
+        <flag name='egl'>Build EGL utilities</flag>
+        <flag name='gles1'>Build OpenGL ES 1 utilities</flag>
+        <flag name='gles2'>Build OpenGL ES 2 utilities</flag>
+</use>
+</pkgmetadata>
diff --git a/x11-apps/metadata.xml b/x11-apps/metadata.xml
new file mode 100644
index 0000000..acb438f
--- /dev/null
+++ b/x11-apps/metadata.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		x11-apps contains applications distributed as part of X.Org X11.
+	</longdescription>
+	<longdescription lang="ja">
+		x11-appsカテゴリにはX.Org X11のパッケージソフトが含まれます。
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie x11-apps enthält Applikationen welche mit X.Org 
+		X11 ausgeliefert werden.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria x11-apps contém aplicações distribuídas como parte
+		do X.Org X11.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria x11-apps zawiera programy wchodzące w skład środowiska
+		graficznego X.Org X11.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría x11-apps contiene aplicaciones que se distribuyen como
+		parte de X.Org X11.
+	</longdescription>
+</catmetadata>
+
diff --git a/x11-apps/mkfontdir/metadata.xml b/x11-apps/mkfontdir/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/mkfontdir/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/mkfontscale/metadata.xml b/x11-apps/mkfontscale/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/mkfontscale/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/rgb/metadata.xml b/x11-apps/rgb/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/rgb/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/setxkbmap/metadata.xml b/x11-apps/setxkbmap/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/setxkbmap/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/xauth/metadata.xml b/x11-apps/xauth/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/xauth/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/xcursorgen/metadata.xml b/x11-apps/xcursorgen/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/xcursorgen/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/xdpyinfo/metadata.xml b/x11-apps/xdpyinfo/metadata.xml
new file mode 100644
index 0000000..1400b5f
--- /dev/null
+++ b/x11-apps/xdpyinfo/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+<use>
+	<flag name='dmx'>Builds support for Distributed Multiheaded X
+		<pkg>x11-base/xorg-server</pkg></flag>
+</use>
+</pkgmetadata>
diff --git a/x11-apps/xdriinfo/metadata.xml b/x11-apps/xdriinfo/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/xdriinfo/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/xev/metadata.xml b/x11-apps/xev/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/xev/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/xhost/metadata.xml b/x11-apps/xhost/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/xhost/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/xinput/metadata.xml b/x11-apps/xinput/metadata.xml
new file mode 100644
index 0000000..6cc3982
--- /dev/null
+++ b/x11-apps/xinput/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/xinput_calibrator/metadata.xml b/x11-apps/xinput_calibrator/metadata.xml
new file mode 100644
index 0000000..6cc3982
--- /dev/null
+++ b/x11-apps/xinput_calibrator/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/xkbcomp/metadata.xml b/x11-apps/xkbcomp/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/xkbcomp/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/xlsatoms/metadata.xml b/x11-apps/xlsatoms/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/xlsatoms/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/xlsclients/metadata.xml b/x11-apps/xlsclients/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/xlsclients/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/xmodmap/metadata.xml b/x11-apps/xmodmap/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/xmodmap/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/xprop/metadata.xml b/x11-apps/xprop/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/xprop/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/xrandr/metadata.xml b/x11-apps/xrandr/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/xrandr/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/xrdb/metadata.xml b/x11-apps/xrdb/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/xrdb/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/xset/metadata.xml b/x11-apps/xset/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/xset/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/xsetroot/metadata.xml b/x11-apps/xsetroot/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/xsetroot/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/xwd/metadata.xml b/x11-apps/xwd/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/xwd/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-apps/xwininfo/metadata.xml b/x11-apps/xwininfo/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-apps/xwininfo/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-drivers/metadata.xml b/x11-drivers/metadata.xml
new file mode 100644
index 0000000..2357fd1
--- /dev/null
+++ b/x11-drivers/metadata.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		x11-drivers contain drivers that interface with the core X11 server.
+	</longdescription>
+	<longdescription lang="ja">
+		x11-driversカテゴリにはX11コアサーバとインタフェスするドライバが含まれます。
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie x11-drivers enthält zusätzliche Treiber für den X-Server.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria x11-drivers contém drivers que fazem interface com
+		o servidor de X11 principal.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria x11-drivers zawiera sterowniki dla serwera X11.
+	</longdescription>
+	<longdescription lang="es">
+		x11-drivers contiene controladores que interactúan con el servidor
+		principal X11.
+	</longdescription>
+</catmetadata>
+
diff --git a/x11-drivers/xf86-input-keyboard/metadata.xml b/x11-drivers/xf86-input-keyboard/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-drivers/xf86-input-keyboard/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-drivers/xf86-input-mouse/metadata.xml b/x11-drivers/xf86-input-mouse/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-drivers/xf86-input-mouse/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-drivers/xf86-input-synaptics/metadata.xml b/x11-drivers/xf86-input-synaptics/metadata.xml
new file mode 100644
index 0000000..c923f3f
--- /dev/null
+++ b/x11-drivers/xf86-input-synaptics/metadata.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>x11</herd>
+	<herd>proxy-maintainers</herd>
+	<maintainer>
+		<email>eva@gentoo.org</email>
+		<name>Gilles Dartiguelongue</name>
+	</maintainer>
+	<maintainer>
+		<email>egore@gmx.de</email>
+		<name>Christoph Brill</name>
+		<description>upstream co-maintainer</description>
+	</maintainer>
+</pkgmetadata>
diff --git a/x11-drivers/xf86-video-ati/metadata.xml b/x11-drivers/xf86-video-ati/metadata.xml
new file mode 100644
index 0000000..b19c4dc
--- /dev/null
+++ b/x11-drivers/xf86-video-ati/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+<use>
+	<flag name="glamor">Enable Glamor OpenGL 2D acceleration</flag>
+</use>
+</pkgmetadata>
diff --git a/x11-drivers/xf86-video-fbdev/metadata.xml b/x11-drivers/xf86-video-fbdev/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-drivers/xf86-video-fbdev/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-drivers/xf86-video-nouveau/metadata.xml b/x11-drivers/xf86-video-nouveau/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-drivers/xf86-video-nouveau/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-drivers/xf86-video-vmware/metadata.xml b/x11-drivers/xf86-video-vmware/metadata.xml
new file mode 100644
index 0000000..8a4ab6d
--- /dev/null
+++ b/x11-drivers/xf86-video-vmware/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>x11</herd>
+	<maintainer>
+		<email>dev-zero@gentoo.org</email>
+		<name>Tiziano Müller</name>
+	</maintainer>
+</pkgmetadata>
diff --git a/x11-libs/cairo/metadata.xml b/x11-libs/cairo/metadata.xml
new file mode 100644
index 0000000..b5a25ce
--- /dev/null
+++ b/x11-libs/cairo/metadata.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>x11</herd>
+  <maintainer>
+    <email>yngwin@gentoo.org</email>
+    <name>Ben de Groot</name>
+  </maintainer>
+  <use>
+    <flag name='opengl' restrict="&gt;=x11-libs/cairo-1.10.0">
+      Use Mesa backend for acceleration</flag>
+    <flag name='drm'>Use Linux DRM for backend acceleration</flag>
+    <flag name='gallium'>Use Mesa's Gallium backend for acceleration</flag>
+    <flag name='glib'>Compile with GLib Object System support</flag>
+    <flag name='legacy-drivers'>Include the buggy gradients patch (for legacy drivers, such as nvidia-drivers older than 304.30)</flag>
+    <flag name='openvg'>Use OpenVG for backend acceleration</flag>
+  </use>
+</pkgmetadata>
diff --git a/x11-libs/gdk-pixbuf/metadata.xml b/x11-libs/gdk-pixbuf/metadata.xml
new file mode 100644
index 0000000..6e0e2ec
--- /dev/null
+++ b/x11-libs/gdk-pixbuf/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>gnome</herd>
+</pkgmetadata>
diff --git a/x11-libs/gtk+/metadata.xml b/x11-libs/gtk+/metadata.xml
new file mode 100644
index 0000000..2652778
--- /dev/null
+++ b/x11-libs/gtk+/metadata.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>gnome</herd>
+  <longdescription>
+    GTK+ is a multi-platform toolkit for creating graphical user
+    interfaces. Offering a complete set of widgets, GTK+ is suitable
+    for projects ranging from small one-off projects to complete
+    application suites.
+  </longdescription>
+  <use>
+    <flag name="colord">Use <pkg>x11-misc/colord</pkg> for color management
+	  in printing</flag>
+	<flag name="egl">Use EGL surfaces and Cairo GL in the wayland
+	  backend. This flag has no effect on X or aqua backends.</flag>
+    <flag name="packagekit">Enable support for the distro-neutral package
+	  manager GUI <pkg>app-admin/packagekit</pkg> in application chooser</flag>
+  </use>
+</pkgmetadata>
diff --git a/x11-libs/libICE/metadata.xml b/x11-libs/libICE/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libICE/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libSM/metadata.xml b/x11-libs/libSM/metadata.xml
new file mode 100644
index 0000000..8b3fa73
--- /dev/null
+++ b/x11-libs/libSM/metadata.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+<use>
+	<flag name="uuid">Use UUID for session identification instead of IP address
+		and system time.
+	</flag>
+</use>
+</pkgmetadata>
diff --git a/x11-libs/libX11/metadata.xml b/x11-libs/libX11/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libX11/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXScrnSaver/metadata.xml b/x11-libs/libXScrnSaver/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXScrnSaver/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXau/metadata.xml b/x11-libs/libXau/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXau/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXaw/metadata.xml b/x11-libs/libXaw/metadata.xml
new file mode 100644
index 0000000..f58d351
--- /dev/null
+++ b/x11-libs/libXaw/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+<use>
+	<flag name="deprecated">Install deprecated Xaw6 library.</flag>
+</use>
+</pkgmetadata>
diff --git a/x11-libs/libXcomposite/metadata.xml b/x11-libs/libXcomposite/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXcomposite/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXcursor/metadata.xml b/x11-libs/libXcursor/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXcursor/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXdamage/metadata.xml b/x11-libs/libXdamage/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXdamage/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXdmcp/metadata.xml b/x11-libs/libXdmcp/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXdmcp/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXext/metadata.xml b/x11-libs/libXext/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXext/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXfixes/metadata.xml b/x11-libs/libXfixes/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXfixes/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXfont/metadata.xml b/x11-libs/libXfont/metadata.xml
new file mode 100644
index 0000000..3d13756
--- /dev/null
+++ b/x11-libs/libXfont/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<herd>x11</herd>
+	<use>
+		<flag name="bzip2">Support bzip2 compressed PCF fonts.</flag>
+		<flag name="truetype">Use media-libs/freetype for font rasterization.</flag>
+	</use>
+</pkgmetadata>
diff --git a/x11-libs/libXft/metadata.xml b/x11-libs/libXft/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXft/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXi/metadata.xml b/x11-libs/libXi/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXi/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXinerama/metadata.xml b/x11-libs/libXinerama/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXinerama/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXmu/metadata.xml b/x11-libs/libXmu/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXmu/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXpm/metadata.xml b/x11-libs/libXpm/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXpm/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXrandr/metadata.xml b/x11-libs/libXrandr/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXrandr/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXrender/metadata.xml b/x11-libs/libXrender/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXrender/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXt/metadata.xml b/x11-libs/libXt/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXt/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXtst/metadata.xml b/x11-libs/libXtst/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXtst/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXv/metadata.xml b/x11-libs/libXv/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXv/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXvMC/metadata.xml b/x11-libs/libXvMC/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXvMC/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libXxf86vm/metadata.xml b/x11-libs/libXxf86vm/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libXxf86vm/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libfontenc/metadata.xml b/x11-libs/libfontenc/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libfontenc/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/libva/metadata.xml b/x11-libs/libva/metadata.xml
new file mode 100644
index 0000000..af702ea
--- /dev/null
+++ b/x11-libs/libva/metadata.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <maintainer>
+    <email>aballier@gentoo.org</email>
+    <name>Alexis Ballier</name>
+  </maintainer>
+	<use>
+		<flag name='egl'>Enables EGL support.</flag>
+    </use>
+</pkgmetadata>
diff --git a/x11-libs/libvdpau/metadata.xml b/x11-libs/libvdpau/metadata.xml
new file mode 100644
index 0000000..a445a73
--- /dev/null
+++ b/x11-libs/libvdpau/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>cardoe@gentoo.org</email>
+		<name>Doug Goldstein</name>
+	</maintainer>
+</pkgmetadata>
diff --git a/x11-libs/libxkbfile/metadata.xml b/x11-libs/libxkbfile/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/libxkbfile/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/metadata.xml b/x11-libs/metadata.xml
new file mode 100644
index 0000000..875590a
--- /dev/null
+++ b/x11-libs/metadata.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The x11-libs category contains various X11-related libraries.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie x11-libs enthält verschiedene Bibliotheken für
+		die X11-Programmierung.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría x11-libs contiene varias librerías para X11.
+	</longdescription>
+	<longdescription lang="ja">
+		x11-libsカテゴリーには様々なX11関連のライブラリが含まれています。
+	</longdescription>
+	<longdescription lang="nl">
+		De categorie x11-libs bevat allerlei aan X11 gerelateerde bibliotheken.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm x11-libs chứa các thư viện liên quan đến X11.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria x11-libs contiene varie librerie per X11.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria x11-libs contém várias bibliotecas relacionadas a
+		X11.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria x11-libs zawiera biblioteki powiązane z X11.
+	</longdescription>
+</catmetadata>
+
diff --git a/x11-libs/pixman/metadata.xml b/x11-libs/pixman/metadata.xml
new file mode 100644
index 0000000..bd23997
--- /dev/null
+++ b/x11-libs/pixman/metadata.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+<use>
+	<flag name="loongson2f">Enable Loongson2f MMI optimizations.</flag>
+	<flag name="mmxext">Enable MMX2 support.</flag>
+</use>
+</pkgmetadata>
diff --git a/x11-libs/xcb-util-image/metadata.xml b/x11-libs/xcb-util-image/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/xcb-util-image/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/xcb-util-keysyms/metadata.xml b/x11-libs/xcb-util-keysyms/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/xcb-util-keysyms/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/xcb-util-renderutil/metadata.xml b/x11-libs/xcb-util-renderutil/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/xcb-util-renderutil/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/xcb-util-wm/metadata.xml b/x11-libs/xcb-util-wm/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/xcb-util-wm/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/xcb-util/metadata.xml b/x11-libs/xcb-util/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/xcb-util/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-libs/xtrans/metadata.xml b/x11-libs/xtrans/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-libs/xtrans/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-misc/makedepend/metadata.xml b/x11-misc/makedepend/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-misc/makedepend/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-misc/metadata.xml b/x11-misc/metadata.xml
new file mode 100644
index 0000000..dfa319e
--- /dev/null
+++ b/x11-misc/metadata.xml
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		The x11-misc category contains miscellaneous X11 applications which do
+		not belong elsewhere.
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie x11-misc enthält verschiedene X11-Applikationen die sich
+		nicht anderweitig einordnen lassen.
+	</longdescription>
+	<longdescription lang="es">
+		La categoría x11-misc contiene aplicaciones mixtas de X11 que no
+		pertenecen a ninguna otra categoría.
+	</longdescription>
+	<longdescription lang="ja">
+		x11-miscカテゴリーには他のカテゴリーに分類されなかった
+		多種多様なX11アプリケーションが含まれて>います。
+	</longdescription>
+	<longdescription lang="nl">
+		De categorie x11-misc bevat allerlei X11-applicaties die niet in andere
+		categorieën thuishoren.
+	</longdescription>
+	<longdescription lang="vi">
+		Nhóm x11-misc chứa các ứng dụng X11 không thuộc vào nơi nào khác.
+	</longdescription>
+	<longdescription lang="sk">
+		Kategória x11-misc obsahuje rôzne aplikácie pre X11, ktoré nie sú
+		zaradené do iných kategórií.
+	</longdescription>
+	<longdescription lang="it">
+		La categoria x11-misc contiene applicazioni miste per X11 che non appartengono ad altre categorie.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria x11-misc contém aplicações mistas de X11 que não
+		pertencem a outras categorias.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria x11-misc zawiera aplikacje dla X11, które nie pasują do żadnej
+		z pozostałych kategorii.
+	</longdescription>
+</catmetadata>
+
diff --git a/x11-misc/read-edid/metadata.xml b/x11-misc/read-edid/metadata.xml
new file mode 100644
index 0000000..540f810
--- /dev/null
+++ b/x11-misc/read-edid/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <herd>desktop-misc</herd>
+</pkgmetadata>
diff --git a/x11-misc/shared-mime-info/metadata.xml b/x11-misc/shared-mime-info/metadata.xml
new file mode 100644
index 0000000..8c86806
--- /dev/null
+++ b/x11-misc/shared-mime-info/metadata.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>freedesktop</herd>
+<maintainer>
+<email>freedesktop-bugs@gentoo.org</email>
+</maintainer>
+</pkgmetadata>
diff --git a/x11-misc/util-macros/metadata.xml b/x11-misc/util-macros/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-misc/util-macros/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-misc/x11vnc/metadata.xml b/x11-misc/x11vnc/metadata.xml
new file mode 100644
index 0000000..e54ae9f
--- /dev/null
+++ b/x11-misc/x11vnc/metadata.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+  <maintainer>
+	  <email>floppym@gentoo.org</email>
+	  <name>Mike Gilbert</name>
+  </maintainer>
+  <longdescription>
+The primary goal of this program is to create a portable and simple command-line
+server utility that allows a VNC viewer to connect to an actual X display.
+	</longdescription>
+  <use>
+    <flag name="system-libvncserver">Build x11vnc against the system libvncserver (experimental)</flag>
+    <flag name="tk">Support the simple tcl/tk -gui option</flag>
+  </use>
+</pkgmetadata>
diff --git a/x11-misc/xbitmaps/metadata.xml b/x11-misc/xbitmaps/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-misc/xbitmaps/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-misc/xdotool/metadata.xml b/x11-misc/xdotool/metadata.xml
new file mode 100644
index 0000000..9daac93
--- /dev/null
+++ b/x11-misc/xdotool/metadata.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+	<maintainer>
+		<email>joker@gentoo.org</email>
+		<name>Christian Birchinger</name>
+	</maintainer>
+	<longdescription>This tool lets you programatically (or manually) simulate keyboard input and
+mouse activity, move and resize windows, etc. It does this using X11's XTEST
+extension and other Xlib functions. </longdescription>
+	<upstream>
+		<remote-id type="google-code">semicomplete</remote-id>
+	</upstream>
+</pkgmetadata>
diff --git a/x11-proto/bigreqsproto/metadata.xml b/x11-proto/bigreqsproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/bigreqsproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/compositeproto/metadata.xml b/x11-proto/compositeproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/compositeproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/damageproto/metadata.xml b/x11-proto/damageproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/damageproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/dri2proto/metadata.xml b/x11-proto/dri2proto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/dri2proto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/fixesproto/metadata.xml b/x11-proto/fixesproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/fixesproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/fontsproto/metadata.xml b/x11-proto/fontsproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/fontsproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/glproto/metadata.xml b/x11-proto/glproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/glproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/inputproto/metadata.xml b/x11-proto/inputproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/inputproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/kbproto/metadata.xml b/x11-proto/kbproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/kbproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/metadata.xml b/x11-proto/metadata.xml
new file mode 100644
index 0000000..855298e
--- /dev/null
+++ b/x11-proto/metadata.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE catmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<catmetadata>
+	<longdescription lang="en">
+		x11-proto contains the X11 protocol headers.
+	</longdescription>
+	<longdescription lang="ja">
+		x11-protoカテゴリにはX11のプロトコルヘーダが含まれます。
+	</longdescription>
+	<longdescription lang="de">
+		Die Kategorie x11-proto enthält die Headerdateien für das
+		X11-Protokoll.
+	</longdescription>
+	<longdescription lang="pt">
+		A categoria x11-proto contém os cabeçalhos de protocolo de X11.
+	</longdescription>
+	<longdescription lang="pl">
+		Kategoria x11-proto zawiera nagłówki protokołu X11.
+	</longdescription>
+	<longdescription lang="es">
+		x11-proto contiene las cabeceras del protocolo X11.
+	</longdescription>
+</catmetadata>
+
diff --git a/x11-proto/randrproto/metadata.xml b/x11-proto/randrproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/randrproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/recordproto/metadata.xml b/x11-proto/recordproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/recordproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/renderproto/metadata.xml b/x11-proto/renderproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/renderproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/resourceproto/metadata.xml b/x11-proto/resourceproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/resourceproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/scrnsaverproto/metadata.xml b/x11-proto/scrnsaverproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/scrnsaverproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/trapproto/metadata.xml b/x11-proto/trapproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/trapproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/videoproto/metadata.xml b/x11-proto/videoproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/videoproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/xcmiscproto/metadata.xml b/x11-proto/xcmiscproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/xcmiscproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/xf86bigfontproto/metadata.xml b/x11-proto/xf86bigfontproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/xf86bigfontproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/xf86dgaproto/metadata.xml b/x11-proto/xf86dgaproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/xf86dgaproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/xf86driproto/metadata.xml b/x11-proto/xf86driproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/xf86driproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/xf86rushproto/metadata.xml b/x11-proto/xf86rushproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/xf86rushproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/xf86vidmodeproto/metadata.xml b/x11-proto/xf86vidmodeproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/xf86vidmodeproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/xineramaproto/metadata.xml b/x11-proto/xineramaproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/xineramaproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
diff --git a/x11-proto/xproto/metadata.xml b/x11-proto/xproto/metadata.xml
new file mode 100644
index 0000000..01c4c00
--- /dev/null
+++ b/x11-proto/xproto/metadata.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">
+<pkgmetadata>
+<herd>x11</herd>
+</pkgmetadata>
