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



NNAAMMEE
       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_?

GGEENNEERRAALL
   WWhhaatt iiss SSyynncctthhiinngg??
       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.

   IIss iitt ââssyynncctthhiinnggââ,, ââSSyynncctthhiinnggââ oorr ââSSyynnccTThhiinnggââ??
       Itâs  SSyynncctthhiinngg,  although the command and source repository is spelled
       ssyynncctthhiinngg so it may be referred to in that way as well. Itâs definitely
       not  SyncThing, even though the abbreviation sstt is used in some circum‐
       stances and file names.

   WWhhaatt tthhiinnggss aarree ssyynncceedd??
       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 tthhee ccoonnffiigguurraattiioonn 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)

   IIss ssyynncchhrroonniizzaattiioonn ffaasstt??
       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).

   HHooww ddooeess SSyynncctthhiinngg ddiiffffeerr ffrroomm BBiittTToorrrreenntt//RReessiilliioo SSyynncc??
       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

   IIss tthheerree aann iiOOSS cclliieenntt??
       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

   SShhoouulldd II kkeeeepp mmyy ddeevviiccee IIDDss sseeccrreett??
       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!)

       SSEEEE AALLSSOO::
          device-ids

TTRROOUUBBLLEESSHHOOOOTTIINNGG
   WWhheerree aarree tthhee SSyynncctthhiinngg llooggss??
       Syncthing logs to stdout by default. On Windows  Syncthing  by  default
       also creates ssyynncctthhiinngg..lloogg in Syncthingâs home directory (run ssyynncctthhiinngg
       ----ppaatthhss to see where that is). The command line option ----llooggffiillee 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.

   WWhhyy iiss tthhee ssyynncc ssoo ssllooww??
       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.

   WWhhyy ddooeess iitt uussee ssoo mmuucchh CCPPUU??
       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 lloowweerr tthhee pprroocceessss
       pprriioorriittyy when starting up.

       To  further limit the amount of CPU used when syncing and scanning, set
       the environment variable GGOOMMAAXXPPRROOCCSS to the maximum number of CPU  cores
       Syncthing  should use at any given moment. For example, GGOOMMAAXXPPRROOCCSS==22 on
       a machine with four cores will limit Syncthing to no more than half the
       systemâs CPU power.

   WWhhyy iiss tthhee sseettuupp mmoorree ccoommpplliiccaatteedd tthhaann BBiittTToorrrreenntt//RReessiilliioo SSyynncc??
       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.

   WWhhyy ddoo II ggeett ââHHoosstt cchheecckk eerrrroorrââ iinn tthhee GGUUII//AAPPII??
       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
       <hhttttppss::////eenn..wwiikkiippeeddiiaa..oorrgg//wwiikkii//DDNNSS__rreebbiinnddiinngg> against the GUI.

       To  pass  this test, ensure that you are accessing the GUI using an URL
       that begins with hhttttpp::////llooccaallhhoosstt,  hhttttpp::////112277..00..00..11  or  hhttttpp::////[[::::11]].
       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 HHoosstt header containing llooccaallhhoosstt, or

       · Set gguuii..iinnsseeccuurreeSSkkiippHHoossttcchheecckk 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.

   MMyy SSyynncctthhiinngg ddaattaabbaassee iiss ccoorrrruupptt
       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 <hhttttppss::////ddooccss..ssyynncctthhiinngg..nneett//uusseerrss//ccoonn‐‐
       ffiigg..hhttmmll##ddeessccrriippttiioonn> 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.

   WWhhyy ddoo II sseeee SSyynncctthhiinngg ttwwiiccee iinn ttaasskk mmaannaaggeerr??
       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.

   HHooww ccaann II vviieeww tthhee hhiissttoorryy ooff cchhaannggeess??
       The  web  GUI  contains  a  RReecceenntt CChhaannggeess button under the device list
       which displays changes since the last (re)start of Syncthing. With  the
       ----aauuddiitt option you can enable a persistent, detailed log of changes and
       most activities, which contains a JJSSOONN formatted  sequence of events in
       the ~~//..ccoonnffiigg//ssyynncctthhiinngg//aauuddiitt--__ddaattee__--__ttiimmee__..lloogg file.

   DDooeess tthhee aauuddiitt lloogg ccoonnttaaiinn eevveerryy cchhaannggee??
       The  audit  log  (and  the RReecceenntt CChhaannggeess 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.

   WWhhyy ddooeess SSyynncctthhiinngg ccoonnnneecctt ttoo tthhiiss uunnkknnoowwnn//ssuussppiicciioouuss aaddddrreessss??
       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 <hhttttppss::////rreellaayyss..ssyynncctthhiinngg..nneett>. Relays do not and can not
       see the data transmitted via them.

UUSSAAGGEE
   WWhhaatt iiff tthheerree iiss aa ccoonnfflliicctt??
       SSEEEE AALLSSOO::
          conflict-handling

   HHooww ddoo II sseerrvvee aa ffoollddeerr ffrroomm aa rreeaadd oonnllyy ffiilleessyysstteemm??
       Syncthing  requires  a  âfolder  markerâ to indicate that the folder is
       present and healthy. By default this is a  directory  called  ..ssttffoollddeerr
       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 MMaarrkkeerr NNaammee to the name of some file or
       folder that you know will always exist in the folder.

   II rreeaallllyy hhaattee tthhee ..ssttffoollddeerr ddiirreeccttoorryy,, ccaann II rreemmoovvee iitt??
       See the previous question.

   AAmm II aabbllee ttoo nneesstt sshhaarreedd ffoollddeerrss iinn SSyynncctthhiinngg??
       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.

   HHooww ddoo II rreennaammee//mmoovvee aa ssyynncceedd ffoollddeerr??
       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 ..ssttffoollddeerr marker), edit the path directly in  ccoonnffiigg..xxmmll
       in  the  configuration  folder (see /users/config) and then start Sync‐
       thing again.

   HHooww ddoo II ccoonnffiigguurree mmuullttiippllee uusseerrss oonn aa ssiinnggllee mmaacchhiinnee??
       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).

   DDooeess SSyynncctthhiinngg ssuuppppoorrtt ssyynncciinngg bbeettwweeeenn ffoollddeerrss oonn tthhee ssaammee ssyysstteemm??
       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  <hhttttppss::////rrssyynncc..ssaammbbaa..oorrgg//>
       or _U_n_i_s_o_n <hhttttppss::////wwwwww..cciiss..uuppeennnn..eedduu//~~bbccppiieerrccee//uunniissoonn>.

   WWhheenn  II  ddoo  hhaavvee  ttwwoo ddiissttiinncctt SSyynncctthhiinngg--mmaannaaggeedd ffoollddeerrss oonn ttwwoo hhoossttss,, hhooww
       ddooeess SSyynncctthhiinngg hhaannddllee mmoovviinngg ffiilleess bbeettwweeeenn tthheemm??
       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.

   CCaann II hheellpp iinniittiiaall ssyynncc bbyy ccooppyyiinngg ffiilleess mmaannuuaallllyy??
       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.

   IIss SSyynncctthhiinngg mmyy iiddeeaall bbaacckkuupp aapppplliiccaattiioonn??
       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.

   HHooww ccaann II eexxcclluuddee ffiilleess wwiitthh bbrraacckkeettss (([[]])) iinn tthhee nnaammee??
       The patterns in .stignore are glob patterns, where brackets are used to
       denote  character  ranges.  That is, the pattern qq[[aabbcc]]xx will match the
       files qqaaxx, qqbbxx and qqccxx.

       To match an actual file _c_a_l_l_e_d qq[[aabbcc]]xx the pattern  needs  to  âescapeâ
       the brackets, like so: qq\\[[aabbcc\\]]xx.

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

   HHooww ddoo II aacccceessss tthhee wweebb GGUUII ffrroomm aannootthheerr ccoommppuutteerr??
       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  GGUUII  lliisstteenn  aaddddrreessss
       through  the  web  UI from 112277..00..00..11::88338844 to 00..00..00..00::88338844 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  <hhttttppss::////ddooccss..mmii‐‐
       ccrroossoofftt..ccoomm//wwiinnddoowwss//wwssll//iinnssttaallll>.

       Another  Windows  way  to  run  ssh  is to install _g_o_w _(_G_n_u _O_n _W_i_n_d_o_w_s_)
       <hhttttppss::////ggiitthhuubb..ccoomm//bbmmaattzzeellllee//ggooww>. The easiest way to install  gow  is
       with the _c_h_o_c_o_l_a_t_e_y <hhttttppss::////cchhooccoollaatteeyy..oorrgg//> package manager.

   II ddoonnââtt lliikkee tthhee GGUUII oorr tthhee tthheemmee.. CCaann iitt bbee cchhaannggeedd??
       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 gguuii 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  ----ppaatthhss  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
       rreedd//aasssseettss//ccssss//tthheemmee..ccssss 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.

   HHooww ddoo II uuppggrraaddee SSyynncctthhiinngg??
       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 ssyynncctthhiinngg ----uuppggrraaddee.

       Note that your system  should  have  CA  certificates  installed  which
       allows  a  secure  connection to GitHub (e.g. FreeBSD requires ssuuddoo ppkkgg
       iinnssttaallll ccaa__rroooott__nnssss). If ccuurrll or wwggeett works with  normal  HTTPS  sites,
       then so should Syncthing.

   WWhheerree ddoo II ffiinndd tthhee llaatteesstt rreelleeaassee??
       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   <hhttttppss::////ggiitthhuubb..ccoomm//ssyynncctthhiinngg//ssyynncc‐‐
       tthhiinngg//rreelleeaasseess//llaatteesstt>.  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        <hhttttppss::////aappii..ggiitthhuubb..ccoomm//rreeppooss//ssyynncctthhiinngg//ssyynncc‐‐
       tthhiinngg//rreelleeaasseess//llaatteesstt> and parsing the JSON response.

   HHooww ddoo II rruunn SSyynncctthhiinngg aass aa ddaaeemmoonn pprroocceessss oonn LLiinnuuxx??
       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 <hhttttppss::////ggiitthhuubb..ccoomm//ssyynncctthhiinngg//ssyynncctthhiinngg//ttrreeee//mmaaiinn//eettcc>.

       If  however  youâre  not using one of these tools, you have a couple of
       options.  If your system has a tool called ssttaarrtt--ssttoopp--ddaaeemmoonn  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 ssttaarrtt--ssttoopp--ddaaeemmoonn, 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.

   HHooww ddoo II iinnccrreeaassee tthhee iinnoottiiffyy lliimmiitt ttoo ggeett mmyy ffiilleessyysstteemm wwaattcchheerr ttoo wwoorrkk??
       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

   HHooww ddoo II rreesseett tthhee GGUUII ppaasssswwoorrdd??
       If youâve forgotten / lost the GUI password, you can reset it using the
       ----gguuii--ppaasssswwoorrdd (and possibly ----gguuii--uusseerr) options to the ssyynncctthhiinngg  ggeenn‐‐
       eerraattee subcommand.  This should be done while Syncthing is not running.

       1. Stop Syncthing: ssyynncctthhiinngg ccllii ooppeerraattiioonnss sshhuuttddoowwnn

       2. ssyynncctthhiinngg  ggeenneerraattee ----gguuii--ppaasssswwoorrdd==mmyyNNeewwPPaasssswwoorrdd ----gguuii--uusseerr==nneewwUUsseerr‐‐
          NNaammee

       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 <<uusseerr>> and <<ppaassss‐‐
       wwoorrdd>>  XML  tags from the <<gguuii>> block in file ccoonnffiigg..xxmmll.  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>

AAUUTTHHOORR
       The Syncthing Authors

CCOOPPYYRRIIGGHHTT
       2014-2019, The Syncthing Authors



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