The following people have commit access to the Subversion sources.
Note that this is not a full list of Subversion's authors, however --
for that, you'd need to look over the log messages to see all the
patch contributors.

If you have a question or comment, it's probably best to mail
dev@subversion.tigris.org, rather than mailing any of these people
directly.

Blanket commit access:

          jimb   Jim Blandy <jimb@redhat.com>
       sussman   Ben Collins-Sussman <sussman@collab.net>
        kfogel   Karl Fogel <kfogel@collab.net>
        gstein   Greg Stein <gstein@lyra.org>
         brane   Branko Čibej <brane@xbc.nu>
           joe   Joe Orton <joe@light.plus.com>
       ghudson   Greg Hudson <ghudson@mit.edu>
          fitz   Brian W. Fitzpatrick <fitz@collab.net>
        daniel   Daniel Stenberg <daniel@haxx.se>
      cmpilato   C. Michael Pilato <cmpilato@collab.net>
         kevin   Kevin Pilch-Bisson <kevin@pilchie.homeip.net>
        philip   Philip Martin <philip@codematters.co.uk>
   jerenkrantz   Justin Erenkrantz <justin@erenkrantz.com>
        rooneg   Garrett Rooney <rooneg@electricjellyfish.net>
      bcollins   Ben Collins <bcollins@debian.org>
         blair   Blair Zajac <blair@orcaware.com>
       striker   Sander Striker <striker@apache.org>
         naked   Nuutti Kotivuori <naked@iki.fi>
       dwhedon   David Kimdon <dwhedon@debian.org>
           dlr   Daniel Rall <dlr@finemaltcoding.com>
         kraai   Matt Kraai <kraai@alumni.cmu.edu>
           mbk   Mark Benedetto King <mbk@lowlatency.com>
           epg   Eric Gillespie <epg@pretzelnet.org>
           jaa   Jani Averbach <jaa@iki.fi>
    julianfoad   Julian Foad <julianfoad@btopenworld.com>
     ringstrom   Tobias Ringström <tobias@ringstrom.mine.nu>
       jpieper   Josh Pieper <jpieper@andrew.cmu.edu>
  jszakmeister   John Szakmeister <john@szakmeister.net>
      dionisos   Erik Hülsmann <e.huelsmann@gmx.net>
        breser   Ben Reser <ben@reser.org>
           djh   D.J. Heap <dj@shadyvale.net>
          maxb   Max Bowsher <maxb@ukf.net>
      lundblad   Peter N. Lundblad <peter@famlundblad.se>
       dberlin   Daniel Berlin <dberlin@dberlin.org>

