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

Idesk
is a simple program for adding icons to your X desktop. It can also manage your wallpaper with a built in changer similar to that found in Windows 7.
Installation
Install
the
idesk
AUR
package and
create
the
~/.config/idesktop/
directory.
Configuration
At the first run
idesk
will create the
~/.config/.ideskrc
configuration file. If
~/.config/idesktop/
is empty, it will also create the
~/.config/idesktop/default.lnk
icon, which just runs
xdialog
AUR
to display a welcome message. It can be used as a template for other icons.
The
idesk
AUR
package does not come with a man page, but it does come with a readme file:
/usr/share/idesk/README
. There is also documentation on
SourceForge.net
, however most of the configuration options should be self-explanatory.
Background options
If you are using another wallpaper setter such as
Feh
or
Nitrogen
, Idesk's background settings do not need to be modified.
If you are using Idesk's own background setter, supported wallpaper formats include JPEG, PNG, GIF, and XPM. Using either
Background.File
or
Background.Source
, specify the path to the image file you wish to use as a wallpaper.
Tip
Background.Source
seems to take precedence over
Background.File
; however, it is ignored if
Background.Delay
is set to 0.
Icons
Idesk looks in
~/.idesktop/
for files which names end with
.lnk
for icons. Each file should define one icon. If you attempt to define a second icon, it will be silently ignored. Aside from ending with
.lnk
, the files' names are not important.
Example for Chromium:
chromium.lnk
table Icon
  Caption: Chromium
  ToolTip.Caption: Google's OSS Web Browser
  Icon: /usr/share/icons/hicolor/32x32/apps/chromium.png
  Width: 32
  Height: 32
  X: 977
  Y: 369
  Command[0]: chromium
end
Width
and
Height
should match the actual dimensions of the icon.
X
and
Y
will be modified by idesk to reflect the icon's actual position.
Tip
Most system icons can be found in the following locations:
/usr/share/icons/hicolor/
,
/usr/share/icons/gnome/
and
/usr/share/pixmaps/
.
Many icon themes provide a variety of different sizes of icon - 48x48 is a commonly used size for desktop icons.
Idesktool
The
idesk-extras
AUR
package provides a graphical configuration tool for Idesk. It can be started by running the
idesktool
command. Users can use Idesktool to create and remove icons, modify settings and restart Idesk.
incron

incron
is an "inotify cron" system. It consists of a daemon and a table manipulator. You can use it a similar way as the regular cron. The difference is that the inotify cron handles
filesystem events
rather than time periods.
Installation
Install
the
incron
package.
Activation and autostart
After installation, the daemon will not be enabled by default.  You can
enable
incrond.service
.
Configuration
Incrontabs should never be edited directly; instead, users should use the
incrontab
program to work with their incrontabs.
Using incrontab
To view their incrontabs, users should issue the command:
$ incrontab -l
To edit their incrontabs, they should use:
$ incrontab -e
To remove their incrontabs, they may use:
$ incrontab -r
To reload
incrond
, use:
$ incrontab -d
To edit another user's incrontab, isue the following command:
# incrontab -u
user
-e
Incrontab format
Each row in an incrontab file is a table that the dameon runs when an event happens to a certain directory or file.
The basic format for an incrontab is:
path
mask
command
path
the directory or file that
incrond
will monitor for changes.
mask
the type of filesystem event that incrond will monitor for. This paramter can be seperated by commas.
command
the command to be run after the specified filesystem event(s) occur.
Mask types
incrontab
uses mask types to specify which file system event to monitor for. For more options see
inotify(7)
To trigger a command if a file is accessed or read:
IN_ACCESS
To trigger a command if metadata of a file change (e.g.
timestamps
,
permissons
):
IN_ATTRIB
To trigger a command  if a file opened for writing is closed:
IN_CLOSE_WRITE
To trigger a command if a file or directory not opened for writing is closed:
IN_CLOSE_NOWRITE
To trigger a command if a file or directory is created in a watched directory:
IN_CREATE
To trigger a command if a file or directory is deleted from a watched directory:
IN_DELETE
To trigger a command if a watched file or directory is deleted (or moved to a different filesystem):
IN_DELETE_SELF
To trigger a command if a file was modified:
IN_MODIFY
To trigger a command if a watched file or directory is moved within the filesystem:
IN_MOVE_SELF
To trigger a command if a file or directory is moved out of the watched directory:
IN_MOVED_FROM
To trigger a command if a file or directory is moved to the watched directory:
IN_MOVED_TO
To trigger a command if a watched file or directory is opened:
IN_OPEN
Custom Mask Types
Incrond provides additional custom event types to modify its monitoring behavior.
For instance, to pause monitoring an event until the current one is completely handled, add
loopable=true
to the event list, eg:
IN_CLOSE,loopable=true
An event with the loopable event enabled will not fire again until the associated command exits.
See
incrontab(5)
for the complete list of custom mask types.
Init 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
init
scripts, e.g.
openrc
AUR
.
Package naming
For
init
scripts, use
modulename-
init
. For example:
ananicy-cpp-openrc
AUR
,
ananicy-cpp-runit
AUR
,
ananicy-cpp-dinit
AUR
,
ananicy-cpp-s6
AUR
.
Note
The package name should be entirely lowercase.
Architecture
See
PKGBUILD#arch
.
A init script should be architecture-independent.
Depends
All scripts should depend on its init, i.e.
ananicy-cpp-openrc
AUR
requires
openrc
AUR
for it to work.
InspIRCd

