• Frame – en helt ny X11-server skriven i assembler

    Samtidigt som stora delar av Linuxvärlden lämnar det gamla grafiksystemet X11 till förmån för Wayland väljer den norske utvecklaren Geir Isene att gå åt motsatt håll. Han har byggt en helt ny X11-server från grunden – skriven nästan uteslutande i assembler för x86-64-processorer.

    Projektet heter Frame och är ett tekniskt experiment som försöker besvara en ovanlig fråga: Hur liten och enkel kan en fungerande grafisk Linuxmiljö egentligen bli?

    Programmet som placerar bilden på skärmen

    För att förstå vad Frame gör behöver man först känna till vad en grafikserver är.

    När ett program som Firefox eller GIMP vill visa ett fönster på skärmen ritar programmet normalt inte direkt mot bildskärmen. I stället skickar det instruktioner till ett underliggande system som hanterar fönster, tangentbord, muspekare och bildskärmar.

    På traditionella Linuxdatorer har denna uppgift länge skötts av X.Org Server, den vanligaste implementationen av X11-systemet. X11 har sina rötter i 1980-talet och har under årtionden byggts ut för att fungera med många olika datorer, grafikkort och användningsområden.

    Resultatet är ett stort och komplicerat system med många historiska lager.

    Frame försöker i stället börja om från början.

    Byggd direkt ovanpå Linuxkärnan

    Frame bygger inte vidare på X.Org och använder inte heller vanliga programbibliotek som libc, Mesa, Xlib eller FreeType. I stället kommunicerar servern direkt med Linuxkärnan genom systemanrop.

    För att visa grafik använder Frame Linux gränssnitt DRM och KMS, vilka hanterar grafikkort och bildskärmslägen. Tangentbord och mus läses genom evdev, det normala gränssnittet för inmatningsenheter i Linux.

    Program som Firefox kommunicerar med Frame genom själva X11-protokollet.

    Man kan likna det vid att bygga en bil utan att köpa färdiga delar från en underleverantör. I stället tillverkar utvecklaren stora delar av motorn, elsystemet och instrumentpanelen själv och kopplar dem direkt till chassit.

    Resultatet är en statiskt länkad programfil utan vanliga beroenden till installerade bibliotek.

    Skriven i assembler

    De flesta moderna program skrivs i språk som C, C++, Rust eller Python. Frame är i stället skriven i assembler.

    Assembler ligger mycket nära processorns egna maskininstruktioner. Utvecklaren arbetar därför direkt med register, minnesadresser, instruktioner och systemanrop.

    Det ger stor kontroll över exakt vad datorn gör, men gör samtidigt utvecklingen betydligt mer komplicerad. Funktioner som vanliga programmeringsspråk och bibliotek erbjuder automatiskt måste ofta byggas manuellt.

    Frame består enligt utvecklaren av omkring 20 000 rader assemblerkod. Vid en senare genomgång låg källkoden närmare 25 000 rader. Det är fortfarande litet jämfört med etablerade grafiksystem, men antalet kodrader säger inte automatiskt något om stabilitet, säkerhet eller hur komplett programmet är.

    Kan redan köra Firefox och GIMP

    Frame är långt ifrån en fullständig implementation av X11, men servern stöder redan tillräckligt många delar av protokollet för att kunna köra riktiga skrivbordsprogram.

    Bland funktionerna finns stöd för att skapa och hantera fönster, läsa tangentbord och mus, hantera urklipp, bilder och egenskaper samt kommunicera med program genom X11-protokollet.

    Servern innehåller även stöd för flera vanliga X11-utökningar, exempelvis RANDR för bildskärmshantering, SHAPE för fönster med särskilda former och MIT-SHM för snabbare överföring av bilddata mellan program.

    Isene uppger att han använder Frame som sin dagliga grafikserver och att både Firefox och bildredigeringsprogrammet GIMP fungerar på systemet.

    Det betyder dock inte att alla X11-program fungerar. X11 är ett omfattande protokoll med många funktioner och tillägg som utvecklats under flera årtionden. Program kan därför använda funktioner som Frame ännu inte känner till.

    En hel skrivbordsmiljö i assembler

    Frame är nära kopplad till ett större projekt som heter CHasm, en förkortning av ”CHange to ASM”.

    CHasm består av flera små Linuxprogram som också är skrivna i x86-64-assembler. Där ingår bland annat:

    • Tile, en fönsterhanterare som placerar fönster sida vid sida.
    • Glass, en terminalemulator.
    • Bare, ett kommandoskal.
    • Strip, en statusrad.
    • Bolt, ett skärmlås och inloggningsverktyg.

    Tillsammans kan dessa program skapa en komplett, men mycket minimalistisk, grafisk Linuxsession. Projekten är fristående och utgör inte en traditionell skrivbordsmiljö som KDE Plasma eller GNOME.

    CHasm-verktygen kommunicerar direkt med Linuxkärnan eller med X11-protokollet och saknar dynamiska programberoenden. Enligt projektets dokumentation omfattar den körbara delen av hela sessionen mindre än 500 kilobyte, även om detta inte inkluderar Linuxkärnan, drivrutinerna eller de vanliga program som användaren startar.

    Ett skrivbord som försöker göra ingenting

    Ett av projektets viktigaste mål är att datorn ska vara helt stilla när användaren inte arbetar.

    Moderna skrivbordsmiljöer kan ha många processer som regelbundet vaknar för att kontrollera tiden, uppdatera animationer, läsa systeminformation eller kontrollera om något har förändrats. Varje sådan aktivitet använder lite processortid och kan i teorin påverka batteritiden.

    Frame och CHasm är i stället konstruerade för att vänta tills det faktiskt händer något, exempelvis att användaren rör musen eller att ett program skickar nya bilddata.

    Isene genomförde ett informellt test där Frame och X.Org hade ungefär samma totala strömförbrukning när datorn stod oanvänd. X.Org använde däremot enligt hans mätning nästan tre gånger så mycket processortid.

    Skillnaden i total strömförbrukning var liten eftersom bildskärmen, nätverket och andra delar av datorn använder betydligt mer energi än en vilande grafikserver. Mätningen är dessutom utförd av utvecklaren själv på en enda dator och ska därför inte betraktas som ett oberoende prestandatest.

    Artificiell intelligens har hjälpt till

    Projektet har utvecklats med omfattande hjälp av AI-verktyget Claude Code. Isene beskriver hur han förklarar problem och önskade funktioner för AI-systemet, som sedan hjälper till att skapa och ändra assemblerkoden.

    Det gör Frame intressant även ur ett annat perspektiv. Att skriva en X11-server i assembler är normalt ett mycket tidskrävande specialprojekt. Moderna AI-verktyg kan göra det möjligt för en ensam utvecklare att experimentera med systemprogrammering på en nivå som tidigare ofta krävde större grupper.

    Samtidigt innebär AI-genererad kod inte att programmet automatiskt är korrekt. En grafikserver hanterar minne, inmatning, andra program och hårdvara. Fel kan orsaka allt från grafikproblem och krascher till säkerhetsbrister.

    Frame behöver därför granskas, testas och underhållas på samma sätt som all annan systemnära programvara – kanske ännu mer noggrant eftersom assembler saknar många av de säkerhetsfunktioner som finns i modernare språk.

    Ingen ersättare för X.Org ännu

    Frame är för närvarande ett experimentellt projekt och inte ett praktiskt alternativ för vanliga Linuxanvändare.

    Servern fungerar endast på Linuxdatorer med x86-64-processor. Den saknar delar av X11-protokollet, har begränsat hårdvarustöd och använder huvudsakligen mjukvarurendering i stället för fullständig grafikacceleration.

    Det finns inte heller några etablerade installationspaket eller färdiga inloggningssessioner för stora Linuxdistributioner. Projektet är främst byggt för utvecklarens egen dator och hans eget arbetssätt.

    CHasm-dokumentationen säger uttryckligen att verktygen främst publiceras som inspiration. Tanken är inte nödvändigtvis att användare ska installera dem som de är, utan att intresserade utvecklare ska studera, ändra och anpassa koden efter sina egna behov.

    Ett experiment om kontroll och enkelhet

    Frame kommer sannolikt inte att ersätta X.Org eller konkurrera med Wayland inom den närmaste framtiden. Projektets verkliga betydelse ligger i stället i vad det demonstrerar.

    Det visar att det fortfarande är möjligt för en enskild utvecklare att bygga en fungerande grafikserver direkt ovanpå Linuxkärnan. Det visar också hur mycket av ett modernt datorsystem som egentligen består av valbara lager – bibliotek, ramverk och verktyg som är praktiska, men inte alltid absolut nödvändiga.

    Frame är därför mindre en färdig produkt och mer ett tekniskt laboratorium.

    Projektet ställer en fråga som ofta försvinner när programvaran växer: Hur mycket kod behöver vi egentligen för att öppna ett fönster, ta emot ett tangenttryck och placera några bildpunkter på skärmen?

    Geir Isenes svar är att det går att göra med betydligt mindre än vad dagens vanliga Linuxskrivbord använder – men också att enkelhet på ytan kan kräva mycket avancerat arbete under huven.

    https://github.com/isene/chasm

    $ teknisk_faktaruta –frame
    Projekt: Frame
    Typ: Experimentell X11-server
    Utvecklare: Geir Isene
    Plattform: Linux på x86-64
    Programmeringsspråk: x86-64-assembler
    Kodmängd: Cirka 20 000 rader assemblerkod
    Grafik: DRM/KMS och mjukvarurendering
    Inmatning: evdev för tangentbord och mus
    Kommunikation: X11:s trådprotokoll
    X11-utökningar: Bland annat RANDR, SHAPE, XInput2 och MIT-SHM
    Externa beroenden: Inga vanliga körberoenden som libc, Mesa, Xlib eller FreeType
    Testade program: Bland annat Firefox och GIMP
    Status: Experimentellt och ännu inte en fullständig ersättare för X.Org
    root@linux:~# Frame är användbart på utvecklarens dator, men saknar fortfarande fullständigt protokoll- och hårdvarustöd.
  • KernelScript 0.1: nytt språk vill göra eBPF enklare för Linuxutvecklare

    KernelScript 0.1 är ett nytt experimentellt programmeringsspråk som vill göra avancerad Linuxutveckling enklare. Genom att samla eBPF-program, användarprogram och kernelintegration i en och samma kodbas kan utvecklare slippa mycket av den manuella C-kod och libbpf-hantering som annars krävs. Resultatet är ett lovande, men ännu omoget, verktyg för den som vill arbeta närmare Linuxkärnan utan att fastna i all teknisk kringkod.

    Att skriva program som kör nära Linuxkärnan är kraftfullt – men också svårt. Med eBPF kan utvecklare skapa små program som körs i kernelmiljö utan att själva Linuxkärnan behöver byggas om. Tekniken används redan i dag för allt från nätverksfiltrering och prestandamätning till säkerhet, felsökning och övervakning av system.

    Nu har den första publika versionen av KernelScript 0.1 släppts. Det är ett nytt öppet programmeringsspråk som vill göra utveckling med eBPF mer lättillgänglig, säkrare och mindre beroende av stora mängder handskriven stödkod.

    Ett språk för flera världar

    Traditionellt kräver eBPF-utveckling ofta att man skriver flera olika delar separat. Själva eBPF-programmet skrivs ofta i C. Sedan behövs kod i användarrymden för att ladda programmet, hantera kartor, läsa data och kommunicera med kärnan. I vissa fall krävs även integration med kernelmoduler och särskilda byggfiler.

    KernelScript försöker samla detta i en enda källkod. Utvecklaren skriver programmet i KernelScripts eget språk, och verktyget genererar därefter den C-kod, de användarprogram, Makefiles och integrationsdelar som behövs.

    Tanken är alltså inte att ersätta Linuxkärnan eller eBPF, utan att lägga ett högre och mer lättanvänt lager ovanpå.

    Varför eBPF är kraftfullt – men svårt

    eBPF har blivit en av de mest intressanta teknikerna i moderna Linuxsystem. Den gör det möjligt att köra små verifierade program i kärnan, till exempel för att analysera nätverkspaket, mäta systemanrop eller samla in prestandadata.

    Men tekniken har en hög tröskel. Den som skriver eBPF-program måste förstå hur Linux verifierar programmen innan de får köras, vilka hjälpfunktioner som är tillåtna, hur minne får användas och hur eBPF-kartor fungerar. Dessutom krävs ofta kunskap om libbpf och hur användarrymd och kernelkod samverkar.

    KernelScript försöker minska den komplexiteten genom att erbjuda ett mer specialiserat språk, anpassat just för eBPF-flöden.

    Stöd för vanliga eBPF-program

    I den första versionen finns stöd för flera viktiga typer av eBPF-program. Det omfattar bland annat XDP, som används för snabb paketbehandling mycket tidigt i nätverksstacken, och TC, som används för trafikstyrning.

    Språket har också stöd för olika typer av probes, alltså program som kan kopplas till funktioner i kärnan för spårning och felsökning. Dessutom finns stöd för perf event-program, som används vid prestandamätning.

    Det gör KernelScript intressant för utvecklare som arbetar med nätverk, observability, felsökning, säkerhet eller låg nivå-prestanda i Linuxmiljöer.

    eBPF-kartor som vanliga variabler

    En central del av eBPF är så kallade maps, eller kartor. De fungerar som datastrukturer där eBPF-program kan spara och dela information. De kan exempelvis användas för räknare, statistik, tillståndstabeller eller kommunikation mellan kernelprogram och användarprogram.

    KernelScript gör dessa kartor till en del av språket. Det finns stöd för bland annat hash maps, per-CPU arrays, LRU maps och pinned maps. Genom att behandla dem som språkvariabler slipper utvecklaren en del av den vanliga libbpf-koden som annars krävs.

    Det kan göra enklare eBPF-projekt både kortare och lättare att förstå.

    Avancerade funktioner redan från början

    Trots att KernelScript 0.1 är en tidig version innehåller den stöd för flera avancerade eBPF-funktioner. Bland annat nämns automatisk hantering av tail calls, enklare dynptr-hantering, kontroll av programlivscykel, struct_ops och inbyggd integration med kfuncs.

    För den som redan arbetar med avancerad eBPF-utveckling kan detta vara särskilt intressant. Det visar att KernelScript inte bara är tänkt som ett pedagogiskt förenklingslager, utan som ett försök att bygga ett mer komplett utvecklingsverktyg för Linuxnära programmering.

    Inte redo för produktion

    Samtidigt är det viktigt att betona att KernelScript fortfarande är experimentellt. Projektet beskrivs som beta, och utvecklarna varnar för att syntax, API:er och funktioner kan ändras utan bakåtkompatibilitet.

    Det betyder att KernelScript i nuläget främst bör ses som något för testning, utvärdering och experiment. För produktionssystem är det fortfarande säkrare att använda etablerade verktyg och arbetsflöden kring eBPF, C och libbpf.

    Ett tecken på vart Linuxutveckling är på väg

    KernelScript 0.1 visar ändå en tydlig trend. eBPF har blivit så viktigt att det nu växer fram nya språk och verktyg som försöker göra tekniken mer tillgänglig. På samma sätt som högnivåspråk en gång gjorde vanlig systemutveckling enklare, försöker KernelScript göra kernel-nära programmering mer strukturerad och mindre felbenägen.

    Om projektet lyckas återstår att se. Men idén är intressant: ett enda språk som kan beskriva logiken för eBPF, användarrymd och kernelintegration på samma gång.

    För Linuxutvecklare som vill följa framtidens systemprogrammering är KernelScript därför ett projekt att hålla ögonen på – även om det än så länge hör hemma i labbmiljö snarare än i skarpa driftsystem.

    https://github.com/multikernel/kernelscript

    Teknisk faktaruta: KernelScript 0.1

    Typ: Experimentellt programmeringsspråk och DSL för Linuxutveckling.

    Fokus: eBPF, användarprogram och kernelintegration från en gemensam kodbas.

    Licens: Apache 2.0.

    Syfte: Att minska behovet av handskriven C-kod, libbpf-boilerplate, Makefiles och separat användarrymdskod vid eBPF-utveckling.

    Stöd: XDP, TC, probes, perf events, eBPF maps, tail calls, dynptr, struct_ops och kfunc-integration.

    Status: Beta/experimentell. Rekommenderas ännu inte för produktion.

  • Linux 7.0 är här – men den stora nyheten är inte siffran

    Linux 7.0 är här – men bakom det nya versionsnumret döljer sig ingen dramatisk omvälvning. I stället handlar det om en rad genomtänkta förbättringar som gör operativsystemet säkrare, snabbare och mer framtidssäkrat. Med stabilt stöd för Rust, nya säkerhetslösningar och smartare hantering av resurser fortsätter Linux att utvecklas i små men viktiga steg.

    När Linux 7.0 nu har släppts är det lätt att tro att vi står inför ett dramatiskt teknikskifte. Men versionshoppet från 6.19 till 7.0 är framför allt en praktisk omnumrering, inte en revolution. Linus Torvalds beskriver releasen som stabil och relativt odramatisk, med fokus på många små förbättringar snarare än stora förändringar.

    Det betyder dock inte att uppdateringen är ointressant. Tvärtom visar Linux 7.0 hur modern systemutveckling fungerar: genom kontinuerliga förbättringar som tillsammans gör systemet snabbare, säkrare och mer flexibelt.

    Rust blir en etablerad del av kärnan

    En av de mest uppmärksammade nyheterna är att programmeringsspråket Rust inte längre betraktas som experimentellt i Linuxkärnan.

    Det innebär inte att C försvinner, men det markerar att Rust nu är ett accepterat verktyg för utvecklare. Fördelen är att Rust är designat för att undvika många vanliga minnesfel redan innan programmet körs. På sikt kan det leda till färre buggar och säkrare system.

    Säkerhet i fokus – redo för framtidens hot

    Linux 7.0 tar också steg mot framtidens cybersäkerhet. Stöd för post-kvantkryptografi införs genom ML-DSA-signaturer, samtidigt som äldre och osäkrare metoder som SHA-1 tas bort.

    Det visar hur kärnan utvecklas i takt med nya hot – även sådana som ännu inte är fullt verklighet, som attacker från framtida kvantdatorer.

    Bättre kontroll och isolering i systemet

    Ett annat viktigt område är förbättrad kontroll i systemet. Den snabba I/O-mekanismen io_uring får bättre filtrering, vilket gör det lättare att begränsa vad program får göra i känsliga miljöer.

    Dessutom introduceras nullfs, ett minimalistiskt filsystem som fungerar som en tom startpunkt innan det riktiga systemet laddas. Det gör uppstarten mer flexibel och renare, särskilt i container- och molnmiljöer.

    Prestanda och lagring förbättras

    Linux 7.0 innehåller flera förbättringar inom lagring och minneshantering. Swap-systemet förenklas och blir mer effektivt, och filsystem som XFS får nya funktioner för övervakning och självläkning.

    Även andra filsystem förbättras, till exempel med bättre stöd för stora blockstorlekar och modern komprimering. Det handlar om små tekniska steg som tillsammans kan ge märkbara prestandavinster.

    Smartare nätverk och modernare infrastruktur

    På nätverkssidan aktiveras AccECN, en teknik som hjälper datorer att reagera tidigare på trängsel i nätverket. Det kan leda till stabilare och snabbare dataöverföringar.

    Samtidigt fortsätter förbättringar inom virtualisering och molnstöd, vilket gör Linux ännu bättre anpassat för moderna IT-miljöer.

    En evolution – inte en revolution

    Det kanske viktigaste med Linux 7.0 är vad det representerar. Trots det nya versionsnumret handlar det inte om ett stort språng, utan om fortsatt evolution.

    Linux utvecklas steg för steg: säkrare kod, bättre prestanda, renare arkitektur och fler verktyg för framtiden. Det är just denna stabila och metodiska utveckling som gjort Linux till ryggraden i allt från servrar till mobiltelefoner och superdatorer.

    Kort sagt: Linux 7.0 ser kanske stort ut på ytan, men den verkliga styrkan ligger i de många små förbättringarna som driver tekniken framåt.

    https://lore.kernel.org/lkml/CAHk-=wj2WqpPBwpAXo8bj_Hx-NxKMRVTVMUaQis7+Vm6XLRZiw@mail.gmail.com/T/#u

    Teknisk fakta: Linux 7.0

    Version: Linux Kernel 7.0

    Typ av release: Versionsskifte från 6.19, främst en omnumrering

    Viktig nyhet: Rust-stöd är inte längre markerat som experimentellt

    Säkerhet: Stöd för ML-DSA post-kvant-signaturer, SHA-1 för modulsignering borttaget

    Filsystem: Uppdateringar för Btrfs, EROFS, XFS och F2FS

    Nätverk: AccECN aktiverat, CAKE får multiqueue-stöd

    Virtualisering: Förbättringar i KVM och Hyper-V

    Övrigt: NULLFS introduceras, förbättringar i minneshantering och swap

    Andra artiklar om Linux Kernel

  • Rust 1.94 gör språket mer uttrycksfullt och kraftfullt

    Programmeringsspråket Rust fortsätter att utvecklas i snabb takt. Den nya versionen Rust 1.94 introducerar flera förbättringar som gör språket både mer ergonomiskt och mer kraftfullt. Bland nyheterna finns en ny iterator för slice-data, förbättrad konfigurationshantering i Cargo, stöd för den senaste versionen av TOML-formatet och flera stabiliserade API:er i standardbiblioteket.

    Tillsammans innebär förändringarna att utvecklare kan skriva mer tydlig kod, organisera projekt bättre och dra nytta av nya funktioner i både språket och verktygskedjan.

    Ny iterator för slices: array_windows

    En av de mest uppmärksammade nyheterna är metoden array_windows för slices. Den fungerar på liknande sätt som den befintliga metoden windows, men med en viktig skillnad: den returnerar arrayer med fast storlek i stället för dynamiska slices.

    Detta gör att kompilatorn kan veta storleken på varje fönster redan vid kompilering, vilket förenklar kod och kan ge bättre optimeringar.

    En praktisk användning är när man vill analysera mönster i en dataström. Ett klassiskt exempel är att leta efter så kallade ABBA-mönster, där två olika tecken följs av samma två tecken i omvänd ordning, exempelvis abba eller xyyx.

    Med array_windows kan en sådan kontroll skrivas mycket kompakt:

    Här kan kompilatorn automatiskt förstå att varje fönster ska bestå av fyra element eftersom de destruktureras till fyra variabler.

    Cargo får bättre stöd för modulär konfiguration

    Rusts byggverktyg Cargo får i version 1.94 en ny funktion: möjligheten att inkludera konfigurationsfiler i andra konfigurationsfiler.

    Detta gör att större projekt kan dela upp sin konfiguration i flera mindre filer, vilket gör dem enklare att underhålla och återanvända mellan olika projekt eller utvecklingsmiljöer.

    Ett exempel är:

    Det går även att ange mer avancerade alternativ via så kallade inline-tabeller, exempelvis om en konfigurationsfil är valfri:

    Detta gör det möjligt att skapa konfigurationer som fungerar både lokalt och i olika utvecklingsmiljöer utan att alla filer behöver finnas överallt.

    Stöd för TOML 1.1

    Cargo kan nu också läsa TOML 1.1, den senaste versionen av konfigurationsformatet som används i Rust-projekt.

    Bland förbättringarna i TOML 1.1 finns:

    • inline-tabeller som kan skrivas över flera rader
    • stöd för fler escape-sekvenser i strängar
    • möjlighet att utelämna sekunder i tidsangivelser
    • trailing commas i vissa strukturer

    Det innebär exempelvis att beroenden i Cargo.toml kan skrivas mer läsbart:

    Om man använder dessa nya funktioner höjs dock projektets MSRV (Minimum Supported Rust Version), eftersom äldre Cargo-versioner inte kan tolka den nya syntaxen. Samtidigt hanterar Cargo detta automatiskt vid publicering genom att skriva om manifestfiler så att de förblir kompatibla med äldre verktyg.

    Nya matematiska konstanter i standardbiblioteket

    Rusts standardbibliotek har också utökats med några klassiska matematiska konstanter. Bland de nya konstanterna finns:

    • Euler–Mascheroni-konstanten (EULER_GAMMA)
    • det gyllene snittet (GOLDEN_RATIO)

    De finns tillgängliga för både f32 och f64 och kan användas direkt i numeriska beräkningar utan att utvecklare behöver definiera dem själva.

    Fler stabiliserade API:er

    Som i varje Rust-release har även flera tidigare experimentella funktioner nu blivit stabila API:er. Bland dessa finns bland annat:

    • array_windows och element_offset för slices
    • nya metoder för LazyCell och LazyLock
    • nya metoder i iteratorn Peekable
    • hårdvaruintrinsics för AVX-512 FP16 på x86 och NEON FP16 på AArch64

    Dessutom kan vissa funktioner, som mul_add för flyttal, nu användas i konstanta uttryck.

    Fortsatt snabb utveckling av Rust

    Rust 1.94 visar tydligt hur språket fortsätter att utvecklas i både små och stora steg. Förbättringar som array_windows gör koden mer uttrycksfull, medan förändringar i Cargo och TOML gör projekthanteringen mer flexibel.

    Utvecklare som redan använder Rust kan uppdatera till den nya versionen med kommandot:

    Den nya versionen är resultatet av arbete från ett stort antal bidragsgivare i Rust-communityt – ett exempel på hur ett modernt open source-projekt fortsätter att förbättras genom globalt samarbete.

    C vs Rust

    C

    C är ett klassiskt programspråk som har använts i årtionden för operativsystem, drivrutiner, inbyggda system och annan prestandakritisk programvara.

    Språket ger programmeraren mycket direkt kontroll över minne och hårdvara, vilket gör det snabbt och flexibelt.

    Nackdelen är att C saknar inbyggt skydd mot många vanliga minnesfel, vilket kan leda till buggar, krascher och säkerhetsproblem.

    Rust

    Rust är ett modernare systemspråk som också fokuserar på hög prestanda, men samtidigt vill minska risken för minnesfel och osäker kod.

    Genom sitt ägarskapssystem och sina kompilatorkontroller kan Rust förhindra många problem redan innan programmet körs.

    Det gör språket särskilt intressant för säkerhetskritiska system, servrar, verktyg och ny systemprogrammering.

    https://blog.rust-lang.org/2026/03/05/Rust-1.94.0

    Teknisk fakta: Rust 1.94

    Version: Rust 1.94.0

    Typ av uppdatering: Stabil utgåva

    Viktig nyhet: array_windows för slices

    Ny Cargo-funktion: stöd för include i konfigurationsfiler

    Manifestformat: Cargo kan nu tolka TOML 1.1

    Nya matematiska konstanter: EULER_GAMMA och GOLDEN_RATIO

    Fler förbättringar: stabiliserade API:er i standardbiblioteket och fler funktioner tillgängliga i const-kontext

    Uppdateringskommando:

    rustup update stable
  • Linux 7.0 är här – stabil Rust och smartare lagring

    Linuxvärlden tar ett steg in i en ny versionsserie när den första testversionen av Linux kernel 7.0 nu är ute. Bakom det nya huvudnumret döljer sig ingen dramatisk omvälvning – men däremot ett stabilt Rust-stöd, smartare filsystem och tekniska förbättringar som stärker säkerhet och prestanda inför framtiden.

    Den första testversionen av Linux kernel 7.0 har nu släppts för allmän testning. Det markerar början på några månaders finjustering innan den färdiga versionen väntas i april 2026.

    Att versionsnumret nu kliver upp från 6.19 till 7.0 betyder dock inte att hela systemet gör en dramatisk kursändring. Enligt skaparen Linus Torvalds handlar det snarare om en praktisk omstart av nummerserien än om någon teknisk revolution. Linux har länge utvecklats genom stabila, stegvisa förbättringar snarare än genom stora språng mellan huvudversioner.

    Rust blir en permanent del av kärnan

    Den kanske viktigaste nyheten är att stödet för programmeringsspråket Rust nu betraktas som stabilt. Tidigare har det legat under en experimentell etikett, men i version 7.0 anses tekniken mogen.

    Rust är känt för att minska risken för minnesrelaterade säkerhetsproblem, som buffer overflows och use-after-free-buggar. Sådana fel har historiskt varit en vanlig orsak till säkerhetsbrister i systemprogramvara.

    Det betyder inte att Linux skrivs om i Rust. Kärnan är fortfarande till största delen skriven i C. Men Rust blir nu ett etablerat komplement, särskilt för ny kod där säkerhet är extra viktig.

    Prestandalyft för moderna processorer

    Linux 7.0 introducerar stöd för atomiska 64-bytesläsningar på ARM-processorer. Det är en teknisk detalj som framför allt gynnar servrar och avancerade inbyggda system, där effektiv hantering av minne och parallell bearbetning är avgörande.

    En annan förbättring gäller hur in- och utdata hanteras. Genom att optimera så kallade submission queue-poster kan systemet hålla data närmare processorns cacheminne, vilket minskar fördröjningar.

    För vanliga användare märks detta kanske inte direkt, men i datacenter och molntjänster kan sådana förbättringar ge påtagliga effektivitetsvinster.

    Filsystem som kan reparera sig själva

    Två viktiga filsystem får uppmärksamhet i 7.0.

    Btrfs får ett första stöd för en funktion kallad remap-tree. Den gör det möjligt att ändra logiska blockadresser utan att behöva flytta själva datan. Det kan underlätta avancerad hantering av Copy-on-Write och datarörlighet. Funktionen betraktas dock fortfarande som experimentell.

    XFS får stöd för mer autonom självläkning. Det innebär att systemet i vissa fall själv kan upptäcka och korrigera skador i filsystemets metadata. För stora lagringssystem kan detta minska risken för driftstopp och dataförlust.

    Förberedelser för en kvantframtid

    En annan viktig förändring är stödet för ML-DSA, en signaturalgoritm anpassad för en framtid där kvantdatorer kan hota dagens krypteringsmetoder. Genom att redan nu integrera post-kvantkryptografi visar Linuxprojektet att det planerar för långsiktig säkerhet.

    Vad händer nu?

    En Release Candidate innebär att nya funktioner är låsta och att fokus ligger på testning och buggfixar. Vanligtvis släpps en ny testversion varje vecka.

    Om utvecklingen följer normal takt kan den slutliga versionen av Linux 7.0 släppas i mitten av april 2026.

    Linux 7.0 är alltså inte en dramatisk omvälvning. Men den visar tydligt hur världens mest använda operativsystemskärna fortsätter att utvecklas metodiskt: säkrare, effektivare och bättre rustad för framtidens teknik.

    https://kernel.org

    TEKNISK FAKTARUTA
    Ämne
    Linux-kärnan 7.0 rc1
    Vad är en RC?
    Release Candidate: testversion där fokus är buggfixar och stabilisering.
    Versionshoppet 7.0
    Ny huvudversion av praktiska skäl (inte “feature-revolution”).
    Stabil nyhet
    Rust-stöd räknas som stabilt (inte längre “experimentellt”).
    CPU / arkitektur
    Stöd för atomiska 64-bytesläsningar på ARM.
    Filsystem: Btrfs
    Direct I/O vid blockstorlek större än sidstorlek; initialt remap-tree (experimentellt).
    Filsystem: XFS
    Stöd för mer autonom “self-healing”.
    Säkerhet
    Stöd för ML-DSA post-kvant-signaturer.
    Komprimering
    EROFS: LZMA som standard.
    Tidslinje
    Slutrelease väntas i mitten av april 2026 (beroende på antal RC).
    Tips: Testa RC i icke-kritiska miljöer och rapportera buggar uppströms.

