diff --git a/debian/linuxcnc.install.in b/debian/linuxcnc.install.in
index a71302665a0..ef175c797bf 100644
--- a/debian/linuxcnc.install.in
+++ b/debian/linuxcnc.install.in
@@ -40,6 +40,7 @@ usr/bin/kinslimits
 usr/bin/latency-histogram
 usr/bin/latency-plot
 usr/bin/latency-test
+usr/bin/latency-ping
 usr/bin/lineardelta
 usr/bin/linuxcnc
 usr/bin/linuxcnc_check_ini
@@ -84,6 +85,8 @@ usr/bin/qtvcp
 usr/bin/rotarydelta
 usr/bin/rs274
 usr/bin/rtapi_app
+usr/bin/realtime-config-kernel
+usr/sbin/realtime-config-ethernet
 usr/bin/scaragui
 usr/bin/schedrmt
 usr/bin/scorbot-er-3
diff --git a/docs/po4a.cfg b/docs/po4a.cfg
index 5ca4619aa21..baa0f44e579 100644
--- a/docs/po4a.cfg
+++ b/docs/po4a.cfg
@@ -137,6 +137,7 @@
 [type: AsciiDoc_def] src/hal/tutorial.adoc $lang:build/adoc/$lang/hal/tutorial.adoc
 [type: AsciiDoc_def] src/hal/twopass.adoc $lang:build/adoc/$lang/hal/twopass.adoc
 [type: AsciiDoc_def] src/install/latency-test.adoc $lang:build/adoc/$lang/install/latency-test.adoc
+[type: AsciiDoc_def] src/install/latency-tuning.adoc $lang:build/adoc/$lang/install/latency-tuning.adoc
 [type: AsciiDoc_def] src/integrator/steppers.adoc $lang:build/adoc/$lang/integrator/steppers.adoc
 [type: AsciiDoc_def] src/integrator/stepper-timing.adoc $lang:build/adoc/$lang/integrator/stepper-timing.adoc
 [type: AsciiDoc_def] src/integrator/wiring.adoc $lang:build/adoc/$lang/integrator/wiring.adoc
diff --git a/docs/src/Master_Documentation.adoc b/docs/src/Master_Documentation.adoc
index b1c373e7d59..3355403ac73 100644
--- a/docs/src/Master_Documentation.adoc
+++ b/docs/src/Master_Documentation.adoc
@@ -64,6 +64,8 @@ include::config/integrator-concepts.adoc[]
 
 include::install/latency-test.adoc[]
 
+include::install/latency-tuning.adoc[]
+
 include::motion/tweaking-steppers.adoc[]
 
 include::config/ini-config.adoc[]
diff --git a/docs/src/Submakefile b/docs/src/Submakefile
index 5bd1092d01f..6252deb2d96 100644
--- a/docs/src/Submakefile
+++ b/docs/src/Submakefile
@@ -238,6 +238,7 @@ DOC_SRCS_EN := \
 	hal/tutorial.adoc \
 	hal/twopass.adoc \
 	install/latency-test.adoc \
+	install/latency-tuning.adoc \
 	integrator/steppers.adoc \
 	integrator/stepper-timing.adoc \
 	integrator/wiring.adoc \
diff --git a/docs/src/config/images/latency-ping.png b/docs/src/config/images/latency-ping.png
new file mode 100644
index 00000000000..459074b76fb
Binary files /dev/null and b/docs/src/config/images/latency-ping.png differ
diff --git a/docs/src/getting-started/system-requirements.adoc b/docs/src/getting-started/system-requirements.adoc
index 6f5d5f941a6..712e13983b5 100644
--- a/docs/src/getting-started/system-requirements.adoc
+++ b/docs/src/getting-started/system-requirements.adoc
@@ -54,7 +54,11 @@ such as checking G-code, testing config files and learning the system.
 To work with these kernel versions there are two versions of LinuxCNC distributed.
 The package names are "linuxcnc" and "linuxcnc-uspace".
 
-The realtime kernel options are preempt-rt, RTAI and Xenomai.
+The realtime kernel options are PREEMPT_RT, RTAI, Xenomai3 and Xenomai4 EVL.
+
+For most cases, PREEMPT_RT is the simplest option. For better latency, Xenomai4 EVL can help.
+
+RTAI is not maintained any more but still works on some systems.
 
 You can discover the kernel version of your system with the command:
 
@@ -63,7 +67,7 @@ uname -a
 ----
 
 If you see (as above) `-rt-` in the kernel name then you are running the
-preempt-rt kernel and should install the "uspace" version of LinuxCNC.
+PREEMPT_RT kernel and should install the "uspace" version of LinuxCNC.
 You should also install uspace for "sim" configs on non-realtime kernels.
 
 If you see `-rtai-` in the kernel name then you are running RTAI
@@ -71,16 +75,30 @@ realtime. See below for the LinuxCNC version to install.
 
 === Preempt-RT with 'linuxcnc-uspace' package
 
-Preempt-RT is the newest of the realtime systems, and is also the version
+Preempt-RT is the version
 that is closest to a mainline kernel. Preempt-RT kernels are available
 as precompiled packages from the main repositories. The search term
 "PREEMPT_RT" will find them, and one can be downloaded and installed
 just like any other package.
-Preempt-RT will generally have the best driver support and is the only
-option for systems using the Mesa ethernet-connected hardware driver
-cards. In general preempt-rt has the worst latency of the available
+Preempt-RT will generally have the best support.
+ In general Preempt-RT has the worst latency of the available
 systems, but there are exceptions.
 
+=== Xenomai3 with 'linuxcnc-uspace' package
+
+Xenomai3 is supported, but you will have to find or build the kernel
+and compile LinuxCNC from source to utilise it.
+
+Prebuilt experimental kernels can be found here: https://github.com/hdiethelm/xenomai3-linuxcnc
+
+=== Xenomai4 EVL with 'linuxcnc-uspace' package
+
+Xenomai4 is supported, but you will have to find or build the kernel
+and compile LinuxCNC from source to utilise it. It has support for
+Mesa ethernet-connected hardware driver with out of band realtime ethernet.
+
+Prebuilt experimental kernels can be found here: https://github.com/hdiethelm/xenomai4-linuxcnc
+
 === RTAI with 'linuxcnc' package
 
 RTAI has been the mainstay of LinuxCNC distributions for many years. It
@@ -88,16 +106,13 @@ will generally give the best realtime performance in terms of low
 latency, but might have poorer peripheral support and not as many screen
 resolutions. An RTAI kernel is available from the LinuxCNC package
 repository. If you installed from the Live/Install image then switching
-kernel and LinuxCNC flavour is described in [Installing-RTAI].
+kernel and LinuxCNC flavour is described in <<cha:Installing-RTAI>>.
 
-=== Xenomai with 'linuxcnc-uspace' package
-
-Xenomai is also supported, but you will have to find or build the kernel
-and compile LinuxCNC from source to utilise it.
+Prebuilt experimental kernels can be found here: https://github.com/NTULINUX/RTAI
 
 === RTAI with 'linuxcnc-uspace' package
 
-It is also possible to run LinuxCNC with RTAI in user-space mode.
+It is possible to run LinuxCNC with RTAI in user-space mode.
 As with Xenomai you will need to compile from source to do this.
 
 == Problematic Hardware
diff --git a/docs/src/index.tmpl b/docs/src/index.tmpl
index 2b0d800ae21..67c668e9723 100644
--- a/docs/src/index.tmpl
+++ b/docs/src/index.tmpl
@@ -67,6 +67,7 @@
 	<ul>
 		<li><a href="config/integrator-concepts.html">Integrator Concepts</a></li>
 		<li><a href="install/latency-test.html">Latency Test</a></li>
+		<li><a href="install/latency-tuning.html">Latency Tuning</a></li>
 		<li><a href="motion/tweaking-steppers.html">Stepper Tuning</a></li>
 		<li><a href="config/ini-config.html">INI Configuration</a></li>
 		<li><a href="config/ini-homing.html">Homing Configuration</a></li>
diff --git a/docs/src/install/latency-test.adoc b/docs/src/install/latency-test.adoc
index 1097b21cf4a..105d1926533 100644
--- a/docs/src/install/latency-test.adoc
+++ b/docs/src/install/latency-test.adoc
@@ -33,6 +33,48 @@ However, software step pulses also have some disadvantages:
 - jitter in the generated pulses
 - loads the CPU
 
+[[sec:latency-to-achive]]
+== What to Achieve?
+This depends on your application. If step pulses are directly generated by the PC, minimal
+latency is key to achieve a hight step rate. See <<cha:stepper-config>>
+for requirements.
+
+As soon as the step pulses are generated using an external hardware like Mesa cards, the latency
+constraints are looser.
+
+If the servo-thread has period of 1 ms, latency of 100-200 us can still be used.
+
+However, in this case, the total thread runtime is more important. The time from where
+the thread should have started to the next cycle should never exceed the thread's period.
+If this happens, the following warning is shown:
+----
+Unexpected realtime delay on task 0 with period 1000000
+This Message will only display once per session.
+Run the Latency Test and resolve before continuing.
+----
+
+Especially for ethernet connected cards, the ethernet latency is often the limiting factor,
+not the pure thread start latency. When using ethernet, LinuxCNC sends a request to the card
+and waits for the response. This has to happen in one thread period.
+
+Often, bad thread latency correlates with bad ethernet latency, due to the LinuxCNC and ethernet
+kernel latency adds up.
+
+[[sec:latency-load]]
+== Perform Latency Tests
+Having a system that has low latency when mostly idle but behaves badly as soon
+as some load is added will result in an unreliable system.
+
+While the test is running, you should 'abuse' the computer.
+Move windows around on the screen. Surf the web. Copy some large files
+around on the disk. Play some music.
+Run an OpenGL program such as glxgears.
+Run a load and stress tool such as stress-ng.
+The idea is to put the PC through its paces while
+the latency test checks to see what the worst case numbers are.
+
+For quick comparisons between different settings, a test of a few minutes are fine.
+However, for final testing, a several hours long test should be performed.
 
 [[sec:latency-tests]]
 == Latency Tests
@@ -87,13 +129,6 @@ After starting a latency test you should see something like this:
 .HAL Latency Test
 image::../config/images/latency-test_en.png["HAL Latency Test",align="center"]
 
-While the test is running, you should 'abuse' the computer.
-Move windows around on the screen. Surf the web. Copy some large files
-around on the disk. Play some music.
-Run an OpenGL program such as glxgears.
-The idea is to put the PC through its paces while
-the latency test checks to see what the worst case numbers are.
-
 The important number for software stepping is the 'max jitter' of the base thread.
 In the example above, that is 6693 nanoseconds (ns), or 6.693 microseconds (µs).
 Record this number, and enter it in StepConf when it is requested.