Commit access for specific areas:

  Bindings:

       pmayweg   Patrick Mayweg <mayweg@qint.de>             (JavaHL bindings)
          rey4   Russell Yanofsky <rey4@columbia.edu>        (Swig bindings)
         clkao   Chia-liang Kao <clkao@clkao.org>            (Swig-Perl b.)
           kou   Kouhei Sutou <kou@cozmixng.org>             (Swig-Ruby b.)
        djames   David James <james@cs.toronto.edu>          (Swig-Ruby b.)

  Packages:

         david   David Summers <david@summersoft.fay.ar.us>  (RPMs)

  Miscellaneous:

      kbohling   Kirby C. Bohling <kbohling@birddog.com>     (tools/dev)
           nsd   Nick Duffek <nick@duffek.com>               (doc)
        xsteve   Stefan Reichör <stefan@xsteve.at>           (psvn.el)
      josander   Jostein Andersen <jostein@josander.net>     (various)
      niemeyer   Gustavo Niemeyer <niemeyer@conectiva.com>   (svnperms.py)
        zbrown   Zack Brown <zbrown@tumblerings.org>         (doc)
        mprice   Michael Price <mprice@atl.lmco.com>         (releases)
           pll   Paul lussier <p.lussier@comcast.net>        (releases)
           kon   Kalle Olavi Niemitalo <kon@iki.fi>          (psvn.el)
    jrepenning   Jack Repenning <jrepenning@collab.net>      (tools/dev)
      lonestar   Martin Maurer <martin.maurer@email.de>      (svnshow)
       shlomif   Shlomi Fish <shlomif@vipe.technion.ac.il>   (svn-push)
       mthelen   Michael W Thelen <mike@pietdepsi.com>       (doc)
  jeremybettis   Jeremy Bettis <jeremy@deadbeef.com>         (chk-case-insens)
      martinto   Martin Tomes <lists@tomes.org>              (chk-case-insens)
        danpat   Daniel Patterson <danpat@danpat.net>        (svn-graph.pl)
   archiecobbs   Archie Cobbs <archie@awarix.com>            (svnmerge)
        offby1   Eric Hanchrow <offby1@blarg.net>            (doc)
       nomis80   Simon Perreault <nomis80@nomis80.org>       (svn-clean)

  Translation:

       fmatias   Féliciano Matias <feliciano.matias@free.fr> (doc: fr)
      dimentiy   Dmitriy O. Popkov <dimentiy@dimentiy.info>  (doc: ru)
       niqueco   Nicolás Lichtmaier <nick@reloco.com.ar>     (po: es)
        luebbe   Lübbe Onken <luebbe@tigris.org>             (po: de)
    khmarbaise   Karl Heinz Marbaise <khmarbaise@gmx.de>     (doc: de)
      oyvindmo   Øyvind Møll <svn@moll.no>                   (doc, po: nb)
      sunny256   Øyvind A. Holm <sunny@sunbase.org>          (doc, po: nb)
          nori   KOBAYASHI Noritada <nori1@dolphin.c.u-tokyo.ac.jp> (po: ja)
        jzgoda   Jaroslaw Zgoda <jzgoda@o2.pl>               (po: pl)
      karolszk   Karol Szkudlarek <karol@mikronika.com.pl>   (po: pl)
        plasma   Wei-Hon Chen <plasma@ms9.hinet.net>         (po: zh_TW)
       jihuang   June-Yen Huang <jihuang@iis.sinica.edu.tw>  (po: zh_TW)
       marcosc   Marcos Chaves <mchvs@hotmail.com>           (po: pt_BR)
        pynoos   Hojin Choi <hojin.choi@gmail.com>           (po: ko)
       blueboh   Jeong Seolin <blueboh@ahnlab.com>           (po: ko)
        hynnet   YingNing Huang <hyn@bao.hynnet.com>         (po: zh_CN)
          lark   Wang Jian <lark@linux.net.cn>               (po: zh_CN)
     beerfrick   Ariel Arjona <beerfrick@gmail.com>          (doc: es)
        gradha   Grzegorz A. Hankiewicz <gradha@titanium.sabren.com> (doc: es)
         ruben   Rubén Gómez <rugoli@euskalnet.net>          (doc: es)
      dbrouard   Diego Brouard <dbrouard@gmail.com>          (doc: es)
  gerhardoettl   Gerhard Oettl <gerhard.oettl.ml@oesoft.at>  (doc: de)
giorgio_valoti   Giorgio Valoti <giorgio_v@mac.com>          (po: it)
        nebiac   Federico Nebiacolombo <cint1@amsjv.it>      (po: it)
        fabien   Fabien Coelho <fabien@coelho.net>           (po: fr)
       marcelg   Marcel Gosselin <marcel.gosselin@polymtl.ca> (po: fr)

  Experimental branches:

     gthompson   Glenn A. Thompson <gthompson@cdr.net>       (pluggable-db br.)
       sigfred   Sigfred Håversen <bsdlist@mumak.com>        (svnserve-ssl br.)
        pmarek   Ph. Marek <philipp.marek@bmlv.gv.at>        (meta-data-v br.)
      markphip   Mark Phippard <MarkP@softlanding.com>       (ebcdic)
        pburba   Paul Burba <PaulB@softlanding.com>          (ebcdic)

  Subprojects that are complete or abandoned:

          xela   Alexander Müller <alex@littleblue.de>       (Java JNI b.)
       yoshiki   Yoshiki Hayashi <yoshiki@xemacs.org>        (Non-SWIG Ruby b.)
        mmacek   Marko Maček <Marko.Macek@gmx.net>           (cvs2svn branch)
          mass   David Waite <mass@akuma.org>                (certs branch)
      sergeyli   Sergey A. Lipnevich <sergey@optimaltec.com> (neon-0.24 port)
      ballbach   Michael Ballbach <ballbach@rten.net>        (Old Mandrake RPM)
        morten   Morten Ludvigsen <morten@2ps.dk>            (Swig-Java b.)
      jespersm   Jesper Steen Møller <jesper@selskabet.org>  (Swig-Java b.)
        knacke   Kai Nacke <kai.nacke@redstar.de>            (Swig-Java b.)

Committers who have asked to be listed as dormant:

        bdenny   Brian Denny <brian@briandenny.net>
      rassilon   Bill Tutt <rassilon@lyra.org> (Win32, COM, issue-1003-dev br.)

## Local Variables:
## coding:utf-8
## End:
## vim:encoding=utf8
