MAIN AUTHOR

  John J. Boyer <john.boyer@abilitiessoft.org> from Abilitiessoft, Inc.
  - is the founder, creator and original author of the liblouis
    project(s)
  - has put his heart and soul into liblouis
  - has written the bulk of the code
  - maintainer emeritus

CODE CONTRIBUTORS

A team of three developers has taken over maintenance work since John
Boyer did a step back in 2014:

  Christian Egli <christian.egli@sbs.ch> from SBS <www.sbs.ch>
  - maintains the build and version control systems and does releases
    on a regular basis
  - has done code contributions
  - is one of the project maintainers

  Mesar Hameed <mesar.hameed@gmail.com>
  - has done code contributions
  - has done a lot of table maintenance
  - was the main developer of the test harness
  - is one of the project maintainers

  Bert Frees <bertfrees@gmail.com> for DocArch <www.docarch.be> and SBS <www.sbs.ch>
  - has done code contributions
  - has done table contributions as well
  - is one of the project maintainers

Considerable coding was done by:

  Davy Kager <mail@davykager.nl>
  Eitan Isaacson <eitan@ascender.com>
  James Teh <jamie@jantrid.net>
  Michael Curran <mick@kulgan.net>
  Michael Whapples <mwhapples@aim.com>
  Mike Gray <mgray@aph.org>
  Dave Mielke <dave@mielke.cc>

Patches were provided by:

  Jeremy Roman <jbroman@google.com>
  Milan Zamazal <pdm@brailcom.org>
  Peter Nilsson Lundblad <plundblad@google.com>
  Timothy Lee <timothy.ty.lee@gmail.com>
  Vincent Untz <vuntz@gnome.org>
  Volker Bijewitz <v.bijewitz@baum.de>
  Simon Aittamaa, Index Braille <simon.aittamaa@indexbraille.com>
  Ken Perry <kperry@aph.org>
  Martin Michlmayr <tbm@cyrius.com>
  Arend Arends <arend.arends@hccnet.nl>
  Victor Montalvao vicmont@microsoft.com
  Bue Vester-Andersen <bue@vester-andersen.dk>

BRLTTY AUTHORS

Liblouis was derived from the Linux screen reader BRLTTY. Because it
is rather difficult to trace back exactly which parts of BRLTTY ended
up in liblouis we just list all BRLTTY contributors here (see also
brltty.com/contact.html).

The team:

  Dave Mielke <dave@mielke.cc>
  Nicolas Pitre <nico@fluxnic.net>
  Stéphane Doyon <s.doyon@videotron.ca>

Other contributors:

  Andreas Gross <andi@andi-bika.de>
  August Hörandl <hoerandl@elina.htlw1.ac.at>
  Brailcom o.p.s. <technik@brailcom.cz>
  Christian Comaschi <christian_comaschi@libero.it>
  Coscell Kao <coscell@mail.batol.net>
  James Bowden
  John Boyer <director@chpi.org>
  Jos Lemmens <jlemmens@inter.nl.net>
  Mario Lang <mlang@delysid.org>
  Nikhil Nair <nn201@cus.cam.ac.uk>
  Oscar Fernandez <ofa@once.es>
  Per Lejontand <pele@acc.umu.se>
  Samuel Thibault <samuel.thibault@labri.fr>
  Sébastien Hinderer <sebastien.hinderer@libertysurf.fr>
  Stephane Dalton <sdalton@videotron.ca>
  Wolfgang Astleitner <wolfgang.astleitner@liwest.at>
  Yannick Plassiard <Yannick.Plassiard@free.fr>

