SYNCTHING-FAQ(7)                   Syncthing                  SYNCTHING-FAQ(7)



NNAAMMEE
       syncthing-faq - Frequently Asked Questions

       · _G_e_n_e_r_a_l

         · _W_h_a_t _i_s _S_y_n_c_t_h_i_n_g_?

         · _I_s _i_t _â_s_y_n_c_t_h_i_n_g_â_, _â_S_y_n_c_t_h_i_n_g_â _o_r _â_S_y_n_c_T_h_i_n_g_â_?

         · _W_h_a_t _t_h_i_n_g_s _a_r_e _s_y_n_c_e_d_?

         · _I_s _s_y_n_c_h_r_o_n_i_z_a_t_i_o_n _f_a_s_t_?

         · _H_o_w _d_o_e_s _S_y_n_c_t_h_i_n_g _d_i_f_f_e_r _f_r_o_m _B_i_t_T_o_r_r_e_n_t_/_R_e_s_i_l_i_o _S_y_n_c_?

         · _I_s _t_h_e_r_e _a_n _i_O_S _c_l_i_e_n_t_?

         · _S_h_o_u_l_d _I _k_e_e_p _m_y _d_e_v_i_c_e _I_D_s _s_e_c_r_e_t_?

       · _T_r_o_u_b_l_e_s_h_o_o_t_i_n_g

         · _W_h_e_r_e _a_r_e _t_h_e _S_y_n_c_t_h_i_n_g _l_o_g_s_?

         · _W_h_y _i_s _t_h_e _s_y_n_c _s_o _s_l_o_w_?

         · _W_h_y _d_o_e_s _i_t _u_s_e _s_o _m_u_c_h _C_P_U_?

         · _W_h_y _i_s _t_h_e _s_e_t_u_p _m_o_r_e _c_o_m_p_l_i_c_a_t_e_d _t_h_a_n _B_i_t_T_o_r_r_e_n_t_/_R_e_s_i_l_i_o _S_y_n_c_?

         · _W_h_y _d_o _I _g_e_t _â_H_o_s_t _c_h_e_c_k _e_r_r_o_r_â _i_n _t_h_e _G_U_I_/_A_P_I_?

         · _M_y _S_y_n_c_t_h_i_n_g _d_a_t_a_b_a_s_e _i_s _c_o_r_r_u_p_t

         · _W_h_y _d_o _I _s_e_e _S_y_n_c_t_h_i_n_g _t_w_i_c_e _i_n _t_a_s_k _m_a_n_a_g_e_r_?

         · _H_o_w _c_a_n _I _v_i_e_w _t_h_e _h_i_s_t_o_r_y _o_f _c_h_a_n_g_e_s_?

         · _D_o_e_s _t_h_e _a_u_d_i_t _l_o_g _c_o_n_t_a_i_n _e_v_e_r_y _c_h_a_n_g_e_?

         · _W_h_y _d_o_e_s _S_y_n_c_t_h_i_n_g _c_o_n_n_e_c_t _t_o _t_h_i_s _u_n_k_n_o_w_n_/_s_u_s_p_i_c_i_o_u_s _a_d_d_r_e_s_s_?

       · _U_s_a_g_e

         · _W_h_a_t _i_f _t_h_e_r_e _i_s _a _c_o_n_f_l_i_c_t_?

         · _H_o_w _d_o _I _s_e_r_v_e _a _f_o_l_d_e_r _f_r_o_m _a _r_e_a_d _o_n_l_y _f_i_l_e_s_y_s_t_e_m_?

         · _I _r_e_a_l_l_y _h_a_t_e _t_h_e _._s_t_f_o_l_d_e_r _d_i_r_e_c_t_o_r_y_, _c_a_n _I _r_e_m_o_v_e _i_t_?

         · _A_m _I _a_b_l_e _t_o _n_e_s_t _s_h_a_r_e_d _f_o_l_d_e_r_s _i_n _S_y_n_c_t_h_i_n_g_?

         · _H_o_w _d_o _I _r_e_n_a_m_e_/_m_o_v_e _a _s_y_n_c_e_d _f_o_l_d_e_r_?

         · _H_o_w _d_o _I _c_o_n_f_i_g_u_r_e _m_u_l_t_i_p_l_e _u_s_e_r_s _o_n _a _s_i_n_g_l_e _m_a_c_h_i_n_e_?

         · _D_o_e_s _S_y_n_c_t_h_i_n_g _s_u_p_p_o_r_t _s_y_n_c_i_n_g _b_e_t_w_e_e_n _f_o_l_d_e_r_s _o_n _t_h_e _s_a_m_e _s_y_s_t_e_m_?

         · _W_h_e_n _I _d_o _h_a_v_e _t_w_o _d_i_s_t_i_n_c_t _S_y_n_c_t_h_i_n_g_-_m_a_n_a_g_e_d _f_o_l_d_e_r_s _o_n _t_w_o _h_o_s_t_s_,
           _h_o_w _d_o_e_s _S_y_n_c_t_h_i_n_g _h_a_n_d_l_e _m_o_v_i_n_g _f_i_l_e_s _b_e_t_w_e_e_n _t_h_e_m_?

         · _C_a_n _I _h_e_l_p _i_n_i_t_i_a_l _s_y_n_c _b_y _c_o_p_y_i_n_g _f_i_l_e_s _m_a_n_u_a_l_l_y_?

         · _I_s _S_y_n_c_t_h_i_n_g _m_y _i_d_e_a_l _b_a_c_k_u_p _a_p_p_l_i_c_a_t_i_o_n_?

         · _H_o_w _c_a_n _I _e_x_c_l_u_d_e _f_i_l_e_s _w_i_t_h _b_r_a_c_k_e_t_s _(_[_]_) _i_n _t_h_e _n_a_m_e_?

         · _H_o_w _d_o _I _a_c_c_e_s_s _t_h_e _w_e_b _G_U_I _f_r_o_m _a_n_o_t_h_e_r _c_o_m_p_u_t_e_r_?

         · _I _d_o_n_â_t _l_i_k_e _t_h_e _G_U_I _o_r _t_h_e _t_h_e_m_e_. _C_a_n _i_t _b_e _c_h_a_n_g_e_d_?

         · _H_o_w _d_o _I _u_p_g_r_a_d_e _S_y_n_c_t_h_i_n_g_?

         · _W_h_e_r_e _d_o _I _f_i_n_d _t_h_e _l_a_t_e_s_t _r_e_l_e_a_s_e_?

         · _H_o_w _d_o _I _r_u_n _S_y_n_c_t_h_i_n_g _a_s _a _d_a_e_m_o_n _p_r_o_c_e_s_s _o_n _L_i_n_u_x_?

         · _H_o_w _d_o _I _i_n_c_r_e_a_s_e _t_h_e _i_n_o_t_i_f_y _l_i_m_i_t _t_o _g_e_t _m_y _f_i_l_e_s_y_s_t_e_m _w_a_t_c_h_e_r _t_o
           _w_o_r_k_?

         · _H_o_w _d_o _I _r_e_s_e_t _t_h_e _G_U_I _p_a_s_s_w_o_r_d_?