InspIRCd
(Inspire IRC daemon) is a modular and lightweight IRC daemon written in C++. As it is one of the few IRCd projects written from scratch, it avoids a number of design flaws and speed issues that plague other more established IRCd projects with the same or less features, such as UnrealIRCd 3. It is the IRCd used by the
Chatspike IRC network
.
Installing
Note
Before you begin, check that you do not have any user or group named
inspircd
as the package will create and run using this user privileges (for security reasons).
Install
the
inspircd
AUR
package.
Configuring
The configuration file
/etc/inspircd/inspircd.conf
is
mandatory
, XML-formatted and needs to be created when installing.
How you set your configuration file will depend a lot on your needs and system configuration, reason why there is no configuration file set by default.
Tip
You can use the example (and very well documented) configuration file located at
/etc/inspircd/examples/inspircd.example.conf
. Copy this file to
/etc/inspircd/inspircd.conf
, read and edit it carefully to fit your needs.
Its markup language format may be somewhat different of what most of the people is used to. The format of an instruction within the configuration file looks like the following:
<tagname variable="value">
Note
The example file has some
<die value="anything here">
lines in the example file to make sure you read the entire thing. You must remove these entries otherwise the server will not start.
Make sure to set the pidfile to
/var/lib/inspircd/inspircd.pid
, as explained in the package's
install script
.
Further information is available at the
InspIRCd configuration
wiki page.
Loading modules
By default, InspIRCd loads no modules. As every feature outside of
RFC 1459
is actually a module, by loading no modules your ircd really will not do anything impressive.
You can load modules by adding for instance:
<module name="m_silence.so">
This will load the m_silence module (which provides the somewhat standard SILENCE list facility). You must restart the daemon for changes to take effect.
A list of the available modules is available at the
InspIRCd modules
wiki page.
Third-party modules
To install a third-party module, save the
[module].cpp
within
[build-dir]/inspircd/src/inspircd/src/modules/
and continue the build process. If you have already built and installed InspIRCd and have the source files intact, compile the module with
./configure -modupdate; make
and copy to:
/usr/lib/inspircd/modules/
.
Starting/Stopping the daemon
The factual accuracy of this article or section is disputed.
Reason:
Restarting until the problems go away is not a recommended method of debugging (Discuss in
Talk:InspIRCd
)
Start
or
stop
inspircd.service
.
The first start fails sometimes so try restarting until you get no errors. After this you shall have no further problems.
The reason behind this is because of security reasons the daemon does not run as root as you normally would see, so the script must ensure that the user
irc
has permission to write/read the pid and log files.
External links
Inspire IRCd (website)
Inspire IRCd (wiki)
Inspire IRCd (irc channel)
Install Arch Linux with accessibility options

The official Arch Linux installation medium supports various
Accessibility
features:
speech is provided by the
espeakup
package
braille terminal
support is handled by the
brltty
package
This document describes how to install
Arch Linux
using these features.
Note
This page describes only steps which are different from the
Installation guide
.
Pre-installation
Boot the live environment
Note
The
boot loaders
on the installation medium have a timeout of 15 seconds before they start the default menu item.
When the installation medium starts booting, press
Down
followed by
Enter
to boot with speech enabled.
USB braille displays should be detected automatically via
udev
.
Multiple sound cards
If your computer has several sound cards, you will hear the following message:
Please select your sound card for speech output.
When you hear a beep on the output that you would like to use, press
Enter
to select the card.
Change speech language
To change the
espeak-ng
language/voice used by
espeakup.service
,
edit
the unit so that the language code is appended to
default_voice=
in the
Environment=
directive.
You can also change the
espeak-ng
voice variant by appending
+
variant
to the language code. See
espeakup(8)
and
espeak-ng(1)
for more information.
Installation
Install essential packages
For speech support in the installed system, you need
espeakup
and
alsa-utils
. If you use a braille display,
install
the
brltty
package.
Append the required packages to the
pacstrap(8)
call when installing:
# pacstrap -K /mnt base linux linux-firmware espeakup alsa-utils
Configure the system
Sound card
If
#Multiple sound cards
were detected, copy the
/etc/asound.conf
file, which has been generated in the installation medium:
# cp /etc/asound.conf /mnt/etc/
Enable the services
To have speech support after booting into the installed system you need to
enable
espeakup.service
. See also
#Change speech language
.
Reboot
After booting into the newly installed system it should start speaking automatically.
Troubleshooting
See
Accessibility#Troubleshooting
.
Intel NUC X15