@@ -103,7 +138,7 @@ You should run the test for at least several minutes; sometimes
 the worst case latency doesn't happen very often, or only happens
 when you do some particular action. For instance, one Intel
 motherboard worked pretty well most of the time, but every 64
-seconds it had a very bad 300 µs latency. Fortunately that was fixable, see <<_latency_tuning>>.
+seconds it had a very bad 300 µs latency. Fortunately that was fixable, see <<cha:latency_tuning>>.
 
 So, what do the results mean?
 
@@ -156,7 +191,7 @@ Options:
 .`latency-plot` Window
 image::../config/images/latency-plot.png["latency-plot Window"]
 
-
+[[sec:latency-histogram]]
 === Latency Histogram
 
 The application latency-histogram displays a histogram of latency (jitter) for
@@ -192,6 +227,36 @@ Use `--show` to show count for the off-chart [pos|neg] bin.
 .`latency-histogram` Window
 image::../config/images/latency-histogram.png["latency-histogram Window"]
 
+[[sec:latency-ping]]
+=== Latency Ping
+
+The application latency-ping displays a histogram of the round trip time for
+a realtime thread pinging an ip address. This useful for network latency tuning where
+ip_address should be a Mesa card, an EtherCAT device or any other device which
+has a realtime capable ethernet interface to be used together with LinuxCNC.
+
+Due to ping is used, it should work with virtually any device without any setup.
+
+It is recommended to use the `if_name` argument to allow for static arp, so arp
+renewal is disabled and does not influence the response time.
+
+----
+Usage:
+       latency-ping [-t timeout] [-p period] [-n nbins ] [-b binsize ] ip_address [if_name]
+
+Example:
+       latency-ping 192.168.1.121 enp1s0
+
+Defaults:     timeout=800000nS period=1000000nS nbins=200 binsize=period/2/nbins
+Equivalently: timeout=800µs period=1ms nbins=200 binsize=2500
+
+Times may be specified with suffix "s", "ms", "us" "µs", or "ns"
+Times without a suffix and less than 1000 are taken to be in us;
+other times without a suffix are taken to be in ns
+----
+
+.`latency-ping` Window
+image::../config/images/latency-ping.png["latency-ping Window"]
 
 [[sec:latency-status-bar]]
 === Realtime status bar
@@ -227,95 +292,4 @@ isolcpus::
     for latency>>.
 
 
-[[_latency_tuning]]
-== Latency tuning
-
-LinuxCNC can run on many different hardware platforms and with many
-different realtime kernels, and they all may benefit from tuning for
-optimal latency.
-
-A primary goal in tuning the system for LinuxCNC is to reserve a CPU for the exclusive use of LinuxCNC's realtime tasks, so that other tasks (both user programs and kernel threads) do not interfere with LinuxCNC's access to that CPU.
-
-When specific tuning options are believed to be universally helpful
-LinuxCNC does this tuning automatically at startup, but many tuning
-options are machine-specific and cannot be done automatically.  The person
-installing LinuxCNC will need to experimentally determine the optimal
-tuning for their system.
-
-
-=== Tuning the BIOS for latency
-
-PC BIOSes vary wildly in their latency behavior.
-
-Tuning the BIOS is tedious because you have to reboot the computer,
-make one small tweak in the BIOS, boot Linux, and run the latency test
-(potentially for a long time) to see what effects your BIOS change had.
-Then repeat for all the other BIOS settings you want to try.
-
-Because BIOSes are all different and non-standard, providing a detailed
-BIOS tuning guide is not practical.  In general, some things to try
-tuning in the BIOS are:
-
-* Disable ACPI, APM, and any other power-saving features.  This includes
-  anything related to power saving, suspending, CPU sleep states, CPU
-  frequency scaling, etc.
-
-* Disable CPU "turbo" mode.
-
-* Disable CPU hyperthreading.
-
-* Disable (or otherwise control) System Management Interrupt (SMI).
-
-* Disable any hardware you do not intend to use.
-
-
-[[sec:latency-governor]]
-=== CPU frequency governor
-
-Frequency scaling lets the CPU lower its clock speed to save power, which adds
-latency while the CPU ramps back up to service a realtime thread. For the best
-latency, set the governor to `performance` on every CPU:
-
-----
-echo performance | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor
-----
-
-This setting does not survive a reboot. To make it permanent, apply it at boot
-with a small systemd service, or with a CPU frequency management tool such as
-`cpupower` (Debian/Ubuntu package `linux-cpupower`) or `tuned`.
-
-
-[[sec:tuning-preempt-rt]]
-=== Tuning Preempt-RT for latency
-
-The Preempt-RT kernel may benefit from tuning in order to provide the
-best latency for LinuxCNC.  Tuning may be done via the kernel command
-line, sysctl, and via files in `/proc` and `/sys`.
-
-Some tuning parameters to look into:
-
-Kernel command line::
-
-    Details here: <https://www.kernel.org/doc/Documentation/admin-guide/kernel-parameters.txt>
-
-    * `isolcpus`: Prevent most non-LinuxCNC processes from using these
-      CPUs, leaving more CPU time available for LinuxCNC.
-
-    * `irqaffinity`: Select which CPUs service interrupts, so that the
-      CPUs reserved for LinuxCNC realtime don't have to perform this task.
-
-    * `rcu_nocbs`: Prevent RCU callbacks from running on these CPUs.
-
-    * `rcu_nocb_poll`: Poll for RCU callbacks instead of using sleep/wake.
-
-    * `nohz_full`: Disable clock tick on these CPUs.
-
-Sysctl::
-
-    Details here: <https://www.kernel.org/doc/html/latest/scheduler/sched-rt-group.html>
-
-    * `sysctl.kernel.sched_rt_runtime_us`: Set to -1 to remove the limit
-      on how much time realtime tasks may use.
-
-
 // vim: set syntax=asciidoc:
diff --git a/docs/src/install/latency-tuning.adoc b/docs/src/install/latency-tuning.adoc
new file mode 100644
index 00000000000..bb96ef9be81
--- /dev/null
+++ b/docs/src/install/latency-tuning.adoc
@@ -0,0 +1,290 @@
+:lang: en
+:toc:
+
+[[cha:latency_tuning]]
+= Latency Tuning
+
+LinuxCNC can run on many different hardware platforms and with many
+different realtime kernels, and they all may benefit from tuning for
+optimal latency.
+
+A primary goal in tuning the system for LinuxCNC is to reserve a CPU for
+the exclusive use of LinuxCNC's realtime tasks, so that other tasks
+(both user programs and kernel threads) do not interfere with LinuxCNC's
+access to that CPU.
+
+When specific tuning options are believed to be universally helpful
+LinuxCNC does this tuning automatically at startup, but many tuning
+options are machine-specific and cannot be done automatically.  The person
+installing LinuxCNC will need to experimentally determine the optimal
+tuning for their system.
+
+== Basic process
+
+=== For x86 PREEMPT_RT or Xenomai4 EVL
+
+==== Basic configuration
+
+1. Install realtime kernel
+2. Run `realtime-config-kernel`
+3. Reboot
+4. Check latency: <<sec:latency-histogram>>
+5. If good, continue. If bad, try BIOS tuning and manually adjust kernel parameters.
+
+==== Network configuration
+
+This is only needed if you use an Ethernet IO card, EtherCAT or anything connected over Ethernet which the servo-thread communicates with.
+
+To determine the CPU LinuxCNC runs on, start any LinuxCNC app that uses realtime (`latency-histogram` for example) in the console and it will show it in the log output.
+
+1. Configure network card by editing `/etc/network/interfaces`. Example:
+
+* Replace `eth0` with the interface used for LinuxCNC
+
+* Replace `192.168.1.120/31` with the address/netmask
+
+* Replace `ISOLATED_CPU` with the CPU LinuxCNC runs on
++
+----
+auto eth0
+    iface eth0 inet static
+    address 192.168.1.120/31
+    post-up realtime-config-ethernet eth0 ISOLATED_CPU
+----
+
+2. If you use NetworkManager: `sudo systemctl restart NetworkManager` to reload the config. Otherwise, NetworkManager will interfere with the static config.
+3. Activate interface: `sudo ifup eth0`
+4. Test network latency: <<sec:latency-ping>>
+5. If good, continue. If bad, try <<sec:network-tuning>> or use a different network card.
+
+==== Final test
+
+Add a timedelta component to your configuration to check the thread
+jitter while LinuxCNC is running. It should be added as the first function.
+
+For servo-thread only:
+
+----
+loadrt timedelta count=1
+...
+addf timedelta.0 servo-thread
+----
+
+For base- and servo-thread only:
+
+----
+loadrt timedelta count=2
+...
+addf timedelta.0 servo-thread
+...
+addf timedelta.1 base-thread
+----
+
+While LinuxCNC is running, use `hal-histogram` to measure the available timing information. Example:
+
+`hal-histogram --minvalue 0 --binsize 0.5e-5 --nbins 200 servo-thread.time`
+
+Pins to watch are:
+
+* `servo-thread.time`: Time of servo thread. Must be < servo period.
+* `timedelta.0.current-jitter`: Jitter of servo thread
+* `hm2_7i96s.0.read.time`: If you are using a mesa card, time it takes to read from the card. Must be < 0.8 * servo period.
+* `base-thread.time`: Time of base thread. Must be < base period.
+* `timedelta.1.current-jitter`: Jitter of base thread
+
+=== For other hardware or kernels
+
+* Start with the always needed kernel and sysctl parameters and configuration
+** If you are using grub, they are added to `/etc/default/grub`
++
+Example for CPU3 isolated: `GRUB_CMDLINE_LINUX_DEFAULT="isolcpus=managed_irq,domain,3 irqaffinity=0-2"`
+** sysctl parameters are set in `/etc/sysctl.d/50-linuxcnc-rt.conf`
+** `sudo update-grub` updates the grub configuration, reboot
+* Test latency
+* Try and error until it works. Ideally, only one parameter at a time is changed. Some settings can make latency worse and if you set multiple at once, it might well be that you miss the ideal parameter due to an other one makes everything worse.
+
+[[sec:latency-scripts]]
+== Automated scripts
+
+These scripts should allow to achieve good realtime performance by setting general parameters. However, due to sheer amount of existing hardware, manual adjustment might be needed.
+
+realtime-config-kernel::
+This scripts creates a kernel command line that should achieve good latency for most x86 PC's. It is interactive and asks for settings where multiple choices are possible. The following settings are performed:
+
+* Full core isolation compatible with SMT enabled (if desired)
+* Any frequency scaling is disabled
+* The idle states are limited to 1
+* Sets `evl.oobcpus` to the isolated CPU if a Xenomai4 EVL kernel is running
+
+realtime-config-ethernet::
+Usage: realtime-config-ethernet nic cpu
++
+This script configures a network card for good latency. It needs to be run after the network card is up. The following settings are performed:
++
+* Any coalesce parameters are set to zero
+* All channels are set to one
+* Energy efficient ethernet is disabled
+* All network card threads and interrupts are assigned to the given CPU
+
+[[sec:bios-latency]]
+== Tuning the BIOS for latency
+
+PC BIOSes vary wildly in their latency behavior.
+
+Some settings can be modified in BIOS and also using the kernel command
+line. For example "turbo" mode and Hyper-Threading can also be disabled using
+`cpufreq.off=1` and `nosmt`.
+
+Tuning the BIOS is tedious because you have to reboot the computer,
+make one small tweak in the BIOS, boot Linux, and run the latency test
+(potentially for a long time) to see what effects your BIOS change had.
+Then repeat for all the other BIOS settings you want to try.
+
+Because BIOSes are all different and non-standard, providing a detailed
+BIOS tuning guide is not practical.  In general, some things to try
+tuning in the BIOS are:
+
+* Disable ACPI, APM, and any other power-saving features.  This includes
+  anything related to power saving, suspending, CPU sleep states, CPU
+  frequency scaling, etc.
+
+* Disable CPU "turbo" mode.
+
+* Disable CPU Hyper-Threading.
+
+* Disable (or otherwise control) System Management Interrupt (SMI).
+
+* Disable any hardware you do not intend to use.
+
+
+[[sec:latency-governor]]
+== CPU frequency governor
+
+Frequency scaling lets the CPU lower its clock speed to save power, which adds
+latency while the CPU ramps back up to service a realtime thread. For the best
+latency, set the governor to `performance` on every CPU:
+
+----
+echo performance | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor
+----
+
+This setting does not survive a reboot. To make it permanent:
+
+* Kernel command line: `cpufreq.default_governor=performance`
+
+* Apply it at boot with a small systemd service
+
+* Use CPU frequency management tool such as `cpupower` (Debian/Ubuntu package `linux-cpupower`) or `tuned`.
+
+[[sec:hyper-threading]]
+== SMT or Hyper-Threading
+
+Hyper-Threading has a big influence on latency if not handled correctly.
+
+If the Hyper-Threading is enabled and the isolated core has a sibling that is not
+isolated, latency will be similar to no core isolation.
+
+This is handled by the `realtime-config-kernel` script. Ideally, SMT is simply
+disabled. If you prefer to leave SMT enabled due to performance reason, the SMT
+sibling is isolated also.
+
+[[sec:tuning-preempt-rt]]
+== Tuning Preempt-RT for latency
+
+The Preempt-RT kernel may benefit from tuning in order to provide the
+best latency for LinuxCNC.  Tuning may be done via the kernel command
+line, sysctl, and via files in `/proc` and `/sys`.
+
+Some tuning parameters to look into:
+
+Kernel command line::
+Details here: <https://www.kernel.org/doc/Documentation/admin-guide/kernel-parameters.txt>
++
+Set in `/etc/default/grub` by adding to `GRUB_CMDLINE_LINUX_DEFAULT` and running `sudo update-grub`
++
+* `isolcpus`: Prevent most non-LinuxCNC processes from using these
+    CPUs, leaving more CPU time available for LinuxCNC.
+* `irqaffinity`: Select which CPUs service interrupts, so that the
+    CPUs reserved for LinuxCNC realtime don't have to perform this task.
+* `rcu_nocbs`: Prevent RCU callbacks from running on these CPUs.
+* `rcu_nocb_poll`: Poll for RCU callbacks instead of using sleep/wake.
+* `nohz=on`: Enables nohz
+* `nohz_full`: Disable clock tick on these CPUs.
+* `intel_idle.max_cstate=1`: Sets the maximum C-state to 1 for intel CPUs
+* `processor.max_cstate=1`: Sets the maximum C-state to 1 for other CPUs using ACPI
+* `intel_pstate=disable`: Disables intel power states (frequency scaling)
+* `cpufreq.off=1`: Disables any frequency scaling
+* `cpufreq.default_governor=performance`: Sets the frequency scaling governor to performance
+* `nosoftlockup`: Disable the soft-lockup detector.
+* `nowatchdog`: Disable both lockup detectors, soft-lockup and NMI watchdog
+* `nosmt`: Disable symmetric multithreading (SMT)
+* `mitigations=off`: Disable any CPU vulnerabilities mitigation WARNING: This makes your PC vulnerable to cyberattacks!
+* `pcie_aspm=off`: Disable PCIe power saving
+* `skew_tick=1`: Offset the periodic timer tick
+* `mce=off`: Disable machine check interrupt
+* `idle=poll`: Instead of using C-states when the CPU is idle, it does a busy wait. This will make the CPUs eat a lot more power.
+
+Sysctl::
++
+Details here: <https://www.kernel.org/doc/html/latest/scheduler/sched-rt-group.html>
++
+Set using `sudo sysctl -w` or as a persistent setting in `/etc/sysctl.d/50-linuxcnc-rt.conf`
++
+* `sysctl.kernel.sched_rt_runtime_us=-1`: Set to -1 to remove the limit
+    on how much time realtime tasks may use.
+* `kernel.timer_migration=0`: Prevents timers from being migrated between cores, which creates jitter
+
+[[sec:network-tuning]]
+== Network tuning
+
+Most network card's default settings are optimized for throughput, not latency. Below how some parameters to investigate. Read the `ethtool` manpage for details.
+
+* Any coalesce parameters should be set to zero. `sudo ethtool -c eth0`
+
+* The channels should be set to one. Multichannel is good for throughput but increases latency. `sudo ethtool -l eth0`
+
+* Energy efficient ethernet should be disabled. `ethtool --show-eee eth0`
+
+* Hardware offloading can be an issue: `sudo ethtool -k eth0`
+
+* Package drops and CRC errors due to bad cabling or hardware issues can be investigated with: `sudo ethtool -S eth0`
+
+* For driver issues, the following command helps determining which driver is used: `sudo ethtool -i eth0`
+
+If the network card interrupt and threads are assigned to the same CPU that the servo-thread runs on, any additional latency can be reduced. This will not slow down the servo-thread: It waits for the data anyway.
+
+Use `cat /proc/interrupts` to show the interrupts. Use `echo 8 | sudo tee /proc/irq/16/smp_affinity` to set the affinity of an interrupt to a specific CPU. In this example, the mask is 8 meaning the interrupt 16 is assigned to CPU 3. Use `cat /proc/interrupts` while pinging the remote device to see if the interrupt count is increasing on the CPU configured.
+
+PREEMPT_RT uses a kernel task for some network card drivers. Use `ps -Af | grep irq` to show all kernel interrupt tasks. If you see an interrupt task for your network card, use `taskset` and `chrt` to assign it to the isolated core and set to realtime priority.
+
+All the above settings are volatile and interrupt numbers can change from boot to boot. A script is needed set them in a persistent way.
+
+== Known good and bad hardware
+
+* Dedicated NVidia GPU's are only usable with the Nouveau driver. The nvidia-driver Debian package will not build for PREEMPT_RT. Latency spikes of 100-200us are common.
+* Integrated GPU's use the PC's main memory and therefore block the CPU from memory access. Wider latency distributions of 50-100us are common.
+* Dedicated AMD GPU's work quite well.
+* Intel Network Cards that use the e1000e driver have a high network latency of about 200us
+* Intel Network Cards that use the igb driver work well with a latency of <100us
+* Realtek Network Cards that use the r8169 driver can be cumbersome. Installing r8168-dkms or r8125-dkms can improve it.
+
+== Identifying issues
+
+By watching `latency-histogram` while performing certain tasks, hardware issues can be identified.
+
+* Start `glx-gears`: If the distribution gets wider, it is a GPU issue.
+* Run `stress-ng --cpu $(nproc)` If the distribution gets wider, it is a CPU issue.
+* Run `stress-ng --cpu $(nproc)` before starting `latency-histogram` and stop `stress-ng` while it is running. If the distribution gets wider without load, it might be a frequency scaling or sleep state issue. If the CPU clocks down or activates sleep states, latency gets worse.
+* Play some music. It might be a sound card issue.
+
+If you expect a GPU issue which can even be triggered just running `latency-histogram` on the PC, try running it over SSH from another PC.
+
+There are also command line tools to measure latency independently:
+
+PREEMT_RT: `sudo cyclictest --mlockall -a ISOLATED_CPU --priority=97 -N --interval=1000`
+
+PREEMT_RT network testing: `sudo taskset 8 chrt 90 ping -i .001 -q 192.168.1.121`
+
+Xenomai4 EVL: `sudo latmus -c ISOLATED_CPU`
+
+// vim: set syntax=asciidoc:
diff --git a/docs/src/man/man9/hm2_eth.9.adoc b/docs/src/man/man9/hm2_eth.9.adoc
index 603da4e6812..f82bce859c6 100644
--- a/docs/src/man/man9/hm2_eth.9.adoc
+++ b/docs/src/man/man9/hm2_eth.9.adoc
@@ -16,7 +16,7 @@ IO boards, with HostMot2 firmware.
   As shipped, the board address is 192.168.1.121.
 *board_rtnet* [default: posix]::
   The real time ethernet implementation of the board(s), separated by
-  commas. Use *posix* for PREEMT_RT. Use *evl* if you are running a
+  commas. Use *posix* for PREEMPT_RT. Use *evl* if you are running a
   Xenomai4 EVL kernel and have a supported network card.
 *firewall* [default: auto]::
   Selects the firewall backend used to isolate the dedicated interface.
@@ -58,6 +58,9 @@ hm2_eth should be used on a dedicated network interface, with only a
 cable between the PC and the board. Wireless and USB network interfaces
 are not suitable.
 
+Good network latency of the PC is important. Read the chapters
+*Latency Testing* and *Latency Tuning* in the LinuxCNC manual.
+
 These instructions assume your dedicated network interface is "eth1",
 192.168.1/24 is an unused private network, that the hostmot2 board is
 using the default address of 192.168.1.121, that you are using Debian 7
@@ -81,13 +84,14 @@ mitigate most accidental causes of interference.
 === Configure network with static address
 
 Add these lines to the file /etc/network/interfaces to configure the
-ethernet interface eth1 with a static address:
+ethernet interface eth1 with a static address. Replace ISOLATED_CPU
+with the isolated CPU LinuxCNC runs on:
 
 ----
 auto eth1
 iface eth1 inet static
     address 192.168.1.1
-    hardware-irq-coalesce-rx-usecs 0
+    post-up realtime-config-ethernet eth0 ISOLATED_CPU
 ----
 
 == PACKET LOSS
@@ -262,12 +266,6 @@ Tear the rules down by deleting the whole private table:
 nft delete table inet hm2_eth
 ----
 
