Världens sämsta runristare


<p class="has-medium-font-size"><strong>Hur dåligt kunde man rista och ändå komma undan med det? Vad var en vikingatida runstensbeställare beredd att acceptera? Och fanns det de som kunde men inte ville?</strong></p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ATT RISTA EN</mark></strong> runsten var säkert ingen lätt uppgift. Runristaren skulle inte bara finna en lämplig form för ett språkligt meddelande och överföra detta till runor, utan gärna ha en viss konstnärlig begåvning och gestaltningsförmåga samt dessutom behärska själva huggningsarbetet. Även om de flesta runristare besatt dess färdigheter stöter man emellanåt på ristningar där det har funnits ambitioner, men där ristaren av olika skäl inte har nått hela vägen fram.</p>



<p>   I ett bergsparti vid Sundby i Spånga i nordvästra Stockholm finns två runristningar, som ser helt olika ut. Den ena är utförd av en mycket skicklig runristare och det är inte några svårigheter att läsa texten: »Andvätt och Gärdar lät rista dessa runor efter Sven, sin fader, och Kättilvi efter sin make.» Den andra ristningen består bara av ett enkelt och aldrig avslutat textband, där inskriften utgörs av ett ensamt namn <strong>+ ermuntr </strong>»Ärnmund» i början av slingan och inget mer. Tydligen har ristaren gett upp efter att ha ristat detta namn, som kanske var hans eget. Runforskaren Elias Wessén, som hade en ganska bestämd uppfattning om vad man kunde kräva av forntidens skribenter, har i detta fall inte skrätt på orden: »Allt talar för att ristningen har utförts av en ovan klåpare, som icke har förmått att fullborda den.»</p>



<p>   Om ristaren i detta fall har arbetat för egen räkning eller om det har funnits någon uppdragsgivare i bakgrunden kan vi naturligtvis inte veta. En del runstensbeställare tycks samtidigt ha nöjt sig med att resultatet inte alltid blev det bästa. Till dessa kan räknas den runsten som 1975 påträffades under en strävpelare till det Hornska gravkoret i Uppsala domkyrka och som nog skulle kunna karakteriseras som Upplands fulaste runsten. Runormen är här ovanligt tilltrasslad och runorna står extremt glest i ormkroppen, ibland med flera decimeters avstånd. Om denna sten hade påträffats på någon annan plats så skulle man nog ha tänkt sig för både en och två gånger innan den skulle ha godkänts som äkta. Det råder dock ingen som helst tvekan om att det rör sig om en senvikingatida runsten och den som stavar sig igenom texten märker snart att den är avfattad på oklanderlig runsvenska:</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:30px"></div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:66.66%">
<p><strong>rikr · ok · hulti · fastkair · þaiʀ · litu · …a stain · at · uikmar · faþur · sin · styriman · koþan : likbiarn · risti</strong></p>



<p>»Ring och Hulte (och) Fastger de lät (hugg)a stenen efter Vigmar, sin fader, en god skeppshövding. Likbjörn ristade.»</p>
</div>
</div>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/11/1.-Uppsala-domkyrka-MK-1024x768.jpg" alt="" class="wp-image-1705" width="446" height="335" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Runstenen vid Uppsala domkyrka som kanske intar tät­positionen som Upplands fulaste runsten. Likbjörn höll i mejseln. Foto: Magnus Källström</mark></strong></figcaption></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">NÄR DET KOMMER</mark></strong> till runorna och språket har alltså Likbjörn inte haft några problem, utan det är i det konstnärliga som det har brustit, men lika mycket handlar det kanske om hur vi idag tycker att en vikingatida runsten borde se ut. De som har gett Likbjörn uppdraget har nog haft en annan uppfattning och de har uppenbarligen inte tillhört de minst välbeställda i trakten. En <em>styrimaðr</em>, som den döde Vigmar sägs ha varit, var den som höll i styråran och förde befälet på ett skepp. Runstenen från domkyrkan är inte heller Likbjörns enda, utan hans namn återkommer på ytterligare två eller tre stenar och det finns minst ett tiotal osignerade runstenar som han bör ha utfört. Ingen av dessa är dock på långa vägar så ful som stenen i Uppsala.</p>