Hardware
PCI/USB ID
Working?
Bluetooth
8087:0026
Yes
Webcam
04f2:b71a
Yes
Ethernet
8086:15f3
Yes
Wi-Fi
8086:43f0
Yes
GPU (Intel)
8086:9a60
Yes
GPU (NVIDIA)
10de:249d
Yes
GPU (Intel)
8086:3029
Yes
Touchpad
Yes
Keyboard
Yes
TPM
Yes
SD-card reader
0bda:0316
Yes
Audio
8086:43c8
Yes
Installation
This device can only boot in
UEFI
mode.
This device has an IR camera that can be used for face recognition authentication, try
Howdy
if you want to use that feature.
To control the keyboard RGB backlighting, you can try
python-ite8291r3-ctl
AUR
and
hid-ite8291r3-dkms-git
AUR
. The latter is not required but provides more functionality.
If the AUR does not recognize the device, try building it yourself from Github.
The most comprehensive driver for this device is
qc71-laptop-dkms-git
AUR
, which can read and control fan speed, control the lightbar, enable Fn lock function keys, enable Meta key lock, and control charging limit. It has no user interface, but is quite functional.
To have touchpad toggle and Airplane mode toggle working, you can also try
uniwill_wmi
module in
tuxedo-drivers-dkms
AUR
. It has fewer features but has a user interface.
It is worth noting that these two AUR conflict with each other.
Additional steps may be required to get the screen to use a high refresh rate, see
Intel graphics#Add support for 165Hz monitor
and
Kernel mode setting#Forcing modes and EDID
.
Accessibility
The appearance of the UEFI is simple and not very colorful, so it might work well with OCR software. Navigation can be controlled by keyboard or mouse.
Note
By default, this device requires manual installation of memory and hard disk. Ask for help if you are not able to do it by yourself.
Blind users should request the help of a sighted person to change UEFI settings.
System Setup:
F2
Update BIOS:
F7
Windows Recovery Mode:
F8
Boot Menu:
F10
Network Boot:
F12
Firmware
Secure Boot
custom keys work well on this device.
fwupd
does not support this device yet.
Function keys
Key
Visible?
1
Marked?
2
Effect
Fn+Esc
No
Yes
Toggles Fn lock
Fn+F1
Yes
3
Yes
XF86Sleep
Fn+F2
Yes
Yes
XF86AudioMute
Fn+F3
Yes
Yes
XF86AudioLowerVolume
Fn+F4
Yes
Yes
XF86AudioRaiseVolume
Fn+F5
No
Yes
XF86AudioMicMute
, does not work.
Fn+F7
Yes
Yes
XF86TouchpadToggle
Fn+F8
No
Yes
Toggles keyboard backlight brightness
Fn+F9
Yes
Yes
XF86MonBrightnessDown
Fn+F10
Yes
Yes
XF86MonBrightnessUp
Fn+F11
Yes
Yes
Inputs
Super_L+P
Fn+F12
Yes
Yes
XF86RFKill
Fn+Insert
Yes
Yes
Print
Fn+Scroll_Lock
Yes
Yes
Num_Lock
The key is visible to
xev
and similar tools
The physical key has a symbol on it, which describes its function
systemd-logind handles this by default
Intel QC71

This article or section does not follow the
Laptop page guidelines
.
Reason:
Hardware table needs PCI/USB IDs, missing function keys table (Discuss in
Talk:Intel QC71
)
Hardware
PCI/USB ID
Working?
GPU (Intel)
Yes
GPU (nvidia)
Yes
Ethernet
Yes
Card Reader
Yes
Wireless
Yes
Bluetooth
Yes
Audio
Yes
Touchpad
Yes
Webcam
Yes
Thunderbolt
Yes
Function Keys
Yes
The Intel QC71 is also known as Intel NUC 9 Extreme Laptop Kit (LAPQC71), XMG FUSION 15 (powered by TUXEDO), Eluktronics Mag-15, Aftershock / LEVEL 51 Vapor 15 Pro, MAINGEAR ELEMENT and Avell A60 Muv.
Installation
During the installation an external keyboard might be needed.
Function Keys
Most
Fn
function keys are recognized correctly and given sufficient userspace support they work out of the box. To have working
touchpad toggle
(Fn + F5), and
keyboard brightness up/down
keys (Fn + F6/F7, respectively), you can install
tuxedo-drivers-dkms
AUR
.
Since BIOS version 0114, it is possible to configure Fn+ESC to toggle the Fn lock. This can be configured in the BIOS or with the
qc71-laptop-dkms-git
AUR
kernel module.
Lightbar
The LED bar on the front of the device maybe controlled using one of the following:
the
tuxedo-drivers-dkms
AUR
kernel driver made by TUXEDO Computers; or
the
qc71-laptop-dkms-git
AUR
kernel module.
Power management
Battery charge threshold
Since BIOS version 0114, it is possible to configure a percentage threshold at which charging will stop. This can be configured in the BIOS or with the
qc71-laptop-dkms-git
AUR
kernel module.
Reduced fan duty cycle and always-on mode
Since BIOS version 0114, it is possible to configure the fans to spin at about 25% of their maximum speed instead of 30% at idle. It is also possible to configure the fans to always be active. These options are configurable in the BIOS or with the
qc71-laptop-dkms-git
AUR
kernel module.
TUXEDO Control Center
TUXEDO Computers provides their own Control Center named
TUXEDO Control Center
(short TCC),
tuxedo-control-center-bin
AUR
.
TCC helps you to control fan speed, energy and performance.
IPMI

Intelligent Platform Management Interface
(IPMI) is a set of computer interface specifications for an autonomous computer subsystem that provides management and monitoring capabilities independently of the host system's CPU, firmware (BIOS or
UEFI
) and operating system.
Arch Linux has the following IPMI-related packages:
freeipmi
— Sensor monitoring, system event monitoring, power control, and serial-over-LAN (SOL).
https://www.gnu.org/software/freeipmi/
||
freeipmi
openipmi
— Full-function IPMI (Intelligent Platform Management Interface) system.
https://openipmi.sourceforge.net/
||
openipmi
ipmiutil
— A simple program that lists results from the hardware detection library.
https://sourceforge.net/projects/ipmiutil/
||
ipmiutil
AUR
ipmitool
— Command-line interface to IPMI-enabled devices.
https://github.com/ipmitool/ipmitool
||
ipmitool
ipmiview
— Supermicro IPMI tool.
https://www.supermicro.com/products/nfo/ipmi.cfm
[
dead link
2025-11-17—HTTP 404]
||
ipmiview
AUR
ipmicfg
— Supermicro IPMI configuration tool.
https://www.supermicro.com/en/solutions/management-software/ipmi-utilities
||
ipmicfg
AUR
This article or section needs expansion.
Reason:
Needs info about how these tools differ (Discuss in
Talk:IPMI#Add more information about how listed utilities differ
)
Firmware
To update the
Baseboard Management Controller
firmware on Supermicro servers, you can use
supermicro-update-manager
AUR
.
See also
Wikipedia:out-of-band management
Iptv.org EPG Grabber