Etikett: systemprogrammering

  • Frame – en helt ny X11-server skriven i assembler

    Samtidigt som stora delar av Linuxvärlden lämnar det gamla grafiksystemet X11 till förmån för Wayland väljer den norske utvecklaren Geir Isene att gå åt motsatt håll. Han har byggt en helt ny X11-server från grunden – skriven nästan uteslutande i assembler för x86-64-processorer. Projektet heter Frame och är ett tekniskt experiment som försöker besvara en…

  • KernelScript 0.1: nytt språk vill göra eBPF enklare för Linuxutvecklare

    KernelScript 0.1 är ett nytt experimentellt programmeringsspråk som vill göra avancerad Linuxutveckling enklare. Genom att samla eBPF-program, användarprogram och kernelintegration i en och samma kodbas kan utvecklare slippa mycket av den manuella C-kod och libbpf-hantering som annars krävs. Resultatet är ett lovande, men ännu omoget, verktyg för den som vill arbeta närmare Linuxkärnan utan att…

  • Linux 7.0 är här – men den stora nyheten är inte siffran

    Linux 7.0 är här – men bakom det nya versionsnumret döljer sig ingen dramatisk omvälvning. I stället handlar det om en rad genomtänkta förbättringar som gör operativsystemet säkrare, snabbare och mer framtidssäkrat. Med stabilt stöd för Rust, nya säkerhetslösningar och smartare hantering av resurser fortsätter Linux att utvecklas i små men viktiga steg. När Linux…

  • Rust 1.94 gör språket mer uttrycksfullt och kraftfullt

    Programmeringsspråket Rust fortsätter att utvecklas i snabb takt. Den nya versionen Rust 1.94 introducerar flera förbättringar som gör språket både mer ergonomiskt och mer kraftfullt. Bland nyheterna finns en ny iterator för slice-data, förbättrad konfigurationshantering i Cargo, stöd för den senaste versionen av TOML-formatet och flera stabiliserade API:er i standardbiblioteket. Tillsammans innebär förändringarna att utvecklare…

  • Linux 7.0 är här – stabil Rust och smartare lagring

    Linuxvärlden tar ett steg in i en ny versionsserie när den första testversionen av Linux kernel 7.0 nu är ute. Bakom det nya huvudnumret döljer sig ingen dramatisk omvälvning – men däremot ett stabilt Rust-stöd, smartare filsystem och tekniska förbättringar som stärker säkerhet och prestanda inför framtiden. Den första testversionen av Linux kernel 7.0 har…