What kernel does Manjaro generally use? Does it use the latest kernel (6.15.2) or does it use LTS (6.12.33) or something else based on curation? I noticed the ISO said 612.
Which kernel you use is up to you. I believe the .ISOs are now sticking with LTS versions but I will have to check on that.
If your installation .ISO came with an LTS kernel and it works OK, I’d generally suggest keeping with that series. But that’s more down to my own preferences and equipment; I’ve had some issues with certain HWE kernels, specifically trackpad related.
2 Likes
That is the version the ISO uses - and what will be installed initially.
You can very easily change it if you so desire.
At any time.
You can have two or more installed to choose from as well.
1 Like
This is the current list of available kernels on my branch (Testing), and the two kernels I currently have installed on my system:
mhwd-kernel -l | sort -V && mhwd-kernel -li
available kernels:
* linux54
* linux61
* linux61-rt
* linux66
* linux66-rt
* linux510
* linux515
* linux612
* linux612-rt
* linux613-rt
* linux614
* linux614-rt
* linux615
* linux615-rt
* linux616
Currently running: 6.15.2-2-MANJARO (linux615)
The following kernels are installed in your system:
* linux612
* linux615
I usually install the most recent LTS kernel (currently linux612), and the latest kernel. Although I’m holding off installing linux616 (which is still a release candidate) until the next RC version arrives, as the current RC prevents my system from waking up.
1 Like
Ok, I know I can manually install whatever kernel I want, but I was wondering what Manjaro installs by default. I also didn’t know if Manjaro does an online install, so even if the ISO says 612, it could update it during the install to a newer version. Or if it does an offline install, if it would update the kernel upon first boot. But, if it’s using LTS kernels, then updates don’t happen that often.
LTS kernels are updated at the same pace as anything else in the system. But it is important here to make the distinction between an update and a version bump.
By default, Manjaro will not version-bump kernels during an update. However, if you’re not using an LTS kernel, then you need to pay attention, because if you happen to be running an EOL kernel, then it may get removed as part of the bundled-update process.
In the past, Manjaro ISOs used to come with whatever kernel.org upstream considered the stable mainline kernel at the time the ISO was created. As of recently however, ISOs are now being released with the most recent LTS kernel — currently this is 6.12. All of the Manjaro Spins — which are created by forum members — also follow this principle.
2 Likes
Thanks, @Aragorn. And thanks for helping me in my other post. I tried to reply, but it closed before I had a chance to. So far everyone here has been very helpful.
I have one more question, but I don’t know if it’s appropriate to ask it here. I just wanted to know how quickly Manjaro releases DE version updates. Such as, KDE Plasma 6.4 being released today (6/17).
1 Like
that depends on the branch you are in. the latest packages are first made available on the unstable branch, then they get propogated to “testing” and finally “stable” as manjaro team decides the stability of those packages for general use.
the latest packages due from archlinux are synced to manjaro “unstable” branch repos as they are released from arch repos (arch-stable). kernels on the other hand are built inhouse by the manajro team, and are available as soon as they are ready for buiding upstream from kernel.org. so are other overlaid packages (i.e. systemd, etc.)
1 Like
As with all software that’s inherited from Arch, it will first have to go through their process before it arrives in out Unstable branch, and trickling down from there.
So to put it simply: when it’s ready.
This Week in Plasma: Plasma 6.4 is nigh - KDE Blogs
Saturday, 7 June 2025
This week we continued to focus on bug fixing and user interface polish for Plasma 6.4, which will be released next Thursday
Arch Linux - plasma-desktop 6.3.5-1 (x86_64)
Flagged out-of-date on 2025-06-17
The ISO usually default to use the latest LTS - it is however possible to download a minimal ISO with other LTS kernels
Which kernel the ISO is based can be deduced from the ISO filename…
Filename format for a full ISO
manjaro-<edition>-<version>-<yymmdd>-linux<XY>.iso
Filename format for a minimal ISO
manjaro-<edition>-<version>-minimal-<yymmdd>-linux<XY>.iso
Manjaro Linux unstable branch is manually synced from Arch Linux stable at arbitrary intervals where these intervals depends on the size and/or complexity of the new packages; if they introduce instability on an Arch based system; after the sync to unstable it may take up to four (4) weeks - in certain cases even longer before the updates reach stable branch.
2 Likes
Right now I see a list (Testing) from Linux 6.16.0rc1-3 (Experimental) and I’m running 6.15.2-2 - but the list is quite long and scrolls off my screen.
Check it out - open Manjaro Settings and click the Penguin (Kernel) icon.
Otherwise, open a terminal:
❯ mhwd-kernel -l | sort -V
available kernels:
* linux54
* linux61
* linux61-rt
* linux66
* linux66-rt
* linux510
* linux515
* linux612
* linux612-rt
* linux613-rt
* linux614
* linux614-rt
* linux615
* linux615-rt
* linux616
đź’ˇ kernel => mhwd-kernel
Generally, you’d expect an installer (snapshot) to be the latest LTS kernel… so the answer will depend on exactly which snapshot/ISO is downloaded.
To put it simply:
The installed one. Which one is installed? Well, that depends on you.
2 Likes
sort with mhwd-kernel -l is not good…
A test script written with @tracyanne return sorted and more infos :
# recommended, package, version, lts, installed, eol
linux615 6.15
linux614 6.14
* linux612 6.12 LTS (i)
* linux66 6.6 LTS (i)
* linux61 6.1 LTS
* linux515 5.15 LTS
* linux510 5.10 LTS
* linux54 5.4 LTS
linux614-rt 6.14
linux613-rt 6.13
linux612-rt 6.12
linux66-rt 6.6
linux61-rt 6.1
python source :
#!/usr/bin/env python
import gzip
from pathlib import Path
import platform
import re
import subprocess
import sys
from urllib import request, error
class Kernel:
def __init__(self, pkg_name):
self.name = pkg_name
self.is_rt = False
self.major, self.minor = self._parse_version(pkg_name)
self.version = f"{self.major}.{self.minor}"
self.installed = False
self.recommended = False
self.lts = False
self.eol = False
def _parse_version(self, name):
name = name.removeprefix("linux")
if name.endswith("-rt"):
self.is_rt = True
name = name.removesuffix("-rt")
return int(name[0]), int(name[1:])
def get_version(self) -> str:
ver = f"{self.major}.{self.minor}"
return f"{ver:4} {'LTS' if self.lts else ' ' * 3}"
def __str__(self) -> str:
rec = "*" if self.recommended else " "
inst = "(i)" if self.installed else " " * 3
eol = "EOL" if self.eol else " " * 3
return f"{rec} {self.name:12} {self.get_version()} {inst} {eol}"
def __lt__(self, other: "Kernel"):
"""for good sort"""
if self.is_rt != other.is_rt:
return self.is_rt and not other.is_rt
a, b = self.major, other.major
if a != b:
return a < b
a, b = self.minor, other.minor
if a != b:
return a < b
class EolManager:
DB_FILE = Path("/tmp/core.db")
def __init__(self):
self.state = 0
self.unstable = []
self.kernels = []
if self.download():
self.state = 1
self.unstable = sorted(self.filter_kernels(self.get_pkgs(self.DB_FILE)))
if not self.unstable:
return
def __del__(self):
self.DB_FILE.unlink(True)
pass
def get_eol(self) -> tuple[str]:
if not self.state or not self.unstable:
return []
if not self.kernels:
self.kernels = sorted(list(self._get_current_kernels()))
# print("# --dev : for test, add fake EOL kernels : 66 and 54\n")
if "--dev" in sys.argv:
if i := self.unstable.index("linux66"):
del self.unstable[i]
if i := self.unstable.index("linux54"):
del self.unstable[i]
return tuple(k for k in self.kernels if k not in self.unstable)
def download(self) -> bool:
if self.DB_FILE.exists():
return True
url = self._get_url()
if not url:
return False
try:
with request.urlopen(url, timeout=4) as response:
with open(self.DB_FILE, "wb") as download:
download.write(response.read())
# print(" #", self.DB_FILE, "downloaded")
return True
except Exception:
return False
@staticmethod
def _get_current_kernels():
output = subprocess.run(
"pacman -Ssq | grep -E '^linux[0-9]{2,3}(-rt)?$'", capture_output=True, shell=True, text=True, timeout=3
).stdout
return output.splitlines()
@staticmethod
def get_pkgs(file_):
"""parse pacman database gz file"""
"""
%NAME%
linux612
%VERSION%
6.12.32-1
%BUILDDATE%
1749062743
"""
with gzip.open(file_, "rt") as f:
for line in f:
if not line.startswith("%NAME%"):
continue
name = next(f)
if not name.startswith("linux"):
continue
yield name.rstrip()
@staticmethod
def filter_kernels(names):
# filter only kernels
reg = re.compile(r"^linux[0-9]{2,3}(-rt)?$")
yield from (n for n in names if reg.match(n))
@staticmethod
def _get_url() -> str:
# search unstable url for core
output = subprocess.run(
"pacman-conf -r core | grep '^Server' -m1", capture_output=True, shell=True, text=True, timeout=3
).stdout
if not output or "/unstable/" in output:
return None
url = output.split("=")[1].strip()
url = url.replace("/stable/", "/unstable/")
url = url.replace("/testing/", "/unstable/")
return f"{url}/core.db"
def get_kernels() -> dict[str, Kernel]:
reg = r"LANG=en pacman -Si | grep -E '^Name' | grep -E 'Name.*linux[0-9]{2,3}(-rt)?$' -A1"
output = subprocess.run(reg, capture_output=True, shell=True, text=True, timeout=30).stdout
lines = iter(l for l in output.split("\n") if l and not l.startswith("--"))
kernels = {}
for name, version in zip(lines, lines):
name = name.split(":")[1].strip()
kernels[name] = Kernel(name)
return kernels
def get_installeds() -> dict[str, Kernel]:
reg = r"pacman -Qq | grep -E '^linux[0-9]{2,3}(-rt)?$'"
output = subprocess.run(reg, capture_output=True, shell=True, text=True, timeout=30).stdout
return [l.strip() for l in output.split("\n")]
def get_lts_from_kernel_org() -> list[str, str]:
import xml.etree.ElementTree as ET
results = []
with request.urlopen(
"https://www.kernel.org/feeds/kdist.xml",
timeout=3,
) as response:
root = ET.fromstring(response.read().decode("utf-8"))[0]
for title in root.iter("title"):
if "longterm" not in title.text:
continue
ver = title.text.split(".")[0:2]
results.append(f"linux{ver[0]}{ver[1]}")
return results
def get_kernels_from_gitlab() -> dict[str, list[str]]:
"""read manjaro datas from gitlab .c file"""
def filter_line(line) -> bool:
if "::getLtsKernels" in line or "::getRecommendedKernels" in line:
return True
if "return QStringList() <<" in line:
return True
return False
results = []
with request.urlopen(
"https://gitlab.manjaro.org/applications/manjaro-settings-manager/-/raw/master/src/libmsm/KernelModel.cpp",
timeout=3,
) as response:
content = [l.replace('"', "").replace(";", "") for l in response.read().decode("utf-8").split("\n") if filter_line(l)]
results = [k.strip() for k in content[3].split("<<")[1:]]
return results
def sort_kernels(kernels):
result = {}
for k in sorted(kernels.values(), reverse=True):
result[k.name] = k
return result
if platform.freedesktop_os_release()["ID"].lower() != "manjaro":
exit(66)
if platform.machine() != "x86_64":
exit(67)
if __name__ == "__main__":
print("# recommended, package, version, lts, installed, eol")
print()
kernels = get_kernels()
lts = get_lts_from_kernel_org()
for kernel_lts in lts:
if kernel := kernels.get(kernel_lts, None):
kernel.lts = True
for kernel_rec in get_kernels_from_gitlab():
if kernel := kernels.get(kernel_rec, None):
kernel.recommended = True
for kernel_inst in get_installeds():
if kernel := kernels.get(kernel_inst, None):
kernel.installed = True
manager = EolManager()
for kernel_eol in manager.get_eol():
if kernel := kernels.get(kernel_eol, None):
kernel.eol = True
kernels = sort_kernels(kernels)
for kernel in kernels.values():
print(kernel)
if exists some EOL (not now !), we can have output as
* linux612 6.12 LTS (i)
linux62 6.2 (i) EOL
* linux61 6.1 LTS
* linux510 5.10 LTS
linux52 5.2 EOL
4 Likes