Iptv.org EPG Grabber
is a nodejs/html application with utilities for downloading the
EPG
for thousands of TV channels from hundreds of sources.
It can later be used by
Kodi
,
MythTV
,
Tvheadend
and other compatible Television and Home Theater front-end media players.
Installation
Install
the
iptvorg-epg
AUR
package.
Usage
First step is to create a working directory for
iptvorg-epg
EPG grabber. The working directory will be saved to the home directory of the active user or to a chosen path. All configuration and output files are stored in the working directory.
To create a working directory type:
# iptvorg-epg -d
/path/to/working_directory
At this point all necessary files are created and it's now possible to grab EPG data from a chosen site or custom channels xml configuration file.
To generate EPG guide file (default:
guide.xml
), type:
# iptvorg-epg -d
/path/to/working_directory
-s
my.site.example
In addition to the command above, it can be combined with
--gzip
,
--days
days
and
-o, --output
file
.
For a full listing of the active
sites
(including status), type:
# iptvorg-epg -ps
For a full usage information, type:
# iptvorg-epg --help
Custom channels list
With custom channels list it is possible to use multiple channels from multiple sites lists.
An example XML file is included in the working directory called
my.channels.xml
. Make sure to place any custom XML channels file inside the working directory.
To generate a custom EPG guide file, type:
# iptvorg-epg -d
/path/to/working_directory
-c
my.channels.xml
Configuration
Iptvorg-epg can be run in different ways, both manually and automated. For automated solutions custom scripts and systemd unit can be used. It is also possible to run the EPG grabber with the command
sudo -u
username
iptvorg-epg
...
Here is an example systemd service to run with iptvorg-epg:
/usr/lib/systemd/system/iptvorg-epg.service
[Unit]
Description=Creates EPG guide file in /path/to/
guide.xml
Requires=network-online.target
After=network-online.target

[Service]
ExecStart=/my/custom/
script.sh
[Install]
WantedBy=multi-user.target
This can be combined with a timer (runs every day at 6:00) like this:
/usr/lib/systemd/system/iptvorg-epg.timer
[Timer]
Persistent=true
OnCalendar=*-*-* 06:00:00
Unit=iptvorg-epg.service

[Install]
WantedBy=timers.target
Remember to
enable/start
any custom systemd services.
See also
Official website
]
Official EPG website README
Iscsi-util

Introduction
iscsi-util
is a graphical user interface (GUI) for managing iSCSI sessions on Linux.  
It is built with the cross‑platform
Avalonia
framework and provides a simple alternative to using
iscsiadm
directly.  
The project offers a portable AppImage as well as an AUR package.
Features
Target discovery.
Session management (login/logout).
CHAP authentication support.
Session parameter configuration.
Cross‑platform Avalonia-based interface.
Portable AppImage with no external dependencies.
Integration with
open-iscsi
.
Installation
From AUR
The package is available as
iscsi-util
AUR
:
bash
yay -S iscsi-util
AppImage
The AppImage can be downloaded from the project’s release page:
https://github.com/mijocecr/Iniciador-iSCSI-GUI-Manjaro/releases/tag/iscsi-util-1.0.6
Make it executable:
bash
chmod +x iscsi-util.appimage
./iscsi-util.appimage
Dependencies
open-iscsi
— required for actual session management.
dotnet-runtime
(only for non-AppImage builds).
Usage
When launched, the application automatically detects existing configuration under
/etc/iscsi
.  
The main operations include:
Discovering targets:
bash
iscsiadm -m discovery -t sendtargets -p <IP>
Logging in to a target.
Logging out.
Configuring CHAP authentication.
Viewing active sessions.
The application acts as a visual layer on top of these operations.
System integration
iscsi-util can configure iSCSI nodes so that they are automatically logged in at boot using the standard
open-iscsi
mechanisms.  
For details on how automatic login works, see:
iSCSI
Open-iSCSI#Automatic_login
Troubleshooting
Ensure the
iscsid
service is running:
bash
systemctl status iscsid
Verify network connectivity to the target.
Check logs:
bash
journalctl -u iscsid
External links
Official repository
AUR package
iSCSI

With
iSCSI
you can access storage over an IP-based network.
The exported storage entity is the
target
and the importing entity is the
initiator
.
Since Linux 2.6.38
LIO
is the in-kernel iSCSI target.
Before that it was tgt.
SCST
was another candidate for kernel inclusion.
[1]
The current initiator is
Open-iSCSI
.
It is possible to
boot Arch Linux via iSCSI
.
See also
Gentoo:iSCSI
Islamic tools

Islamic tools
are a software set for Quran, Hijri calendar, prayer times, and Qibla direction.
Hijri
emacs
: ships with
cal-islam.el
module, which converts dates based on the algorithms specified in
Calendrical Calculations
book by Dershowitz and Reingold.
itools
AUR
: a rewrite of
cal-islam.el
in C. Offers
ical
and
idate
analogous to
cal
and
date
utilities.
python-hijri-converter
AUR
.
Libraries
libitl
AUR
: Islamic Tools Library provided by
Wikipedia:Arabeyes
contains a set of command-line utilities for date conversion and Islamic APIs.
luaHijri
:
Lua
module, used by Arabic Wikipedia in the main page.
phphijri
Supported in
java8
and above.
Other
Prayer times
prayer-times
AUR
: based on the algorithm provided by
praytimes.org
.
salahtime
AUR
: A small C program for showing prayer time.
Quran
quran-companion
AUR
: a modern Quran reader/player with translations.
zekr
AUR
: research tool for Quran.
quran-rofi
AUR
: a
rofi
script for looking up verses and chapters.
cnoor-git
AUR
: simple framebuffer Quran viewer.
See also
Umm Alqura algorithm technical reading
Localization/Arabic
Bidirectional text
JDBC and MySQL