-"hardware-irq-coalesce-rx-usecs" decreases time waiting to receive a packet on most systems,
-but on at least some Marvel-chipset NICs it is harmful.
-If the line does not improve system performance, then remove it.
-A reboot is required for the value to be set back to its power-on default.
-This requires the ethtool package to be installed.
-
 == BUGS
 
 Some hostmot2 functions such uart are coded in a way that causes
diff --git a/scripts/latency-ping b/scripts/latency-ping
new file mode 100755
index 00000000000..474cc80ab71
--- /dev/null
+++ b/scripts/latency-ping
@@ -0,0 +1,93 @@
+#!/bin/bash
+SCRIPT_LOCATION=$(dirname "$(readlink -f "$0")");
+if [ -f "$SCRIPT_LOCATION/rip-environment" ] && [ -z "$EMC2_HOME" ]; then
+    . "$SCRIPT_LOCATION/rip-environment"
+fi
+
+T=$(mktemp -d)
+trap 'cd / && [ -d "$T" ] && rm -rf "$T"' SIGINT SIGTERM EXIT
+cd "$T" || { echo "E: Cannot change directory to '$T'"; exit 1; }
+
+calc() { awk "BEGIN { print ($1); }" < /dev/null; }
+icalc() { awk "BEGIN { printf \"%.0f\n\", ($1); }" < /dev/null; }
+
+parse_time () {
+    case $1 in
+    -)   echo "0" ;;
+    *ns) icalc "${1%ns}" ;;
+    *us|*µs) icalc "1000*${1%us}" ;;
+    *ms) icalc "1000*1000*${1%ms}" ;;
+    *s)  icalc "1000*1000*1000*${1%s}" ;;
+    *)   if [ "$1" -lt 1000 ]; then icalc "1000*$1"; else icalc "$1"; fi ;;
+    esac
+}
+
+human_time () {
+    if [ "$1" -eq 0 ]; then echo "-"
+    elif [ "$1" -ge 1000000000 ]; then echo "$(calc "$1"/1000/1000/1000)s"
+    elif [ "$1" -ge 1000000 ]; then echo "$(calc "$1"/1000/1000)ms"
+    elif [ "$1" -ge 1000 ]; then echo "$(calc "$1"/1000)µs"
+    else echo "$1ns"
+    fi
+}
+
+usage () {
+    echo "Usage:"
+    echo "       latency-ping [-t timeout] [-p period] [-n nbins ] [-b binsize ] ip_address [if_name]"
+    echo ""
+    echo "Example:"
+    echo "       latency-ping 192.168.1.121 enp1s0"
+    echo ""
+    echo "Defaults:     timeout=${TIMEOUT}nS period=${PERIOD}nS nbins=$NBINS binsize=period/2/nbins"
+    echo "Equivalently: timeout=$(human_time "$TIMEOUT") period=$(human_time "$PERIOD") nbins=$NBINS binsize=2500"
+    echo ""
+    echo "Times may be specified with suffix \"s\", \"ms\", \"us\" \"µs\", or \"ns\""
+    echo "Times without a suffix and less than 1000 are taken to be in us;"
+    echo "other times without a suffix are taken to be in ns"
+}
+
+TIMEOUT=$(parse_time 800us)
+PERIOD=$(parse_time 1ms)
+NBINS=200
+
+while getopts t:p:n:b:h opt; do
+    case "$opt" in
+    t) TIMEOUT=$(parse_time "$OPTARG");;
+    p) PERIOD=$(parse_time "$OPTARG");;
+    n) NBINS="$OPTARG";;
+    b) BINSIZE="$OPTARG";;
+    h|?) usage; exit 0 ;;
+    *) usage; exit 1 ;;
+    esac
+done
+shift $((OPTIND-1))
+
+case $# in
+1) IP="$1" ;;
+2) IP="$1" IF="$2" ;;
+*) usage; exit 1 ;;
+esac
+
+if [ -z "$BINSIZE" ]; then
+    BINSIZE=$((PERIOD/2/NBINS))
+fi
+
+if [ -z "$IF" ]; then
+cat > lat.hal <<EOF
+loadrt ping ip_address=$IP timeout=$TIMEOUT
+loadrt threads name1=thread period1=$PERIOD
+addf ping thread
+start
+loadusr -w hal-histogram --minvalue 0 --binsize $BINSIZE --nbins $NBINS ping.ping-rtt
+EOF
+else
+cat > lat.hal <<EOF
+loadrt ping ip_address=$IP if_name=$IF timeout=$TIMEOUT
+loadrt threads name1=thread period1=$PERIOD
+addf ping thread
+start
+loadusr -w hal-histogram --minvalue 0 --binsize $BINSIZE --nbins $NBINS ping.ping-rtt
+EOF
+fi
+
+halrun lat.hal
diff --git a/scripts/realtime-config-ethernet b/scripts/realtime-config-ethernet
new file mode 100755
index 00000000000..7e12f8c5f2a
--- /dev/null
+++ b/scripts/realtime-config-ethernet
@@ -0,0 +1,137 @@
+#!/usr/bin/env bash
+# realtime-config-ethernet: Configure a network card for realtime
+#
+# This sets all network card parameters known to improve latency
+# with ethtool.
+#
+# Additionally, the IRQ and IQR handler process is assigned to
+# the given CPU which should be the one linuxcnc runs on.
+#
+# Realtime priority is assigned to the IRQ handler process.
+# Only PREEMPT_RT has a dedicated IRQ handler process and some
+# network drivers (r8169 for example) use ksoftirqd on the same
+# CPU the IRQ is assigned to. So realtime priority is also set
+# for ksoftirqd/$CPU.
+#
+# Warning: These settings are not persistent, so they have
+# to be set after each boot.
+#
+# Can be integrated in /etc/network/interfaces the following way
+# assuming your network card is enp2s0f0 and your realtime
+# CPU is CPU3:
+#
+#auto enp2s0f0
+#iface enp2s0f0 inet static
+#  address 192.168.1.120/31
+#  post-up realtime-config-ethernet enp2s0f0 3
+#
+#Copyright: 2026 Hannes Diethelm <hannes.diethelm@gmail.com>
+#License: GPL Version 2
+
+set -euo pipefail
+trap 'echo "ERROR: line $LINENO: $BASH_COMMAND" >&2' ERR
+
+if [[ "$#" -ne 2 ]]; then
+    echo "Usage: realtime-config-ethernet nic cpu" >&2
+    exit 1
+fi
+
+if [[ $EUID -ne 0 ]]; then
+    echo "Error: run this script as root (sudo)" >&2
+    exit 1
+fi
+
+NIC=$1
+CPU=$2
+
+if [[ ! -d "/sys/class/net/$NIC" ]]; then
+    echo "Interface $NIC does not exist" >&2
+    exit 1
+fi
+
+if [[ ! "$CPU" =~ ^[0-9]+$ ]]; then
+    echo "Error: cpu must be a positive integer, got $CPU" >&2
+    exit 1;
+fi
+
+#Priority 90 should be fine for most cases
+#It should be lower than lowest linuxcnc task
+RT_PRIO_IRQ=90
+RT_PRIO_KSOFTIRQD=80
+
+#Build mask for taskset and smp_affinity
+if [ "$CPU" -gt 63 ]; then
+    echo "No support for 64 CPU's yet"
+    exit 1
+fi
+MASK=$(printf '%x\n' "$((2**CPU))")
+if (( ${#MASK} > 8 )); then
+    MASKIRQ="${MASK:0:${#MASK}-8},${MASK: -8}"
+else
+    MASKIRQ=$MASK
+fi
+
+echo Setting network card config----------------------
+echo These fail if not supported by card
+echo
+echo Setting coalesce...
+ethtool -C "$NIC" rx-usecs 0 || true
+ethtool -C "$NIC" rx-frames 1 || true
+ethtool -C "$NIC" adaptive-rx off || true
+ethtool -C "$NIC" tx-usecs 0 || true
+ethtool -C "$NIC" tx-frames 1 || true
+ethtool -C "$NIC" adaptive-tx off || true
+echo
+echo Coalesce  config:
+ethtool -c "$NIC" || true
+echo
+
+echo Setting channels...
+ethtool -L "$NIC" rx 1 || true
+ethtool -L "$NIC" tx 1 || true
+ethtool -L "$NIC" combined 1 || true
+echo
+echo Channels config:
+ethtool -l "$NIC" || true
+echo
+
+echo Setting eee...
+ethtool --set-eee "$NIC" eee off || true
+echo eee config:
+ethtool --show-eee ens4 || true
+echo
+
+echo Setting process and IRQ config-------------------
+echo
+echo "Setting affinity for $NIC to use CPU Mask $MASK..."
+
+IRQS=$(grep "$NIC" /proc/interrupts | awk -F: '{print $1}' | tr -d ' ') || true
+if [ -z "$IRQS" ]; then
+    echo "Error: No IRQ's found for $NIC"
+    exit 1
+fi
+
+for IRQ in $IRQS; do
+	PID=$(pgrep "irq/$IRQ-$NIC" || true)
+	if [ -z "$PID" ]; then
+		echo "No process found for IRQ $IRQ, this is no issue if you use a kernel without PREEMPT_RT patch"
+	else
+		echo "Setting pid $PID irq $IRQ process $(cat "/proc/$PID/comm") to use realtime priority $RT_PRIO_IRQ and mask $MASK"
+		chrt -p "$RT_PRIO_IRQ" "$PID"
+		taskset -p "$MASK" "$PID"
+	fi
+	echo "Setting irq $IRQ to mask $MASKIRQ"
+	echo "$MASKIRQ" > "/proc/irq/$IRQ/smp_affinity"
+done
+echo
+echo "Setting affinity for ksoftirqd/$CPU..."
+PID=$(pgrep -x "ksoftirqd/$CPU" || true)
+if [ -z "$PID" ]; then
+	echo "No process found for ksoftirqd/$CPU"
+else
+	echo "Setting pid $PID process $(cat "/proc/$PID/comm") to use realtime priority $RT_PRIO_KSOFTIRQD"
+	chrt -p "$RT_PRIO_KSOFTIRQD" "$PID"
+fi
+
+echo
+echo "done"
diff --git a/scripts/realtime-config-kernel b/scripts/realtime-config-kernel
new file mode 100755
index 00000000000..46f8b6474b3
--- /dev/null
+++ b/scripts/realtime-config-kernel
@@ -0,0 +1,412 @@
+#!/usr/bin/env bash
+# realtime-config-kernel — config kernel command line and sysctl for this machine
+#
+# Rules
+#   - isolate the highest logical CPU and it's SMT sibling if SMT is active
+#   - irqaffinity on all remaining CPU's
+#   - rcu_nocbs / nohz_full on the isolated CPU
+#   - SMT state from smt/control:
+#       notsupported -> no SMT hardware, no 'nosmt', no question
+#       on / off     -> SMT hardware exists -> ASK whether to add 'nosmt'
+#   - intel_idle.max_cstate=1 and processor.max_cstate=1 to work on both AMD and Intel
+#
+# Copyright: 2026 Hannes Diethelm <hannes.diethelm@gmail.com>
+# License: GPL Version 2
+
+set -euo pipefail
+trap 'echo "ERROR: line $LINENO: $BASH_COMMAND" >&2' ERR
+
+# --- CPU detection -------------------------------------------
+
+# Convert Linux CPU lists (0-3,8,10-11) into Bash arrays.
+parse_cpulist() {
+    local list="$1"
+    local part first last cpu
+
+    CPU_LIST=()
+
+    IFS=',' read -ra parts <<< "$list"
+
+    for part in "${parts[@]}"; do
+        if [[ "$part" == *-* ]]; then
+            first="${part%-*}"
+            last="${part#*-}"
+
+            for ((cpu=first; cpu<=last; cpu++)); do
+                CPU_LIST+=("$cpu")
+            done
+        elif [[ -n "$part" ]]; then
+            CPU_LIST+=("$part")
+        fi
+    done
+}
+
+# Convert Bash CPU array into Linux CPU-list notation.
+format_cpulist() {
+    local -n cpus=$1
+    local cpu start previous
+    local result=""
+
+    local -a sorted=()
+
+    mapfile -t sorted < <(
+        printf '%s\n' "${cpus[@]}" | sort -nu
+    )
+
+    ((${#sorted[@]})) || return 0
+
+    start="${sorted[0]}"
+    previous="$start"
+
+    for cpu in "${sorted[@]:1}"; do
+        if (( cpu == previous + 1 )); then
+            previous="$cpu"
+            continue
+        fi
+
+        [[ -n "$result" ]] && result+=","
+
+        if (( start == previous )); then
+            result+="$start"
+        else
+            result+="$start-$previous"
+        fi
+
+        start="$cpu"
+        previous="$cpu"
+    done
+
+    [[ -n "$result" ]] && result+=","
+
+    if (( start == previous )); then
+        result+="$start"
+    else
+        result+="$start-$previous"
+    fi
+
+    echo "$result"
+}
+
+# --- Hybrid CPU detection ------------------------------------
+
+cpu_type=uniform
+
+if [[ -s /sys/devices/cpu_core/cpus &&
+      -s /sys/devices/cpu_atom/cpus ]]; then
+
+    echo "Hybrid CPU detected"
+    echo "Big CPUs   : $(cat /sys/devices/cpu_core/cpus)"
+    echo "Little CPUs: $(cat /sys/devices/cpu_atom/cpus)"
+
+    read -r -p "Use Big or Little CPUs? [B/l] " ans
+    ans="${ans:-b}"
+
+    case "$ans" in
+        b|B) cpu_type=big ;;
+        l|L) cpu_type=little ;;
+        *) echo "b or l"; exit 1 ;;
+    esac
+fi
+
+# --- Kernel detection ----------------------------------------
+kernel_type=UNKNOWN
+if [[ -c /dev/evl/control ]]; then
+    kernel_type=EVL
+    echo "Xenomai4 EVL kernel detected"
+elif uname -v | grep -q PREEMPT_RT; then
+    kernel_type=PREEMPT_RT
+    echo "PreemptRT kernel detected"
+else
+    echo "WARNING: Please install PreemptRT or Xenomai4 EVL Kernel"
+fi
+
+# --- SMT detection -------------------------------------------
+# SMT hardware state from smt/active: none (notsupported) / on / off
+smtcontrol="$(cat "/sys/devices/system/cpu/smt/control" 2>/dev/null || echo "")"
+if [[ -z "$smtcontrol" ]]; then
+    echo "Error, could not determine SMT state, assuming on"
+    smtstate=on
+else
+    case "$smtcontrol" in
+        notsupported) smtstate=none ;;
+        off|forceoff) smtstate=off ;;
+        on)           smtstate=on ;;
+        *)            echo "Error, could not determine SMT state, assuming on"; smtstate=on ;;
+    esac
+fi
+
+nosmt=""
+if [[ "$smtstate" != "none" ]]; then
+    read -r -p "SMT hardware present (currently: $smtstate). Add 'nosmt' (run without SMT)? [Y/n] " ans
+    ans="${ans:-y}"
+    case "$ans" in
+        y|Y) nosmt="nosmt" ;;
+        n|N) ;;
+        *) echo "y or n"; exit 1;;
+    esac
+    if [[ "$smtstate" != "on" && -z "$nosmt" ]]; then
+        echo "Can not determine SMT sibling, run \"echo on | sudo tee /sys/devices/system/cpu/smt/control\" to enable SMT and try again"
+        exit 1
+    fi
+fi
+
+# --- CPU topology and isolation ------------------------------
+
+# Available CPU IDs.
+read -r online_list < /sys/devices/system/cpu/online
+parse_cpulist "$online_list"
+online_cpus=("${CPU_LIST[@]}")
+
+# Select CPU class.
+case "$cpu_type" in
+    big)
+        read -r selected_list < /sys/devices/cpu_core/cpus
+        ;;
+    little)
+        read -r selected_list < /sys/devices/cpu_atom/cpus
+        ;;
+    *)
+        selected_list="$online_list"
+        ;;
+esac
+
+parse_cpulist "$selected_list"
+selected_cpus=()
+
+for cpu in "${CPU_LIST[@]}"; do
+    if [[ " ${online_cpus[*]} " == *" $cpu "* ]]; then
+        selected_cpus+=("$cpu")
+    fi
+done
+
+if ((${#selected_cpus[@]} == 0)); then
+    echo "ERROR: No online CPUs in selected CPU class"
+    exit 1
+fi
+
+# Select highest-numbered CPU in selected class.
+isolated_main=0
+
+for cpu in "${selected_cpus[@]}"; do
+    (( cpu > isolated_main )) && isolated_main=$cpu
+done
+
+siblings=()
+isolated_cpus=("${isolated_main[@]}")
+if [[ "$smtstate" = "on" ]]; then
+    # Determine SMT siblings of selected CPU.
+    sibling_list="$(cat "/sys/devices/system/cpu/cpu$isolated_main/topology/thread_siblings_list")"
+    parse_cpulist "$sibling_list"
+    siblings=()
+    for cpu in "${CPU_LIST[@]}"; do
+        [[ "$cpu" == "$isolated_main" ]] || siblings+=("$cpu")
+    done
+
+    if [[ -z "$nosmt" ]]; then
+        # SMT stays active: Isolate all in the siblings list
+        isolated_cpus=("${CPU_LIST[@]}")
+    else
+        # SMT going to be disabled: Isolate the first CPU in the list which is the main one
+        # which will survive nosmt
+        siblings=()
+        isolated_main="${CPU_LIST[0]}"
+        isolated_cpus=("${isolated_main[@]}")
+    fi
+fi
+
+# Build isolated CPU lookup.
+declare -A isolated_map=()
+
+for cpu in "${isolated_cpus[@]}"; do
+    isolated_map[$cpu]=1
+done
+
+# When using nosmt, exclude all siblings of the isolated CPU
+# from IRQ affinity as well.
+if [[ -n "$nosmt" ]]; then
+    for cpu in "${siblings[@]}"; do
+        isolated_map[$cpu]=1
+    done
+fi
+
+# Build nonisolated CPU list.
+nonisolated_cpus=()
+
+for cpu in "${online_cpus[@]}"; do
+    if [[ -n "${isolated_map[$cpu]:-}" ]]; then
+        continue
+    fi
+
+    if [[ "$smtstate" == "on" && -n "$nosmt" ]]; then
+        sibling_list="$(cat "/sys/devices/system/cpu/cpu$cpu/topology/thread_siblings_list")"
+        parse_cpulist "$sibling_list"
+
+        # Only the first CPU in the sibling list survives nosmt.
+        if [[ "$cpu" == "${CPU_LIST[0]}" ]]; then
+            nonisolated_cpus+=("$cpu")
+        fi
+    else
+        nonisolated_cpus+=("$cpu")
+    fi
+done
+
+isolated="$(format_cpulist isolated_cpus)"
+nonisolated="$(format_cpulist nonisolated_cpus)"
+
+if [[ -z "$nonisolated" ]]; then
+    echo "ERROR: No CPUs available for IRQ affinity"
+    exit 1
+fi
+
+# --- report cpu ----------------------------------------------
+echo "Online CPUs      : $online_list"
+echo "CPU type         : $cpu_type"
+echo "SMT              : $smtstate"
+echo "Isolated CPU     : $isolated_main"
+if ((${#siblings[@]} > 0)); then
+    echo "Sibling of CPU $isolated_main: ${siblings[*]} (also isolated)"
+fi
+echo "IRQ affinity     : $nonisolated"
+
+
+# --- commandline ---------------------------------------------
+
+cmdline="isolcpus=managed_irq,domain,$isolated irqaffinity=$nonisolated rcu_nocbs=$isolated rcu_nocb_poll"
+if [[ "$kernel_type" != "EVL" ]]; then
+    #evl has issues with nohz
+    cmdline="$cmdline nohz=on nohz_full=$isolated"
+fi
+cmdline="$cmdline intel_idle.max_cstate=1 processor.max_cstate=1 cpufreq.off=1 nosoftlockup nowatchdog"
+if [[ -n "$nosmt" ]]; then
+    cmdline="$cmdline nosmt"
+fi
+if [[ "$kernel_type" == "EVL" ]]; then
+    #evl needs evl.oobcpus, so the network card tasks run on the correct CPU
+    cmdline="$cmdline evl.oobcpus=$isolated_main"
+fi
+
+#Contains all set or unset parameters for merge with existing cmdline
+cmdline_parameters=("isolcpus" "irqaffinity" "rcu_nocbs" "rcu_nocb_poll"
+    "nohz" "nohz_full"
+    "intel_idle.max_cstate" "processor.max_cstate" "cpufreq.off" "nosoftlockup" "nowatchdog"
+    "nosmt"
+    "evl.oobcpus")
+
+# --- report cmdline ------------------------------------------
+echo
+echo Recommended kernel command line:
+echo "$cmdline"
+echo
+
+# --- add to grub ---------------------------------------------
+
+merge_cmdline() {
+    local existing="$1"
+    local new="$2"
+    local -a param_list
+    read -r -a param_list <<< "$3"
+    local token key opt
+    local -a result=()
+
+    # Keep existing parameters not overridden by the new ones,
+    # except options in param_list.
+    for token in $existing; do
+        key=${token%%=*}
+
+        # Skip options that should be removed unless explicitly set in new.
+        for opt in "${param_list[@]}"; do
+            [[ "$key" == "$opt" ]] && continue 2
+        done
+
+        result+=("$token")
+    done
+
+    # Append the new parameters.
+    for token in $new; do
+        result+=("$token")
+    done
+
+    printf '%s' "${result[*]}"
+}
+
+grub_confg="/etc/default/grub"
+
+change_grub=false
+if [[ ! -f "$grub_confg" ]]; then
+    echo "$grub_confg not found, edit your bootloader configuration by hand"
+else
+    tmpfile=$(mktemp /tmp/grub.XXXXXX)
+    source <(grep '^[[:space:]]*GRUB_CMDLINE_LINUX_DEFAULT=' $grub_confg)
+    cp "$grub_confg" "$tmpfile"
+    existing=$GRUB_CMDLINE_LINUX_DEFAULT
+    if [[ "$cmdline" = "$existing" ]]; then
+        echo "Configured kernel command line is equal to recommended: nothing to do"
+    elif [[ -n "$existing" ]]; then
+        merged=$(merge_cmdline "$existing" "$cmdline" "${cmdline_parameters[*]}")
+        echo "Existing command line:"
+        echo "$existing"
+        echo
+        echo "Merged command line:"
+        echo "$merged"
+        echo
+        read -r -p "Use recommended, merged or abort? [r,m,A] " ans
+        ans="${ans:-a}"
+        case "$ans" in
+            r|R) change_grub=true;;
+            m|M) cmdline=$merged; change_grub=true ;;
+            a|A) echo "Edit /etc/default/grub manually";;
+            *) echo "r, m or a"; exit 1;;
+        esac
+    else
+        change_grub=true
+    fi
+fi
+
+if [[ "$change_grub" == "true" ]]; then
+    sed -i "s|^GRUB_CMDLINE_LINUX_DEFAULT=.*|GRUB_CMDLINE_LINUX_DEFAULT=\"$cmdline\"|" "$tmpfile"
+
+    echo Diff existing vs. new $grub_confg:
+    diff -u "$grub_confg" "$tmpfile" || true
+
+    read -r -p "Apply changes and update grub? [y/N] " ans
+    ans="${ans:-n}"
+    case "$ans" in
+        y|Y) sudo cp "$tmpfile" "$grub_confg" ; sudo update-grub;;
+        n|N) ;;
+        *) echo "y or n"; exit 1;;
+    esac
+fi
+rm "$tmpfile"
+echo
+
+# --- sysctl --------------------------------------------------
+
+sysctl="/etc/sysctl.d/50-linuxcnc-rt.conf"
+tmpfile=$(mktemp /tmp/50-linuxcnc-rt.XXXXXX)
+chmod go+r "$tmpfile"
+
+cat > "$tmpfile" <<'EOF'
+kernel.sched_rt_runtime_us=-1
+kernel.timer_migration=0
+EOF
+
+if cmp -s "$sysctl" "$tmpfile" ; then
+    echo "$sysctl is ok: nothing to do"
+else
+    if [[ ! -f "$sysctl" ]]; then
+        echo "$sysctl does not exist. Recommended:"
+        cat "$tmpfile"
+        read -r -p "Create this file? [y/N] " ans
+    else
+        echo "$sysctl does not contain recommended content:"
+        diff -u "$sysctl" "$tmpfile" || true
+        read -r -p "Replace this file? [y/N] " ans
+    fi
+    ans="${ans:-n}"
+    case "$ans" in
+        y|Y) sudo cp "$tmpfile" "$sysctl" ;;
+        n|N) ;;
+        *) echo "y or n"; exit 1;;
+    esac
+fi
+rm "$tmpfile"
diff --git a/src/Makefile b/src/Makefile
index 05715dd7985..210cc551f3c 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -664,6 +664,9 @@ endif
 	$(EXE) ../scripts/latency-test $(DESTDIR)$(bindir)
 	$(EXE) ../scripts/latency-plot $(DESTDIR)$(bindir)
 	$(EXE) ../scripts/latency-histogram $(DESTDIR)$(bindir)
