WikEmacs - User contributions [en]

Emacs server

2015-06-25T01:07:19Z

Miabraha: /* Linux */

Emacs includes an optional client-server architecture. The benefit of running emacs in server mode is that new client instances can be started up instantaneously. If you have 100+ packages and starting Emacs usually takes several three seconds, using server mode creates a much more streamlined workflow without sacrificing customization functionality.

== Starting the Server ==

=== With <code>server-start</code> ===
To start a server in an existing Emacs session, run {{Command|server-start}}. A server started in this manner will close when the last visible Emacs frame closes. If you want Emacs to automatically run a server on startup, add the following to your configuration file.

<syntaxhighlight lang="lisp">
(server-start)
</syntaxhighlight>

=== With <tt>--daemon</tt> ===
Emacs 23 and higher provide the <tt>--daemon</tt> command-line argument, which will cause Emacs to immediately start a server and fork into the background. A server started in this manner is fully daemonized and will remain running even with no visible Emacs frames and after its parent terminal has closed (for example, after an SSH session has disconnected).

Note that, if using <tt>--daemon</tt>, your configuration file will be run while Emacs is still in a terminal. This may affect your theming if you usually use graphical Emacs.

{{Note}}This option is not supported on [[Windows]].

== Using Clients ==

Once the server is started you may use the <code>emacsclient</code> command outside of Emacs to send a file to Emacs for editing, e.g. <code>emacsclient ~/.emacs.d/init.el</code> to modify your init file. On a GNU/Linux system it might be a good idea to set your <tt>EDITOR</tt> environment variable to <tt>emacsclient</tt> or <tt>emacsclient -t</tt>. Using <tt>emacsclient</tt> without any arguments will cause the calling process to simply pause and wait for the Emacs server to report that it's done editing. Using <tt>emacsclient -t</tt> will cause the calling process to put up a text-mode frame in the same terminal.

If the server was started using <tt>--daemon</tt>, you should run <tt>emacsclient -t</tt> or <tt>emacsclient -nc</tt> to create a visible frame to interact with.
== Finishing Up ==