This document describes how to set up your Arch system so that MySQL databases can be accessed via Java programs.
Installation
Installing MySQL
Install
a
MySQL
implementation.
To allow for network access, make sure that
/etc/mysql/my.cnf
has the following line commented out, as shown here:
#skip-networking
Your MySQL version may use the following line instead to restrict network access:
bind-address = *
Then, start the MySQL
service
.
Installing JDBC
Install a JDBC driver according to your MySQL variant:
mariadb-jdbc
AUR
- for the Arch Linux endorsed server
mysql-connector-java
AUR
- for the Oracle variant
Testing
To access MySQL's command line tool, run:
$ mysql
Creating the test database
The following commands create a database
test
, and grant all privileges to user
foo
identified by password
bar
. Change the variables at your discretion.
create database
test
;
grant all privileges on
test
.* to
foo
@localhost identified by "
bar
";
flush privileges;
Afterwards, use
Ctrl + d
to exit the command line tool.
Creating the test program
Use a text editor to create the file
DBDemo.java
with the following code in it. You will need to change the username and password accordingly.
import java.sql.*;

public class DBDemo {
  public static void main(String[] args) throws SQLException, ClassNotFoundException {
    // Load the JDBC driver
    Class.forName("org.mariadb.jdbc.Driver");
    System.out.println("Driver loaded");

    // Try to connect
    Connection connection = DriverManager.getConnection
      ("jdbc:mariadb://localhost/
test
", "
foo
", "
bar
");

    System.out.println("It works!");

    connection.close();
  }
}
If using Oracle MySQL (as opposed to MariaDB), the above class name should be set to
com.mysql.jdbc.Driver
.
Running the program
To compile and run the program (you will need
jre-openjdk
), execute:
$ javac DBDemo.java
$ java -classpath /usr/share/java/mariadb-jdbc/mariadb-java-client.jar:. DBDemo
If all was configured correctly, you should see:
Driver loaded
It works!
Joplin

This article is being considered for redirection to
List of applications/Documents#Graphical 3
.
Notes:
Still nothing Arch-specific in here that is not already covered by the upstream readme. (Discuss in
Talk:Joplin
)
From
What is Joplin?
:
Joplin is a free, open source note taking and to-do application, which can handle a large number of notes organised into notebooks. The notes are searchable, can be copied, tagged and modified either from the applications directly or from your own text editor. The notes are in Markdown format.
Joplin is "offline first", which means you always have all your data on your phone or computer. This ensures that your notes are always accessible, whether you have an internet connection or not.
The notes can be securely synchronised using end-to-end encryption with various cloud services including Nextcloud, Dropbox, OneDrive and Joplin Cloud.
Full text search is available on all platforms to quickly find the information you need. The app can be customised using plugins and themes, and you can also easily create your own.
The application is available for Windows, Linux, macOS, Android and iOS. A Web Clipper, to save web pages and screenshots from your browser, is also available for Firefox and Chrome.
Installation
Install
joplin
AUR
for the
Joplin Terminal application
.
Install
joplin-desktop
AUR
for the
Joplin Desktop application
.
Synchronization
See
the official documentation on Synchronization
for instructions on how to sync notes across devices using either cloud-based or offline sync.
Plugins
The desktop application can be extended with
plugins
. Plugins are not available in the Terminal application.
See
the official documentation on plugins
for information on installing plugins. The desktop application downloads plugins into
~/.config/joplin-desktop/plugins
.
Tips and tricks
Importing Notes from Other Applications
See
the official documentation on Importing and Exporting
for instructions on importing notes from Evernote, OneDrive, and other note-taking applications.
See also
Joplin Documentation
Joplin Home Page
Joplin Official Plugin Repository
JPEG XL

From
Wikipedia:JPEG XL
:
JPEG XL is a royalty-free raster-graphics file format that supports both lossy and lossless compression. It is designed to outperform existing raster formats and thus become their universal replacement.
Usage
libjxl
comes with the official encoder/decoder programs:
cjxl
and
djxl
. JPEG XL is also supported by
imagemagick
and
ffmpeg
. To convert existing formats to jxl (JPEG files are compressed losslessly by default) use:
$ cjxl input.jpg lossless.jxl
To display image metadata:
$ jxlinfo input.jxl
Exiftool
also supports jxl since 12.25, but might be limited by
some metadata
that needs to be decoded.
--compress_boxes=0
flag can be passed to
cjxl
to keep metadata uncompressed, making it possible for Exiftool to parse it.
For file de-duplication purposes, it might be desirable to get the checksum of the actual encoded image:
$ exiftool -api ImageHashType=MD5 -ImageDataHash
Support
Browsers:
Firefox
(nightly): set
image.jxl.enabled
to
true
in
about:config
.
Chromium
: Enable the flag
chrome://flags/#enable-jxl-image-format
.
Image viewers:
Gwenview
: install
kimageformats
nsxiv
swayimg
Previewers:
Dolphin
: install
kimageformats
ueberzugpp
See also
Information and support status of JPEG XL
List of supported software
Tracker for support status in software
Julia

Related articles
List of programming languages
Julia
is a high-level, high-performance dynamic programming language for numerical computing. It provides a sophisticated compiler, distributed parallel execution, numerical accuracy, and an extensive mathematical function library.
Tip
https://julialang.org/
has an open-source
documentation
, non-Arch-specific information should be contributed there.
Installation
You can
install
one of three packages:
The
julia
package.
Note
This package is compiled against system libraries and is therefore
unsupported
by the upstream. While it may be suitable for basic usage, it is incompatible with external packages (or their dependents) which rely on Julia's bundled versions of its dependencies (e.g.
Sundials.jl
). Bugs reported to Julia's maintainers against this binary
will be closed
.
julia-bin
AUR
provides official builds compiled against
patched LLVM libs
.
juliaup
AUR
provides a binary manager, similar to
rustup
, that allows to use different versions of Julia.
Troubleshooting
If you get the following error while using
pyplots()
with
julia-bin
AUR
,
WARNING: You are using Matplotlib 0.0.0, which is no longer officialy supported by the Plots community. To ensure smooth Plots.jl integration update your Matplotlib library to a version >= 2.0.0
first install
python-matplotlib
and
tk
. Then, install
VersionParsing.jl
with
] add VersionParsing
within the Julia prompt
[1]
, and restart Julia.
Integration with editors
Vim
Syntax highlighting and more
julia-vim
Linting
The
julialint
plugin combined with the
Lint.jl
package can provide linting.
REPL vim bindings
The
VimBindings.jl
package provides
vim
emulation within the Julia REPL.
Emacs
Syntax highlighting
julia-emacs
.
Linting
lsp-julia
: provides linting using the LSP protocol.
REPL integration
julia-repl
: for interacting with a Julia REPL running inside
Emacs
.
Jumper EZBOOK 3 PRO

