Adi Dascal <ad@baum.ro>
Adi Kushnir <adikushnir@gmail.com>
Alan Coopersmith <alan.coopersmith@oracle.com>
Alex Bernier <alex.bernier@free.fr>
Andreas Gross <andi@andi-bika.de>
Angela Engel <angela.engel@gmx.at>
Arthur Breuneval <arthur.breuneval@yahoo.fr>
Attila Hammer <hammera@pickup.hu>
August Hörandl <august.hoerandl@gmx.at>
Aura Kelloniemi <kaura.dev@sange.fi>
Boris Daix <Boris.Daix@insa-lyon.fr>
Cheryl Homiak <cah4110@icloud.com>
Chris Brannon <chris@the-brannons.com>
Christian Comaschi <christian_comaschi@libero.it>
Christoph-Simon Senjak <christoph.senjak@googlemail.com>
Coscell Kao <coscell@molerat.net>
Daniel Dalton <d.dalton@iinet.net.au>
Dave Mielke <dave@mielke.cc>
David Sauer <sauer@brailcom.cz>
Didier Poitou <d.poitou@eurobraille.fr>
Dietmar Segbert <dietmarsegbert@gmx.de>
Dominic Mazzoni <dmazzoni@google.com>
Emilio Pozuelo Monfort <emilio.pozuelo@um.es>
Étienne Carrier <etienne.carrier@humanware.com>
Hans Schou <chlor@schou.dk>
Helge Havnegjerde <helge.havnegjerde@getmail.no>
Hermann Bender <meinelisten@onlinehome.de>
James Teh <jamie@jantrid.net>
Jan Buchal <buchal@brailcom.org>
Jani Kinnunen <jani.kinnunen@wippies.fi>
Jaroslav Skarvada <jskarvad@redhat.com>
Jean-Philippe Mengual <jpmengual@debian.org>
Joanmarie Diggs <jdiggs@igalia.com>
John J. Boyer <john.boyer@jjb-software.com>
Jozko Gregorc <jozko.gregorc@guest.arnes.si>
Julian Sackmann <masackma@microsoft.com>
Kazunori Minatani <99112004@gakushuin.ac.jp>
Keith Wessel <keith@wessel.com>
Lars Bjørndal <lars.bjorndal@broadpark.no>
Lee Maschmeyer <leemer1@comcast.net>
Luke Yelavich <themuso@ubuntu.com>
Mario Lang <mlang@delysid.org>
Mark Mielke <mark@mielke.cc>
Marko Lalic <markola@microsoft.com>
Matthew Miller <mattdm@mattdm.org>
Michael Curran <mick@kulgan.net>
Michel Such <michel.such@free.fr>
Mike Gorse <mgorse@alum.wpi.edu>
Mike Pedersen <mpedersen@mindspring.com>
Miranda Woudstra <Miran.Woudstra@gmail.com>
Neal Gompa (ニール・ゴンパ) <NGompa13@gmail.com>
Nicolas Pitre <nico@fluxnic.net>
Nikita Tseykovets <tseikovets@rambler.ru>
Olaf Hering <olaf@aepfle.de>
Ole Guldberg <ole@omgwtf.dk>
Olivier Bert <obert01@mistigri.org>
Ollie Mallard <mallard@ilgerone.net>
Ondřej Lysoněk <OLysonek@RedHat.com>
Oscar Fernandez <ofa@once.es>
Pete De Vasto <pdevasto@incyte.com>
Peter Lundblad <plundblad@google.com>
Petr Řehák <rehak@adaptech.cz>
Raoul Megelas <rmgls@free.fr>
Regiane Mendonça Villela <regianevillela@gmail.com>
Rich Burridge <Rich.Burridge@Sun.COM>
Rimas Kudelis <rq@akl.lt>
Robert Pösel <robyer@seznam.cz>
Rudolf Weeber <Rudolf.Weeber@gmx.de>
Samuel Thibault <samuel.thibault@ens-lyon.org>
Samuel Yang <mison@bbs.ee.ntu.edu.tw>
Sebastiano Pistore <SebastianoPistore.info@protonmail.ch>
Sébastien Hinderer <sebastien.hinderer@ens-lyon.org>
Sebastian Krahmer <krahmer@suse.com>
Sérgio Neves <sergionevess@gmail.com>
Simon Kainz <simon@familiekainz.at>
Simon Meers <drmeers@gmail.com>
Stepan Kasal <kasal@ucw.cz>
Stefan Moisei <vortex37@gmail.com>
Stephane Dalton <sdalton@videotron.ca>
Stéphane Doyon <s.doyon@videotron.ca>
Tapio Kelloniemi <tapio.kelloniemi@thack.org>
Thu Trang <phamtrang2002@softhome.net>
Timothy Spaulding <spaulding@icanbrew.com>
Timo Matsinen <matsinen@jyu.fi>
Tom spot Callaway <tcallawa@redhat.com>
Tomáš Janoušek <tomi@nomi.cz>
Tomas Mårdsjö <tomas.mardsjo@icap.nu>
Tomoyuki Kudou <kudou@cypac.co.jp>
Tony Hernandez <tonyhspeaks@gmail.com>
Ulf Beckmann <beckmann@flusoft.de>
Victor Montalvao <vicmont@microsoft.com>
Victor Tsaran <vtsaran@yahoo.com>
Vipul Kute <vipul.kute@gmail.com>
Willi Lutzenberger <willutz@gmx.net>
William Hubbs <w.d.hubbs@gmail.com>
Wolfgang Astleitner <wolfgang.astleitner@liwest.at>
Yair K. <caesium@hotpop.com>
Yannick Plassiard <yan@mistigri.org>