<p>   Ett närmast motsatt förhållande möter den som besöker parken till Jakobsbergs folkhögskola i Järfälla utanför Stockholm. Här finns två runstenar som ursprungligen stod på den sedan länge försvunna gården Vibbles ägor. Den ena blev på 1800-talet av misstag söndersprängd och ristningen genomkorsas i dag av djupa sprickor. Detta försvårar läsningen, men även om man kompletterar den delvis söndertrasade texten med hjälp av äldre avbildningar, så är den allt annat än lättläst:</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:30px"></div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:50%">
<p><br /><strong>fununrok : kit : itfriþ&#8212;u : rnisn : stnia : hlmstain : aukhulmi : isnistu : -min : a-frustin : kmuai…n iubnrt</strong></p>
</div>
</div>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DET SOM HAR</mark></strong> hänt är att ristaren flera gånger har förväxlat runor som liknar varandra. I det första namnet <strong>fununr </strong>har han sannolikt avsett kvinnonamnet <em>Gunnvor</em>, som borde ha ristats kunuar. Här har han alltså använt <mark class="has-inline-color has-vivid-red-color">ᚠ </mark><strong>f</strong> i stället för <mark class="has-inline-color has-vivid-red-color">ᚴ </mark><strong>k</strong> och <mark class="has-inline-color has-vivid-red-color">ᚾ</mark> <strong>n </strong>istället för <mark class="has-inline-color has-vivid-red-color">ᛅ</mark> <strong>a</strong>. Något liknande har skett i <strong>rnisn : stnia</strong> som borde ha lytt <strong>raisa : stain</strong> »resa stenen» och där alltså <mark class="has-inline-color has-vivid-red-color">ᚾ</mark> <strong>n </strong>och <mark class="has-inline-color has-vivid-red-color">ᛅ</mark> <strong>a </strong>är systematiskt förväxlade. Märkligast är dock runföljden <strong>isnistu </strong>som måste vara fel för <strong>raistu </strong>»reste». Här har ristaren inte bara råkat skriva <strong>n </strong>för <strong>a</strong>, utan också delat upp runan <mark class="has-inline-color has-vivid-red-color">ᚱ </mark><strong>r </strong>i två olika runor: <mark class="has-inline-color has-vivid-red-color">ᛁ</mark> <strong>i </strong>och <mark class="has-inline-color has-vivid-red-color">ᛋ</mark> <strong>s</strong>. Det sista felet är mycket avslöjande och visar att denna ristare inte kan ha varit runkunnig utan att han måste ha följt en förskrift som han inte alls har förstått. Annars skulle ett fel av den sistnämnda typen aldrig ha kunnat uppkomma. Trots de många misstagen kan vi dock uttyda det mesta av texten, som lyder:</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:30px"></div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:50%">
<p>»Gunnvor och Kättilfrid lät resa stenen. Holm­sten och Holme reste stenen efter Frösten …»</p>
</div>
</div>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">VAD DE SISTA</mark></strong> runorna <strong>kmuai…n iubnrt</strong> döljer för budskap har däremot ingen ännu lyckats begripa. En forskare har gissat att ristarens namn skulle kunna dölja sig i runföljden <strong>iubnrt</strong> som står fritt på stenytan bredvid korset, men inte heller denna har gått tolka. När det kommer till ornamentiken och huggningstekniken finns det däremot inget att invända emot. I detta hänseende verkar denna runristare ha varit hur skicklig som helst.</p>


<div class="wp-block-image">
<figure class="alignright size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/11/2.-U-81-Sundby-Sp†nga-Faith-Ell-1938-ATA.jpg" alt="" class="wp-image-1708" width="336" height="485" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Runristningen vid Sundby i Spånga där runristaren gav upp efter sju runor. Foto­: Harald Faith-Ell, ATA.</mark></strong></figcaption></figure></div>