TABLE CONTRIBUTORS

  Amar Usama <ammar.usama@nlb.no>
  Aaron Cannon <cannona@fireantproductions.com>
  Abdolamir Banisaeid <saedjan@gmail.com>
  Adi Kushnir <adikushnir@gmail.com>
  Alex Ho
  Ammar Usama <ammar.usama@nlb.no>
  André-Abush Clause <clause.andreabush@gmail.com>
  Birkir Gunnarsson <birkir@midstod.is>
  Brailcom, o.p.s. <technik@brailcom.cz>
  Branislav Mamojka <mamojka@unss.sk>
  Bue Vester-Andersen <bue@vester-andersen.dk>
  Carles Sadurní Anguita <www.transcriptor.net>
  Carlos Ferreira <cferreira9886@gmail.com>
  Caterina Avoledo <catery81@yahoo.it>
  Chennai Shankar <brailleacl@gmail.com> from Braille Section Team, Anna Centenary Library
  Christian Waldvogel <christian.waldvogel@sbszh.ch> from SBS <www.sbs.ch>
  Coscell Kao <coscell@molerat.net>
  Danko Butorac <danko@ipsis.hr>
  Dave Mielke <dave@mielke.cc>
  David Hole
  David Reynolds <dkreynolds@ntlworld.com>
  Dinakar T.D. <td.dinkar@gmail.com>
  Dinesh Kaushal<dineshkaushal@hotmail.com>
  Dipendra Manocha <d@saksham.org>
  Eric Yip
  Frédéric Schwebel
  Greg Kearney <gkearney@gmail.com>
  Henri Apperloo <h.apperloo@cbb.nl> from CBB <www.cbb.nl>
  International league of Blind Esperantists (LIBE) <libe.narzan.com>
  Igor B. Poretsky <poretsky@mlbox.ru>
  James Bowden <james.bowden@rnib.org.uk> from Royal National Institute of Blind People (RNIB)
  Jan Halousek <merit@login.cz> from MERIT
  Jan Hegr <hegrjan@gmail.com>
  Joseph Lee <joseph.lee22590@gmail.com>
  Jostein Austvik Jacobsen <josteinaj@gmail.com>
  José Enrique Fernández del Campo <jefdelcampo@gmail.com>
  Jožef Gregorc <jozko.gregorc@gmail.com>
  Juan Carlos Buño Suárez <quetzatl@eresmas.net>
  Jukka Eerikäinen <jukka.eerikainen@celia.fi> from Celia <www.celia.fi>
  Jürgen Dengo <jyrgen.dengo@gmail.com>
  Halim Sahin <halim.sahin@web.de>
  Hammer Attila <hammera@pickup.hu>, <hammer.attila@infoalap.hu> from IT Foundation for the Visually Impaired in Hungary
  Hans Schou <chlor@schou.dk>
  Harri Pasanen <harri@mpaja.com>
  Him Prasad Gautam
  Kaifang Bao baokaifang@gmail.com from RejoinTech
  Karol Pecyna <HarpoDeveloper@gmail.com> from Harpo <http://int.harpo.com.pl>
  Keny Yuen
  KM Yuen
  Knut Arne Bjørndal <bob+liblouis@cakebox.net>
  Lars Bjørndal <lars@handytech.no>, <lars@lamasti.net>
  Leon Ungier <Leon.Ungier@ViewPlus.com> from ViewPlus Technologies, Inc. <www.viewplus.com>
  Leona Holloway <Leona.Holloway@visionaustralia.org> from Vision Australia
  Mateja Jenčič
  Michel Such <michel.such@free.fr>
  Mike Sivill <mike.sivill@viewplustechnologies.com> from ViewPlus Technologies, Inc.
  Mohammed R. Ramadan <mramadan@nattiq.com>
  Monk Jeremiah from Visoki Dečani <visokidecani@gmail.com>
  Neil Soiffer <NeilS@dessci.com>
  Nicolas Pitre <nico@cam.org>
  Nicolai Svendsen <chojiro1990@gmail.com>
  Patrick Zajda
  Paul Wood <paulw.torchtrust@gmail.com>
  Peter Engström <peter.engstrom@indexbraille.com> from Index Braille
  Peter Vágner <pvdeejay@gmail.com>
  Rui Batista <ruiandrebatista@gmail.com>
  Rui Fontes <rui.fontes@tiflotecnia.com>
  Rumiana Kamenska <rkamenska@gmail.com>
  Samuel Thibault <samuel.thibault@ens-lyon.org>
  Sébastien Sablé <sable@users.sourceforge.net>
  Simone Dal Maso <simone.dalmaso@juvox.it>
  Sreeja Parameswaran <sreeja.param@gmail.com>
  Stefan Moisei <vortex37@gmail.com>
  Tamru E. Belay <tamru@sympatico.ca>, <g.braille@sympatico.ca> from Adaptive Technology Center for the Blind (ATCB)
  Tom Johnston <Tom.Johnston@accessibilityconsulting.co.uk>
  Tsengel Maidar tsengel@digitalsunngo.org
  Yuemei Sun from ViewPlus Technologies, Inc.
  Zvonimir Stanecic <zvonimirek222@yandex.com>
  <Aliminator83@gmail.com>
  <eric@integra-belgium.com>

LIBHNJ AUTHORS

Code was borrowed from the hyphenation library Libhnj.

  Raph Levien <raph@acm.org>

Hyphenation dictionaries were copied from OpenOffice.org.

OTHER CONTRIBUTORS

These are contributions not in the form of code or tables.

  John Gardner <john.gardner@viewplus.com> from ViewPlus Technologies, Inc. <www.viewplus.com>

Unknown contribution:

  Alastair Irving