Once you have finished with a buffer that was opened via <tt>emacsclient</tt> you should use the {{CommandKeys|C-x #|server-edit}} to properly close the loop. Killing the buffer normally will not send the signal to <tt>emacsclient</tt> that Emacs has finished with the file.

If you're in an Emacs session that was started using <tt>--daemon</tt>, {{Keys|C-x C-c}} will only close the frame that it was invoked in. It will also signal to the client that owns the frame that its editing job is done, so <tt>emacsclient -c</tt> or <tt>emacsclient -t</tt> as <tt>EDITOR</tt> will behave much like a full <tt>emacs</tt> or <tt>emacs -nw</tt>.

To entirely close a server started with <tt>--daemon</tt>, run {{Command|save-buffers-kill-emacs}} in a frame.
= Adding To OS Startup =
== Linux ==

Configuration through the init daemon <code>systemd</code> is the preferred method of starting Emacs at launch on most major distributions, including Debian, Ubuntu, Fedora, OpenSUSE, Arch, and derivatives.

To tell systemd to start Emacs on init, place the following script <code>emacsd.service</code> in your systemd user configuration folder, modifying the binary . On Debian-based distributions, this file should be named <code>~/.config/systemd/user/emacsd.service</code>.

[Unit]
Description=Emacs: the extensible, self-documenting text editor
Documentation=man:emacs(1) info:Emacs

[Service]
Type=forking
ExecStart=/usr/bin/emacs --daemon
ExecStop=/usr/bin/emacsclient --eval "(progn (setq kill-emacs-hook nil) (kill-emacs))"
Restart=on-failure
Environment=DISPLAY=:%i
TimeoutStartSec=0

[Install]
WantedBy=default.target

Enable the new module with <code>systemctl --user enable emacsd</code>; useful commands besides <code>enable</code> include <code>stop</code>, <code>kill</code> and <code>restart</code>. After running enable, the service will be enabled permanently. You can use <code>disable</code> if you no longer want systemd to run an Emacs daemon.

A few parts of this script are not quite self-documenting. Two are just technical: <code>Type</code> tells systemd it should expect <code>emacs --systemd</code> to fork a server process, and <code>Environment</code> sets an environment variable to ensure Emacs works properly with multiple X displays. The Restart command asks systemd to restart Emacs whenever there is a nonzero exit code. For example, if Emacs hangs in the middle of a loop and you kill it in a task manager or run <code>systemctl --user kill</code>, systemd will restart Emacs. Alternative values you may want to use are <code>no</code> and <code>always</code>. TimeoutStartSec=0 tells systemd it shouldn't worry about how long it takes Emacs to start. Specifying a timeout might be useful if you occasionally break your Emacs init file.

Systemd will not know what to do if Emacs tries to ask for input before closing, for example, if Desktop mode prompts for confirmation before overwriting a desktop file. If the simple <code>(progn)</code> script executed on ExecStop</code> is not suitable, You may need to define your own command for a clean exit and call that function instead.

If systemd is not available on your distribution, you can add <code>/usr/bin/emacs --daemon</code> to your crontab. However using systemd is preferable because of the ability to easily configure Emacs to restart, and because the process will begin at boot, i.e. without depending on the <code>cron</code> process to start.

== OS X ==
<code>launchd</code> is the OS X analog of <code>systemd</code> and can be configured just as easily. If someone is familiar with launchd configuration please fill this in.

== MS Windows ==
Open the startup folder by running the command <code>shell:startup</code> in a run dialog or by typing it in the Windows Explorer path bar. Place a shortcut to Emacs in this folder to run Emacs at boot. Change the target to <code>emacs --daemon</code> to run start it in daemon mode. The best option for more advanced Emacs daemon-mode configuration on Windows is still not settled, there is some discussion on the Emacs Wiki which could potentially be sifted through.

[[Category: Server]]

Emacs server

2015-06-25T01:06:59Z

Miabraha: /* Linux */

Emacs server

2015-06-25T01:06:32Z

Miabraha: Expanded systemd instructions

Emacs includes an optional client-server architecture. The benefit of running emacs in server mode is that new client instances can be started up instantaneously. If you have 100+ packages and starting Emacs usually takes several three seconds, using server mode creates a much more streamlined workflow without sacrificing customization functionality.

== Starting the Server ==

=== With <code>server-start</code> ===
To start a server in an existing Emacs session, run {{Command|server-start}}. A server started in this manner will close when the last visible Emacs frame closes. If you want Emacs to automatically run a server on startup, add the following to your configuration file.

<syntaxhighlight lang="lisp">
(server-start)
</syntaxhighlight>

=== With <tt>--daemon</tt> ===
Emacs 23 and higher provide the <tt>--daemon</tt> command-line argument, which will cause Emacs to immediately start a server and fork into the background. A server started in this manner is fully daemonized and will remain running even with no visible Emacs frames and after its parent terminal has closed (for example, after an SSH session has disconnected).

Note that, if using <tt>--daemon</tt>, your configuration file will be run while Emacs is still in a terminal. This may affect your theming if you usually use graphical Emacs.

{{Note}}This option is not supported on [[Windows]].

== Using Clients ==

Once the server is started you may use the <code>emacsclient</code> command outside of Emacs to send a file to Emacs for editing, e.g. <code>emacsclient ~/.emacs.d/init.el</code> to modify your init file. On a GNU/Linux system it might be a good idea to set your <tt>EDITOR</tt> environment variable to <tt>emacsclient</tt> or <tt>emacsclient -t</tt>. Using <tt>emacsclient</tt> without any arguments will cause the calling process to simply pause and wait for the Emacs server to report that it's done editing. Using <tt>emacsclient -t</tt> will cause the calling process to put up a text-mode frame in the same terminal.

If the server was started using <tt>--daemon</tt>, you should run <tt>emacsclient -t</tt> or <tt>emacsclient -nc</tt> to create a visible frame to interact with.
== Finishing Up ==

Once you have finished with a buffer that was opened via <tt>emacsclient</tt> you should use the {{CommandKeys|C-x #|server-edit}} to properly close the loop. Killing the buffer normally will not send the signal to <tt>emacsclient</tt> that Emacs has finished with the file.

If you're in an Emacs session that was started using <tt>--daemon</tt>, {{Keys|C-x C-c}} will only close the frame that it was invoked in. It will also signal to the client that owns the frame that its editing job is done, so <tt>emacsclient -c</tt> or <tt>emacsclient -t</tt> as <tt>EDITOR</tt> will behave much like a full <tt>emacs</tt> or <tt>emacs -nw</tt>.

To entirely close a server started with <tt>--daemon</tt>, run {{Command|save-buffers-kill-emacs}} in a frame.
= Adding To OS Startup =
== Linux ==

Configuration through the init daemon <code>systemd</code> is the preferred method of starting Emacs at launch on most major distributions, including Debian, Ubuntu, Fedora, OpenSUSE, Arch, and derivatives.

To tell systemd to start Emacs on init, place the following script <code>emacsd.service</code> in your systemd user configuration folder, modifying the binary . On Debian-based distributions, this file should be named <code>~/.config/systemd/user/emacsd.service</code>.

[Unit]
Description=Emacs: the extensible, self-documenting text editor
Documentation=man:emacs(1) info:Emacs

[Service]
Type=forking
ExecStart=/usr/bin/emacs --daemon
ExecStop=/usr/bin/emacsclient --eval "(progn (setq kill-emacs-hook nil) (kill-emacs))"
Restart=on-failure
Environment=DISPLAY=:%i
TimeoutStartSec=0

[Install]
WantedBy=default.target

Enable the new module with <code>systemctl --user enable emacsd</code>; useful commands besides <code>enable</code> include <code>stop</code>, <code>kill</code> and <code>restart</code>. After running enable, the service will be enabled permanently. You can use <code>disable</code> if you no longer want systemd to run an Emacs daemon.

A few parts of this script are not quite self-documenting. Two are just technical: <code>Type</code> tells systemd it should expect <code>emacs --systemd</code> to fork a server process, and <code>Environment sets an environment variable to ensure Emacs works properly with multiple X displays. The Restart command asks systemd to restart Emacs whenever there is a nonzero exit code. For example, if Emacs hangs in the middle of a loop and you kill it in a task manager or run <code>systemctl --user kill</code>, systemd will restart Emacs. Alternative values you may want to use are <code>no</code> and <code>always</code>. TimeoutStartSec=0 tells systemd it shouldn't worry about how long it takes Emacs to start. Specifying a timeout might be useful if you occasionally break your Emacs init file.

Systemd will not know what to do if Emacs tries to ask for input before closing, for example, if Desktop mode prompts for confirmation before overwriting a desktop file. If the simple <code>(progn)</code> script executed on ExecStop</code> is not suitable, You may need to define your own command for a clean exit and call that function instead.

If systemd is not available on your distribution, you can add <code>/usr/bin/emacs --daemon</code> to your crontab. However using systemd is preferable because of the ability to easily configure Emacs to restart, and because the process will begin at boot, i.e. without depending on the <code>cron</code> process to start.

== OS X ==
<code>launchd</code> is the OS X analog of <code>systemd</code> and can be configured just as easily. If someone is familiar with launchd configuration please fill this in.

== MS Windows ==
Open the startup folder by running the command <code>shell:startup</code> in a run dialog or by typing it in the Windows Explorer path bar. Place a shortcut to Emacs in this folder to run Emacs at boot. Change the target to <code>emacs --daemon</code> to run start it in daemon mode. The best option for more advanced Emacs daemon-mode configuration on Windows is still not settled, there is some discussion on the Emacs Wiki which could potentially be sifted through.

[[Category: Server]]

Emacs server

2015-06-23T03:21:38Z

Miabraha: /* Linux */

Emacs includes an optional client-server architecture. The benefit of running emacs in server mode is that new client instances can be started up instantaneously. If you have 100+ packages and starting Emacs usually takes several three seconds, using server mode creates a much more streamlined workflow without sacrificing customization functionality.

== Starting the Server ==

=== With <code>server-start</code> ===
To start a server in an existing Emacs session, run {{Command|server-start}}. A server started in this manner will close when the last visible Emacs frame closes. If you want Emacs to automatically run a server on startup, add the following to your configuration file.

<syntaxhighlight lang="lisp">
(server-start)
</syntaxhighlight>

=== With <tt>--daemon</tt> ===
Emacs 23 and higher provide the <tt>--daemon</tt> command-line argument, which will cause Emacs to immediately start a server and fork into the background. A server started in this manner is fully daemonized and will remain running even with no visible Emacs frames and after its parent terminal has closed (for example, after an SSH session has disconnected).

Note that, if using <tt>--daemon</tt>, your configuration file will be run while Emacs is still in a terminal. This may affect your theming if you usually use graphical Emacs.

{{Note}}This option is not supported on [[Windows]].

== Using Clients ==

Once the server is started you may use the <code>emacsclient</code> command outside of Emacs to send a file to Emacs for editing, e.g. <code>emacsclient ~/.emacs.d/init.el</code> to modify your init file. On a GNU/Linux system it might be a good idea to set your <tt>EDITOR</tt> environment variable to <tt>emacsclient</tt> or <tt>emacsclient -t</tt>. Using <tt>emacsclient</tt> without any arguments will cause the calling process to simply pause and wait for the Emacs server to report that it's done editing. Using <tt>emacsclient -t</tt> will cause the calling process to put up a text-mode frame in the same terminal.

If the server was started using <tt>--daemon</tt>, you should run <tt>emacsclient -t</tt> or <tt>emacsclient -nc</tt> to create a visible frame to interact with.
== Finishing Up ==

Once you have finished with a buffer that was opened via <tt>emacsclient</tt> you should use the {{CommandKeys|C-x #|server-edit}} to properly close the loop. Killing the buffer normally will not send the signal to <tt>emacsclient</tt> that Emacs has finished with the file.

If you're in an Emacs session that was started using <tt>--daemon</tt>, {{Keys|C-x C-c}} will only close the frame that it was invoked in. It will also signal to the client that owns the frame that its editing job is done, so <tt>emacsclient -c</tt> or <tt>emacsclient -t</tt> as <tt>EDITOR</tt> will behave much like a full <tt>emacs</tt> or <tt>emacs -nw</tt>.

To entirely close a server started with <tt>--daemon</tt>, run {{Command|save-buffers-kill-emacs}} in a frame.
= Adding To OS Startup =
== Linux ==

Configuration through the init daemon <code>systemd</code> is the preferred method of starting Emacs at launch on most major distributions, including Debian, Ubuntu, Fedora, OpenSUSE, Arch, and derivatives.

To tell systemd to start Emacs on init, place the following script <code>emacsd.service</code> in your systemd user configuration folder, replacing the location of the emacs executable if necessary. On Debian-based distributions, this file should be named <code>/etc/systemd/user/emacsd.service</code>.

[Unit]
Description=GNU Emacs daemon
Documentation=man:emacs(1) info:Emacs

[Service]
Type=forking
ExecStart=/usr/bin/emacs --daemon
ExecStop=/usr/bin/emacsclient --e "(kill-emacs)"
Restart=always

[Install]
WantedBy=console.target

Enable the new module with <code>systemctl --user enable emacsd</code>.

If systemd is not available on your distribution, you can add <code>/usr/bin/emacs --daemon</code> to your crontab. However using systemd is preferable because the process will begin up at boot, i.e. without depending on the <code>cron</code> process to start first.

== OS X ==
<code>launchd</code> is the OS X analog of <code>systemd</code> and can be configured just as easily. If someone is familiar with launchd configuration please fill this in.

== MS Windows ==
Open the startup folder by running the command <code>shell:startup</code> in a run dialog or by typing it in the Windows Explorer path bar. Place a shortcut to Emacs in this folder to run Emacs at boot. Change the target to <code>emacs --daemon</code> to run start it in daemon mode. The best option for more advanced Emacs daemon-mode configuration on Windows is still not settled, there is some discussion on the Emacs Wiki which could potentially be sifted through.

[[Category: Server]]

Emacs server

2015-06-23T00:21:33Z

Miabraha: /* Linux */

Emacs includes an optional client-server architecture. The benefit of running emacs in server mode is that new client instances can be started up instantaneously. If you have 100+ packages and starting Emacs usually takes several three seconds, using server mode creates a much more streamlined workflow without sacrificing customization functionality.

== Starting the Server ==

=== With <code>server-start</code> ===
To start a server in an existing Emacs session, run {{Command|server-start}}. A server started in this manner will close when the last visible Emacs frame closes. If you want Emacs to automatically run a server on startup, add the following to your configuration file.

<syntaxhighlight lang="lisp">
(server-start)
</syntaxhighlight>

=== With <tt>--daemon</tt> ===
Emacs 23 and higher provide the <tt>--daemon</tt> command-line argument, which will cause Emacs to immediately start a server and fork into the background. A server started in this manner is fully daemonized and will remain running even with no visible Emacs frames and after its parent terminal has closed (for example, after an SSH session has disconnected).

Note that, if using <tt>--daemon</tt>, your configuration file will be run while Emacs is still in a terminal. This may affect your theming if you usually use graphical Emacs.

{{Note}}This option is not supported on [[Windows]].

== Using Clients ==

Once the server is started you may use the <code>emacsclient</code> command outside of Emacs to send a file to Emacs for editing, e.g. <code>emacsclient ~/.emacs.d/init.el</code> to modify your init file. On a GNU/Linux system it might be a good idea to set your <tt>EDITOR</tt> environment variable to <tt>emacsclient</tt> or <tt>emacsclient -t</tt>. Using <tt>emacsclient</tt> without any arguments will cause the calling process to simply pause and wait for the Emacs server to report that it's done editing. Using <tt>emacsclient -t</tt> will cause the calling process to put up a text-mode frame in the same terminal.

If the server was started using <tt>--daemon</tt>, you should run <tt>emacsclient -t</tt> or <tt>emacsclient -nc</tt> to create a visible frame to interact with.
== Finishing Up ==

Once you have finished with a buffer that was opened via <tt>emacsclient</tt> you should use the {{CommandKeys|C-x #|server-edit}} to properly close the loop. Killing the buffer normally will not send the signal to <tt>emacsclient</tt> that Emacs has finished with the file.

If you're in an Emacs session that was started using <tt>--daemon</tt>, {{Keys|C-x C-c}} will only close the frame that it was invoked in. It will also signal to the client that owns the frame that its editing job is done, so <tt>emacsclient -c</tt> or <tt>emacsclient -t</tt> as <tt>EDITOR</tt> will behave much like a full <tt>emacs</tt> or <tt>emacs -nw</tt>.

To entirely close a server started with <tt>--daemon</tt>, run {{Command|save-buffers-kill-emacs}} in a frame.
= Adding To OS Startup =
== Linux ==

Configuration through the init daemon <code>systemd</code> is the preferred method of starting Emacs at launch on most major distributions, including Debian, Ubuntu, Fedora, OpenSUSE, Arch, and derivatives.

To tell systemd to start Emacs on init, place the following script <code>emacsd.service</code> in your systemd user configuration folder, replacing the location of the emacs executable if necessary. On Debian-based distributions, this file should be named <code>/etc/systemd/user/emacsd.service</code>.

[Unit]
Description=Emacs daemon

[Service]
Type=forking
WorkingDirectory=%h
ExecStart=/usr/bin/emacs --daemon
ExecStop=/usr/bin/emacsclient --e "(kill-emacs)"
Restart=always

[Install]
WantedBy=console.target

Enable the new module with <code>systemctl --user enable emacsd</code>.

If systemd is not available on your distribution, you can add <code>/usr/bin/emacs --daemon</code> to your crontab. However using systemd is preferable because the process will begin up at boot, i.e. without depending on the <code>cron</code> process to start first.

== OS X ==
<code>launchd</code> is the OS X analog of <code>systemd</code> and can be configured just as easily. If someone is familiar with launchd configuration please fill this in.

== MS Windows ==
Open the startup folder by running the command <code>shell:startup</code> in a run dialog or by typing it in the Windows Explorer path bar. Place a shortcut to Emacs in this folder to run Emacs at boot. Change the target to <code>emacs --daemon</code> to run start it in daemon mode. The best option for more advanced Emacs daemon-mode configuration on Windows is still not settled, there is some discussion on the Emacs Wiki which could potentially be sifted through.

[[Category: Server]]

Emacs server

2015-06-23T00:21:21Z

Miabraha: /* Linux */

Emacs includes an optional client-server architecture. The benefit of running emacs in server mode is that new client instances can be started up instantaneously. If you have 100+ packages and starting Emacs usually takes several three seconds, using server mode creates a much more streamlined workflow without sacrificing customization functionality.

== Starting the Server ==

=== With <code>server-start</code> ===
To start a server in an existing Emacs session, run {{Command|server-start}}. A server started in this manner will close when the last visible Emacs frame closes. If you want Emacs to automatically run a server on startup, add the following to your configuration file.

<syntaxhighlight lang="lisp">
(server-start)
</syntaxhighlight>

=== With <tt>--daemon</tt> ===
Emacs 23 and higher provide the <tt>--daemon</tt> command-line argument, which will cause Emacs to immediately start a server and fork into the background. A server started in this manner is fully daemonized and will remain running even with no visible Emacs frames and after its parent terminal has closed (for example, after an SSH session has disconnected).

Note that, if using <tt>--daemon</tt>, your configuration file will be run while Emacs is still in a terminal. This may affect your theming if you usually use graphical Emacs.

{{Note}}This option is not supported on [[Windows]].

== Using Clients ==

Once the server is started you may use the <code>emacsclient</code> command outside of Emacs to send a file to Emacs for editing, e.g. <code>emacsclient ~/.emacs.d/init.el</code> to modify your init file. On a GNU/Linux system it might be a good idea to set your <tt>EDITOR</tt> environment variable to <tt>emacsclient</tt> or <tt>emacsclient -t</tt>. Using <tt>emacsclient</tt> without any arguments will cause the calling process to simply pause and wait for the Emacs server to report that it's done editing. Using <tt>emacsclient -t</tt> will cause the calling process to put up a text-mode frame in the same terminal.

If the server was started using <tt>--daemon</tt>, you should run <tt>emacsclient -t</tt> or <tt>emacsclient -nc</tt> to create a visible frame to interact with.
== Finishing Up ==

Once you have finished with a buffer that was opened via <tt>emacsclient</tt> you should use the {{CommandKeys|C-x #|server-edit}} to properly close the loop. Killing the buffer normally will not send the signal to <tt>emacsclient</tt> that Emacs has finished with the file.

If you're in an Emacs session that was started using <tt>--daemon</tt>, {{Keys|C-x C-c}} will only close the frame that it was invoked in. It will also signal to the client that owns the frame that its editing job is done, so <tt>emacsclient -c</tt> or <tt>emacsclient -t</tt> as <tt>EDITOR</tt> will behave much like a full <tt>emacs</tt> or <tt>emacs -nw</tt>.

To entirely close a server started with <tt>--daemon</tt>, run {{Command|save-buffers-kill-emacs}} in a frame.
= Adding To OS Startup =
== Linux ==

Configuration through the init daemon <code>systemd</code> is the preferred method of starting Emacs at launch on most major distributions, including Debian, Ubuntu, Fedora, OpenSUSE, Arch, and derivatives.

To tell systemd to start Emacs on init, place the following script <code>emacsd.service</code> in your systemd user configuration folder, replacing the location of the emacs executable if necessary. On Debian-based distributions, this file should be named <code>/etc/systemd/user/emacsd.service</code>.

[Unit]
Description=Emacs daemon

[Service]
Type=forking
WorkingDirectory=%h
ExecStart=/usr/bin/emacs --daemon
ExecStop=/usr/bin/emacsclient --e "(kill-emacs)"
Restart=always

[Install]
WantedBy=console.target

Enable the new module with <code>systemctl --user enable emacsd</code>.

If systemd is not available on your distribution, you can simply add <code>/usr/bin/emacs --daemon</code> to your crontab. However using systemd is preferable because the process will begin up at boot, i.e. without depending on the <code>cron</code> process to start first.

== OS X ==
<code>launchd</code> is the OS X analog of <code>systemd</code> and can be configured just as easily. If someone is familiar with launchd configuration please fill this in.

== MS Windows ==
Open the startup folder by running the command <code>shell:startup</code> in a run dialog or by typing it in the Windows Explorer path bar. Place a shortcut to Emacs in this folder to run Emacs at boot. Change the target to <code>emacs --daemon</code> to run start it in daemon mode. The best option for more advanced Emacs daemon-mode configuration on Windows is still not settled, there is some discussion on the Emacs Wiki which could potentially be sifted through.

[[Category: Server]]

Emacs server

2015-06-22T21:30:12Z

Miabraha: Updated intro

Emacs includes an optional client-server architecture. The benefit of running emacs in server mode is that new client instances can be started up instantaneously. If you have 100+ packages and starting Emacs usually takes several three seconds, using server mode creates a much more streamlined workflow without sacrificing customization functionality.

== Starting the Server ==

=== With <code>server-start</code> ===
To start a server in an existing Emacs session, run {{Command|server-start}}. A server started in this manner will close when the last visible Emacs frame closes. If you want Emacs to automatically run a server on startup, add the following to your configuration file.

<syntaxhighlight lang="lisp">
(server-start)
</syntaxhighlight>

=== With <tt>--daemon</tt> ===
Emacs 23 and higher provide the <tt>--daemon</tt> command-line argument, which will cause Emacs to immediately start a server and fork into the background. A server started in this manner is fully daemonized and will remain running even with no visible Emacs frames and after its parent terminal has closed (for example, after an SSH session has disconnected).

Note that, if using <tt>--daemon</tt>, your configuration file will be run while Emacs is still in a terminal. This may affect your theming if you usually use graphical Emacs.

{{Note}}This option is not supported on [[Windows]].

== Using Clients ==

Once the server is started you may use the <code>emacsclient</code> command outside of Emacs to send a file to Emacs for editing, e.g. <code>emacsclient ~/.emacs.d/init.el</code> to modify your init file. On a GNU/Linux system it might be a good idea to set your <tt>EDITOR</tt> environment variable to <tt>emacsclient</tt> or <tt>emacsclient -t</tt>. Using <tt>emacsclient</tt> without any arguments will cause the calling process to simply pause and wait for the Emacs server to report that it's done editing. Using <tt>emacsclient -t</tt> will cause the calling process to put up a text-mode frame in the same terminal.

If the server was started using <tt>--daemon</tt>, you should run <tt>emacsclient -t</tt> or <tt>emacsclient -nc</tt> to create a visible frame to interact with.
== Finishing Up ==

Once you have finished with a buffer that was opened via <tt>emacsclient</tt> you should use the {{CommandKeys|C-x #|server-edit}} to properly close the loop. Killing the buffer normally will not send the signal to <tt>emacsclient</tt> that Emacs has finished with the file.

If you're in an Emacs session that was started using <tt>--daemon</tt>, {{Keys|C-x C-c}} will only close the frame that it was invoked in. It will also signal to the client that owns the frame that its editing job is done, so <tt>emacsclient -c</tt> or <tt>emacsclient -t</tt> as <tt>EDITOR</tt> will behave much like a full <tt>emacs</tt> or <tt>emacs -nw</tt>.

To entirely close a server started with <tt>--daemon</tt>, run {{Command|save-buffers-kill-emacs}} in a frame.
= Adding To OS Startup =
== Linux ==

Configuration through the init daemon <code>systemd</code> is the preferred method of starting Emacs at launch on most major distributions, including Debian, Ubuntu, Fedora, OpenSUSE, Arch, and derivatives.

To tell systemd to start Emacs on init, place the following script <code>emacsd.service</code> in your systemd user configuration folder, replacing the location of the emacs executable if necessary. On Debian-based distributions, this file should be named <code>/etc/systemd/user/emacsd.service</code>.

[Unit]
Description=Emacs daemon

[Service]
Type=forking
WorkingDirectory=%h
ExecStart=/usr/bin/emacs --daemon
ExecStop=/usr/bin/emacsclient --e "(kill-emacs)"
Restart=always

[Install]
WantedBy=console.target

If systemd is not available on your distribution, you can simply add <code>/usr/bin/emacs --daemon</code> to your crontab. However using systemd is preferable because the process will begin up at boot, i.e. without depending on the <code>cron</code> process to start first.

== OS X ==
<code>launchd</code> is the OS X analog of <code>systemd</code> and can be configured just as easily. If someone is familiar with launchd configuration please fill this in.

== MS Windows ==
Open the startup folder by running the command <code>shell:startup</code> in a run dialog or by typing it in the Windows Explorer path bar. Place a shortcut to Emacs in this folder to run Emacs at boot. Change the target to <code>emacs --daemon</code> to run start it in daemon mode. The best option for more advanced Emacs daemon-mode configuration on Windows is still not settled, there is some discussion on the Emacs Wiki which could potentially be sifted through.

[[Category: Server]]

Emacs server

2015-06-22T21:25:52Z

Miabraha: /* In OS X */

Emacs includes an optional client-server architecture.

== Starting the Server ==

=== With <code>server-start</code> ===
To start a server in an existing Emacs session, run {{Command|server-start}}. A server started in this manner will close when the last visible Emacs frame closes. If you want Emacs to automatically run a server on startup, add the following to your configuration file.

<syntaxhighlight lang="lisp">
(server-start)
</syntaxhighlight>

=== With <tt>--daemon</tt> ===
Emacs 23 and higher provide the <tt>--daemon</tt> command-line argument, which will cause Emacs to immediately start a server and fork into the background. A server started in this manner is fully daemonized and will remain running even with no visible Emacs frames and after its parent terminal has closed (for example, after an SSH session has disconnected).

Note that, if using <tt>--daemon</tt>, your configuration file will be run while Emacs is still in a terminal. This may affect your theming if you usually use graphical Emacs.

{{Note}}This option is not supported on [[Windows]].

== Using Clients ==

Once the server is started you may use the <code>emacsclient</code> command outside of Emacs to send a file to Emacs for editing, e.g. <code>emacsclient ~/.emacs.d/init.el</code> to modify your init file. On a GNU/Linux system it might be a good idea to set your <tt>EDITOR</tt> environment variable to <tt>emacsclient</tt> or <tt>emacsclient -t</tt>. Using <tt>emacsclient</tt> without any arguments will cause the calling process to simply pause and wait for the Emacs server to report that it's done editing. Using <tt>emacsclient -t</tt> will cause the calling process to put up a text-mode frame in the same terminal.

If the server was started using <tt>--daemon</tt>, you should run <tt>emacsclient -t</tt> or <tt>emacsclient -nc</tt> to create a visible frame to interact with.
== Finishing Up ==

Once you have finished with a buffer that was opened via <tt>emacsclient</tt> you should use the {{CommandKeys|C-x #|server-edit}} to properly close the loop. Killing the buffer normally will not send the signal to <tt>emacsclient</tt> that Emacs has finished with the file.

If you're in an Emacs session that was started using <tt>--daemon</tt>, {{Keys|C-x C-c}} will only close the frame that it was invoked in. It will also signal to the client that owns the frame that its editing job is done, so <tt>emacsclient -c</tt> or <tt>emacsclient -t</tt> as <tt>EDITOR</tt> will behave much like a full <tt>emacs</tt> or <tt>emacs -nw</tt>.

To entirely close a server started with <tt>--daemon</tt>, run {{Command|save-buffers-kill-emacs}} in a frame.
= Adding To OS Startup =
== Linux ==

Configuration through the init daemon <code>systemd</code> is the preferred method of starting Emacs at launch on most major distributions, including Debian, Ubuntu, Fedora, OpenSUSE, Arch, and derivatives.

To tell systemd to start Emacs on init, place the following script <code>emacsd.service</code> in your systemd user configuration folder, replacing the location of the emacs executable if necessary. On Debian-based distributions, this file should be named <code>/etc/systemd/user/emacsd.service</code>.

[Unit]
Description=Emacs daemon

[Service]
Type=forking
WorkingDirectory=%h
ExecStart=/usr/bin/emacs --daemon
ExecStop=/usr/bin/emacsclient --e "(kill-emacs)"
Restart=always

[Install]
WantedBy=console.target

If systemd is not available on your distribution, you can simply add <code>/usr/bin/emacs --daemon</code> to your crontab. However using systemd is preferable because the process will begin up at boot, i.e. without depending on the <code>cron</code> process to start first.

== OS X ==
<code>launchd</code> is the OS X analog of <code>systemd</code> and can be configured just as easily. If someone is familiar with launchd configuration please fill this in.

== MS Windows ==
Open the startup folder by running the command <code>shell:startup</code> in a run dialog or by typing it in the Windows Explorer path bar. Place a shortcut to Emacs in this folder to run Emacs at boot. Change the target to <code>emacs --daemon</code> to run start it in daemon mode. The best option for more advanced Emacs daemon-mode configuration on Windows is still not settled, there is some discussion on the Emacs Wiki which could potentially be sifted through.

[[Category: Server]]

Emacs server

2015-06-22T21:25:41Z

Miabraha: Discuss starting on Windows

Emacs includes an optional client-server architecture.

== Starting the Server ==

=== With <code>server-start</code> ===
To start a server in an existing Emacs session, run {{Command|server-start}}. A server started in this manner will close when the last visible Emacs frame closes. If you want Emacs to automatically run a server on startup, add the following to your configuration file.

<syntaxhighlight lang="lisp">
(server-start)
</syntaxhighlight>

=== With <tt>--daemon</tt> ===
Emacs 23 and higher provide the <tt>--daemon</tt> command-line argument, which will cause Emacs to immediately start a server and fork into the background. A server started in this manner is fully daemonized and will remain running even with no visible Emacs frames and after its parent terminal has closed (for example, after an SSH session has disconnected).

Note that, if using <tt>--daemon</tt>, your configuration file will be run while Emacs is still in a terminal. This may affect your theming if you usually use graphical Emacs.

{{Note}}This option is not supported on [[Windows]].

== Using Clients ==

Once the server is started you may use the <code>emacsclient</code> command outside of Emacs to send a file to Emacs for editing, e.g. <code>emacsclient ~/.emacs.d/init.el</code> to modify your init file. On a GNU/Linux system it might be a good idea to set your <tt>EDITOR</tt> environment variable to <tt>emacsclient</tt> or <tt>emacsclient -t</tt>. Using <tt>emacsclient</tt> without any arguments will cause the calling process to simply pause and wait for the Emacs server to report that it's done editing. Using <tt>emacsclient -t</tt> will cause the calling process to put up a text-mode frame in the same terminal.

If the server was started using <tt>--daemon</tt>, you should run <tt>emacsclient -t</tt> or <tt>emacsclient -nc</tt> to create a visible frame to interact with.
== Finishing Up ==

Once you have finished with a buffer that was opened via <tt>emacsclient</tt> you should use the {{CommandKeys|C-x #|server-edit}} to properly close the loop. Killing the buffer normally will not send the signal to <tt>emacsclient</tt> that Emacs has finished with the file.

If you're in an Emacs session that was started using <tt>--daemon</tt>, {{Keys|C-x C-c}} will only close the frame that it was invoked in. It will also signal to the client that owns the frame that its editing job is done, so <tt>emacsclient -c</tt> or <tt>emacsclient -t</tt> as <tt>EDITOR</tt> will behave much like a full <tt>emacs</tt> or <tt>emacs -nw</tt>.

To entirely close a server started with <tt>--daemon</tt>, run {{Command|save-buffers-kill-emacs}} in a frame.
= Adding To OS Startup =
== Linux ==

Configuration through the init daemon <code>systemd</code> is the preferred method of starting Emacs at launch on most major distributions, including Debian, Ubuntu, Fedora, OpenSUSE, Arch, and derivatives.

To tell systemd to start Emacs on init, place the following script <code>emacsd.service</code> in your systemd user configuration folder, replacing the location of the emacs executable if necessary. On Debian-based distributions, this file should be named <code>/etc/systemd/user/emacsd.service</code>.

[Unit]
Description=Emacs daemon

[Service]
Type=forking
WorkingDirectory=%h
ExecStart=/usr/bin/emacs --daemon
ExecStop=/usr/bin/emacsclient --e "(kill-emacs)"
Restart=always

[Install]
WantedBy=console.target

If systemd is not available on your distribution, you can simply add <code>/usr/bin/emacs --daemon</code> to your crontab. However using systemd is preferable because the process will begin up at boot, i.e. without depending on the <code>cron</code> process to start first.

== In OS X ==
<code>launchd</code> is the OSX analog of <code>systemd</code> and can be configured just as easily. If someone is familiar with launchd configuration please fill this in.

== MS Windows ==
Open the startup folder by running the command <code>shell:startup</code> in a run dialog or by typing it in the Windows Explorer path bar. Place a shortcut to Emacs in this folder to run Emacs at boot. Change the target to <code>emacs --daemon</code> to run start it in daemon mode. The best option for more advanced Emacs daemon-mode configuration on Windows is still not settled, there is some discussion on the Emacs Wiki which could potentially be sifted through.

[[Category: Server]]

Emacs server

2015-06-22T21:17:10Z

Miabraha: /* Adding To OS Startup */

Emacs includes an optional client-server architecture.

== Starting the Server ==

=== With <code>server-start</code> ===
To start a server in an existing Emacs session, run {{Command|server-start}}. A server started in this manner will close when the last visible Emacs frame closes. If you want Emacs to automatically run a server on startup, add the following to your configuration file.

<syntaxhighlight lang="lisp">
(server-start)
</syntaxhighlight>

=== With <tt>--daemon</tt> ===
Emacs 23 and higher provide the <tt>--daemon</tt> command-line argument, which will cause Emacs to immediately start a server and fork into the background. A server started in this manner is fully daemonized and will remain running even with no visible Emacs frames and after its parent terminal has closed (for example, after an SSH session has disconnected).

Note that, if using <tt>--daemon</tt>, your configuration file will be run while Emacs is still in a terminal. This may affect your theming if you usually use graphical Emacs.

{{Note}}This option is not supported on [[Windows]].

== Using Clients ==

Once the server is started you may use the <code>emacsclient</code> command outside of Emacs to send a file to Emacs for editing, e.g. <code>emacsclient ~/.emacs.d/init.el</code> to modify your init file. On a GNU/Linux system it might be a good idea to set your <tt>EDITOR</tt> environment variable to <tt>emacsclient</tt> or <tt>emacsclient -t</tt>. Using <tt>emacsclient</tt> without any arguments will cause the calling process to simply pause and wait for the Emacs server to report that it's done editing. Using <tt>emacsclient -t</tt> will cause the calling process to put up a text-mode frame in the same terminal.

If the server was started using <tt>--daemon</tt>, you should run <tt>emacsclient -t</tt> or <tt>emacsclient -nc</tt> to create a visible frame to interact with.
== Finishing Up ==

Once you have finished with a buffer that was opened via <tt>emacsclient</tt> you should use the {{CommandKeys|C-x #|server-edit}} to properly close the loop. Killing the buffer normally will not send the signal to <tt>emacsclient</tt> that Emacs has finished with the file.

If you're in an Emacs session that was started using <tt>--daemon</tt>, {{Keys|C-x C-c}} will only close the frame that it was invoked in. It will also signal to the client that owns the frame that its editing job is done, so <tt>emacsclient -c</tt> or <tt>emacsclient -t</tt> as <tt>EDITOR</tt> will behave much like a full <tt>emacs</tt> or <tt>emacs -nw</tt>.

To entirely close a server started with <tt>--daemon</tt>, run {{Command|save-buffers-kill-emacs}} in a frame.
= Adding To OS Startup =
== Using Systemd ==

This is the preferred method of starting Emacs at launch on most major distributions, including Debian, Ubuntu, Fedora, OpenSUSE, Arch, and derivatives.

To tell systemd to start Emacs on init, place the following script <code>emacsd.service</code> in your systemd user configuration folder, replacing the location of the emacs executable if necessary. On Debian-based distributions, this file should be named <code>/etc/systemd/user/emacsd.service</code>.

[Unit]
Description=Emacs daemon

[Service]
Type=forking
WorkingDirectory=%h
ExecStart=/usr/bin/emacs --daemon
ExecStop=/usr/bin/emacsclient --e "(kill-emacs)"
Restart=always

[Install]
WantedBy=console.target

If systemd is not available on your distribution, you can simply add <code>/usr/bin/emacs --daemon</code> to your crontab. However using systemd is preferable because the process will begin up at boot, i.e. without depending on the <code>cron</code> process to start first.

== In OS X ==
<code>launchd</code> is the OSX analog of <code>systemd</code> and can be configured just as easily. If someone is familiar with launchd configuration please fill this in.

[[Category: Server]]

Emacs server

2015-06-22T21:15:56Z

Miabraha: /* Using Systemd */

Emacs includes an optional client-server architecture.

== Starting the Server ==

=== With <code>server-start</code> ===
To start a server in an existing Emacs session, run {{Command|server-start}}. A server started in this manner will close when the last visible Emacs frame closes. If you want Emacs to automatically run a server on startup, add the following to your configuration file.

<syntaxhighlight lang="lisp">
(server-start)
</syntaxhighlight>

=== With <tt>--daemon</tt> ===
Emacs 23 and higher provide the <tt>--daemon</tt> command-line argument, which will cause Emacs to immediately start a server and fork into the background. A server started in this manner is fully daemonized and will remain running even with no visible Emacs frames and after its parent terminal has closed (for example, after an SSH session has disconnected).

Note that, if using <tt>--daemon</tt>, your configuration file will be run while Emacs is still in a terminal. This may affect your theming if you usually use graphical Emacs.

{{Note}}This option is not supported on [[Windows]].

== Using Clients ==

Once the server is started you may use the <code>emacsclient</code> command outside of Emacs to send a file to Emacs for editing, e.g. <code>emacsclient ~/.emacs.d/init.el</code> to modify your init file. On a GNU/Linux system it might be a good idea to set your <tt>EDITOR</tt> environment variable to <tt>emacsclient</tt> or <tt>emacsclient -t</tt>. Using <tt>emacsclient</tt> without any arguments will cause the calling process to simply pause and wait for the Emacs server to report that it's done editing. Using <tt>emacsclient -t</tt> will cause the calling process to put up a text-mode frame in the same terminal.

If the server was started using <tt>--daemon</tt>, you should run <tt>emacsclient -t</tt> or <tt>emacsclient -nc</tt> to create a visible frame to interact with.
== Finishing Up ==

Once you have finished with a buffer that was opened via <tt>emacsclient</tt> you should use the {{CommandKeys|C-x #|server-edit}} to properly close the loop. Killing the buffer normally will not send the signal to <tt>emacsclient</tt> that Emacs has finished with the file.

If you're in an Emacs session that was started using <tt>--daemon</tt>, {{Keys|C-x C-c}} will only close the frame that it was invoked in. It will also signal to the client that owns the frame that its editing job is done, so <tt>emacsclient -c</tt> or <tt>emacsclient -t</tt> as <tt>EDITOR</tt> will behave much like a full <tt>emacs</tt> or <tt>emacs -nw</tt>.

To entirely close a server started with <tt>--daemon</tt>, run {{Command|save-buffers-kill-emacs}} in a frame.
= Adding To OS Startup =
== Using Systemd ==

This is the preferred method of starting Emacs at launch on most major distributions, including Debian, Ubuntu, Fedora, OpenSUSE, Arch, and derivatives.

To tell systemd to start Emacs on init, place the following script <code>emacsd.service</code> in your systemd user configuration folder, replacing the location of the emacs executable if necessary. On Debian-based distributions, this file should be named <code>/etc/systemd/user/emacsd.service</code>.

[Unit]
Description=Emacs daemon

[Service]
Type=forking
WorkingDirectory=%h
ExecStart=/usr/bin/emacs --daemon
ExecStop=/usr/bin/emacsclient --e "(kill-emacs)"
Restart=always

[Install]
WantedBy=console.target

If systemd is not available on your distribution, you can simply add <code>/usr/bin/emacs --daemon</code> to your crontab. However using systemd is preferable because the process will begin up at boot, i.e. without depending on the <code>cron</code> process to start first.

== In OS X ==
It is possible to use launchd to perform the very same behavior. If someone is familiar with launchd configuration please fill this in.

[[Category: Server]]

Emacs server

2015-06-22T21:15:44Z

Miabraha: /* Using Systemd */

Emacs includes an optional client-server architecture.

== Starting the Server ==

=== With <code>server-start</code> ===
To start a server in an existing Emacs session, run {{Command|server-start}}. A server started in this manner will close when the last visible Emacs frame closes. If you want Emacs to automatically run a server on startup, add the following to your configuration file.

<syntaxhighlight lang="lisp">
(server-start)
</syntaxhighlight>

=== With <tt>--daemon</tt> ===
Emacs 23 and higher provide the <tt>--daemon</tt> command-line argument, which will cause Emacs to immediately start a server and fork into the background. A server started in this manner is fully daemonized and will remain running even with no visible Emacs frames and after its parent terminal has closed (for example, after an SSH session has disconnected).

Note that, if using <tt>--daemon</tt>, your configuration file will be run while Emacs is still in a terminal. This may affect your theming if you usually use graphical Emacs.

{{Note}}This option is not supported on [[Windows]].

== Using Clients ==

Once the server is started you may use the <code>emacsclient</code> command outside of Emacs to send a file to Emacs for editing, e.g. <code>emacsclient ~/.emacs.d/init.el</code> to modify your init file. On a GNU/Linux system it might be a good idea to set your <tt>EDITOR</tt> environment variable to <tt>emacsclient</tt> or <tt>emacsclient -t</tt>. Using <tt>emacsclient</tt> without any arguments will cause the calling process to simply pause and wait for the Emacs server to report that it's done editing. Using <tt>emacsclient -t</tt> will cause the calling process to put up a text-mode frame in the same terminal.

If the server was started using <tt>--daemon</tt>, you should run <tt>emacsclient -t</tt> or <tt>emacsclient -nc</tt> to create a visible frame to interact with.
== Finishing Up ==

Once you have finished with a buffer that was opened via <tt>emacsclient</tt> you should use the {{CommandKeys|C-x #|server-edit}} to properly close the loop. Killing the buffer normally will not send the signal to <tt>emacsclient</tt> that Emacs has finished with the file.

If you're in an Emacs session that was started using <tt>--daemon</tt>, {{Keys|C-x C-c}} will only close the frame that it was invoked in. It will also signal to the client that owns the frame that its editing job is done, so <tt>emacsclient -c</tt> or <tt>emacsclient -t</tt> as <tt>EDITOR</tt> will behave much like a full <tt>emacs</tt> or <tt>emacs -nw</tt>.

To entirely close a server started with <tt>--daemon</tt>, run {{Command|save-buffers-kill-emacs}} in a frame.
= Adding To OS Startup =
== Using Systemd ==

This is the preferred method of starting Emacs at launch on most major distributions, including Debian, Ubuntu, Fedora, OpenSUSE, Arch, and derivatives.

To tell systemd to start Emacs on init, place the following script <code>emacsd.service</code> in your systemd user configuration folder, replacing the location of the emacs executable if necessary. On Debian-based distributions, this file should be named <code>/etc/systemd/user/emacsd.service</code>.

[Unit]
Description=Emacs daemon

[Service]
Type=forking
WorkingDirectory=%h
ExecStart=/usr/bin/emacs --daemon
ExecStop=/usr/bin/emacsclient --e "(kill-emacs)"
Restart=always

[Install]
WantedBy=console.target

If systemd is not available on your distribution, you can simply add <code>/usr/bin/emacs --daemon</code> to your crontab. However using systemd is preferable because the process will begin up at boot, i.e. without depending on the <code>cron</code> process to start first

== In OS X ==
It is possible to use launchd to perform the very same behavior. If someone is familiar with launchd configuration please fill this in.

[[Category: Server]]

Emacs server

2015-06-22T21:09:31Z

Miabraha: /* Adding To OS Startup */

Emacs includes an optional client-server architecture.

== Starting the Server ==

=== With <code>server-start</code> ===
To start a server in an existing Emacs session, run {{Command|server-start}}. A server started in this manner will close when the last visible Emacs frame closes. If you want Emacs to automatically run a server on startup, add the following to your configuration file.

<syntaxhighlight lang="lisp">
(server-start)
</syntaxhighlight>

=== With <tt>--daemon</tt> ===
Emacs 23 and higher provide the <tt>--daemon</tt> command-line argument, which will cause Emacs to immediately start a server and fork into the background. A server started in this manner is fully daemonized and will remain running even with no visible Emacs frames and after its parent terminal has closed (for example, after an SSH session has disconnected).

Note that, if using <tt>--daemon</tt>, your configuration file will be run while Emacs is still in a terminal. This may affect your theming if you usually use graphical Emacs.

{{Note}}This option is not supported on [[Windows]].

== Using Clients ==

Once the server is started you may use the <code>emacsclient</code> command outside of Emacs to send a file to Emacs for editing, e.g. <code>emacsclient ~/.emacs.d/init.el</code> to modify your init file. On a GNU/Linux system it might be a good idea to set your <tt>EDITOR</tt> environment variable to <tt>emacsclient</tt> or <tt>emacsclient -t</tt>. Using <tt>emacsclient</tt> without any arguments will cause the calling process to simply pause and wait for the Emacs server to report that it's done editing. Using <tt>emacsclient -t</tt> will cause the calling process to put up a text-mode frame in the same terminal.

If the server was started using <tt>--daemon</tt>, you should run <tt>emacsclient -t</tt> or <tt>emacsclient -nc</tt> to create a visible frame to interact with.
== Finishing Up ==

Once you have finished with a buffer that was opened via <tt>emacsclient</tt> you should use the {{CommandKeys|C-x #|server-edit}} to properly close the loop. Killing the buffer normally will not send the signal to <tt>emacsclient</tt> that Emacs has finished with the file.

If you're in an Emacs session that was started using <tt>--daemon</tt>, {{Keys|C-x C-c}} will only close the frame that it was invoked in. It will also signal to the client that owns the frame that its editing job is done, so <tt>emacsclient -c</tt> or <tt>emacsclient -t</tt> as <tt>EDITOR</tt> will behave much like a full <tt>emacs</tt> or <tt>emacs -nw</tt>.

To entirely close a server started with <tt>--daemon</tt>, run {{Command|save-buffers-kill-emacs}} in a frame.
= Adding To OS Startup =
== Using Systemd ==

During systemd's widespread adoption, part of the discussion which has been missed is the functionality it offers. To tell systemd to start Emacs on init, place the following script <code>emacsd.service</code> in your systemd user configuration folder, replacing the location of the emacs executable if necessary. On Debian-based distributions, this file should be named <code>/etc/systemd/user/emacsd.service</code>.

[Unit]
Description=Emacs daemon

[Service]
Type=forking
WorkingDirectory=%h
ExecStart=/usr/bin/emacs --daemon
ExecStop=/usr/bin/emacsclient --e "(kill-emacs)"
Restart=always

[Install]
WantedBy=console.target

If systemd is not available on your distribution, you can simply add <code>/usr/bin/emacs --daemon</code> to your crontab. However using systemd is preferable because the process will begin up at boot, i.e. without depending on the <code>cron</code> process to start first

== In OS X ==
It is possible to use launchd to perform the very same behavior. If someone is familiar with launchd configuration please fill this in.

[[Category: Server]]

Shell

2015-05-24T16:40:49Z

Miabraha: Cleaned up the shell mode hook stuff

'''Shell-mode''' gives access to a shell in a normal emacs buffer, meaning you can move around and edit it as usual. A drawback is that you can not launch programs like htop or other ncurses ones, like you would in term-mode.

= Usage =

== basics ==

{{Command|shell}}

Look at the menu: you have several keys to interact with the shell. Some of them are:

* {{Keys|M-p}} previous input of command line
* {{Keys|M-r}} search backward a regexp in commands' history (like C-r in term). Use C-r to cycle.
* {{Keys|C-c r}} go to beginning of output (useful when you have a large output and want to read through the beginning)
* {{Keys|C-c-p}} go to beginning of previous output group
* {{Keys|C-c-c}} send the '''C-c''' command to the shell
* {{Keys|C-c-o}} delete the output of the last command

To launch a shell in the directory of the current buffer, have a look to '''shell-here''': https://github.com/ieure/shell-here (available through ELPA).

== re-execute successive commands ==

Often it is useful to reexecute several successive shell commands that were previously executed in sequence. To do this, first find and reexecute the first command of the sequence. Then type {{Keys|C-c C-x}}, that will fetch the following command--the one that follows the command you just repeated. Then type RET to reexecute this command. You can reexecute several successive commands by typing {{Keys|C-c C-x RET}} over and over.

= Customisation =

== More colors ==

If you have bad colors in the output, try using '''ansi-mode''':

(require 'ansi-color)
(defun colorize-compilation-buffer ()
(toggle-read-only)
(ansi-color-apply-on-region (point-min) (point-max))
(toggle-read-only))
(add-hook 'compilation-filter-hook 'colorize-compilation-buffer)

You can highlight some text based on regexp (useful to see "OK" or warnings):

(add-hook 'shell-mode-hook (lambda () (highlight-regexp "\\[OK\\]" "hi-green-b")))

== Make URLs clickable ==

(add-hook 'shell-mode-hook (lambda () (goto-address-mode )))

== Make file paths clickable ==

Every line representing a path to a file will be colorized and made clickable, so that you can jump to that file and that line, like in compilation-mode (specially useful when compiling a program or running tests):

(add-hook 'shell-mode-hook 'compilation-shell-minor-mode)

Now you can use key bindings from the mode: use {{CommandKeys|C-x `|next-error}} (backquote) to go to the next error detected in the shell. You can't do that in an xterm !

== Shell completion with a nice menu à la zsh ==

So you are in shell-mode and you are annoyed that emacs opens a new window with the list of completions when you press TAB and you like the pop-up menu that zsh offers ? The solution is to ask [http://company-mode.github.io/ company-mode] to do the shell completion. It has a built-in backend ''company-capf'' which fetches completion candidates from emacs' ''completion-at-point-functions'' (the same mechanism that powers completion in the shell) as such completion offered by company is as accurate as the built-in shell-mode while making the user interface very convenient. We can activate it with:

(add-hook 'shell-mode-hook #'company-mode)
(define-key shell-mode-map (kbd "TAB") #'company-manual-begin))

And the result:

[[File:emacs-shell-company.png]]

== Change directory with ido-mode ==

Using [[ido]]'s completion system for changing directories is a big gain in usability and efficiency for emacs' shell. The little package [https://gitlab.com/emacs-stuff/fasd-shell fasd-shell] allows to use the '''fasd''' shell utility in conjonction with '''ido-completion''' to effectively change directories. Its code comes from this Stack Overflow question: http://stackoverflow.com/questions/20952995/emacs-shell-change-directory-with-ido

== Shared and persistent history ==

By default a shell session inside emacs via '''shell-mode''' won't persist accross sessions and won't read your shell's history. The '''history''' shell command works as expected, but you can't search (with '''M-r''') a command that you typed in shell-mode in another emacs instance or in a term. The following fixes that.

For '''comint-mode''' and derivatives (including '''shell-mode''') the searchable history is read in via '''comint-read-input-ring''', which uses '''comint-input-ring-file-name''' which you can set in a mode hook. However I would suggest that you actually set your HISTFILE environment variable to ~/.zsh_history because shell-mode automatically defers to that.

The documentation suggests that:

<source lang="lisp">
(add-hook 'shell-mode-hook 'my-shell-mode-hook)
(defun my-shell-mode-hook ()
(setq comint-input-ring-file-name "~/.zsh_history") ;; or bash_history
(comint-read-input-ring t))
</source>

Note that if you want to persist more variables (mini-buffer history,…), enable '''savehist-mode''' and configure the variables you wish to persist between sessions. See {{Command|customize-group RET savehist RET}}.

== Sync environment variables like $PATH from the shell ==

On OSx (and elsewhere ?) the $PATH environment variable and `exec-path' used by a windowed Emacs instance will usually be the system-wide default path, rather than that seen in a terminal window. The library [http://melpa.milkbox.net/#/exec-path-from-shell '''exec-path-from-shell'''] (in MELPA) allows the user to set Emacs' <code>exec-path</code> and $PATH from the shell path, so that <code>shell-command</code>, <code>compile</code> and the like work as expected. It also allows other environment variables to be retrieved from the shell, so that Emacs will see the same values you get in a terminal.

== Change directory or find files based on "frecency" with z/autojump/fasd ==

[https://github.com/clvv/fasd Fasd], z or autojump are popular shell tools for jumping around commonly used directories and (for fasd) to execute actions on files. It uses "[https://github.com/rupa/z/wiki/frecency frecency]" as a metric for determining which directory you intend to jump to based on keyword completions. So if I commonly cd to {{Filename|~/.ssh}}, I can <code>fasd ssh</code> to jump there.

The first question is: how to find files with these tools in Emacs ?

And next, since they work but can not use the built-in shell completion, how to get them use ido completion in emacs shell mode ?

=== Find files with fasd ===

There's an emacs package to find files with fasd: https://github.com/steckerhalter/emacs-fasd
If you want it to be more interactive, you can set:

(setq fasd-enable-initial-prompt nil) ;; don't ask for first query but fire fuzzy completion straight away.

=== Get ido completion to cd in shell ===

A great complementary thing with these tools is the use of the shell's completion to change directories, where zsh is a winner. Let's use [[ido]] for that. This feature is available as a minor mode with this code: https://gitlab.com/emacs-stuff/fasd-shell/tree/master

Now you can type <code>d my doc TAB</code> and ido will ask what directory (a directory that you already visited with the regular cd and that has both "my" and "doc" in its full path) to cd to.

== Use a buffer as $PAGER ==

This is possible with [https://github.com/mbriggs/emacs-pager emacs-pager]. Now things like ''less'' will open in a new buffer with colorized output.

= See also =

== shell-pop ==

'''shell-pop''' to pop up and pop out a shell buffer window easily (installable via ELPA), a bit like guake terminal in Gnome.

== Shell-here ==

Use [https://github.com/ieure/shell-here shell-here] to open an Emacs shell in the current directory.

== dirswitch ==

With [https://github.com/mickeynp/dirswitch.el dirswitch], cycle through directories you've visited, like in fish shell.

[[Category:Shell]]
[[Category:Intermediate]]