GGEENNEERRAALL
   WWhhaatt iiss SSyynncctthhiinngg??
       Syncthing is an application that lets you synchronize your files across
       multiple devices. This means the creation, modification or deletion  of
       files  on  one  machine  will automatically be replicated to your other
       devices. We believe your data is your data alone  and  you  deserve  to
       choose  where  it  is  stored. Therefore Syncthing does not upload your
       data to the cloud but exchanges your data across your machines as  soon
       as they are online at the same time.

   IIss iitt ââssyynncctthhiinnggââ,, ââSSyynncctthhiinnggââ oorr ââSSyynnccTThhiinnggââ??
       Itâs  SSyynncctthhiinngg,  although the command and source repository is spelled
       ssyynncctthhiinngg so it may be referred to in that way as well. Itâs definitely
       not  SyncThing, even though the abbreviation sstt is used in some circum‐
       stances and file names.

   WWhhaatt tthhiinnggss aarree ssyynncceedd??
       The following things are _a_l_w_a_y_s synchronized:

       · File contents

       · File modification times

       The following may be synchronized or not, depending:

       · File permissions (when supported by file system; on Windows only  the
         read only bit is synchronized)

       · Symbolic links (synced, except on Windows, but never followed)

       The following are _n_o_t synchronized;

       · File or directory owners and Groups (not preserved)

       · Directory modification times (not preserved)

       · Hard links (followed, not preserved)

       · Windows  junctions  (synced as ordinary directories; require enabling
         in tthhee ccoonnffiigguurraattiioonn on a per-folder basis)

       · Extended attributes, resource forks (not preserved)

       · Windows, POSIX or NFS ACLs (not preserved)

       · Devices, FIFOs, and other specials (ignored)

       · Sparse file sparseness (will become sparse, when supported by the  OS
         & filesystem)

   IIss ssyynncchhrroonniizzaattiioonn ffaasstt??
       Syncthing  segments  files into pieces, called blocks, to transfer data
       from one device to another. Therefore, multiple devices can  share  the
       synchronization  load,  in  a  similar way to the torrent protocol. The
       more devices you have online, the  faster  an  additional  device  will
       receive  the data because small blocks will be fetched from all devices
       in parallel.

       Syncthing handles renaming files and  updating  their  metadata  in  an
       efficient  manner.  This  means  that  renaming a file will not cause a
       retransmission of that file. Additionally, appending data  to  existing
       files should be handled efficiently as well.

       Temporary  files  are  used to store partial data downloaded from other
       devices. They are automatically removed whenever a  file  transfer  has
       been  completed  or after the configured amount of time which is set in
       the configuration file (24 hours by default).

   HHooww ddooeess SSyynncctthhiinngg ddiiffffeerr ffrroomm BBiittTToorrrreenntt//RReessiilliioo SSyynncc??
       The two are different and not related. Syncthing and BitTorrent/Resilio
       Sync  accomplish  some of the same things, namely syncing files between
       two or more computers.

       BitTorrent Sync, now called Resilio Sync, is a proprietary peer-to-peer
       file  synchronization  tool available for Windows, Mac, Linux, Android,
       iOS, Windows Phone, Amazon Kindle Fire and BSD.  [1]  Syncthing  is  an
       open source file synchronization tool.

       Syncthing  uses an open and documented protocol, and likewise the secu‐
       rity mechanisms in use are well defined and visible in the source code.
       Resilio  Sync  uses an undocumented, closed protocol with unknown secu‐
       rity properties.

       [1]  _h_t_t_p_s_:_/_/_e_n_._w_i_k_i_p_e_d_i_a_._o_r_g_/_w_i_k_i_/_R_e_s_i_l_i_o___S_y_n_c

   IIss tthheerree aann iiOOSS cclliieenntt??
       There are no plans by the current Syncthing team to officially  support
       iOS in the foreseeable future.

       iOS  has significant restrictions on background processing that make it
       very hard to run Syncthing reliably and integrate it into the system.

       However, there is a commercial packaging  of  Syncthing  for  iOS  that
       attempts to work within these limitations. [2]

       [2]  _h_t_t_p_s_:_/_/_w_w_w_._m_o_b_i_u_s_s_y_n_c_._c_o_m

   SShhoouulldd II kkeeeepp mmyy ddeevviiccee IIDDss sseeccrreett??
       No.  The IDs are not sensitive. Given a device ID itâs possible to find
       the IP address for that device, if global discovery is enabled  on  it.
       Knowing  the device ID doesnât help you actually establish a connection
       to that device or get a list of files, etc.

       For a connection to be established, both devices need to know about the
       otherâs  device  ID.  Itâs not possible (in practice) to forge a device
       ID. (To forge a device ID you need to create  a  TLS  certificate  with
       that  specific SHA-256 hash.  If you can do that, you can spoof any TLS
       certificate. The world is your oyster!)

       SSEEEE AALLSSOO::
          device-ids