This article or section does not follow the
Laptop page guidelines
.
Reason:
Needs IDs in hardware table, an accessibility, expanded firmware and a function keys section (Discuss in
Talk:Jumper EZBOOK 3 PRO
)
Hardware
PCI/USB ID
Working?
Touchpad
Yes
Keyboard
Yes
Video
Yes
Webcam
Yes
Audio
Yes
Wireless
Yes
Firmware
Do not change the operating system setting in the BIOS from Windows to Linux. This causes the built in keyboard to become unresponsive during boot-time (although USB keyboards still work) and reverses the backlight controls.
Audio
This article or section is out of date.
Reason:
"right now" was 2018-03-22, is this still applicable? (Discuss in
Talk:Jumper EZBOOK 3 PRO
)
The HDMI port works but it does not support audio output, it seems to be a common problem with intel devices and Linux right now.
Kakoune

Related articles
Helix
Vim
List of applications/Documents#Vi-style text editors
Kakoune
is a modal text editor. It is inspired by Vim and similar alternatives, but tries to improve the text editing workflow as well as fit better to the Unix philosophy. Besides modal editing, two other main concepts are selection based editing, and multi-cursor editing. It has an interactive help system, and supports many languages. Kakoune inspired editors like
Helix
.
Installation
Install
the
kakoune
package.
Usage
:doc <topic>
opens the documentation of <topic>.
It has an interactive help system, which means e.g. pressing
g
(goto mode)
shows a dialog with possible keys and destinations, or it displays a help dialog with the description of the highlighted completion candidate in
prompt
mode.
Configuration
Kakoune reads configuration from
$XDG_CONFIG_HOME/kak/
.
The main configuration file is
kakrc
, and custom colorschemes can be stored in the
colors
directory.
Every
*.kak
file is loaded from
autoload
at startup. If this directory exists in
$XDG_CONFIG_HOME
, Kakoune does not load the system wide
autoload
dir (located at
/usr/share/kak/autoload
), so it has to be linked there. For example:
$ ln -s /usr/share/kak/autoload $XDG_CONFIG_HOME/kak/autoload/default
See also
Official website
GitHub repository
GitHub wiki
Karma

Karma
is an alert dashboard for
Alertmanager
. It allows the aggregation and deduplication of alerts, as well as the possibility of silencing alerts.
Installation
Install
the
karma-dashboard
AUR
or
karma-dashboard-bin
AUR
package.
Configuration
Karma configuration is done by editing
/etc/karma/karma.yml
and
starting
karma.service
.
Changing alertmanager protocol, address and port
The default configuration assumes that
alertmanager
runs on
http://localhost:9093
.
Change the
uri
parameter to match your configuration.
/etc/karma/karma.yml
alertmanager:
  interval: 1m
  servers:
    - name: production
      uri:
ALERTMANAGER_PROTOCOL
://
ALERTMANAGER_ADDRESS
:
ALERTMANAGER_PORT
/
      timeout: 20s
      proxy: false
      readonly: true
Note
Supported
ALERTMANAGER_PROTOCOL
values are
http
and
https
.
Changing listening address and port
You may want to change the default address and port on which karma listens. To do so, edit
/etc/karma/karma.yml
and add the following parameters:
/etc/karma/karma.yml
listen:
  address:
KARMA_ADDRESS
port:
KARMA_PORT
Note
More configuration parameters can be found in
upstream documentation
.
Starting karma
After
starting
and
enabling
karma.service
, the application can be reached
via
HTTP on
localhost:8080
by default.
See also
Karma official page
Karma Github page
Kata Containers

Related articles
Docker
Podman
Kata Containers (previously Clear Containers) is an OCI-compatible application container runtime meant to provide isolation of potentially untrusted processes from the host system and other processes by leveraging virtualization. Currently upstream-supported hypervisors are
qemu-desktop
,
firecracker
and
cloud-hypervisor
AUR
.
Architecture
kata-agent
- supervisor process running on the hypervised guest sandbox, tasked with managing its lifetime
kata-runtime
- container runtime component responsible for handling commands specified by the OCI runtime specification and tasked with launching shims
kata-proxy
(before 2.0) - routes I/O streams and signals between on-guest agent and host-side processes associated with running a given sandbox using gRPC
kata-shim
(before 2.0) - container process monitor and reaper
kata-ksm-throttler
(optional, before 2.0) -
kata-linux-container
- patched kernel used to launch VMs serving as container/pod sandboxes
kata-containers-image
- initramfs and rootfs images used for spawning VM sandboxes
Usage
Kata, by default, picks up its configuration from
/etc/kata-containers/configuration.toml
, but that can be overridden by providing a path to configuration through the
KATA_CONF_FILE
environment variable. Be sure to initialize configuration from
/usr/share/defaults/kata-containers/configuration-qemu.toml
.
v1
This article or section is out of date.
Reason:
The v1 packages were
dropped from AUR
since they were legacy and not maintained. (Discuss in
Talk:Kata Containers
)
Docker
In order to use Kata Containers with Docker, the user needs to add it to supported runtimes in
/etc/docker/daemon.json
:
{
   "runtimes": {
     "kata": {
       "path": "/usr/bin/kata-runtime"
     }
   }
 }
