What kernel does Manjaro use?

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