<p>   Det senare kan man inte säga om runristaren Fast, som har satt sitt namn på en runhäll vid Såsta i Täby i en annan del av Stockholms utkanter. Här är inte bara ornamentiken mycket valhänt utförd, utan runslingan är fylld av mängder med så kallade bindrunor, som gör texten mycket svår att läsa. Samme Wessén som hade uttalat sig om den ofullgångne runristaren i Spånga skriver här: »Det hela förefaller som en lek, ett besynnerligt infall för att förvirra läsaren, och kanske är också detta den riktiga förklaringen. Att ristaren på detta sätt ha missförstått en förlaga, förefaller mindre sannolikt.»</p>



<p>   Tittar man närmare på texten framstår det dock som klart att det just är det senare som denne runristare måste ha gjort. Inskriften börjar med tre namn <em>Gamall ok Svæinn ok Farulfʀ</em>, vilket ristaren först har återgett som <strong>kamal a suan u fa</strong>. När han kom till den andra runan i det sista namnet har han insett sina misstag och ändrat dessa runor till <strong>kamal × auk suain × auk</strong> genom att hugga de överhoppade runorna ovanpå de runor som han redan hade ristat. På så sätt har det som i dag ger intrycket av komplicerade bindrunor uppkommit. Lite längre fram i inskriften har han råkat hoppa över ett längre avsnitt och därför ser det ut som om namnet <strong>kamal</strong> »Gammal» skulle vara dolt i runföljden <strong>faþur sin</strong> »sin fader». Troligen har Fast precis som runristaren bakom runstenen i folkhögskolan i Jakobsberg med växlande framgång försökt följa en förskrift. Samtidigt har han varit så pass runkunnig att han har upptäckt sina misstag i någorlunda tid och kunnat korrigera dem. Förmodligen har han sedan målat upp ristningen med färg och då dolt felen genom att bara fylla i de riktiga linjerna.</p>



<p>   En annan runristare vars verk knappast förmår att imponera på en nutida betraktare är Grim Skald, som liksom Likbjörn var verksam i trakterna kring Uppsala. Hans ristningar är relativt enkla och han stavar på ett rätt förbryllande sätt. På en runsten som står vid Danmarks kyrka utanför Uppsala möts läsaren av denna text:</p>


<div class="wp-block-image">
<figure class="alignright size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/3.-U-91-Vibble-J„rf„lla-MK-edited.jpg" alt="" class="wp-image-3135" width="358" height="572" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Vibblestenen i Järfälla ristad av en runristare som inte kunde läsa runor. Foto: Magnus Källström.</mark></strong></figcaption></figure></div>


<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:30px"></div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:50%">
<p><strong>kusi × litiʀaisaatakaaoukatkatilarnukin</strong></p>
</div>
</div>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DET SER KANSKE</mark></strong> först ut som om det inte skulle betyda någonting alls, men lyckas man hitta ordgränserna, så är det inte så svårt att förstå:</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:30px"></div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:50%">
<p><strong>kusi × lit iʀaisa at aka aouk at katil arnukin</strong></p>



<p>»Guse (eller Kuse) lät resa efter Åke och efter Kättil den ålderstigne (eller den tidigt böjde).»</p>
</div>
</div>



<p>   En del stavningar ser lite märkliga ut, men Grims inskrifter är samtidigt mycket avslöjande för den som vill få en glimt av hur det talade språket kan ha låtit. Det verkar nämligen som han har försökt hitta de rätta runorna genom att ljuda sig fram.</p>



<p>   Att han lyckas stava ordet <em>ræisa </em>’resa’ med ett inledande <strong>iʀ</strong>, där den senare runan aldrig kan förekomma i början av ett ord, tyder på att han måste ha haft ett glidande uttal av det vanliga <em>r</em>-ljudet. I det lilla ordet <em>ok</em> ’och’ återger han vokalen med inte mindre än tre olika runor (<strong>aouk</strong>), vilket ju borde betyda att ordet inte innehöll ett kort <em>å</em>-ljud utan ännu uttalades med någon form av diftong.</p>



<p>   Även om Grim Skalds runtexter är märkligt stavade och Såstahällen och Vibblestenen lämnar en del att önska när det gäller runkunskapen, så är detta inskrifter som med lite ansträngning ändå går att läsa och begripa. Detta gäller dock inte alla runstenar. Runt om i landet finns också en hel del stenar som inte har kunnat tolkas och där det är ytterst tveksamt om runorna verkligen förmedlar ett språkligt budskap.</p>