To use it as the default runtime for Docker:
{"default-runtime": "kata"}
.
To use it with the Firecracker hypervisor, due to its limitations, the
devicemapper
storage driver
[1]
has to be used:
{"storage-driver": "devicemapper"}
.
Afterward you can use the runtime key:
docker run --runtime kata --rm -ti archlinux/base /bin/bash
.
Podman
Running a container:
podman --runtime /usr/bin/kata-runtime run --rm -ti archlinux/base /bin/bash
.
Keep in mind that a Kata VM sandbox conceptually maps to Kubernetes pods or a shared netns, not just individual containers.
v2
This article or section is out of date.
Reason:
The v2 packages are all out of date. (Discuss in
Talk:Kata Containers
)
Install the runtime
kata-runtime-bin
AUR
, kernel
linux-kata-bin
AUR
and set of initrd and rootfs
kata-containers-image-bin
AUR
.
Docker has added support for OCI-compatible runtimes in Docker Engine 23.0
[2]
. To run a Docker container using Kata:
docker run --runtime io.containerd.kata.v2
Containerd CLI
# ctr image pull docker.io/library/archlinux:latest
# ctr run --rm -t --runtime io.containerd.kata.v2 docker.io/archlinux/base:latest example-container-name date
See also
Project's official site
Architecture reference documentation
Developer Guide (useful for debugging)
Kbuilder

kbuilder is a bash script that allows you to build one of the four officially supported kernels locally with your own optional patches and configuration, under a different package name.
For example, you could fetch the sources of the
linux-lts
kernel, apply a patch that optimizes the kernel for intel processors, and install that kernel as
linux-lts-intel-optimized
.
Installation
The following methods can be used to get kbuilder:
Install
the
kbuilder
AUR
package.
Install the latest development version from the
github repository
.
Building a kernel
To fetch the default vanilla
linux
kernel sources and build the package with the default name
linux-kbuilder-custom
:
$ kbuilder build
Note
The build directory is
~/.kbuilder/cache
.
During the build process, kbuilder will inject a bash shell into the PKGBUILD. The shell will be run right before
build()
is called, allowing you to add any patches or change the kernel config interactively. The build will continue once you exit from the shell.
To install the built packages:
$ kbuilder install
Build variables
Although kbuilder does not have a configuration file, you can control the build process with
environment variables
.
KBUILDER_SOURCE_PKG
should be set as 'linux', 'linux-lts', 'linux-zen' or 'linux-hardened'. kbuilder will fetch and build the kernel specified with this variable. Defaults to 'linux'. For more information about the official kernels, see
kernel
.
Note
Patches that work on one kernel may not necessarily work on another.
KBUILDER_PKG_NAME_APPEND
can be set as any string. It will be appended to the end of the kernel version and the kernel package. Defaults to 'kbuilder-custom'.
KBUILDER_BUILD_JOBS
should be set as an integer. kbuilder will replace the
make all
line in the PKGBUILD with
make -jX all
, where X is the integer specified.
Example usage:
$ KBUILDER_BUILD_JOBS=4 KBUILDER_PKG_NAME_APPEND="my-custom-patch" KBUILDER_SOURCE_PKG="linux-zen" kbuilder build
Hooks
kbuilder looks for hooks in
/etc/kbuilder/hooks/
, and uses run-parts to execute them right before
build()
is called. The run-parts command is executed with the flag
--regex "kbuilder-hook-*"
.
An example hook:
/etc/kbuilder/hooks/05-kbuilder-hook-cpu-optimize.sh
#!/bin/bash
#
# kbuilder hook for applying graysky2's kernel compiler patch:
# https://github.com/graysky2/kernel_compiler_patch
#

SOURCE="https://raw.githubusercontent.com/graysky2/kernel_compiler_patch/master"
PATCH="more-uarches-for-kernel-5.17+.patch"
HOOK_NAME="cpu-optimize-hook"

curl -o $PATCH $SOURCE/$PATCH || { echo "$HOOK_NAME failed when fetching $PATCH from $SOURCE" ; exit 1 ; }
patch -Np1 -i "$PATCH" || { echo "$HOOK_NAME failed when applying $PATCH" ; exit 1 ; }
To create a hook,
create
and make
executable
a file, with a name following the
xx
-kbuilder-hook-
hookname
form: they will be run in order according to the
xx
value.
See also
Kernel
The Linux Kernel Documentation
Applying Patches To The Linux Kernel
KDE 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 article or section is out of date.
Reason:
References kde4, looks really outdated in general (Discuss in
Talk:KDE package guidelines
)
The
KDE
packages on Arch Linux follow a certain schema.
Build directory
A good way of building
CMake
packages is to make a build directory outside the root of the project and run cmake from that directory. The
PKGBUILD
should look this way:
prepare() {
  mkdir -p build
}

