hannah-eee/arch-wiki-docs huggingface dataset:
PuTTY

Related articles
ssh
telnet
Proxy settings
PuTTY
is a port of the popular GUI SSH, Telnet, Rlogin and serial port connection client for Windows. It has support for advanced logging and termcap options, as well as a very configurable appearance and the ability to forward ports or create a SOCKS tunnel through an SSH destination. To start, simply run PuTTY, type the hostname of the host you would like to connect to and hit Open.
Installation
Install
putty
.
Configuration
The settings can be modified through the tabs on the left; however, they will be reset if not saved. To save your settings, type a name into the box under Saved Sessions and click save. To load it again later, click the name of your save and click load. This allows you to persist your visual, termcap and connection settings between connections and also lets you keep one save per regularly used host. The save "Default Settings" is automatically loaded every time you start PuTTY, so save under that name with care.
Importing keys
PuTTY uses its own format to store the private keys on the client side. To import a key that you had previously generated, you need to use the
puttygen
command.
$ puttygen
keyfile
-o
output-keyfile
.ppk
where
keyfile
is an existent private keyfile, and
output-keyfile
.ppk
is the file that will receive the key.
If the
keyfile
is protected with a passphrase, you will be prompted to input it, but the key will still be protected afterwards in the
output-keyfile
.ppk
.
After that, you can import it to make an SSH connection:
Connection > SSH > Auth > Private key file for authentication
and click on
Browse...
to add it.
256 color support
Settings > Connection > Data : Terminal-type string = putty-256color
To test color support, execute the following command
[1]
:
for code in {0..255}; do echo -e "\e[38;05;${code}m $code: Test"; done
See
256colours
for details.
Pydio

Pydio
(formerly AjaXplorer) is an open source web application, written in PHP, for file sharing and synchronization.
Installation
Install
the
pydio
AUR
package. Further you will need a database (e.g.
MariaDB
), a web server (
Apache HTTP Server
,
Lighttpd
or
Nginx
) with
PHP
-support. You may refer following sites:
Configuration
Make sure to adjust following variables to these minimal values in your
php.ini
:
/etc/php/php.ini
extension=exif
extension=gd
extension=iconv
extension=mysqli
session.save_path = "/tmp"
output_buffering = Off

file_uploads = On
post_max_size = 20G
upload_max_filesize = 20G
max_file_uploads = 20000
In this configuration, we will configure the
Nginx
web server to serve Pydio on localhost in the root location without SSL enabled (even though it is recommended to use it with SSL). First, place a copy of the Pydio Nginx configuration
# cp /usr/share/doc/pydio/nginx.conf.sample /etc/webapps/pydio/nginx.conf
replace the domain name
# sed -i 's/pydio.example.com/localhost/g' /etc/webapps/pydio/nginx.conf
and reference this configuration file in the main nginx.conf:
/etc/nginx/nginx.conf
http {
    [...]
    include /etc/webapps/pydio/nginx.conf;
    [...]
 }
Here is an example on how you could setup a database for Pydio with
MariaDB
called
pydio
for the user
pydio
identified by the password
password
:
CREATE DATABASE pydio;
GRANT ALL PRIVILEGES ON pydio.* TO pydio@'localhost' IDENTIFIED BY 'pydio';
FLUSH PRIVILEGES;
Do not forget to (re)start your services (e.g.
nginx.service
and
php-fpm.service
)!
Visit the installation wizard page at
http://127.0.0.1/
and follow the instructions.
pyLoad