<p>   Vid Hjälsta kyrka i Uppland står exempelvis en runsten som ser ut som vilken runsten som helst, men där den som försöker läsa texten möts av ett ganska oväntat meddelande:</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:30px"></div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:66.66%">
<p><strong>fast…ʀ + þuliak × oaʀtþiol × atiurai × fasatiʀ + þaloi + oaʀfsai</strong></p>
</div>
</div>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/11/4.-U-163-detalj-Faith-Ell-ATA-1024x318.jpg" alt="" class="wp-image-1711" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Detalj av Såstahällen i Täby, där runristaren Fast har försökt rätta sina misstag. Foto: Harald Faith-Ell, ATA.</mark></strong></figcaption></figure>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">TILL SKILLNAD MOT</mark></strong> Grim Skalds runsten finns här orduppdelning, men orden svarar inte mot något som vi känner igen som nordiskt språk. Ristaren har säkert haft en uttalad tanke med stenen. Han har velat skapa en runsten, men att inskriften skulle förmedla ett språkligt budskap var uppenbarligen av underordnad betydelse. Sådana runstenar är faktiskt inte helt ovanliga och röjer runbrukare med högst skiftande kompetens. Vissa har uppenbarligen haft en viss bekantskap med runskrift, eftersom de plötsligt kan rista valda delar av runraden med korrekt teckenordning.</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<p>Andra har haft en högst dimmig uppfattning om vilka former runorna kunde ta. På några stenar i nordvästra Uppland har dessa till och med reducerats till små vinklar och hakar som har riktats åt olika håll. Man har i detta sammanhang ofta talat om »meningslösa runinskrifter» eller »nonsensinskrifter». En modernare och mindre värderande term är »icke-lexikala inskrifter», myntad av Uppsalaforskaren Marco Bianchi, som specialstuderade dessa stenar i sin avhandling <em>Runor som resurs</em> från 2010.</p>



<p>   Paradnumret bland dessa ristningar är nog den berömda Gökstenen utanför Strängnäs i Södermanland, som ju liksom ristningen på Ramsundsberget i samma landskap innehåller bildframställningar ur sagan om Sigurd Fafnesbane. En del forskare har menat att Gökstenen är äldre än Ramsundsristningen och att det förklarar den primitivare stilen, men det råder knappast någon tvekan om att det är tvärtom. Inte minst de många missuppfattningarna i motiven tyder på det. På Gökstenen har inte bara Sigurds häst Grane förvandlats till en lite oformlig kamel, utan Regins avhuggna huvud har tecknats som något som liknar en motorcykelhjälm eller en något deformerad Pac-Manfigur. Regin med smedhammaren i handen har också övertagit stekandet av Fafnes hjärta, samtidigt som Sigurds huvud med vidhängande hand, pannlock och kryssformigt öga svävar fritt på ytan mellan honom och hästen. Vissa delar av inskriften framstår däremot som helt normala (<strong>raisti : stai : ain : þansi : at … sin faþu…</strong>), medan andra med outtalbara runföljder som <strong>kbrat </strong>och <strong>msi </strong>inte ger någon vettig mening. Uppenbarligen har denne ristare känt till de vikingatida runformerna och de vanligaste formuleringarna på runstenarna, men han tycks inte ha haft något språkligt meddelande att förmedla till eftervärlden. Samtidigt är Gökstenen ett imponerande runmonument som ändå måste ha haft ett speciellt syfte. En forskare har föreslagit att det kan ha fungerat som landmärke för en färjeförbindelse över ett nu uppgrundat sund strax norr om det väldiga runblocket och då kanske det var viktigare att ristningen syntes på långt håll än att runorna gick att tolka.</p>



<p>   De flesta av runstenarna med »icke-lexikala» inskrifter har säkert tillkommit redan under 1000-talet, medan en del kan misstänkas vara från medeltiden och i något enstaka fall kanske ännu senare. Dessa avslöjar genom att exempelvis innehålla runformer som annars bara finns på runstavar och i runkalendarier.</p>



