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:

  Bue Vester-Andersen <bue@vester-andersen.dk>
  Dave Mielke <dave@mielke.cc>
  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>
  Reiner Dolp <hallo@reinerdolp.com>

Patches were provided by:

  Arend Arends <arend.arends@hccnet.nl>
  Chris Brannon
  Jeremy Roman <jbroman@google.com>
  Ken Perry <kperry@aph.org>
  Martin Michlmayr <tbm@cyrius.com>
  Matt Wenn
  Mike Gorse
  Milan Zamazal <pdm@brailcom.org>
  Peter Nilsson Lundblad <plundblad@google.com>
  Simon Aittamaa, Index Braille <simon.aittamaa@indexbraille.com>
  Timothy Lee <timothy.ty.lee@gmail.com>
  Victor Montalvão vicmont@microsoft.com
  Vincent Untz <vuntz@gnome.org>
  Volker Bijewitz <v.bijewitz@baum.de>

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 AND TEST CONTRIBUTORS

  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 <dev@andreabc.net>
  Anthony Tibbs
  Artis Raugulis
  Ashoka Bandula Weerawardhana
  Birkir Gunnarsson <birkir@midstod.is>
  Brailcom, o.p.s. <technik@brailcom.cz>
  Branislav Mamojka <mamojka@unss.sk>
  Bue Vester-Andersen <bue@vester-andersen.dk>
  Bo-Cheng Jhan <school510587@yahoo.com.tw>
  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>
  Erez Kugler <erez@gaash.com> from TSR GAASH <www.tsr-gaash.co.il>
  Eric Yip
  Frédéric Schwebel
  Gatis Grintals
  Greg Kearney <gkearney@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>
  Henri Apperloo <h.apperloo@cbb.nl> from CBB <www.cbb.nl>
  Him Prasad Gautam
  Hurt Huang <hurt.nzsmr@gmail.com>
  Igor B. Poretsky <poretsky@mlbox.ru>
  Ikrami Ahmad <ikrami.ahmad@gmail.com>
  International league of Blind Esperantists (LIBE) <libe.narzan.com>
  Jake Kyle from Compass Braille <jake@compassbraille.org>
  James Datray from Freedom Scientific
  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>
  Juan Pablo Bello <juanpisjaws@gmail.com>
  Jukka Eerikäinen <jukka.eerikainen@celia.fi> from Celia <www.celia.fi>
  Jürgen Dengo <jyrgen.dengo@gmail.com>
  KM Yuen
  Kaifang Bao baokaifang@gmail.com from RejoinTech
  Karol Pecyna <HarpoDeveloper@gmail.com> from Harpo <http://int.harpo.com.pl>
  Keny Yuen
  Kevin Derome
  Knut Arne Bjørndal <bob+liblouis@cakebox.net>
  Lars Bjørndal <lars@handytech.no>, <lars@lamasti.net>
  Luis Lorente Barajas (ONCE-CIDAT)
  Leon Ungier <Leon.Ungier@ViewPlus.com> from ViewPlus Technologies, Inc. <www.viewplus.com>
  Leona Holloway <Leona.Holloway@visionaustralia.org> from Vision Australia
  Leonard de Ruijter from Babbage B.V. <www.babbage.com>
  Ludovic Oger <oger.ludovic@gmail.com>
  Łukasz Golonka <wulfryk1@gmail.com>
  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>
  Mohammadreza Rashad <mohammadreza5712@gmail.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 Rambags <paulrambags@dedicon.nl>
  Paul Wood <paulw.torchtrust@gmail.com>
  Peter Engström <peter.engstrom@indexbraille.com> from Index Braille
  Peter Vágner <pvdeejay@gmail.com>
  Rimas Kudelis <rq@akl.lt>
  Ronan McGuirk <ronan.p.mcguirk@gmail.com>
  Roshanson <736781877@qq.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>
  Sergiy Moskalets (www.trosti.com.ua)
  Simone Dal Maso <simone.dalmaso@juvox.it>
  Sreeja Parameswaran <sreeja.param@gmail.com>
  Stefan Moisei <vortex37@gmail.com>
  Sukil Etxenike <sukiletxe@yahoo.es>
  Sunian Loomee <ghito@qq.com>
  Tamru E. Belay <tamru@sympatico.ca>, <g.braille@sympatico.ca> from Adaptive Technology Center for the Blind (ATCB)
  Timothy Wynn
  Tom Johnston <Tom.Johnston@accessibilityconsulting.co.uk>
  Tsengel Maidar tsengel@digitalsunngo.org
  Uğur Gürbüz <ugur.gurbuz@brailleteknik.com>
  Yuemei Sun from ViewPlus Technologies, Inc.
  Zlatko Sobočan <zlatko.sobocan@tifloglobus.hr>
  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