This article or section needs language, wiki syntax or style improvements. See
Help:Style
for reference.
Reason:
Some of the shell prompts are wrong since it is not recommended/necessary to run this as root. (Discuss in
Talk:PyLoad
)
pyLoad
is a fast, lightweight and full featured download manager for many One-Click-Hoster, container formats like DLC, video sites or just plain http/ftp links (
supported hosts
). It aims for low hardware requirements and platform independence to be runnable on all kind of systems (desktop pc, netbook, NAS, router). Despite its strict restriction it is packed full of features just like webinterface, captcha recognition, unrar and much more.
pyLoad is divided into core and clients, to make it easily remote accessible.
Available clients (
screenshots
):
a web interface
a command line interface
a GUI written in Qt
and an Android client.
Installation
Install
pyload-ng
AUR
.
Configuration
Create all the files with:
# pyload
Note
This command must be run as the same user that will run pyload. For example if you run pyload as a daemon using the systemd service, either run this command as user pyload or change
/etc/systemd/system/pyload.service
to another user. If you choose to run this command as user pyload you will have to edit
/etc/passwd
to modify pyload's shell from
/bin/false
to
/bin/bash
.
This will give you a jump start, by providing a
basic
but
working
setup. Being a basic setup, there are more options and you should at least look at them, since some sections are untouched by the Assistant, like the permissions section.
Tip
Most (if not all) of the options can be changed with the web interface.
Manual
You can also directly edit
pyload.conf
(located in
~/.pyload/
by default.
While also editable with the web interface, you can change the plugins configuration by editing
~/.pyload/plugins.conf
.
Extraction passwords are stored in
~/.pyload/unrar_passwords.txt
.
Scripts
For more info on this read
/opt/pyload/scripts/Readme.txt
.
If you are interested in running userscripts, before running, you need to
# chown
user
/opt/pyload/scripts/
(the
user
being the one you defined in pyload.conf / permissions settings)
in order for pyLoadCore to create the necessary folders.
Running
Essential
# pyload
To run pyLoad in the background, use:
# pyload --daemon
Interfacing with pyLoad
Using the web interface, with default settings, then:
http://localhost:8000
Daemon
Tip
Do not forget to change
$USER
and
$GROUP
/etc/systemd/system/pyload.service
[Unit]
Description=Downloadtool for One-Click-Hoster written in python.
After=network.target

[Service]
ExecStart=/usr/bin/pyload
User=$USER
Group=$GROUP

[Install]
WantedBy=multi-user.target
To start pyload start
pyload
service.
To have it started automatically on boot, enable
pyload
service.
See also
List of applications/Internet#Download managers
PyPy

PyPy
is an alternate implementation of the
Python
2.7 and 3.11 interpreters. PyPy's benefits are in the area of speed, memory usage, sandboxing and stacklessness. It is compatible with CPython with
some exceptions
. PyPy also can be used to compile RPython programs to C code.
Installation
For Python 2.7, install the
pypy
package. For Python 3.11, install the
pypy3
package.
PyPy is installed in
/opt/pypy
or
/opt/pypy3
and the main pypy executable is
bin/pypy-c
.
Usage
Basic PyPy usage is done through the
pypy
or
pypy3
command and functions similarly to CPython usage. Enter
$ pypy -h
to view the listing of
pypy
options.
Interactive interpreter
To load the PyPy interactive interpreter, run
$ pypy
Run program from file
To run a Python program from a file in PyPy, run
$ pypy
example
.py
Virtual environment creation
To make a virtual environment with PyPy:
$ virtualenv --python=/usr/bin/pypy venv-pypy
See
Python/Virtual environment
for further information.
Installing pip
As Python packages for PyPy are not distributed as Arch packages, it is most convenient to install what you require as your own user:
$ pypy -m ensurepip --user
$ pypy -m pip install --user --upgrade pip
Once you have
pip
, you can install any package you need, e.g.,
sqlalchemy
:
$ pypy -m pip install --user sqlalchemy
If you would prefer to install packages system-wide, just run the previous commands as root without the
--user
. Note that this will result in the packages being installed in
/opt/pypy
without the package manager being aware of them.
EasyInstall
Python libraries and programs can be installed in PyPy through EasyInstall.
EasyInstall installation
EasyInstall does not come with the PyPy package but is automatically installed when installing
pip
and located at
/opt/pypy/bin/easy_install
.
Installing EasyInstall packages
To install the EasyInstall package
package_name
into PyPy, enter
# /opt/pypy/bin/easy_install
package_name
Packages will be located at
/opt/pypy/site-packages
. Installed libraries and applications will be at
/opt/pypy/bin
. Programs installed through EasyInstall on PyPy can usually be ran with
/opt/pypy/bin/program_name
where
program_name
is the name of the PyPy program.
EasyInstall package example
The following will install the Lamson email framework:
# /opt/pypy/bin/easy_install lamson
The following will run the framework's
gen -project
command:
$ /opt/pypy/bin/lamson gen -project
testproject
Qnix QX2710

This article is a short tutorial on how to get the QX2710 to work well on Linux.
Fixing X11 with Nvidia
By default, on some graphics drivers, the QX2710 will enter a debug mode and flip through colors when you start up
X
. The reason for this is that the driver is having issues reading the EDID from the monitor.
This issue with reading the EDID does not occur on Windows, so the read EDID can be acquired with a live Windows media. An example EDID bin that was exported using
Monitor Asset Manager
from Windows 11 is available for download
QX2710.bin
Copy the edid file to
/etc/X11/edid
(create the directory if needed)
Remove any nvidia-generated xorg configs in
/etc/X11/xorg.conf.d
Find the ID of the monitor through the following command
$ nvidia-xconfig --query-gpu-info
Another possibility is to look up the monitor id in the
/var/log/Xorg.0.log
file.
Create
/etc/X11/xorg.conf.d/60-qnix-edid.conf
and add the following to it (remember to change DFP-0 to your monitor ID)
/etc/X11/xorg.conf.d/60-qnix-edid.conf
Section "Device"
     Identifier     "Device0"
     Option         "CustomEDID" "DFP-0:/etc/X11/edid/QX2710.edid"
EndSection
Save the file then restart X. Your monitor should now be working.
Yet another possibility is to write a fixed EDID to the monitor with
EDID/DisplayID Writer
the program will detect that the checksum indicates the EDID is corrupt and will offer to fix the problem.
Razer Book 13 (2020)

This article or section does not follow the
Laptop page guidelines
.
Reason:
Misses an accessibility and function key section. IDs are not completed in the hardware table, too. (Discuss in
Talk:Razer Book 13 (2020)
)
Device
PCI/USB ID
Working?
GPU
8086:9a49
Yes
Wi-Fi
8086:a0f0
Yes
Speakers
8086:a0c8
Yes
Microphone
8086:a0c8
Yes
Touchpad
1532:026a
Yes
Webcam
13d3:5447
Yes
Bluetooth
8087:0026
Yes
Keyboard
1532:026a
Yes
SD-card reader
10ec:5260
Yes
Touchscreen
13d3:5447
Yes
The Razer Book 13 (2020) is an ultrabook introduced in late 2020. It features a 13.4" screen (UHD or FullHD), 11th-gen Intel Core processors (i5 or i7) and integrated
Intel Iris Xe graphics
.
Firmware
Razer is not participating in
fwupd
. Which means that firmware updates must be done using Windows.
Audio
This laptop requires
Sound Open Firmware
in order for the soundcard to work.
Keyboard
Keyboard lighting effects can be controlled using
openrazer-meta-git
AUR
. For more information visit
Razer peripherals
.
rbenv

Related articles
RVM
Chruby
Ruby
rbenv
(Simple Ruby Version Management) lets you easily switch between multiple versions of Ruby. It is simple, unobtrusive, and follows the UNIX tradition of single-purpose tools that do one thing well.
Another tool to be used for the same purpose is
RVM
.
Installation
Install
the
rbenv
package.
Plugins
rbenv can be extended via a plugin system, and the rbenv wiki includes a
list of useful plugins
. The
ruby-build
plugin is especially useful, as it allows you to install Ruby versions with the
rbenv install
command.
See also
Official web site
RecordMyDesktop

recordMyDesktop
is a
screencasting software
for X. It can record audio through ALSA, OSS or the JACK audio server. It is able capture through jack and thus is important for
pro-audio
video tutorials. recordMyDesktop only outputs to Ogg using Theora for video and Vorbis for audio.
Installation
Install
the
recordmydesktop
package.
Usage
The basic usage is simple and a man page (
recordmydesktop(1)
) is provided. Here is a simple example using jack for audio capture:
$ recordmydesktop --use-jack system:capture_1
Troubleshooting
The factual accuracy of this article or section is disputed.
Reason:
Is this section still relevant ? Last major edits to the page are from 2015 and 2012 (Discuss in
Talk:RecordMyDesktop
)
Current versions behave weird and need strange parameters to work properly. Here is an example that should help achieve non-choppy capture:
$ recordmydesktop --use-jack system:capture_1 --v_bitrate 2000000
Audio record is lagging
If it appears that you have lags (error message when starting from the shell:
Broken pipe: Overrun occurred
) in your audio record (often with Intel onboard cards) then it might help to change the audio device. This can be done in two ways.
Assuming that the terminal version is used then recordmydesktop should be started with:
$ recordmydesktop --device plughw:0,0
If a GUI is used then you can change the device from
DEFAULT
to
plughw:0,0
in the audio tab of the settings.
More information on this issue can be found
in this blog post
.
Audio record lags and is out of sync
Using the
plughw:0,0
device as described above may work partially for some Intel cards. You might try:
$ recordmydesktop --device plughw:0,0 --freq 22050 --channels 2
It seems the trick was to specify the correct number of channels generated by the input source (in this case, a stereo mic).
Audio record is distorted (slower/graver)
This happens at least with Rode Podcaster USB Microphone, and can be fixed by setting the frequency to
45000
:
$ recordmydesktop --device plughw:2,0 --freq 45000 --channels 2
No sound with PulseAudio
This is pretty simple, but should be better explained. If recordmydesktop exits like this:
Couldn't open PCM device hw:0,0
Error while opening/configuring soundcard hw:0,0
Try running with the --no-sound or specify a correct device.
Install the package
alsa-plugins
and then run it like:
$ recordmydesktop --device pulse
External Links
Wikipedia:RecordMyDesktop
using ffmpeg directly
Reflector

Related articles
Mirrors
Pacman
Reflector
is a Python script which can retrieve the latest mirror list from the
Arch Linux Mirror Status
page, filter the most up-to-date mirrors, sort them by speed and overwrite the file
/etc/pacman.d/mirrorlist
.
Installation
Install
the
reflector
package.
Alternatively, the
reflector-rs
AUR
package can be used as a drop-in replacement.
Usage
To see all of the available options, run the following command:
$ reflector --help
Note
It is typically not a good idea to filter by country; there are only a finite number of mirrors in a single country. Network throughput is only partly determined by geographical distance.
Examples
See
reflector(1) § EXAMPLES
.
Note
Examples overwriting
/etc/pacman.d/mirrorlist
need to be run as root. Make a backup before proceeding and verify the results afterwards.
Automation
systemd service
Reflector ships with
reflector.service
, which runs Reflector using the options specified in
/etc/xdg/reflector/reflector.conf
. The default options in that file provide a good starting point and example.
Enable
reflector.service
to run Reflector on boot. To run it immediately,
start
the service.
Note
reflector.service
depends on a network wait service to be configured via
network-online.target
.
systemd timer
Reflector provides a
systemd timer
(
reflector.timer
) that starts the
#systemd service
reflector.service
weekly. The schedule can be changed by
editing
reflector.timer
.
For changing the default options that
reflector.service
gets started with, edit the configuration file as described in
#systemd service
. Then,
start
and
enable
reflector.timer
.
To refresh the mirrorlist ahead of schedule,
start
reflector.service
.
Note
Having both
reflector.service
and
reflector.timer
enabled is redundant. With the service enabled, Reflector will run on every boot. To make it only run weekly, as originally designed for the timer, enable only the timer. The service does not to be in the
enabled
state for the timer to function.
pacman hook
pacman-mirrorlist
is not updated regularly, invoking reflector because a mirror in some part of the globe was added or removed is not relevant; use the
#systemd timer
approach instead. If you do not want
mirrorlist.pacnew
to be installed at all, use
NoExtract
in
/etc/pacman.conf
.
See also
Reflector thread on the Arch Linux Forums
Upstream project page including changelog
Remind

Remind
is a sophisticated calendar and alarm program.
Installation
Install
the
remind
package.
Configuration
After installation, the user can define reminders in remind script files (
.rem
). A good place for these files could be
~/.config/remind
.
Here are some example reminders that could be in the remind script:
~/.config/remind/reminders.rem
REM Jan 1 MSG Remind every year on new years day
REM January 1 2015 MSG Remind only on new years day 2015
REM Sunday 2 MSG Remind every second Sunday
REM March Monday 1 --7 MSG remind on the last Monday of February
REM December 25 +30 MSG Christmas
The last particular day of a month is given by subtracting 7 days from the first day of the next month. The
+
symbol tells remind to start reminding that number of days ahead.
See also
remind(1)
man page
for detailed information about configuring
remind
.
Include
A reminder script can also include any number of external scripts. For example, a user might want to have a separate file for birthday reminders and a separate file for holidays. This can be done like so:
include ~/.config/remind/birthdays.rem
include ~/.config/remind/holidays.rem
Usage
The simplest thing one can do with remind, is to check for reminders. Do this by passing a reminder file to
remind
:
remind ~/.config/remind/reminders.rem
This will output a list of reminders that it is scheduled to tell the user about.
To output a text based calendar, use the
-c
option:
remind -c1 ~/.config/remind/reminders.rem
This will output a text calendar for the current month. To print months in advance, replace
1
with the number of months to print.
Postscript/pdf calendars
It is also possible to create calendars in a postscript format.
remind -c2 -p ~/.config/remind/reminders.rem | rem2ps > calendar.ps
The
-p
option makes
remind
print output suitable for
rem2ps
.
rem2ps
by default prints the output to standard output, so it must be redirected to a file so it can be opened by a program like
evince
.
Postscript
files can be converted with
ps2pdf
. Ps2pdf is provided by
ghostscript
.
See also
remind(1)
man page
Remind wiki index
Tim's blog - How I use remind(1)
Remmina

Related articles
Rdesktop
xrdp
Remmina
is a remote desktop client written in
GTK
hosted on Gitlab
[1]
. It supports the following protocols: SSH, VNC, RDP, X2Go, HTTP(S)
Installation
Install
the
remmina
package.
For VNC support install the
libvncserver
or the
gtk-vnc
package.
For SPICE support install the
spice-gtk
package.
For RDP support, also install the optional
freerdp
.
For X2Go support, also install the optional
pyhoca-cli
AUR
.
Password saving depends on
GNOME Keyring
or
KDE Wallet
.
Note
If one of the protocols (e.g. RDP) is not available in the Remmina dropdown menu after installing the required package, make sure to completely quit Remmina first: run
killall remmina
. When you restart Remmina, the protocol should be available.
Configuration
Remmina stores settings and connection profiles under
$XDG_CONFIG_HOME/remmina
.
File
Purpose
remmina.pref
Application preferences
*.remmina
Connection profiles
System-wide defaults from
/etc/xdg/remmina
are copied to the user’s configuration directory on first run.
Usage
Remmina connection profiles are saved connection to connect to your servers, the file name is autogenerated, but you can create manually your own files with the FILE name you prefer.
Profiles can be created through the GUI or manually by placing a
.remmina
file in
$XDG_CONFIG_HOME/remmina
.
To connect with a saved profile:
$ remmina -c /path/to/example.remmina
Quick connect with URIs
Remmina supports URI-based quick connections:
RDP:
remmina -c rdp://user@example.com
RDP with domain:
remmina -c rdp://DOMAIN\\user@example.com
VNC:
remmina -c vnc://user@example.com
VNC with query string:
remmina -c vnc://example.com?VncUsername=user
SSH:
remmina -c
ssh://user@example.com
SPICE:
remmina -c spice://example.com
Using encrypted passwords
URIs can embed encrypted passwords:
rdp://user:ENCRYPTED@server
vnc://user:ENCRYPTED@server
Generate an encrypted password with:
$ remmina --encrypt-password
Updating profiles from the command line
Profile options can be updated non-interactively. Example:
$ echo "mypassword" | remmina --update-profile ~/.config/remmina/example.remmina \
  --set-option username=user \
  --set-option resolution_mode=2 \
  --set-option password
Tips and tricks
Command-line usage is documented at
remmina --help
.
For advanced configuration, see the upstream
Remmina wiki
.
See also
Remmina GitLab Repository
https://gitlab.com/Remmina/Remmina/-/wikis/Home
Reposilite

From the project
repository
, reposilite is a:
Lightweight and easy-to-use repository manager for Maven based artifacts in JVM ecosystem. This is simple, extensible and scalable self-hosted solution to replace managers like Nexus, Archiva or Artifactory, with reduced resources consumption.
Installation
Install
the
reposilite
AUR
package. It can also be downloaded through
Github Releases
.
Package contents
Configuration
Configuration files are located in
/etc/reposilite
:
default.env
: configuration variables used to run reposilite (allocated memory, user, working directory, configuration location)
reposilite.cdn
: main reposilite configuration file
Data directory
Reposilite data is stored in
/var/lib/reposilite
. This include default shared configuration database as well as repositories contents.
Service files
The package contains the
reposilite.service
systemd unit. It is not enabled by default.
Usage
Reposilite does the majority of its configuration through the web interface. When you first install reposilite you will not have any user to login as (reposilite designates users as "tokens"). Before creating the first token, ensure that
reposilite.service
is
stopped
.
Run the reposilite binary as root:
# /usr/bin/reposilite
This will start the server and a CLI interface in the terminal; the next set of commands will be run from the CLI (we will use
!
to indicate that these command are run in the reposilite CLI):
! token-generate
username
m
Remember to replace
username
with the desired username, it is best to let reposilite generate you a secure token, but if you wish to use your own token, you can use the following command:
! token-generate --secret="
your password
"
username
m
Warning
Do not use a weak token, if it is too easy to break an attacker could break into your reposilite server and potentially have access to your servers filesystem!
Note
The trailing "m" character is used to give the user manager permissions (commonly known as an administrator, or root user within other applications), this will allow the user to configure reposilite, therefore keep this user safe!
Now that you have generated the username (if you let reposilite generate your token, make sure to copy this down securely, a password manager is recommended), you can stop the reposilite server using the following command:
! stop
Reposilite will then gracefully shutdown and detach from your terminal.
You can now
start/enable
reposilite.service
and you will be able to access the reposilite web interface over
http://127.0.0.1:8080
.
RepRap

This article or section is a candidate for moving to
3D Printing
.
Notes:
RepRap is a project from the early days of hobbyist 3D printing and is much less relevant these days. Mention of several pieces of popular and heavily used modern software such as PrusaSlicer and OctoPrint is missing as well. It would be better to migrate to a generic 3D printing page with RepRap as a subsection. (Discuss in
Talk:RepRap
)
RepRap is an open-source 3D printer project. A RepRap prints objects of plastic and is intended for rapid-prototyping, the printer itself is built with small plastic parts which can be printed out and replaced. This page explains how to install RepRap host software on Arch Linux and how to print 3D models. More information is available on the
RepRap homepage
.
Installation
Note
Custom firmware may be available to you from your electronics supplier, it may even be pre-installed.
Many of the controller chips for RepRap are arduino based, or arduino derived (such as Melzi). Figure out what electronics you have from the RepRap
Official Electronics
page. You will also find what firmware you have on that page.
Follow the
arduino
wiki page if you have an arduino based controller. Do the Installation and Configuration steps.
Install the host software by following this guide
Installing RepRap on your computer
. There are alternative host software solutions which are easier to install and are described in the following sections.
Configuration
Note
If you do not have firmware installed on your electronics, you may not be able to connect via USB or control the motors.
Connect your 3D printer to your computer and run the host software. Use the host software's user interface to send commands to the printer.
Warning
If you have not tested your printer previously, make sure you have your hand on the emergency stop button (your power plug). Do not let the hotend go through the hotbed, if the stepper motors do not stop when they reach the end stoppers or move the wrong way, stop the printer and check your wiring.
Host software alternatives
See
List of applications/Science#3D printing
.
See also
Calibration
https://youtu.be/wAL9d7FgInk
http://calculator.josefprusa.cz/
https://reprap.org/wiki/Calibration
https://reprap.org/wiki/Triffid_Hunter%27s_Calibration_Guide
https://www.thingiverse.com/thing:5573
https://web.archive.org/web/20220907014303/https://sites.google.com/site/repraplogphase/calibration-of-your-reprap
3D models & STL files
https://www.thingiverse.com/
Manual
http://reprapbook.appspot.com/
Reset lost root password

This guide will show you how to reset a forgotten
root
password. Several methods are listed to help you accomplish this.
Warning
An attacker could use some of the methods mentioned below to break into your system. No matter how secure the operating system is or how good passwords are, having physical access amounts to loading an alternate OS and exposing your data, unless you use
data-at-rest encryption
.
Using sudo
If you have installed
sudo
and have configured permissions for either the
wheel
group or a user whose password you recall, you can change the root password by running
sudo passwd root
.
Using the debug shell
Append
systemd.debug_shell
to the
kernel parameters
.
This will do a normal boot but start
debug-shell.service
which runs a root shell (
/bin/sh
) on
tty9
. Press
Ctrl+Alt+F9
to access it.
Use the
passwd
command to create a new password for the root user.
When done,
stop
debug-shell.service
.
Using bash as init
Append the
init=/bin/bash
kernel parameter
to your boot loader's boot entry.
Your root file system is mounted as read-only now, so remount it as read/write:
mount -n -o remount,rw /
.
Use the
passwd
command to create a new password for the root user.
Reboot by typing
reboot -f
and do not lose your password again!
Note
Some keyboards may not be loaded properly by the init system with this method and you will not be able to type anything at the bash prompt. If this is the case, you will have to use another method.
Using a LiveCD
With a
LiveCD
a couple methods are available: change root and use the
passwd
command, or erase the password field entry directly editing the password file. Any Linux capable LiveCD can be used, albeit to change root it must match your installed architecture type. Here we only describe how to reset your password with chroot, since manual editing the password file is significantly more risky.
Change root
Boot the LiveCD and
mount
the root partition of your main system.
Use the
passwd --root
MOUNT_POINT
USER_NAME
command to set the new password (you will not be prompted for an old one).
Unmount the root partition.
Reboot, and enter your new password.
See also
How To Reset A Forgotten Root Password With Knoppix
Early Debug Shell
RethinkDB

RethinkDB
is a document-oriented database similar to
MongoDB
but aims to overcome scalability and practical limitation of the latter.
[1]
[2]
RethinkDB is built to store JSON documents, and scale to multiple machines with very little effort. It has a pleasant query language that supports queries such as table joins and group by. It is easy to setup and learn.
Installation
Install
rethinkdb
AUR
from the official repositories.
Create and set user rights for RethinkDB folder:
# mkdir /var/lib/rethinkdb/default
# chown -R rethinkdb:rethinkdb /var/lib/rethinkdb/
Now you can start
rethinkdb
from the command-line:
# rethinkdb
Alternatively,
start
and
enable
rethinkdb@default
.
RethinkDB's admin UI is now available on port
8080
.
Configuration
RethinkDB has multi-instance support, which means you can run several independent database instances on the same machine. The
systemd
service also supports multi-instance configuration.
To create a new RethinkDB instance, create its configuration file:
# cd /etc/rethinkdb
# cp instances.d/default.conf instances.d/
Name
.conf
where
Name
represents the configuration you will be using later. Change the configuration options in the new file. Then
start/enable
rethinkdb@
Name
.service
.
The 'default' instance is created at installation time for your convenience. Its data is stored in
/var/lib/rethinkdb/default
.
Ripcord

Ripcord
is a lightweight desktop chat client for group-centric services like
Slack
and
Discord
built upon the
Qt
toolkit. It is proprietary, closed-source software released under a
shareware license
which allows the Discord module to be used free of charge while locking Slack usage behind purchase.
Installation
Install the
ripcord
AUR
package.
Emoji glitch
There is a bug with some emoji fonts (known:
noto-fonts-emoji
,
ttf-joypixels
AUR
,
ttf-twemoji
AUR
) which generates rendering glitches, currently not fixed.
Emoji fonts known to behave well include
ttf-twemoji-color
AUR
and
ttf-symbola
AUR
, so it is recommended to use one of them. Otherwise, the Experimental tab of the Preferences window offers an option to override the system font for Ripcord only.
Some users have reported that
using system libraries
solves the issue.
For further updates and information, see the relevant
ticket
on the issue tracker.
Using system libraries
Warning
The following hack is not supported or guaranteed to work in any way.
The Ripcord AppImage bundles its own copy of required libraries, which are also used by the AUR package. It is however possible to force the program to load libraries preexisting in the system. The main advantage of this is better integration with the
desktop environment
and Arch as a whole. The main disadvantage is that system libraries might be incompatible with the Ripcord release in use.
Note
ripcord-arch-libs
AUR
replaces
ripcord
AUR
and automates the following procedure.
Otherwise, you may proceed as follows:
Install packages
qt5-base
,
qt5-imageformats
,
qt5-multimedia
,
qt5-svg
,
qt5-websockets
AUR
and
qt5-x11extras
(more may be necessary, if you find so please amend this list).
Reach directory
/usr/lib/ripcord
or, if you would rather not touch managed files, download the AppImage, run it with
--appimage-extract
and cd to
squashfs-root
.
Wipe or better move to a backup location the contents of the
lib
folder you find there, leaving the folder itself intact.
Run
ln -s /usr/lib/libsodium.so lib/libsodium.so.18
.
Delete or move to a backup location the whole
plugins
folder.
Set environment variable
QT_QPA_PLATFORM_PLUGIN_PATH=/usr/lib/qt/plugins
.
Finally, run the executable.
IME
If you need to use an
input method
framework,
IBus
is known to behave well out of the box, while
Fcitx
seems to require following the steps in
using system libraries
.
River

Related articles
River Classic
Wayland#Compositors
Note
This page is about the non-monolithic version of River, if you're looking for the dynamic tiling version look at
River Classic
According to
River's homepage
:
River is a non-monolithic Wayland compositor. Unlike other Wayland compositors, river does not combine the compositor and window manager into one program. Instead, users can choose any window manager implementing the river-window-management-v1 protocol.
The stated goals for River is to make getting into Wayland development easier and to allow its "window managers" to be more experimental as they don't need to write a whole compositor. This also allows for things not normally possible with Wayland Compositors such as reloading configurations without closing all windows.
Installation
River is
installed
with the
river
package.
A separate window manager will need to be installed as well. See also
River's wiki
for a more comprehensive list of window managers.
Stacking
Canoe
— Stacking window manager with classic look and feel written in Rust.
https://github.com/roblillack/canoe
||
canoe
AUR
Tiling
Kwm
— Window manager inspired by
dwm
with its built in bar.
https://github.com/kewuaa/kwm
||
kwm
AUR
Other
Rill
— A minimalist scrolling window manager with simple animation.
https://codeberg.org/lzj15/rill
||
rill
AUR
Starting
River can be started by a
display manager
or with the command below.
river
River can be started with select window manager with the "c" argument.
river -c foo
Configuration
River is configured through a executable shell file, by default it is located in
$XDG_CONFIG_HOME/river/init
. By default this is
~/.config/river/init
.
River can use a different configuration if it is called with the "c" argument.
river -c customConfPath
Selecting a default window manager
A window manager can be made the default by appending it to River's configuration file.
Autostart
Since the configuration is executed by the
bourne shell
. Commands placed inside the configuration will be executed on start up, certain window managers also allow for autostarting in their configurations.
Input configuration
Input configuration can be done in multiple ways. Some window managers support input configuration.
There are separate  input managers such as
Channel
and
kwim
AUR
that can be used.
If only the keyboard layout needs to be changed. Change the
environment variable
XKB_DEFAULT_LAYOUT
to the needed layout; example "gb" for UK keyboards.
Troubleshooting
Configuration file does nothing
This may be caused by the configuration file lacking execution permissions. See
File permissions and attributes
.
Screencast via WebRTC does not work
See
River Classic#Troubleshooting
.
See also
River protocols specifications
Example window manager
River wiki
Official Codeberg repository
rkhunter

Related articles
Security
List of applications/Security
AIDE
rkhunter
(Rootkit Hunter) is a security monitoring tool for POSIX compliant systems. It scans for rootkits, and other possible vulnerabilities. It does so by searching for the default directories (of rootkits), misconfigured permissions, hidden files, kernel modules containing suspicious strings, and comparing hashes of important files with known good ones.
It is written in
Bash
, to allow for portability, and can run on most UNIX-based systems.
Installation
Install
the
rkhunter
package.
Configuration
Initial setup
Prior to running rkhunter for the first time, update the
file properties database
:
# rkhunter --propupd
Important files
The main configuration file is located at
/etc/rkhunter.conf
.
By default, a log of the last system check will be placed at
/var/log/rkhunter.log
.
Usage
See
rkhunter(8)
for full details.
Basic commands
To update the file properties database:
# rkhunter --propupd
It is necessary to ensure that the rkhunter data files are kept up-to-date by running:
# rkhunter --update
To run a system check:
# rkhunter --check --sk
To validate the configuration file(s):
# rkhunter --config-check
Troubleshooting
False positives
Out of the box, Rootkit Hunter will throw up some false warnings during the file properties check. This occurs because a few of the core utilities have been replaced by scripts. These warnings can be muted through white-listing:
/etc/rkhunter.conf
SCRIPTWHITELIST=/usr/bin/egrep
SCRIPTWHITELIST=/usr/bin/fgrep
SCRIPTWHITELIST=/usr/bin/ldd
SCRIPTWHITELIST=/usr/bin/vendor_perl/GET
See also
External documentation
Rootkit Hunter Homepage
Rootkit Hunter README
Rootkit Hunter FAQ
Related Wikipedia pages
rkhunter
Host-based intrusion detection system (HIDS)
Intrusion detection system (IDS)
Rockbox

Related articles
Codecs
FAT
Rockbox
is a free replacement firmware for digital audio players (MP3 players). Its enhancements include support for pretty much all
codecs
, advanced sound settings, applications, utilities and games.
Tip
Rockbox can often be installed alongside the original firmware.
Check if your device has a usable Rockbox port:
https://www.rockbox.org/
.
Installation
Rockbox Utility
The official tool to manage Rockbox can be
installed
with the
rbutil
package.
Rockbox Utility
can install the replacement boot loader, the main firmware, and any extra features like fonts, themes and applications.
Installing Rockbox on your device
The Rockbox project has fantastic install instructions. You can find them at
https://www.rockbox.org/manual.shtml
.
Boot loader
It is recommended to install the boot loader using
#Rockbox Utility
. For Rockbox Utility to detect your player, it must have write access to the internal disk of the player.
Tip
As you need write access to the player disk, you could grant that when
mounting
. For example:
# mount -o uid=
1000
,gid=
1000
/dev/
sdb
/mnt
Backup
#Rockbox Utility
can make backups of your device.
Rosegarden

Rosegarden
is a digital audio workstation program written in Qt. It acts as an audio and MIDI sequencer, scorewriter and musical composition and editing tool. It is intended to be a free alternative to such applications as Cubase.
Installation
Install
the
rosegarden
package. Be sure to install a
MIDI
setup first.
Configuration
Customizing keyboard shortcuts
The keyboard shortcuts in rosegarden can be customized by editing a set of XML configuration files. The first step is to download the default configuration files which are packaged with the source code, and place them in
~/.local/share/rosegarden/rc
. A simple way of doing this is to run:
$ cd ~/.local/share/rosegarden
$ svn co
http://svn.code.sf.net/p/rosegarden/code/trunk/rosegarden/data/rc
which will get the configuration files from the development branch of the source code.
Note
The above procedure gets the configuration files from the development branch of Rosegarden, which could possibly be incompatible with the stable release. If needed, the
rc
directory can be found at
data/rc
in the stable release's source tarball instead.
Keyboard shortcuts can then be set or modified by editing the appropriate file in
~/.local/share/rosegarden/rc
. For example, in order to map the
Space
bar to play/pause, edit the following lines of
rosegardenmainwindow.rc
:
~/.local/share/rosegarden/rc/rosegardenmainwindow.rc
<Action name="play" text="&Play" icon="transport-play" shortcut="Ctrl+Enter, Enter, Media Play, Ctrl+Return, Space" shortcut-context="application" />
<Action name="recordtoggle" text="P&unch in Record" icon="transport-record" shortcut="" shortcut-context="application" />
Usage
With Timidity and PulseAudio
Launch
Timidity
as a
daemon
before launching Rosegarden:
$ timidity -iA
This way, Rosegarden will not launch
jackd
and you will still be able to hear sound from other running applications.
See also
Professional audio
rss2email

Related articles
Web feed
List_of_applications/Internet#News,_RSS,_and_blogs
rss2email
is a free tool for retrieving content from RSS feeds and mailing it. It is useful for those who do not want yet another program with which to keep up and for people who have a system for e-mail management that they would like to apply to their RSS feeds as well. People with lots of e-mail often have highly customized systems that let them process their mail efficiently; rss2email allows them to easily apply this system to their feeds as well.
Installation
Install
the
rss2email
package.
Adding feeds
First, tell
rss2email
where it should send feeds by running the command:
$ r2e new
user@example.com
Next, subscribe to an RSS feed. For example, to subscribe to the Arch Linux package updates feed, run:
$ r2e add
name-for-rss
https://www.archlinux.org/feeds/packages/
e-mail address
Note that an e-mail address only has to be given if the feed is to be delivered to an address other than the default one; otherwise, leaving off the e-mail address is acceptable.
After a new feed is added,
rss2email
will e-mail every post it has not previously e-mailed. The first time it is run, therefore, it will e-mail every post. To avoid this behavior, after adding a new feed, run:
$ r2e run --no-send
Getting RSS feeds
To get new stories, execute the command:
$ r2e run
To automate this process and have
rss2email
check for new feeds every 30 minutes, see
Autostarting#On time events
.
Managing rss2email
This article or section needs expansion.
Reason:
Need to add permission info. (Discuss in
Talk:Rss2email
)
To view feeds previously added to rss2email, run:
r2e list
This will output a numbered list of feeds. To delete a feed, run:
r2e delete
number
where
number
is the number of the feed to be deleted.
To change the default e-mail address, run:
r2e email
new_address@example.net
Advanced configuration
The following configuration changes should be made in
rss2email.cfg
, which should be located at
~/.config/rss2email.cfg
.
To have RSS entries sent as HTML e-mails instead of as plain text, set:
HTML-MAIL = 1
To receive new e-mails when RSS posts are updated, set:
TRUST-GUID = 0
To set the date header of e-mails to when the RSS post was written, rather than when the e-mail is actually sent, set:
DATE-HEADER = 1
To fix the error message "sender domain must exist" or to change the address from which e-mails are sent, set:
FROM = user@example.com
To force all feeds to use this address, even if they have their own address set, use:
FORCE-FROM = 1
To have rss2email automatically wrap long lines, set:
BODY-WIDTH = 72
Where 72 is the number of characters after which rss2email should start a new line.
To send mail using an SMTP server rather than the local machine, use:
SMTP_SEND = 1
SMTP_SERVER =
smtp.example.com:25
If the SMTP server requires authentication, set:
SMTP-AUTH = 1
SMTP-USERNAME =
user@example.com
SMTP-PASSSWORD =
password
See also
https://web.archive.org/web/20100412191758/http://www.allthingsrss.com/rss2email/?page_id=31#unix
- Official getting started page
https://www.linux.com/archive/feed/50469
- linux.com article.
Ruby package guidelines

Arch package guidelines
32-bit
–
CLR
–
CMake
–
Cross
–
DKMS
–
Eclipse
–
Electron
–
Font
–
Free Pascal
–
GNOME
–
Go
–
Haskell
–
Java
–
KDE
–
Kernel modules
–
Lisp
–
Meson
–
MinGW
–
Node.js
–
Nonfree
–
OCaml
–
Perl
–
PHP
–
Python
–
R
–
Ruby
–
Rust
-
Security
–
Shell
–
VCS
–
Web
–
Wine
This document covers standards and guidelines on writing
PKGBUILDs
for software that uses
ruby
.
Package naming
For libraries, use
ruby-$_name
(where
$_name
is the upstream project name). For applications, use the project name (without the
ruby-
prefix) and optionally add
ruby-$_name
to
provides
.
Build and tests
Ruby packages should be built from upstream sources as this provides a transparent chain of trust for the build. To ensure integration with the existing set of Ruby packages, it is expected to run tests using
ruby-rake
or
ruby-rspec
.
Note
To detect dependency changes in between releases of a project, have a close look at the
.gemspec
or
Gemfile
upon update.
Template
PKGBUILD
prepare() {
  cd "${_name}-${pkgver}"

  # update gemspec/Gemfile to allow newer version of the dependencies
  sed --in-place --regexp-extended 's|~>|>=|g' "${_name}.gemspec"
}

build() {
  cd "${_name}-${pkgver}"

  local _gemdir="$(gem env gemdir)"

  gem build "${_name}.gemspec"

  gem install \
    --local \
    --verbose \
    --ignore-dependencies \
    --build-root "tmp_install" \
    "${_name}-${pkgver}.gem"

  # remove unrepreducible files
  rm --force --recursive --verbose \
    "tmp_install/${_gemdir}/cache/" \
    "tmp_install/${_gemdir}/gems/${_name}-${pkgver}/vendor/" \
    "tmp_install/${_gemdir}/doc/${_name}-${pkgver}/ri/ext/"

  find "tmp_install/${_gemdir}/gems/" \
    -type f \
    \( \
      -iname "*.o" -o \
      -iname "*.c" -o \
      -iname "*.so" -o \
      -iname "*.time" -o \
      -iname "gem.build_complete" -o \
      -iname "Makefile" \
    \) \
    -delete

  find "tmp_install/${_gemdir}/extensions/" \
    -type f \
    \( \
      -iname "mkmf.log" -o \
      -iname "gem_make.out" \
    \) \
    -delete
}

check() {
  cd "${_name}-${pkgver}"

  local _gemdir="$(gem env gemdir)"

  GEM_HOME="tmp_install/${_gemdir}" rake test
}

package() {
  cd "${_name}-${pkgver}"

  cp --archive --verbose tmp_install/* "${pkgdir}"

  install --verbose -D --mode=0644 LICENSE --target-directory "${pkgdir}/usr/share/licenses/${pkgname}"
  install --verbose -D --mode=0644 *.md --target-directory "${pkgdir}/usr/share/doc/${pkgname}"
}
Tips and tricks
The gem is deriving the files to add with "git ls-files"
In this case you can add the following
sed
command to the
prepare()
function:
# we don't build from a git checkout
sed --in-place --regexp-extended 's|git ls-files|find . -type f -not -path "*/\.git/*"|' "${_name}.gemspec"
The upstream project is using "rspec" to run tests
In this case you can replace the code line in the
check()
function with the following:
GEM_HOME="tmp_install/${_gemdir}" rspec
See also
Ruby language documentation
Rake documentation
Rubygems documentation
ruby(1)
Rygel

Rygel
is a streaming media server compatible with many
DLNA
/
UPnP
clients including the Sony PlayStation, Microsoft Xbox, smart televisions, DLNA speakers and many smartphones. Rygel will automatically transcode media to a format compatible with the client device. It can also utilise published media hierarchies from external applications like
Rhythmbox
and DVB Daemon through the D-Bus MediaServer specification. It is under active development and is a part of the
GNOME
project.
Installation
Install
the
rygel
package.
Starting
On a GNOME environment, go to
Settings > Sharing > Media Sharing
, then turn
Media Sharing
on. In
Folders
add or exclude the folders you want to share or not, and in
Networks
select in which network should the media be shared.
On non-GNOME environments, the
rygel.service
user unit
can be
enabled
to have it start automatically.
To start
rygel
manually, any user can run in a terminal:
$ rygel -g 5
Configuration
Rygel can be configured globally (
/etc/rygel.conf
) or per-user (
~/.config/rygel.conf
). The default
/etc/rygel.conf
is well documented. The command
rygel-preferences
generates the
~/.config/rygel.conf
and allows some basic configuration.
More information on these and other configuration options can be found with
rygel.conf(5)
.
If you use
rygel
behind a firewall (
nftables
,
iptables
, etc.), add a rule to allow the connection to the listening port (see
[1]
). By default,
rygel
assigns a port dynamically which may change from one session to another if the
/etc/rygel.conf
sets
port=0
. To control the listening port (here 50000), start
rygel
as follows:
$ rygel -g -p 50000
Troubleshooting
When starting Rygel from the command line, there are several options that might help you troubleshoot any strange behaviour. Find out more about these options with
rygel(1)
.
See also
Rygel homepage in GNOME Wiki
Rygel FAQ in GNOME Wiki