<p>   Att en runsten i dag ser märklig ut kan ibland ha andra orsaker. Vid den övergivna bebyggelsen Vallby i Holm utanför Enköping finns exempelvis en runsten, där ornamentiken verkar ovanligt trasslig. Detta beror inte på runristarens oskicklighet, utan på att stenen någon gång under 1800-talet har blivit upphuggen, vilket också har gjort delar av inskriften helt obegriplig. Trots att det finns en avbildning från 1600-talet går det numera inte att avgöra vilka linjer som tillhör den ursprungliga ristningen och vilka som har tillkommit senare.</p>



<p>   Sådana sentida ingrepp är lyckligtvis inte så vanliga, men Vallbystenen är inte helt ensam. Ett fall är till och med så sent som från 1902, då den dåvarande ägarinnan till Långtora gård – också i Enköpingstrakten – lät »en i stenhuggerikonsten förfaren korpral» hugga upp ristningen på en runsten på ägorna. När hon fick förebråelser för detta tilltag urskuldade hon sig med »att stenen ännu icke var ’färdig’» och att hon till hösten hade »tänkt måla stenen hvit och ’krumelurerna’ röda»!</p>



<p>    Avslutningsvis kanske det passar bra att citera den runinskrift som antikvarien Jonas Håkansson Rhezelius 1634 fann på en pelare i högkoret till Löts kyrka på Öland:</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:30px"></div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:66.66%">
<p><strong>hævðen ⁝ þe ⁝ mera ⁝ mik ⁝ givit : þt ⁝ u͡æret ⁝ bætar ⁝ skivit</strong></p>



<p>»Hade de mig mera givit, då vore det bättre skrivet.»</p>
</div>
</div>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">RIMMET I DEN</mark></strong> lilla versen är givetvis mycket bättre på fornsvenska, än vad som går att åstadkomma på nutida svenska. Verbet <em>skrīfa </em>är lånat från latinets <em>scribere </em>och användes under medeltiden inte bara i betydelsen ’skriva’ utan också ’måla’. Det är därför inte omöjligt att texten kan ha syftat på någon väggmålning som har funnits i kyrkan. En liten detalj tyder dock på att det i detta fall handlar om skrivkonsten. I det sista ordet saknas uppenbarligen ett <strong>r </strong>och det har sagts att det inte går att veta om det ska skyllas den medeltida skribenten eller Rhezelius som upptecknade runorna. Inskriften finns inte längre kvar, men lyckligtvis sågs den också av sekreteraren i Antikvitetskollegiet i Uppsala Johan Hadorph, som besökte Öland 1673. Även Hadorph har i sina anteckningar formen <strong>skivit</strong> och så måste det alltså ha stått. Kanske är felet i detta fall helt avsiktligt för att förstärka budskapet i texten, som nog även en nutida skribent kan instämma i.</p>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow">
<figure class="wp-block-image size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/5.-U-946-Danmarks-kyrka-MK-edited.jpg" alt="" class="wp-image-1840" width="482" height="482" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Runstenen vid Danmarks kyrka utanför Uppsala, ristad av skalden som inte kunde stava. Foto Magnus Källström.</mark></strong></figcaption></figure>



<figure class="wp-block-image size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/11/6.-U-811-Hj„lsta-kyrka-MK.jpg" alt="" class="wp-image-1713" width="478" height="636" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Hjälstastenen i Uppland, skickligt huggen men med obegripliga runor. Foto Magnus Källström</mark></strong></figcaption></figure>



<figure class="wp-block-image size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/11/7.-S-327-Gkstenen-MK-1024x768.jpg" alt="" class="wp-image-1715" width="483" height="361" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Gökstenen i Söder­manland med en formkänsla hämtad från lussebaket. Foto: Magnus Källström</mark></strong></figcaption></figure>



<figure class="wp-block-image size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/11/8.-U-827-Vallby-Holms-sn-N.-Lagergren-1947-ATA.jpg" alt="" class="wp-image-1716" width="477" height="644" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Vallbystenen, vanställd av senare tiders forntidsvurm. Foto: Nils Lagergren, ATA</mark></strong></figcaption></figure>
</div>
</div>
