Core Git translation language teams
(please keep the list sorted alphabetically on language field)

Language:	bg (Bulgarian)
Repository:	https://github.com/git-l10n/git-po
Leader:		Alexander Shopov <ash@kambanaria.org>

Language:	ca (Catalan)
Repository:	https://github.com/Softcatala/git-po
Leader:		Jordi Mas <jmas@softcatala.org>
Members:	Alex Henrie <alexhenrie24@gmail.com>

Language:	de (German)
Repository:	https://github.com/ralfth/git-po-de
Leader:		Ralf Thielow <ralf.thielow@gmail.com>
Members:	Thomas Rast <tr@thomasrast.ch>
		Jan Krüger <jk@jk.gs>
		Christian Stimming <stimming@tuhh.de>
		Phillip Szelat <phillip.szelat@gmail.com>
		Matthias Rüster <matthias.ruester@gmail.com>
		Magnus Görlitz <magnus.goerlitz@googlemail.com>

Language:	fr (French)
Repository:	https://github.com/jnavila/git
Leader:		Jean-Noël Avila <jn.avila@free.fr>
Members:	Sébastien Helleu <flashcode@flashtux.org>

Language:	is (Icelandic)
Leader:		Ævar Arnfjörð Bjarmason <avarab@gmail.com>

Language:	it (Italian)
Repository:	https://github.com/quizzlo/git-po-it/
Leader:		Marco Paolone <marcopaolone AT gmail.com>
Members:	Stefano Lattarini <stefano.lattarini AT gmail.com>

Language:	ko (Korean)
Repository:	https://github.com/changwoo/git-l10n-ko/
Leader:		Changwoo Ryu <cwryu@debian.org>

Language:	pt_PT (Portuguese - Portugal)
Repository:	https://github.com/vascool/git-po-pt/
Leader:		Vasco Almeida <vascomalmeida@sapo.pt>
Members:	Marco Sousa <marcomsousa AT gmail.com>

Language:	ru (Russian)
Repository:	https://github.com/DJm00n/git-po-ru/
Leader:		Dimitriy Ryazantcev <DJm00n AT mail.ru>
Members:	insolor <insolor AT gmail.com>

Language:	sv (Swedish)
Repository:	https://github.com/nafmo/git-l10n-sv/
Leader:		Peter Krefting <peter@softwolves.pp.se>

Language:	vi (Vietnamese)
Repository:	https://github.com/vnwildman/git/
Leader:		Trần Ngọc Quân <vnwildman AT gmail.com>
Members:	Nguyễn Thái Ngọc Duy <pclouds AT gmail.com>

Language:	zh_CN (Simplified Chinese)
Repository:	https://github.com/jiangxin/git/
Leader:		Jiang Xin <worldhello.net@gmail.com>
Members:	Ray Chen <oldsharp@gmail.com>