build() {
  cd build
  cmake ../${pkgname}-${pkgver}
}
Install prefix
Every packages must set the
CMAKE_INSTALL_PREFIX
variable.
-DCMAKE_INSTALL_PREFIX=/usr
Build type
Generally you should not specify the build type; this makes CMake honor environmental variables like such as
CFLAGS
,
CPPFLAGS
, etc.
[1]
Force Qt version
This article or section needs expansion.
Reason:
Is this the same for Qt6? (Discuss in
Talk:KDE package guidelines
)
KF package naming
Note
Some theme-ralated packages possibly may have incorrect names, and be outdated. Needs rechecking:
kde theme
.
To rename a package, select "Submit Request" on the package page, and in request type select "Merge".
Plasma widgets
Plasma widgets (formerly Plasmoids) packages should be named
plasma6-applets-
widgetname
so that they are recognizable as Plasma 6-related packages; this also distinguishes them from the official packages. See
plasma6-applets examples
.
Runners
Plasma runners packages should be named
plasma6-runners-
runnername
so that they are recognizable as Plasma 6-related packages; this also distinguishes them from the official packages. See
plasma6-runners examples
.
Service menus
Service menus packages should be named
kf6-servicemenus-
servicename
so that they are recognizable as KF6 related packages. See
kf6-servicemenus examples
.
Themes
Plasma themes packages should be named
plasma6-themes-
themename
so that they are recognizable as Plasma 6-related packages. See
plasma6-themes examples
.
Icons and .desktop files installation
Some
KDE
software provide icons in the hicolor icon theme and
.desktop
files, which must be installed via
pacman hooks
. Refrain from using installation command for these type of files in a
.install
, as it would result in unnecessary double execution of them.
Kernel live patching

Related articles
Kernel modules
Kernels/Compilation
Kexec
Kernel Live Patching (KLP) allows quick fixes to the kernel space without rebooting the whole system.  Since version 4.0, related patches have been accepted
[1]
[2]
[3]
, so one can configure their kernel to enable this feature.  Generally, KLP is achieved by the following steps:
Obtain the source tree of the running kernel
Prepare the patch against the kernel
Apply some tools (as follows) to help transform and load the patch
Some projects provide the live patching utilities before KLP was officially supported, such as Oracle's ksplice, SuSE's
#kGraft
, and Red Hat's
#kpatch
.  They implemented the KLP functionality in different ways.  The minimalistic functional set of patches that entered the mainstream kernel were derived from kpatch and kGraft.
kpatch
Installation
Install
kpatch
AUR
for an appropriate kernel and
kpatch-git
AUR
for userspace tools.
You can also manually build a kernel that supports kpatch usage, by enabling
CONFIG_LIVEPATCH
,
CONFIG_DEBUG_INFO
, and
CONFIG_KALLSYMS
.
Note
Remember to update the
boot loader
after you install the special kernel.
Usage
Once both packages are successfully built and after reboot, you may
$ export ROOTDIR=some/dir/aur/linux-kpatch/src/linux-x-y
$ cd $ROOTDIR
Assume that you have done some modifications and have a patch
some.patch
(against the source tree after a
makepkg -o
, not the vanilla kernel of version
x.y
) in the working directory. Launch the kpatch utility,
$ kpatch-build -s $(pwd) -v $(pwd)/vmlinux
some.patch
This command involves two kernel builds, the original one and the patched one, so it may take a period of time to complete.  After the build is over, there should be a
kpatch-some.ko
module in the same directory.  And then,
# insmod
kpatch-some.ko
should do the trick.
For further information, please check the manpages or
the GitHub repository
.
kGraft
This article or section needs expansion.
Reason:
No useful information. (Discuss in
Talk:Kernel live patching
)
KGraft has not been tested in Arch environment.
See also
The kernel document of livepatch
wikipedia:Kpatch
wikipedia:KGraft
wikipedia:Ksplice
Kernel module 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
Package separation
Packages that contain
kernel modules
should be treated specially, to support users who wish to have more than one kernel installed on a system.
When packaging software containing a kernel module and other non-module supporting files/utilities, it is important to separate the kernel modules from the supporting files.
Guidelines
When packaging such software (using the
NVIDIA
drivers as an example) the convention is:
create an
nvidia
package containing just the kernel modules built for the vanilla kernel
create an
nvidia-utils
package containing the supporting files
make sure
nvidia
depends on
nvidia-utils
(unless there is a good reason not to do so)
for another kernel like
linux-mm
, create
nvidia-mm
containing the kernel modules built against that kernel which
provides
nvidia
and also
depends
on
nvidia-utils
make sure
nvidia
depends on the kernel, for example:
depends=('linux' 'nvidia-utils')
Rationale
While kernel modules built for different kernels always live in different directories and can peacefully coexist, the supporting files are expected to be found in one location. If one package contained module and supporting files, you would be unable to install the modules for more than one kernel because the supporting files in the packages would cause pacman file conflicts.
The separation of modules and accompanying files allows multiple kernel module packages to be installed for multiple kernels on the same system while sharing the supporting files among them in the expected location.
File placement
If a package includes a kernel module that is meant to override an existing module of the same name, such module should be placed in the
/lib/modules/
X
.
Y
.
Z
-arch1-1/updates
directory.  When
depmod
is run, modules in this directory will take precedence.
KiwiIRC

KiwiIRC
is a hand-crafted IRC client that you can enjoy. Designed to be used easily and freely.
Installation
Install
either
kiwiirc-server-bin
AUR
or
kiwiirc-git
AUR
.
Running
Apache
Create the Apache configuration file:
/etc/httpd/conf/extra/kiwiirc.conf
Alias /kiwiirc "/usr/share/webapps/kiwiirc"
<Directory "/usr/share/webapps/kiwiirc">
    AllowOverride All
    Options FollowSymlinks
    Require all granted
</Directory>
And include it in
httpd.conf
:
/etc/httpd/conf/httpd.conf
# kiwiirc configuration
Include conf/extra/kiwiirc.conf
After making changes to the Apache configuration file,
restart
httpd.service
.
Lighttpd
Configuring
Lighttpd
, make sure
mod_alias
has been enabled.
Add the following alias for kiwiirc to the config:
alias.url = ( "/kiwiirc" => "/usr/share/webapps/kiwiirc/")