TTRROOUUBBLLEESSHHOOOOTTIINNGG
   WWhheerree aarree tthhee SSyynncctthhiinngg llooggss??
       Syncthing logs to stdout by default. On Windows  Syncthing  by  default
       also creates ssyynncctthhiinngg..lloogg in Syncthingâs home directory (run ssyynncctthhiinngg
       ----ppaatthhss to see where that is). The command line option ----llooggffiillee can be
       used to specify a user-defined logfile.

       If  youâre  running  a  process  manager  like systemd, check there. If
       youâre using a GUI wrapper integration, it may keep the logs for you.

   WWhhyy iiss tthhee ssyynncc ssoo ssllooww??
       When troubleshooting a slow sync, there  are  a  number  of  things  to
       check.

       First  of  all,  verify  that you are not connected via a relay. In the
       âRemote Devicesâ list on the right side of the GUI, double  check  that
       you  see  âAddress:  <some  address>â  and _n_o_t âRelay: <some address>â.
       [image]

       If you are connected via a relay, this is because a  direct  connection
       could  not  be  established. Double check and follow the suggestions in
       firewall-setup to enable direct connections.

       Second, if one of the devices is a very low powered  machine  (a  Rasp‐
       berry  Pi, or a phone, or a NAS, or similar) you are likely constrained
       by the CPU on that device. See the next question for reasons  Syncthing
       likes a faster CPU.

       Third, verify that the network connection is OK. Tools such as iperf or
       just an Internet speed test can be used to verify the performance here.

   WWhhyy ddooeess iitt uussee ssoo mmuucchh CCPPUU??
       1. When new or changed files are detected, or Syncthing starts for  the
          first time, your files are hashed using SHA-256.

       2. Data  that  is  sent over the network is compressed (optionally) and
          encrypted (always). When receiving data it  must  be  decrypted  and
          then (if compressed) decompressed.

       3. There is a certain amount of housekeeping that must be done to track
          the current and available versions of each file in the  index  data‐
          base.

       4. By default Syncthing uses periodic scanning every hour when watching
          for changes or every  minute  if  thatâs  disabled  to  detect  file
          changes. This means checking every fileâs modification time and com‐
          paring it to the database. This can cause spikes of  CPU  usage  for
          large folders.

       Hashing,  compression and encryption cost CPU time. Also, using the GUI
       causes a certain amount of extra CPU usage  to  calculate  the  summary
       data  it  presents. Note however that once things are _i_n _s_y_n_c CPU usage
       should be negligible.

       To minimize the impact of this, Syncthing attempts to lloowweerr tthhee pprroocceessss
       pprriioorriittyy when starting up.

       To  further limit the amount of CPU used when syncing and scanning, set
       the environment variable GGOOMMAAXXPPRROOCCSS to the maximum number of CPU  cores
       Syncthing  should use at any given moment. For example, GGOOMMAAXXPPRROOCCSS==22 on
       a machine with four cores will limit Syncthing to no more than half the
       systemâs CPU power.

   WWhhyy iiss tthhee sseettuupp mmoorree ccoommpplliiccaatteedd tthhaann BBiittTToorrrreenntt//RReessiilliioo SSyynncc??
       Security over convenience. In Syncthing you have to setup both sides to
       connect two devices. An attacker canât do much with a stolen device ID,
       because you have to add the device on the other side too. You have bet‐
       ter control where your files are transferred.

       This is an area that we are working to improve in the long term.

   WWhhyy ddoo II ggeett ââHHoosstt cchheecckk eerrrroorrââ iinn tthhee GGUUII//AAPPII??
       Since version 0.14.6 Syncthing does an extra security  check  when  the
       GUI/API  is  bound to localhost - namely that the browser is talking to
       localhost.  This protects against most forms of  _D_N_S  _r_e_b_i_n_d_i_n_g  _a_t_t_a_c_k
       <hhttttppss::////eenn..wwiikkiippeeddiiaa..oorrgg//wwiikkii//DDNNSS__rreebbiinnddiinngg> against the GUI.

       To  pass  this test, ensure that you are accessing the GUI using an URL
       that begins with hhttttpp::////llooccaallhhoosstt,  hhttttpp::////112277..00..00..11  or  hhttttpp::////[[::::11]].
       HTTPS is fine too, of course.

       If  you are using a proxy in front of Syncthing you may need to disable
       this check, after ensuring that the proxy provides sufficient authenti‐
       cation to protect against unauthorized access. Either:

       · Make sure the proxy sets a HHoosstt header containing llooccaallhhoosstt, or

       · Set gguuii..iinnsseeccuurreeSSkkiippHHoossttcchheecckk in the advanced settings, or

       · Bind the GUI/API to a non-localhost listen port.

       In  all  cases,  username/password  authentication  and HTTPS should be
       used.

   MMyy SSyynncctthhiinngg ddaattaabbaassee iiss ccoorrrruupptt
       This is almost always a result of bad  RAM,  storage  device  or  other
       hardware.   When  the  index  database is found to be corrupt Syncthing
       cannot operate and will note this in the logs  and  exit.  To  overcome
       this  delete the _d_a_t_a_b_a_s_e _f_o_l_d_e_r <hhttttppss::////ddooccss..ssyynncctthhiinngg..nneett//uusseerrss//ccoonn‐‐
       ffiigg..hhttmmll##ddeessccrriippttiioonn> inside Syncthingâs home  directory  and  re-start
       Syncthing. It will then need to perform a full re-hashing of all shared
       folders. You should check your system in case the underlying  cause  is
       indeed faulty hardware which may put the system at risk of further data
       loss.

   WWhhyy ddoo II sseeee SSyynncctthhiinngg ttwwiiccee iinn ttaasskk mmaannaaggeerr??
       One process manages the other, to capture  logs  and  manage  restarts.
       This  makes  it easier to handle upgrades from within Syncthing itself,
       and also ensures that we get a nice log file to help us narrow down the
       cause for crashes and other bugs.

   HHooww ccaann II vviieeww tthhee hhiissttoorryy ooff cchhaannggeess??
       The  web  GUI  contains  a  RReecceenntt CChhaannggeess button under the device list
       which displays changes since the last (re)start of Syncthing. With  the
       ----aauuddiitt option you can enable a persistent, detailed log of changes and
       most activities, which contains a JJSSOONN formatted  sequence of events in
       the ~~//..ccoonnffiigg//ssyynncctthhiinngg//aauuddiitt--__ddaattee__--__ttiimmee__..lloogg file.

   DDooeess tthhee aauuddiitt lloogg ccoonnttaaiinn eevveerryy cchhaannggee??
       The  audit  log  (and  the RReecceenntt CChhaannggeess window) sees the changes that
       your Syncthing sees. When Syncthing is continuously connected  it  usu‐
       ally  sees every change happening immediately and thus knows which node
       initiated the change.  When topology gets complex  or  when  your  node
       reconnects  after  some  time  offline, Syncthing synchronises with its
       neighbours: It gets the latest synchronised state from  the  neighbour,
       which  is  the  _r_e_s_u_l_t  of all the changes between the last known state
       (before disconnect or network delay)  and  the  current  state  at  the
       neighbour,  and  if  there  were  updates, deletes, creates, conflicts,
       which were overlapping we only see the _l_a_t_e_s_t _c_h_a_n_g_e for a  given  file
       or  directory (and the node where that latest change occurred). When we
       connect to multiple neighbours Syncthing decides  which  neighbour  has
       the  latest  state, or if the states conflict it initiates the conflict
       resolution  procedure,  which  in  the  end  results  in  a  consistent
       up-to-date state with all the neighbours.

   WWhhyy ddooeess SSyynncctthhiinngg ccoonnnneecctt ttoo tthhiiss uunnkknnoowwnn//ssuussppiicciioouuss aaddddrreessss??
       If  you  see outgoing connections to odd and unexpected addresses these
       are most likely connections to relay servers. Relay servers are run  by
       volunteers  all  over  the  world.  They usually listen on ports 443 or
       22067, though this is controlled by the user running it. You  can  com‐
       pare  the  address  you  are  concernced about with _t_h_e _c_u_r_r_e_n_t _l_i_s_t _o_f
       _a_c_t_i_v_e _r_e_l_a_y_s <hhttttppss::////rreellaayyss..ssyynncctthhiinngg..nneett>. Relays do not and can not
       see the data transmitted via them.