+	$(EXE) ../scripts/latency-ping $(DESTDIR)$(bindir)
+	$(EXE) ../scripts/realtime-config-ethernet $(DESTDIR)$(sbindir)
+	$(EXE) ../scripts/realtime-config-kernel $(DESTDIR)$(bindir)
 	$(EXE) ../scripts/moveoff_gui $(DESTDIR)$(bindir)
 	$(EXE) ../scripts/hal-histogram $(DESTDIR)$(bindir)
 	$(EXE) ../scripts/xhc-hb04-accels $(DESTDIR)$(bindir)
@@ -810,6 +813,7 @@ endif
 install-kernel-dep:
 	$(DIR)	$(DESTDIR)$(moduledir)/linuxcnc \
 		$(DESTDIR)$(bindir) \
+		$(DESTDIR)$(sbindir) \
 		$(DESTDIR)$(sysconfdir)/linuxcnc
 	$(FILE) ../rtlib/*$(MODULE_EXT) $(DESTDIR)$(EMC2_RTLIB_DIR)
 	$(SETUID) ../bin/linuxcnc_module_helper $(DESTDIR)$(bindir)
diff --git a/src/hal/components/ping.comp b/src/hal/components/ping.comp
new file mode 100644
index 00000000000..773f94ba9db
--- /dev/null
+++ b/src/hal/components/ping.comp
@@ -0,0 +1,357 @@
+component ping "Ping an IP adress";
+description """
+
+Ping an IP address for latency tuning / debugging hostmot2
+or other Ethernet connected peripherals.
+
+Example:
+loadrt ping ip_address=192.168.1.121 if_name=eth0 timeout=800000
+loadrt threads name1=thread period1=1000000
+addf ping thread
+start
+loadusr -w ../scripts/rip-environment ../scripts/hal-histogram --minvalue 0 --binsize 1e3 --nbins 200 ping.ping-rtt
+
+You can use hal-histogram to show a histogram:
+hal-histogram ping.ping-rtt
+Note: You need to tweak minval / bsize / nbins to have a
+useful display. maxval = minval + bsize * nbins
+A good starting point for 0...200 us is:
+hal-histogram --minvalue 0 --binsize 1e3 --nbins 200 ping.ping-rtt
+
+This component works only in userspace.
+
+""";
+pin out sint ping_err=0 "Error counter";
+pin out sint ping_timeout=0 "Timeout counter";
+pin out sint ping_rtt=0 "Roundtrip time (ns)";
+pin out sint ping_rtt_max=0 "Maximum roundtrip time (ns).";
+pin in bool reset "Set this pin to true, then back to false, to reset ping_rtt_max.";
+function _;
+option extra_setup;
+option extra_cleanup;
+option singleton yes;
+
+license "GPL";
+author "H.Diethelm";
+;;
+
+#if defined(__KERNEL__)
+EXTRA_SETUP() {
+    (void)prefix;
+    (void)extra_arg;
+    (void)__comp_inst;
+
+    rtapi_print_msg(RTAPI_MSG_ERR, "ping: error: kernel mode not supported\n");
+
+    return 0;
+}
+
+EXTRA_CLEANUP() {
+
+}
+
+FUNCTION(_) {
+    (void)period;
+}
+#else
+
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <string.h>
+#include <netinet/ip_icmp.h>
+#include <net/if_arp.h>
+#include <stdbool.h>
+
+static char *ip_address = "127.0.0.1";
+RTAPI_MP_STRING(ip_address, "IP address to ping");
+
+static char *if_name = NULL;
+RTAPI_MP_STRING(if_name, "Interface name to ping");
+
+static int timeout = 800000;
+RTAPI_MP_INT(timeout, "Timeout in ns");
+
+#define PING_PKT_SIZE 64
+
+typedef struct{
+    char *ip_address;
+    int sockfd;
+    struct sockaddr_in addr;
+    struct arpreq arp_request;
+    long long int time_start;
+    long long int time_end;
+    uint16_t tx_seq;
+    uint16_t tx_id;
+    bool send;
+    unsigned char tbuffer[PING_PKT_SIZE];
+    unsigned char rbuffer[2*PING_PKT_SIZE];
+}ping_data;
+
+static ping_data data={};
+
+#undef max
+#define max(a,b) ((a)>(b)?(a):(b))
+
+#if BYTE_ORDER == LITTLE_ENDIAN
+# define ODDBYTE(v)	(v)
+#elif BYTE_ORDER == BIG_ENDIAN
+# define ODDBYTE(v)	((unsigned short)(v) << 8)
+#else
+# define ODDBYTE(v)	htons((unsigned short)(v) << 8)
+#endif
+
+//in_cksum from: https://github.com/iputils/iputils/blob/master/ping/ping.c
+//Licence: BSD-3-Clause
+static unsigned short
+in_cksum(const unsigned short *addr, int len, unsigned short csum)
+{
+    int nleft = len;
+    const unsigned short *w = addr;
+    unsigned short answer;
+    int sum = csum;
+
+    /*
+    *  Our algorithm is simple, using a 32 bit accumulator (sum),
+    *  we add sequential 16 bit words to it, and at the end, fold
+    *  back all the carry bits from the top 16 bits into the lower
+    *  16 bits.
+    */
+    while (nleft > 1) {
+        sum += *w++;
+        nleft -= 2;
+    }
+
+    /* mop up an odd byte, if necessary */
+    if (nleft == 1)
+        sum += ODDBYTE(*(unsigned char *)w); /* le16toh() may be unavailable on old systems */
+
+    /*
+        * add back carry outs from top 16 bits to low 16 bits
+        */
+    sum = (sum >> 16) + (sum & 0xffff);	/* add hi 16 to low 16 */
+    sum += (sum >> 16);			/* add carry */
+    answer = ~sum;				/* truncate to 16 bits */
+    return (answer);
+}
+
+bool setup_ping(ping_data *data){
+    int sockfd;
+    data->addr.sin_family = AF_INET;
+    data->addr.sin_port = htons(0);
+    data->addr.sin_addr.s_addr = inet_addr(data->ip_address);
+
+    // Create socket
+    sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_ICMP);
+    if (sockfd < 0) {
+        rtapi_print_msg(RTAPI_MSG_ERR, "ping: error: socket %m");
+        return false;
+    }
+
+    int ttl_val = 64;
+    // Set socket options at IP to TTL 64
+    if(setsockopt(sockfd, SOL_IP, IP_TTL, &ttl_val, sizeof(ttl_val)) != 0) {
+        rtapi_print_msg(RTAPI_MSG_ERR, "ping: error: setsockopt IP_TTL %m\n");
+        close(sockfd);
+        return false;
+    }
+
+    struct timeval tv;
+    tv.tv_sec = timeout/1000000000;
+    tv.tv_usec = (timeout/1000)%1000000;
+
+    // Setting timeout
+    if(setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof tv) != 0) {
+        rtapi_print_msg(RTAPI_MSG_ERR, "ping: error: setsockopt SO_RCVTIMEO %m\n");
+        close(sockfd);
+        return false;
+    }
+    data->tx_id=getpid();
+    data->sockfd=sockfd;
+    data->send=true;
+    return true;
+}
+
+bool setup_arp(ping_data *data, char* if_name) {
+    int ret = 0;
+    memset(&data->arp_request, 0, sizeof(data->arp_request));
+    ((struct sockaddr_in *)&data->arp_request.arp_pa)->sin_family = AF_INET;
+    ((struct sockaddr_in *)&data->arp_request.arp_pa)->sin_addr = data->addr.sin_addr;
+    strncpy(data->arp_request.arp_dev, if_name, sizeof(data->arp_request.arp_dev)-1);
+    ret = ioctl(data->sockfd, SIOCGARP, &data->arp_request);
+    if(ret < 0){
+        rtapi_print_msg(RTAPI_MSG_ERR, "ping: error: ioctl SIOCGARP %m\n");
+        return false;
+    }
+    if(!(data->arp_request.arp_flags | ATF_COM)) {
+        rtapi_print_msg(RTAPI_MSG_ERR, "ping: error: arp request failed\n");
+        return false;
+    } else {
+        rtapi_print_msg(RTAPI_MSG_ERR, "ping: ip=%s mac=%.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n",
+                        data->ip_address,
+                        (uint8_t)data->arp_request.arp_ha.sa_data[0],
+                        (uint8_t)data->arp_request.arp_ha.sa_data[1],
+                        (uint8_t)data->arp_request.arp_ha.sa_data[2],
+                        (uint8_t)data->arp_request.arp_ha.sa_data[3],
+                        (uint8_t)data->arp_request.arp_ha.sa_data[4],
+                        (uint8_t)data->arp_request.arp_ha.sa_data[5]);
+    }
+
+    data->arp_request.arp_flags |= ATF_PERM;
+    ret = ioctl(data->sockfd, SIOCSARP, &data->arp_request);
+    if(ret < 0){
+        rtapi_print_msg(RTAPI_MSG_ERR, "ping: error: ioctl SIOCSARP %m\n");
+        return false;
+    }
+
+    return true;
+}
+
+bool cleanup_arp(ping_data *data){
+    int ret = ioctl(data->sockfd, SIOCDARP, &data->arp_request);
+    if(ret < 0){
+        rtapi_print_msg(RTAPI_MSG_ERR, "ping: error: ioctl SIOCSARP %m\n");
+        return false;
+    }
+    return true;
+}
+
+bool send_ping(ping_data *data) {
+    struct icmphdr *hdr = (struct icmphdr *)(data->tbuffer);
+    unsigned char *msg = data->tbuffer + sizeof(struct icmphdr);
+
+    // Fill the packet
+    bzero(&data->tbuffer, sizeof(data->tbuffer));
+    hdr->type = ICMP_ECHO;
+    hdr->un.echo.id = htons(data->tx_id);
+
+    for (size_t i = 0; i < PING_PKT_SIZE - sizeof(struct icmphdr); i++)
+        msg[i] = i + '0';
+
+    hdr->un.echo.sequence = htons(data->tx_seq);
+    hdr->checksum = in_cksum((unsigned short *)data->tbuffer, sizeof(data->tbuffer), 0);
+
+    // Send packet
+    data->time_start = rtapi_get_time();
+    ssize_t ret = sendto(data->sockfd, data->tbuffer, sizeof(data->tbuffer), 0, (struct sockaddr*)&data->addr, sizeof(data->addr));
+    if (ret <= 0) {
+        rtapi_print_msg(RTAPI_MSG_ERR, "ping: error: sendto %m\n");
+        return false;
+    }else{
+        return true;
+    }
+}
+
+enum{
+    ERR_TIMEOUT = -1,
+    ERR_SKIP = -2,
+    ERR_CORRUPT = -3
+};
+
+rtapi_s32 recv_ping(ping_data *data) {
+    struct sockaddr_in r_addr;
+    rtapi_s32 rtt_nsec = 0;
+
+    // Receive packet
+    socklen_t addr_len = sizeof(r_addr);
+    ssize_t ret = recvfrom(data->sockfd, data->rbuffer, sizeof(data->rbuffer), 0, (struct sockaddr*)&r_addr, &addr_len);
+    if (ret <= 0) {
+        if( errno == EAGAIN){
+            return ERR_TIMEOUT;
+        }else{
+            rtapi_print_msg(RTAPI_MSG_ERR, "ping: error: recvfrom failed: %m\n");
+            return ERR_CORRUPT;
+        }
+    } else {
+        data->time_end = rtapi_get_time();
+
+        struct icmphdr *recv_hdr = (struct icmphdr *)(data->rbuffer);
+        unsigned short checksum = in_cksum((unsigned short *)data->rbuffer, ret, 0);
+        uint16_t rx_seq=ntohs(recv_hdr->un.echo.sequence);
+        if (checksum != 0) {
+            rtapi_print_msg(RTAPI_MSG_ERR, "ping: error: received checksum wrong\n");
+            return ERR_CORRUPT;
+        } else if (recv_hdr->type != 0 || recv_hdr->code != 0) {
+            rtapi_print_msg(RTAPI_MSG_ERR, "ping: error: package corrupt: received size %li with ICMP type %d code %d tx_seq %d rx_seq %d\n", ret, recv_hdr->type, recv_hdr->code, data->tx_seq, rx_seq);
+            return ERR_CORRUPT;
+        } else if (data->tx_seq > rx_seq) {
+            //Probably did skiped a package due to timeout, don't send on next round, so we get to the correct sequence again
+            return ERR_SKIP;
+        } else if (data->tx_seq < rx_seq) {
+            //The sequence of the received package should never be > than the sent one
+            rtapi_print_msg(RTAPI_MSG_ERR, "ping: error: sequence wrong: received size %li with ICMP type %d code %d tx_seq %d rx_seq %d\n", ret, recv_hdr->type, recv_hdr->code, data->tx_seq, rx_seq);
+            return ERR_CORRUPT;
+        } else {
+            rtt_nsec = data->time_end - data->time_start;
+            //rtapi_print_msg(RTAPI_MSG_ERR, "%li bytes from %s msg_seq = %d rtt = %.3f us.\n", ret, data->ip_address, rx_seq, (double)rtt_nsec/1000);
+        }
+        data->tx_seq ++;
+    }
+
+    return rtt_nsec;
+}
+
+// Note: the extra setup is run _before_ the pins are created
+EXTRA_SETUP() {
+    (void)prefix;
+    (void)extra_arg;
+    (void)__comp_inst;
+    data.ip_address=ip_address;
+    if(!setup_ping(&data)){
+        return -1;
+    }
+
+    if(if_name == NULL){
+        rtapi_print_msg(RTAPI_MSG_ERR, "ping: warning: if_name not given, can not set\n"
+            "    static arp. Might increase latency.\n");
+    } else {
+        //Ping once to resolve arp
+        if(send_ping(&data)){
+            recv_ping(&data);
+        }
+
+        if(!setup_arp(&data, if_name)){
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+EXTRA_CLEANUP() {
+    if(if_name != NULL){
+        cleanup_arp(&data);
+    }
+}
+
+FUNCTION(_) {
+    (void)period;
+    bool ret = true;
+    if(data.send){
+        ret = send_ping(&data);
+    }
+    if(ret){
+        rtapi_s32 rtt = recv_ping(&data);
+        data.send = true;
+        if(rtt == ERR_TIMEOUT){
+            ping_timeout_set(ping_timeout + 1);
+        }else if(rtt == ERR_CORRUPT){
+            ping_err_set(ping_err + 1);
+        }else if(rtt == ERR_SKIP){
+            data.send = false;
+        }else if(rtt >= 0){
+            ping_rtt_set(rtt);
+            ping_rtt_max_set(max(ping_rtt_max, rtt));
+        }else{
+            rtapi_print_msg(RTAPI_MSG_ERR, "ping: error: bug");
+        }
+    }
+    if(reset) {
+        ping_timeout_set(0);
+        ping_err_set(0);
+        ping_rtt_max_set(0);
+    }
+}
+#endif
diff --git a/src/rtapi/uspace_posix.cc b/src/rtapi/uspace_posix.cc
index e7d0b88bb30..5e1940be187 100644
--- a/src/rtapi/uspace_posix.cc
+++ b/src/rtapi/uspace_posix.cc
@@ -36,6 +36,14 @@ struct PosixTask : RtapiTask {
 
 struct PosixApp : RtapiApp {
     PosixApp(int policy = SCHED_FIFO) : RtapiApp(policy), do_thread_lock(policy != SCHED_FIFO) {
+
+        rt_cpu_number = find_rt_cpu_number();
+        if (policy == SCHED_OTHER) {
+            rtapi_print_msg(RTAPI_MSG_ERR, "Note: Using POSIX non-realtime on CPU %i\n", rt_cpu_number);
+        } else {
+            rtapi_print_msg(RTAPI_MSG_ERR, "Note: Using POSIX realtime on CPU %i\n", rt_cpu_number);
+        }
+
         pthread_once(&key_once, init_key);
         if (do_thread_lock) {
             pthread_once(&lock_once, init_lock);
@@ -73,8 +81,6 @@ struct PosixApp : RtapiApp {
         task->pll_correction_limit = period_nsec / 100;
         task->pll_correction = 0;
 
-        int nprocs = sysconf(_SC_NPROCESSORS_ONLN);
-
         pthread_attr_t attr;
         int ret;
         if ((ret = pthread_attr_init(&attr)) != 0)
@@ -87,20 +93,16 @@ struct PosixApp : RtapiApp {
             return -ret;
         if ((ret = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED)) != 0)
             return -ret;
-        if (nprocs > 1) {
-            const static int rt_cpu_number = find_rt_cpu_number();
-            rtapi_print_msg(RTAPI_MSG_INFO, "rt_cpu_number = %i\n", rt_cpu_number);
-            if (rt_cpu_number != -1) {
+        if (rt_cpu_number >= 0) {
 #ifdef __FreeBSD__
-                cpuset_t cpuset;
+            cpuset_t cpuset;
 #else
-                cpu_set_t cpuset;
+            cpu_set_t cpuset;
 #endif
-                CPU_ZERO(&cpuset);
-                CPU_SET(rt_cpu_number, &cpuset);
-                if ((ret = pthread_attr_setaffinity_np(&attr, sizeof(cpuset), &cpuset)) != 0)
-                    return -ret;
-            }
+            CPU_ZERO(&cpuset);
+            CPU_SET(rt_cpu_number, &cpuset);
+            if ((ret = pthread_attr_setaffinity_np(&attr, sizeof(cpuset), &cpuset)) != 0)
+                return -ret;
         }
         if (do_thread_lock)
             pthread_mutex_lock(&thread_lock);
@@ -211,6 +213,8 @@ struct PosixApp : RtapiApp {
         clock_gettime(CLOCK_MONOTONIC, &task->nextstart);
     }
 
+    int rt_cpu_number;
+
     bool do_thread_lock;
 
     static pthread_once_t key_once;
@@ -247,10 +251,5 @@ pthread_mutex_t PosixApp::thread_lock;
 extern "C" RtapiApp *make(int policy);
 
 RtapiApp *make(int policy) {
-    if (policy == SCHED_OTHER) {
-        rtapi_print_msg(RTAPI_MSG_ERR, "Note: Using POSIX non-realtime\n");
-    } else {
-        rtapi_print_msg(RTAPI_MSG_ERR, "Note: Using POSIX realtime\n");
-    }
     return new PosixApp(policy);
 }
diff --git a/src/rtapi/uspace_rtai.cc b/src/rtapi/uspace_rtai.cc
index c6f90746848..e67d99dcf5b 100644
--- a/src/rtapi/uspace_rtai.cc
+++ b/src/rtapi/uspace_rtai.cc
@@ -44,6 +44,8 @@ template <class T = RtapiTask> T *get_task(int task_id) {
 
 struct RtaiApp : RtapiApp {
     RtaiApp() : RtapiApp(SCHED_FIFO) {
+        rt_cpu_number = find_rt_cpu_number();
+        rtapi_print_msg(RTAPI_MSG_ERR, "Note: Using LXRT realtime on CPU %i\n", rt_cpu_number);
         pthread_once(&key_once, init_key);
     }
 
@@ -102,9 +104,7 @@ struct RtaiApp : RtapiApp {
 
         int nprocs = sysconf(_SC_NPROCESSORS_ONLN);
         int cpus_allowed = 1 << (nprocs - 1); //Use last CPU as default
-        const static int rt_cpu_number = find_rt_cpu_number();
         if (rt_cpu_number != -1) {
-            rtapi_print_msg(RTAPI_MSG_INFO, "rt_cpu_number = %i\n", rt_cpu_number);
             cpus_allowed = 1 << rt_cpu_number;
         }
         task->rt_task = rt_task_init_schmod(task->id, task->prio, 0, 0, SCHED_FIFO, cpus_allowed);
@@ -192,6 +192,8 @@ struct RtaiApp : RtapiApp {
         }
     }
 
+    static int rt_cpu_number;
+
     static pthread_once_t key_once;
     static pthread_key_t key;
     static void init_key(void) {
@@ -215,6 +217,8 @@ struct RtaiApp : RtapiApp {
     }
 };
 
+int RtaiApp::rt_cpu_number=-1;
+
 pthread_once_t RtaiApp::key_once;
 pthread_key_t RtaiApp::key;
 } // namespace
@@ -225,6 +229,5 @@ RtapiApp *make(int policy) {
     if (policy != SCHED_FIFO) {
         throw std::invalid_argument("Only SCHED_FIFO allowed");
     }
-    rtapi_print_msg(RTAPI_MSG_ERR, "Note: Using LXRT realtime\n");
     return app = new RtaiApp();
 }
diff --git a/src/rtapi/uspace_rtapi_app.cc b/src/rtapi/uspace_rtapi_app.cc
index 8bfbedec1d2..cbaedda4c95 100644
--- a/src/rtapi/uspace_rtapi_app.cc
+++ b/src/rtapi/uspace_rtapi_app.cc
@@ -237,6 +237,14 @@ int RtapiApp::find_rt_cpu_number() {
     if (getenv("RTAPI_CPU_NUMBER"))
         return atoi(getenv("RTAPI_CPU_NUMBER"));
 
+    int nprocs = sysconf(_SC_NPROCESSORS_ONLN);
+    if (nprocs < 0) {
+        rtapi_print_msg(RTAPI_MSG_ERR, "sysconf(_SC_NPROCESSORS_ONLN) failed %m\n");
+    } else if (nprocs == 1) {
+        //On single CPU systems, no CPU assignment needed
+        return -1;
+    }
+
 #ifdef __linux__
     const char *isolated_file = "/sys/devices/system/cpu/isolated";
     cpu_set_t cpuset;
@@ -274,9 +282,7 @@ int RtapiApp::find_rt_cpu_number() {
             }
         }
         rtapi_print_msg(
-            RTAPI_MSG_ERR, "No isolated CPU's found, expect some latency or set RTAPI_CPU_NUMBER to select CPU.\n"
-                "    CPU %i selected as fallback.\n", top
-        );
+            RTAPI_MSG_ERR, "Warning: No isolated CPU's found, expect some latency or set RTAPI_CPU_NUMBER to select CPU.\n");
     }
     return top;
 #else
diff --git a/src/rtapi/uspace_xenomai.cc b/src/rtapi/uspace_xenomai.cc
index bd6813ea9bb..bb878665853 100644
--- a/src/rtapi/uspace_xenomai.cc
+++ b/src/rtapi/uspace_xenomai.cc
@@ -37,6 +37,9 @@ struct XenomaiTask : RtapiTask {
 
 struct XenomaiApp : RtapiApp {
     XenomaiApp() : RtapiApp(SCHED_FIFO) {
+        rt_cpu_number = find_rt_cpu_number();
+        rtapi_print_msg(RTAPI_MSG_ERR, "Note: Using XENOMAI (posix-skin) realtime on CPU %i\n", rt_cpu_number);
+
         pthread_once(&key_once, init_key);
     }
 
@@ -71,8 +74,6 @@ struct XenomaiApp : RtapiApp {
         task->pll_correction_limit = period_nsec / 100;
         task->pll_correction = 0;
 
-        int nprocs = sysconf(_SC_NPROCESSORS_ONLN);
-
         pthread_attr_t attr;
         int ret;
         if ((ret = pthread_attr_init(&attr)) != 0)
@@ -85,16 +86,12 @@ struct XenomaiApp : RtapiApp {
             return -ret;
         if ((ret = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED)) != 0)
             return -ret;
-        if (nprocs > 1) {
-            const static int rt_cpu_number = find_rt_cpu_number();
-            rtapi_print_msg(RTAPI_MSG_INFO, "rt_cpu_number = %i\n", rt_cpu_number);
-            if (rt_cpu_number != -1) {
-                cpu_set_t cpuset;
-                CPU_ZERO(&cpuset);
-                CPU_SET(rt_cpu_number, &cpuset);
-                if ((ret = pthread_attr_setaffinity_np(&attr, sizeof(cpuset), &cpuset)) != 0)
-                    return -ret;
-            }
+        if (rt_cpu_number >= 0) {
+            cpu_set_t cpuset;
+            CPU_ZERO(&cpuset);
+            CPU_SET(rt_cpu_number, &cpuset);
+            if ((ret = pthread_attr_setaffinity_np(&attr, sizeof(cpuset), &cpuset)) != 0)
+                return -ret;
         }
         if ((ret = pthread_create(&task->thr, &attr, &wrapper, reinterpret_cast<void *>(task))) != 0)
             return -ret;
@@ -205,6 +202,8 @@ struct XenomaiApp : RtapiApp {
         clock_gettime(CLOCK_MONOTONIC, &task->nextstart);
     }
 
+    int rt_cpu_number;
+
     static pthread_once_t key_once;
     static pthread_key_t key;
     static void init_key(void) {
@@ -233,6 +232,5 @@ RtapiApp *make(int policy) {
     if (policy != SCHED_FIFO) {
         throw std::invalid_argument("Only SCHED_FIFO allowed");
     }
-    rtapi_print_msg(RTAPI_MSG_ERR, "Note: Using XENOMAI (posix-skin) realtime\n");
     return new XenomaiApp();
 }
diff --git a/src/rtapi/uspace_xenomai_evl.cc b/src/rtapi/uspace_xenomai_evl.cc
index 520f33f4fec..5807f616f3a 100644
--- a/src/rtapi/uspace_xenomai_evl.cc
+++ b/src/rtapi/uspace_xenomai_evl.cc
@@ -48,6 +48,9 @@ struct EvlTask : RtapiTask {
 
 struct EvlApp : RtapiApp {
     EvlApp() : RtapiApp(SCHED_FIFO) {
+        rt_cpu_number = find_rt_cpu_number();
+        rtapi_print_msg(RTAPI_MSG_ERR, "Note: Using XENOMAI4 EVL realtime on CPU %i\n", rt_cpu_number);
+
         pthread_once(&key_once, init_key);
          WithRoot r;
         /* Attach to the EVL core for rtapi_app, so modules can use EVL core
@@ -92,8 +95,6 @@ struct EvlApp : RtapiApp {
         task->pll_correction_limit = period_nsec / 100;
         task->pll_correction = 0;
 
-        int nprocs = sysconf(_SC_NPROCESSORS_ONLN);
-
         pthread_attr_t attr;
         int ret;
         if ((ret = pthread_attr_init(&attr)) != 0)
@@ -106,16 +107,12 @@ struct EvlApp : RtapiApp {
             return -ret;
         if ((ret = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED)) != 0)
             return -ret;
-        if (nprocs > 1) {
-            const static int rt_cpu_number = find_rt_cpu_number();
-            rtapi_print_msg(RTAPI_MSG_INFO, "rt_cpu_number = %i\n", rt_cpu_number);
-            if (rt_cpu_number != -1) {
-                cpu_set_t cpuset;
-                CPU_ZERO(&cpuset);
-                CPU_SET(rt_cpu_number, &cpuset);
-                if ((ret = pthread_attr_setaffinity_np(&attr, sizeof(cpuset), &cpuset)) != 0)
-                    return -ret;
-            }
+        if (rt_cpu_number >= 0) {
+            cpu_set_t cpuset;
+            CPU_ZERO(&cpuset);
+            CPU_SET(rt_cpu_number, &cpuset);
+            if ((ret = pthread_attr_setaffinity_np(&attr, sizeof(cpuset), &cpuset)) != 0)
+                return -ret;
         }
         if ((ret = pthread_create(&task->thr, &attr, &wrapper, reinterpret_cast<void *>(task))) != 0)
             return -ret;
@@ -236,6 +233,8 @@ struct EvlApp : RtapiApp {
         evl_read_clock(EVL_CLOCK_MONOTONIC, &task->nextstart);
     }
 
+    int rt_cpu_number;
+
     static pthread_once_t key_once;
     static pthread_key_t key;
     static void init_key(void) {
@@ -266,6 +265,5 @@ RtapiApp *make(int policy) {
     if (policy != SCHED_FIFO) {
         throw std::invalid_argument("Only SCHED_FIFO allowed");
     }
-    rtapi_print_msg(RTAPI_MSG_ERR, "Note: Using XENOMAI4 EVL realtime\n");
     return new EvlApp();
 }