UUSSAAGGEE
   WWhhaatt iiff tthheerree iiss aa ccoonnfflliicctt??
       SSEEEE AALLSSOO::
          conflict-handling

   HHooww ddoo II sseerrvvee aa ffoollddeerr ffrroomm aa rreeaadd oonnllyy ffiilleessyysstteemm??
       Syncthing  requires  a  âfolder  markerâ to indicate that the folder is
       present and healthy. By default this is a  directory  called  ..ssttffoollddeerr
       that  is  created by Syncthing when the folder is added. If this folder
       canât be created (you are serving files from a CD or something) you can
       instead set the advanced config MMaarrkkeerr NNaammee to the name of some file or
       folder that you know will always exist in the folder.

   II rreeaallllyy hhaattee tthhee ..ssttffoollddeerr ddiirreeccttoorryy,, ccaann II rreemmoovvee iitt??
       See the previous question.

   AAmm II aabbllee ttoo nneesstt sshhaarreedd ffoollddeerrss iinn SSyynncctthhiinngg??
       Sharing a folder that is within an already shared folder  is  possible,
       but  it  has  its  caveats. What you must absolutely avoid are circular
       shares. This is just one example, there may be other undesired effects.
       Nesting  shared folders is not supported, recommended or coded for, but
       it can be done successfully when you know what youâre doing - you  have
       been warned.

   HHooww ddoo II rreennaammee//mmoovvee aa ssyynncceedd ffoollddeerr??
       Syncthing  doesnât  have  a  direct way to do this, as itâs potentially
       dangerous to do so if youâre not careful - it may result in  data  loss
       if  something  goes  wrong  during the move and is synchronized to your
       other devices.

       The easy way to rename or move a synced folder on the local  system  is
       to  remove the folder in the Syncthing UI, move it on disk, then re-add
       it using the new path.

       Itâs important to do this when the folder is already  in  sync  between
       your devices, as it is otherwise unpredictable which changes will âwinâ
       after the move. Changes made on other devices may  be  overwritten,  or
       changes made locally may be overwritten by those on other devices.

       An  alternative  way is to shut down Syncthing, move the folder on disk
       (including the ..ssttffoollddeerr marker), edit the path directly in  ccoonnffiigg..xxmmll
       in  the  configuration  folder (see /users/config) and then start Sync‐
       thing again.

   HHooww ddoo II ccoonnffiigguurree mmuullttiippllee uusseerrss oonn aa ssiinnggllee mmaacchhiinnee??
       Each user should run their own Syncthing instance. Be  aware  that  you
       might  need  to configure listening ports such that they do not overlap
       (see /users/config).

   DDooeess SSyynncctthhiinngg ssuuppppoorrtt ssyynncciinngg bbeettwweeeenn ffoollddeerrss oonn tthhee ssaammee ssyysstteemm??
       No. Syncthing is not designed to sync locally and the overhead involved
       in  doing so using Syncthingâs method would be wasteful. There are bet‐
       ter programs to achieve this such as  _r_s_y_n_c  <hhttttppss::////rrssyynncc..ssaammbbaa..oorrgg//>
       or _U_n_i_s_o_n <hhttttppss::////wwwwww..cciiss..uuppeennnn..eedduu//~~bbccppiieerrccee//uunniissoonn>.

   WWhheenn  II  ddoo  hhaavvee  ttwwoo ddiissttiinncctt SSyynncctthhiinngg--mmaannaaggeedd ffoollddeerrss oonn ttwwoo hhoossttss,, hhooww
       ddooeess SSyynncctthhiinngg hhaannddllee mmoovviinngg ffiilleess bbeettwweeeenn tthheemm??
       Syncthing does not specially handle this case, and most files will most
       likely get re-downloaded.

       In  detail, the behavior depends on the scan order. If you have folders
       A and B, and move files from A to B, if A gets scanned first,  it  will
       announce  the  removal  of the files to others who will then remove the
       files. As you rescan B, B will announce the addition of new files,  and
       other  peers will have nowhere to get them from apart from re-download‐
       ing them.

       If B gets rescanned first, B will announce additions first, and  remote
       peers  will  then  reconstruct the files (not rename, more like copying
       block by block) from A, and then as A gets rescanned,  it  will  remove
       the files from A.

       A  workaround  would be to copy first from A to B, rescan B, wait for B
       to copy the files on the remote side, and then delete from A.

   CCaann II hheellpp iinniittiiaall ssyynncc bbyy ccooppyyiinngg ffiilleess mmaannuuaallllyy??
       If you have a large folder that  you  want  to  keep  in  sync  over  a
       not-so-fast  network, and you have the possibility to move all files to
       the remote device in a faster manner, here is a procedure to follow:

       · Create the folder on the local device, but donât share  it  with  the
         remote device yet.

       · Copy the files from the local device to the remote device using regu‐
         lar file copy. If this takes a long time (perhaps  requiring  travel‐
         ling  there  physically), it may be a good idea to make sure that the
         files on the local device are not updated while you are doing this.

       · Create the folder on the remote device, and copy the Folder  ID  from
         the  folder on the local device, as we want the folders to be consid‐
         ered the same. Then wait until scanning the folder is done.

       · Now share the folder with the other device, on both sides.  Syncthing
         will  exchange  file information, updating the database, but existing
         files will not be transferred. This may still take a while initially,
         be patient and wait until it settled.

   IIss SSyynncctthhiinngg mmyy iiddeeaall bbaacckkuupp aapppplliiccaattiioonn??
       No.  Syncthing is not a great backup application because all changes to
       your files (modifications, deletions, etc.) will be propagated  to  all
       your  devices.  You  can enable versioning, but we encourage you to use
       other tools to keep your data safe from your (or our) mistakes.

   HHooww ccaann II eexxcclluuddee ffiilleess wwiitthh bbrraacckkeettss (([[]])) iinn tthhee nnaammee??
       The patterns in .stignore are glob patterns, where brackets are used to
       denote  character  ranges.  That is, the pattern qq[[aabbcc]]xx will match the
       files qqaaxx, qqbbxx and qqccxx.

       To match an actual file _c_a_l_l_e_d qq[[aabbcc]]xx the pattern  needs  to  âescapeâ
       the brackets, like so: qq\\[[aabbcc\\]]xx.

       On Windows, escaping special characters is not supported as the \\ char‐
       acter is used as a path separator.

   HHooww ddoo II aacccceessss tthhee wweebb GGUUII ffrroomm aannootthheerr ccoommppuutteerr??
       The default listening address is 127.0.0.1:8384, so you can only access
       the  GUI from the same machine. This is for security reasons. To access
       the web GUI from  another  computer,  change  the  GGUUII  lliisstteenn  aaddddrreessss
       through  the  web  UI from 112277..00..00..11::88338844 to 00..00..00..00::88338844 or change the
       config.xml:

          <gui enabled="true" tls="false">
            <address>127.0.0.1:8384</address>

       to

          <gui enabled="true" tls="false">
            <address>0.0.0.0:8384</address>

       Then the GUI is accessible from everywhere. You should set  a  password
       and  enable  HTTPS with this configuration. You can do this from inside
       the GUI.

       If both your computers are Unix-like (Linux, Mac, etc.)  you  can  also
       leave the GUI settings at default and use an ssh port forward to access
       it. For example,

          $ ssh -L 9090:127.0.0.1:8384 user@othercomputer.example.com

       will log you into othercomputer.example.com,  and  present  the  _r_e_m_o_t_e
       Syncthing GUI on _h_t_t_p_:_/_/_l_o_c_a_l_h_o_s_t_:_9_0_9_0 on your _l_o_c_a_l computer.

       If  you  only want to access the remote gui and donât want the terminal
       session, use this example,

          $ ssh -N -L 9090:127.0.0.1:8384 user@othercomputer.example.com

       If only your remote computer is Unix-like, you can still access it with
       ssh from Windows.

       Under  Windows  10 or later (64-bit only) you can use the same ssh com‐
       mand if you install the _W_i_n_d_o_w_s _S_u_b_s_y_s_t_e_m _f_o_r  _L_i_n_u_x  <hhttttppss::////ddooccss..mmii‐‐
       ccrroossoofftt..ccoomm//wwiinnddoowwss//wwssll//iinnssttaallll>.

       Another  Windows  way  to  run  ssh  is to install _g_o_w _(_G_n_u _O_n _W_i_n_d_o_w_s_)
       <hhttttppss::////ggiitthhuubb..ccoomm//bbmmaattzzeellllee//ggooww>. The easiest way to install  gow  is
       with the _c_h_o_c_o_l_a_t_e_y <hhttttppss::////cchhooccoollaatteeyy..oorrgg//> package manager.

   II ddoonnââtt lliikkee tthhee GGUUII oorr tthhee tthheemmee.. CCaann iitt bbee cchhaannggeedd??
       You  can  change  the theme in the settings. Syncthing ships with other
       themes than the default.

       If you want a custom theme or a completely different GUI, you  can  add
       your  own.   By default, Syncthing will look for a directory gguuii inside
       the Syncthing home folder. To change the directory to look for  themes,
       you  need  to set the STGUIASSETS environment variable. To get the con‐
       crete directory, run syncthing with  the  ----ppaatthhss  parameter.  It  will
       print all the relevant paths, including the âGUI override directoryâ.

       To    add    e.g.    a   red   theme,   you   can   create   the   file
       rreedd//aasssseettss//ccssss//tthheemmee..ccssss inside the GUI override directory to  override
       the default CSS styles.

       To   create  a  whole  new  GUI,  you  should  checkout  the  files  at
       _h_t_t_p_s_:_/_/_g_i_t_h_u_b_._c_o_m_/_s_y_n_c_t_h_i_n_g_/_s_y_n_c_t_h_i_n_g_/_t_r_e_e_/_m_a_i_n_/_g_u_i_/_d_e_f_a_u_l_t to get  an
       idea how to do that.

   HHooww ddoo II uuppggrraaddee SSyynncctthhiinngg??
       If  you  use  a  package  manager  such as Debianâs apt-get, you should
       upgrade using the package manager.  If  you  use  the  binary  packages
       linked  from  Syncthing.net, you can use Syncthingâs built-in automatic
       upgrade functionality.

       · If automatic upgrades is enabled (which is  the  default),  Syncthing
         will upgrade itself automatically within 24 hours of a new release.

       · The upgrade button appears in the web GUI when a new version has been
         released. Pressing it will perform an upgrade.

       · To force an upgrade from the command line, run ssyynncctthhiinngg ----uuppggrraaddee.

       Note that your system  should  have  CA  certificates  installed  which
       allows  a  secure  connection to GitHub (e.g. FreeBSD requires ssuuddoo ppkkgg
       iinnssttaallll ccaa__rroooott__nnssss). If ccuurrll or wwggeett works with  normal  HTTPS  sites,
       then so should Syncthing.

   WWhheerree ddoo II ffiinndd tthhee llaatteesstt rreelleeaassee??
       We  release  new  versions through GitHub. The latest release is always
       found   _o_n   _t_h_e   _r_e_l_e_a_s_e   _p_a_g_e   <hhttttppss::////ggiitthhuubb..ccoomm//ssyynncctthhiinngg//ssyynncc‐‐
       tthhiinngg//rreelleeaasseess//llaatteesstt>.  Unfortunately GitHub does not provide a single
       URL to automatically download the latest version. We suggest to use the
       _G_i_t_H_u_b         _A_P_I        <hhttttppss::////aappii..ggiitthhuubb..ccoomm//rreeppooss//ssyynncctthhiinngg//ssyynncc‐‐
       tthhiinngg//rreelleeaasseess//llaatteesstt> and parsing the JSON response.

   HHooww ddoo II rruunn SSyynncctthhiinngg aass aa ddaaeemmoonn pprroocceessss oonn LLiinnuuxx??
       If youâre using systemd, runit, or upstart, we ship _e_x_a_m_p_l_e  _c_o_n_f_i_g_u_r_a_‐
       _t_i_o_n_s <hhttttppss::////ggiitthhuubb..ccoomm//ssyynncctthhiinngg//ssyynncctthhiinngg//ttrreeee//mmaaiinn//eettcc>.

       If  however  youâre  not using one of these tools, you have a couple of
       options.  If your system has a tool called ssttaarrtt--ssttoopp--ddaaeemmoonn  installed
       (thatâs  the name of the command, not the package), look into the local
       documentation for that, it will almost certainly cover 100% of what you
       want  to do.  If you donât have ssttaarrtt--ssttoopp--ddaaeemmoonn, there are a bunch of
       other software packages you could use to do this.  The most well  known
       is called daemontools, and can be found in the standard package reposi‐
       tories for almost every modern Linux distribution.  Other popular tools
       with similar functionality include S6 and the aforementioned runit.

   HHooww ddoo II iinnccrreeaassee tthhee iinnoottiiffyy lliimmiitt ttoo ggeett mmyy ffiilleessyysstteemm wwaattcchheerr ttoo wwoorrkk??
       You  are  probably  reading  this because you encountered the following
       error with the filesystem watcher on linux:
          Failed to start filesystem watcher for  folder  yourLabel  (yourID):
          failed to setup inotify handler. Please increase inotify limits, see
          _h_t_t_p_s_:_/_/_d_o_c_s_._s_y_n_c_t_h_i_n_g_._n_e_t_/_u_s_e_r_s_/_f_a_q_._h_t_m_l_#_i_n_o_t_i_f_y_-_l_i_m_i_t_s

       Linux typically restricts the  amount  of  watches  per  user  (usually
       8192). When you have more directories you need to adjust that number.

       On many Linux distributions you can run the following to fix it:

          echo "fs.inotify.max_user_watches=204800" | sudo tee -a /etc/sysctl.conf

       On Arch Linux and potentially others it is preferred to write this line
       into a separate file, i.e. you should run:

          echo "fs.inotify.max_user_watches=204800" | sudo tee -a /etc/sysctl.d/90-override.conf

       This only takes effect after a reboot. To adjust the limit immediately,
       run:

          echo 204800 | sudo tee /proc/sys/fs/inotify/max_user_watches

   HHooww ddoo II rreesseett tthhee GGUUII ppaasssswwoorrdd??
       If youâve forgotten / lost the GUI password, you can reset it using the
       ----gguuii--ppaasssswwoorrdd (and possibly ----gguuii--uusseerr) options to the ssyynncctthhiinngg  ggeenn‐‐
       eerraattee subcommand.  This should be done while Syncthing is not running.

       1. Stop Syncthing: ssyynncctthhiinngg ccllii ooppeerraattiioonnss sshhuuttddoowwnn

       2. ssyynncctthhiinngg  ggeenneerraattee ----gguuii--ppaasssswwoorrdd==mmyyNNeewwPPaasssswwoorrdd ----gguuii--uusseerr==nneewwUUsseerr‐‐
          NNaammee

       3. Restart Syncthing as usual.

       _A_l_t_e_r_n_a_t_i_v_e_l_y_, _i_n _s_t_e_p _2, you can manually delete the <<uusseerr>> and <<ppaassss‐‐
       wwoorrdd>>  XML  tags from the <<gguuii>> block in file ccoonnffiigg..xxmmll.  The location
       of the file depends on the OS and is  described  in  the  configuration
       documentation.

       For  example,  the two emphasized lines below would be removed from the
       file.

          <gui enabled="true" tls="false" debugging="false">
             <address>127.0.0.1:8384</address>
             <user>syncguy</user>
             <password>$2a$10$s9wWHOQe...Cq7GPye69</password>
             <apikey>9RCKohqCAyrj5RjpyZdR2wXmQ9PyQFeN</apikey>
             <theme>default</theme>
          </gui>

AAUUTTHHOORR
       The Syncthing Authors

CCOOPPYYRRIIGGHHTT
       2014-2019, The Syncthing Authors



v1.19.2                          Apr 05, 2022                 SYNCTHING-FAQ(7)
