Gotland – är det här dalrunorna har sitt ursprung?


<p class="has-medium-font-size"><strong>Kan en kyrkbrand på Gotland i slutet av 1400-talet, två klockgjutare från fastlandet och en reslysten biskop ha gett upphov till att ett nytt skriftsystem etableras i Övre Dalarna hundra år senare? Blotta tanken kan verka befängd, men synar man spåren av runbruket vid medeltidens slut finns det faktiskt en hel del som stöder ett sådant scenario.</strong></p>


<div class="wp-block-image">
<figure class="alignleft size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/2.-Minnestenen-i-Hejde-edited.jpg" alt="" class="wp-image-3088" width="434" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Den runristade minnesstenen över kyrkbranden i Hejnums kyrka som återfanns 2019 under kyrkgolvet. Foto: Magnus Källström</mark></strong></figcaption></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DALRUNOR ÄR EN</mark></strong> speciell variant av runor som användes i Mora och Älvdalens socknar från slutet av 1500-talet fram till 1900-talets början. Runorna har här verkligen varit en levande skrift och fyllde olika praktiska funktioner. Detta har bland annat Carl von Linné vittnat om. När han besökte Älvdalen på sin dalaresa 1734 noterade han att bönderna förutom att de använde kalenderstavar med runor ”skrifwa än i dag sina namn och bomärken med runska bokstäfwer, som synes på wäggar, skötstenar [dvs. nätsänken], skålar etc. Det man på intet annat ställe i Sverje ännu wet continueras”.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DET SOM KARAKTERISERAR</mark></strong> dalrunorna är de innehåller särskilda teckenvarianter som är okända i andra runsystem, men också att flera runor har fått ett annat ljudvärde. Den runa som under medeltiden vanligtvis står för <strong>a </strong>(<mark class="has-inline-color has-vivid-red-color">ᛆ</mark>) är exempelvis i dalrunorna <strong>e</strong>, medan <strong>a</strong>-runan ser ut som en vikingatida <strong>a</strong>-runa med dubbelsidig bistav (<mark class="has-inline-color has-vivid-red-color">ᛅ</mark>), en teckenform som under medeltiden användes för <strong>æ</strong>.</p>



<p>   Tidigare trodde man att dalrunorna utgjorde en direkt utveckling från de medeltida runorna och den variant som i litteraturen har kallats ”det helstungna runalfabetet” dvs. en uppsättning av runor som fullständigt motsvarande tecknen i det latinska alfabetet och som också gärna återgavs uppställda i ABC-ordning. Det märkliga var dock att Dalarna verkade sakna alla spår av en medeltida runtradition. I dag vet vi att detta inte stämmer. Vid Västannor i Leksand har exempelvis påträffats ett par runbleck av bly som kan dateras till 1100- eller 1200-tal och genom systematiska undersökningar av ett antal medeltida träbyggnader i Övre Dalarna har man också upptäckt inristade runor som bör ha tillkommit när virket ännu var färskt och som alltså borde vara medeltida.</p>



<figure class="wp-block-image size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/07/1.-Dalrunor-Stock-fr†n-eldhus-Balsers-f„bodar-1024x337.jpg" alt="" class="wp-image-1392" width="992" height="326" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Dalrunor från 1750 ristade i en stock från Balsers fäbodar i Älvdalen. Texten lyder: »Led mig Jesu här i livet till det rätta vandringsmål …»</mark></strong> <strong><mark class="has-inline-color has-black-color">Foto: Bengt A. Lundberg/RAÄ Forndok</mark></strong></figcaption></figure>



<figure class="wp-block-image size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/07/Dalrunealfabet-kanske-fr-att-visa-hur-detta-alfabetet-ser-ut-1024x548.jpg" alt="" class="wp-image-1438" width="1002" height="534" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Dalrunealfabetet som det såg ut 1736 enligt dalkarlen Reinhold Näsman, som skrev en avhandling om dalmålet. Efter handskriften R 555.</mark></strong> <strong><mark class="has-inline-color has-black-color">Foto: UUB/Alvin</mark></strong></figcaption></figure>



<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-vertically-aligned-top is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:40%">
<figure class="wp-block-image size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/09/Popular-Arkeologi-a-538x1024.png" alt="" class="wp-image-3825" width="281" height="534" /></figure>
</div>



<div class="wp-block-column is-vertically-aligned-center is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:60%">
<figure class="wp-block-image size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/07/3.-Runklockan-i-Hejde-e1680295108256.jpg" alt="" class="wp-image-1401" width="420" height="494" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Runklockan i Hejnum, som troligen göts 1493 av klockgjutare från fastlandet och som ännu är i bruk. Foto: Magnus Källström</mark></strong></figcaption></figure>
</div>
</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-vertically-aligned-top is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:47%">
<figure class="wp-block-image size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/05/Popular-Arkeologi-b.png" alt="" class="wp-image-3826" width="306" height="445" /></figure>
</div>



<div class="wp-block-column is-vertically-aligned-center is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:75%">
<figure class="wp-block-image size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/07/4.-Den-stj„rnformade-h-runan-viktig-1024x646.jpg" alt="" class="wp-image-1407" width="495" height="312" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Den stjärnformade h-runan på minnesstenen i Hejnum. Foto: Magnus Källström</mark></strong></figcaption></figure>
</div>
</div>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ÄVEN OM VI</mark></strong> nu vet att runor har använts i Dalarna under medeltiden är det tveksamt om kunskapen har haft direkt kontinuitet in i nyare tid. Ser man till resten av landet verkar det nämligen som om runbruket i stort sett upphör vid mitten av 1300-talet. De runinskrifter som kan dateras till den senare delen av 1300-talet är mycket fåtaliga och från 1400-talet finns nästan inte ett enda säkert fynd. Varför användningen av runor upphör på 1300-talet vet vi inte, men en god gissning är att det ska tillskrivas digerdödens härjningar. Situationen i Danmark och Norge ser ut att ha varit i stort sett densamma.</p>



<p>   Inget tyder på att Dalarna skulle utgöra något undantag. De byggnader i Mora och Älvdalen där runinskrifter av medeltida typ har påträffats är daterade till 1200- eller 1300-tal (den yngsta är från 1333). En enstaka byggnad i Våmhus är visserligen uppförd av timmer med fällningsåret 1495, men runorna är här ristade i en avvikande teknik och de behöver därför inte vara gjorda när virket var färskt utan kan ha tillkommit långt senare. Det finns alltså även i Dalarna en ungefär tvåhundra år lång period, där vi inte har några säkra spår av runskrift. Varifrån hämtade i så fall dalkarlarna sin kunskap om detta teckensystem?</p>


<div class="wp-block-image">
<figure class="alignright size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/07/6.-Sune-i-Linkpings-domkyrka-r„tt-viktig-och-rolig.jpg" alt="" class="wp-image-1414" width="375" height="500" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Namnet Sune klottrat med runor på en pilaster i Linköpings domkyrka. Foto: Magnus Källström</mark></strong></figcaption></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">EGENTLIGEN ÄR DET</mark></strong> bara på två platser i Norden där man kan tala om en direkt kontinuitet i runbruket från medeltiden och in i nyare tid: Island och Gotland. Den isländska runtraditionen är märklig genom att den med undantag av ett fåtal fynd från vikingatidens slut och medeltidens början först blir riktigt synlig på 1300-talet genom att runor börjar användas på gravmonument på kyrkogårdarna. På Gotland finns däremot en mycket stark runtradition som sträcker sig från 200-talet och ända in i 1500- och 1600-tal. En målad inskrift i Vänge kyrka är exempelvis daterad så sent som 1553 och i Atlingbo kyrka har funnits ett par runinskrifter gjorda med rödkrita, som var försedda med årtalen 1568 och 1621.</p>



<p>   Dalfolket var som bekant ett vandrande folk, där både män och kvinnor periodvis arbetade långt utanför hemmet. Gotland bör dock ha legat utanför deras horisont under denna period, inte minst på grund av att ön var under danskt styre från Valdemar Atterdags erövring 1361 fram till freden i Brömsebro 1645.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">VÅREN 2019 GJORDES</mark></strong> ett fynd som kan kasta nytt ljus över dessa frågor. I samband med renoveringen av Hejde kyrka på Gotland påträffades en runristad golvsten under trägolvet i koret. Stenen var visserligen känd genom äldre avbildningar, men hade varit försvunnen sedan mitten av 1800-talet. Inskriften är minst sagt märklig genom att den bevarar minnet av en medeltida kyrkbrand:</p>



<p>»Kyrkan brann under en procession på (påsk)lördagen. Då var <strong>h </strong>söndag(sruna) och <strong>s</strong> prim(runa) i trettonde raden.»</p>



<p>Slutet utgörs av en datering, där man med hjälp av den s.k. påsktavlan kan räkna ut att året då kyrkan brann var 1492. Golvstenen är inte den enda runinskriften i Hejde kyrka, utan det finns också en gravhäll som på samma sätt daterar sig själv till 1506 och i tornet hänger en kyrkklocka med runor. Klockan, som faktiskt ännu är i bruk, bär texten:</p>



<p>»Ingemar och Olov, svenska män, de göt denna klocka helt och hållet.»</p>



<p>Klockan har alltså gjutits av två män från fastlandet, men runorna är typiskt gotländska och språket forngutniska. Det finns bara en runklocka till på Gotland – i Sanda kyrka – och den antas ha gjutits av samma klockgjutare. Inskriften utgörs här bara av en korthuggen datering: »<strong>k</strong> söndag(sruna) och <strong>tir</strong> prim(runa) i trettonde raden (på påsktavlan)», vilket svarar mot årtalet 1493, alltså året efter kyrkbranden i Hejde. Om de båda klockorna har gjutits vid samma tillfälle kan man dra slutsatsen att den gamla klockan i Hejde måste ha förstörts vid kyrkbranden och att det är därför som Ingemar och Olov har kallats från fastlandet för att gjuta en ny.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">PÅ RUNRISTADE GOLVSTENEN</mark></strong> i Hejde finns en mycket iögonfallande <strong>h</strong>-runa, som närmast liknar en stjärna eller en stiliserad snöflinga. Det märkliga är att när vår förste runforskare, Johannes Bureus, återgav dalrunor på sin stora runtavla 1599, så har <strong>h</strong>-runan där samma stjärnliknande form.</p>



<p>   Denna variant av <strong>h</strong>-runan är i övrigt ytterst sällsynt och verkar under medeltiden bara förekomma i ytterligare två runinskrifter. Båda finns på Gotland – i Havdhems och Eke kyrkor – och ska förmodligen dateras till 1400-talet. Under 1600-talet finns även sporadiska exempel på denna variant i runinskrifter i Norge och på Island. Den förekommer också i senare dalruneinskrifter, men kan då också stå för å. Eftersom Gotland är den enda plats i Norden där denna teckenform används under medeltiden frågar man sig om det möjligen kan finnas något samband mellan dessa förekomster.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p style="font-size:30px"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">Att biskop Henrik har kommit i kontakt med den gotländska runtraditionen under sina besök kan vi nog räkna med.</mark></strong></p>
</blockquote>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">GOTLAND HADE ÄNDÅ</mark></strong> sedan tidig medeltid tillhört Linköpings stift och detta gällde även under den långa period som ön var under danskt styre. Vart tredje år skulle Linköpingsbiskopen göra visitationsresor på ön, men i verkligheten skedde detta inte alls med en sådan regelbundenhet. Från 1400-talet saknas säkra uppgifter om att någon biskop från Linköping skulle ha besökt ön före Henrik Tidemansson, som vigdes till biskop hösten 1468.</p>



<p>   Enligt en inskrift i Linköpings domkyrka berömmer sig däremot denne biskop för att ha visiterat Gotland inte mindre än fem gånger under sin mer än trettioåriga ämbetsperiod. Några årtal för dessa visitationsresor är inte kända, men man vet att Henrik upprättade sitt testamente inför sin fjärde resa. Detta är daterat i december 1487 och resan kan därför tidigast ha genomförts året efter. Henrik dog den 20 december år 1500 och hans femte och sista resa till Gotland måste alltså ha företagits på 1490-talet, det vill säga under samma decennium som kyrkan i Hejde brann.</p>



<p>   Bland de uppgifter som biskopen skulle utföra under sina visitationsresor fanns att återinviga kyrkor och kyrkogårdar som hade blivit vanhelgade, men också att inviga kyrkklockor. Efter kyrkbranden i Hejde 1492 och gjutningen av klockorna i Hejde och Sanda under påföljande år fanns alltså sådana uppgifter som väntade på Gotland. I Sanda kyrka har man också funnit årtalet 1494 inristat på sydportalen, vilket har tolkats som året för en biskopsvisitation och samma årtal finns även i ett par kyrkor i Visby. Detta skulle passa mycket bra som tiden för Henrik Tidemanssons sista besök på Gotland, då han har kunnat inviga de båda kyrkklockorna och kanske också kyrkan i Hejde förutsatt att reparationsarbetena efter branden var klara.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ATT BISKOP HENRIK </mark></strong>har kommit i kontakt med den gotländska runtraditionen under sina besök kan vi nog räkna med. Det måste ju ha varit helt oundvikligt om han skulle inviga de båda runklockorna, som ju enligt ritualerna skulle bestänkas med vigvatten och smörjas med helig olja. Om det var biskopen själv eller någon i hans tolv man starka följe som intresserade sig för runorna och tog detta teckensystem tillbaka till fastlandet är däremot omöjligt att säga.</p>



<p>   På grund av olika stridigheter mellan Sverige och Danmark kom det därefter att dröja ända till 1527 innan en svensk biskop åter besöker Gotland. Då bär biskopen i Linköping namnet Brask och han får bara tillåtelse att besöka Visby och inte den gotländska landsbygden. Söker vi ett tillfälle i historien då den gotländska runkunskapen har kunnat föras över till det svenska fastlandet så är det just i slutet av 1400-talet under Henrik Tidemanssons tid.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">I LINKÖPINGS DOMKYRKA</mark></strong> finns en hel del graffiti av skiftande ålder. En ganska nyligen upptäckt runinskrift som är ristad i en pelare består av namnet <strong>suni</strong> »Sune» och innehåller en s-runa som är karakteristisk för just Gotland. Det är mycket frestande att tänka sig att det finns ett samband mellan dessa runor och Henrik Tidemanssons visitationsresor, även om det givetvis är möjligt att den kan var utförd av någon gotlänning redan under medeltiden.</p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/7.-Spegelbergs-runsignatur-i-Brasks-registratur-rolig-edited.jpg" alt="" class="wp-image-1528" width="377" height="437" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Johan Spegelbergs runsignatur i biskops Brasks registratur. Foto: Riksarkivet</mark></strong></figcaption></figure></div>


<p>   Från 1400-talet finns som nämnts nästan inte en enda runinskrift på det svenska fastlandet, men i början av 1500-talet dyker de plötsligt upp igen och då på skilda platser. Exempelvis skrev boktryckaren Paulus Griis, verksam i Uppsala 1510–19, i en av sina böcker med runor på latin: <strong>paulo · pertinet · liber</strong> »Boken tillhör Paulus».</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">NÅGOT SENARE FÖRSÅG</mark></strong> Johannes Olai Calmarensis korväggen till Runstens kyrka på Öland med denna runtext: »Denna kyrka heter Runsten. Det bör sockenherren (dvs. kyrkoherden) kunna: runor läsa och skriva.» Johannes som kom från Kalmar tros ha varit samma person som 1525 fick fullmakt på Sandby pastorat på Öland av biskop Brask i Linköping. Att runor var kända i kretsen kring denne biskop framgår också av att hans sekreterare Johan Spegelberg på försättsbladet till biskopens registratur från 1523–27 har ritat en fingerad vapensköld med en dödskalle och ett språkband med sitt efternamn i runor.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ÄVEN DEN SVENSKE </mark></strong>reformatorn Olaus Petri, som var bördig från Närke, kunde runor. I det hus som han efter 1527 lät bygga vid Storkyrkobrinken i Stockholm fanns en inskrift som man tror att han själv hade svarat för. Den löd »Skäggig haka passar inte väl i dans» och var en variant av ett medeltida ordspråk.</p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/07/9.-Runor-i-m„ssboken-fr†n-Sidensj-viktig-1024x676.jpg" alt="" class="wp-image-1421" width="384" height="253" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Namnet Andreas Olai skrivet med runor i mässboken från Sidensjö. Foto: Magnus Källström</mark></strong></figcaption></figure></div>


<p>   De nämnda exemplen har ett tydligt gemensamt drag. De tillhör alla den kyrkliga miljön och de som använde runor har ofta varit präster, som ju dels hade skolutbildning ibland till och med utomlands, dels ofta verkade på andra ställen än där de var födda. Det är då inte svårt att förstå hur kännedomen om runalfabetet på kort tid har kunnat sprida sig till olika delar av landet från en central plats som exempelvis Linköping.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">UNGEFÄR SAMTIDIGT HAR</mark></strong> kunskapen om runorna också återuppväckts i Danmark. I en bok tryckt 1521 som har tillhört den siste katolske biskopen i Roskilde, Joachim Rønnow (död 1542), finns på insidan av pärmen ett runalfabet i ABC-ordning, som är försett med överskriften »eth rwne abeceth, som ga<em>m</em>le danske brwgthe, nar the kaste rhuner och en nw staar i ga<em>m</em>le ste<em>n</em>ne Indhogne». Runalfabetet kan dock inte vara hämtat från runstenar, utan runformerna är tydligt medeltida. Det innehåller både den stjärnformade <strong>h</strong>-runan och en s-runa av gotländsk typ och kan alltså mycket väl komma från Gotland. Ungefär vid samma tid har Roskildeklerken Petrus Jacobi Skjold i Skovklosters arkivregistrant från 1528 skrivit sitt binamn med runor, men även upptecknat ett runalfabet. En tredje runkunnig var adelsmannen Bent Bille (1509–1555), som 1531 blev kanik i Roskilde och som under sin tid som skeppsbefälhavare på 1540-talet använde runor som en sorts lönnskrift i sina anteckningar. Inget av de nämnda runsystemen är helt identiskt, men ett gemensamt drag är att de saknar de runtecken för æ (<mark class="has-inline-color has-vivid-red-color">ᛅ</mark>) och ø (<mark class="has-inline-color has-vivid-red-color">ᚯ</mark>) som användes i Danmark under medeltiden. Även detta är ett tecken på gotländskt ursprung, eftersom forngutniskan saknade just dessa ljud.</p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/07/8.-Rnnow-runalfabet-ganska-viktig-1024x223.jpg" alt="" class="wp-image-1419" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Runalfabetet hos Joachim Rønnow med en stjärnformig h-runa och andra gotländska runformer. Efter Thorsen 1877</mark></strong></figcaption></figure>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DET NYUPPTÄCKTA INTRESSET</mark></strong> för runskrift har säkert sina rötter i den under 1400-talet uppblommande göticismen. Redan 1434 höll ärkebiskopen Nils Ragvaldsson sitt berömda tal vid konsiliet i Basel, där han hävdade att den dåvarande kung Erik stammade från goterna. När historikern Ericus Olai på 1470-talet författade en svensk historia gav han den namnet <em>Chronica regni Gothorum</em> »Goternas rikes historia». Om runorna vid denna tid var i stort sett bortglömda på fastlandet, är det inte så konstigt att man identifierade de runor man mötte på Gotland med goternas skrift! Den gotiska bibeln och det gotiska alfabetet var då ännu helt okända för den lärda världen. När de landsflyktiga ärkebiskoparna Johannes och Olaus Magnus, båda med rötter i Linköping, publicerade sina kända historiska verk i Rom 1554 och 1555 återgav de där ett runalfabet som de kallade <em>Alphabetum Gothicum</em> och som har tydliga gotländska drag. Även danskarna gjorde under samma tid anspråk på det gotiska ursprunget genom att hävda ett samband mellan goter och jutar.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">FRÅN ATT TILL</mark></strong> synes ha varit helt bortglömda under mer än hundrafemtio år får alltså runskriften under reformationstiden ett uppsving i både Sverige och Danmark. Det är också tydligt att det är inom de kyrkliga kretsarna, bland prästerna – såväl katolska som protestantiska – som kunskapen odlades. Den nyvunna runkunskapen nådde till och med en så avlägsen bygd som Sidensjö i Ångermanland. På den fullklottrade pärmen till en mässbok från 1500-talet står här med runor <strong>andreas olai</strong> dvs. Anders Olofsson, vilket har antagits syfta på »Herr Anders», som var den förste lutherske kyrkoherden i socknen. Han dog 1556 och är det han själv som har skrivit runorna, så måste han ha varit bekant med dem redan innan bröderna Magnus tryckte sitt runalfabet i Rom.</p>



<p>   Herr Anders hade en son Olof, som också utbildade sig till präst. År 1550 blev han utnämnd till kyrkoherde i Västerfärnebo i Västmanland för att 1574 överta samma befattning i Mora. Detta är samma Olof Andersson – Olaus Andreæ Angermannus – som Helmer Gustavson har utpekat som en av de potentiella skaparna av dalrunorna! Om indiciekedjan håller kan han alltså ha lärt känna runskriften redan under sin uppväxt.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DALRUNORNA HAR VISSERLIGEN</mark></strong> avlägsnat sig ganska långt från den här föreslagna gotländska förlagan och hur det har gått till i detalj vet vi inte. På en sida i en ganska bortglömd handskrift i Uppsala universitetsbibliotek har Johannes Bureus skrivit av några runalfabet som uppges härröra från Laurentius Petri, ärkebiskop i Uppsala från 1531 och bror till Olaus Petri. Här förekommer inte bara den stjärnformade <strong>h</strong>-runan utan också tidigare okända varianter av runan <strong>g</strong>, som mycket väl kan vara föregångare till den egenartade form som senare återfinns bland dalrunorna. Laurentius Petris runalfabet innehåller samtidigt typiskt gotländska former för runorna <strong>c</strong>, <strong>e</strong> och <strong>s</strong>, men saknar (som väntat) tecken för <strong>ä </strong>och<strong> ö</strong>. I stället avslutas hans alfabet med <strong>xyz</strong>, där <strong>y</strong> och <strong>z</strong> förekommer i lite olika varianter. Dessa varianter är slående lika de teckenformer som Bureus har upptecknat som dalrunorna för <strong>å</strong>, <strong>ä</strong> och <strong>ö</strong>. Om det är ett sådant runalfabet som har stått som modell för dalrunorna behöver den stungna <strong>a</strong>-runan för ä inte alls ha något samband med den femhundra år äldre <strong>æ</strong>-runan från Lödöse utan har sitt ursprung i en variant av runan <strong>y</strong>! På samma sätt förstår man att dalrunan för <strong>o</strong> (<mark class="has-inline-color has-vivid-red-color">ᛰ</mark>) rimligtvis har övertagit sin form från den gotländska runan för <strong>x</strong>.</p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2021/07/10.-Laurentius-Petris-runalfabet-mycket-viktig-1024x506.jpg" alt="" class="wp-image-1423" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Runalfabet samlade av Laurentius Petri, där vissa av runformerna kan ha varit förebilder för de senare dalrunorna. Efter handskriften R 556. Montage av Magnus Källström efter fotografier i Alvin.</mark></strong></figcaption></figure>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DET FINNS YTTERLIGARE</mark></strong> likhet mellan dalrunorna och Gotland som man inte tidigare har dragit de fulla konsekvenserna av. När Bureus lärde sig dalkarlarnas skrift fick han också veta att de enskilda tecknen hade namn och på runtavlan från 1599 har han återgivit dessa namn med runor i ABC-ordning: <strong>ar, birke, knäsol, dors</strong> osv. Vissa av dessa namn är identiska med de runnamn som fanns redan under vikingatiden, andra har fått en lite annorlunda form, medan några är nyskapade. Det sistnämnda gäller inte minst namnen för runorna <strong>å</strong>, <strong>ä</strong> och <strong>ö</strong> som enligt Bureus hette <strong>års, half-års</strong> och <strong>hel-års</strong>!</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">VI VET ATT</mark></strong> de gamla runnamnen var kända på Gotland under medeltiden genom att de ibland användes i dateringar efter påsktavlan. »Då jag var skriven var <em>hagall </em>söndag(sbokstav) och <em>undirmaðr </em>primstav i tavlans tolfte rad» står det exempelvis på en runristad gravhäll i Hemse kyrka. <em>Hagall </em>var namnet för<strong> h</strong>-runan, <em>undirmaðr </em>tydligen det gotländska namnet för den runa på västnordiskt område hette <em>ýr </em>och som brukar återges med <strong>R</strong> (Runan hade ju formen av en uppochnedvänd <em>maðr</em>-runa!). Sammanlagt känner vi genom runinskrifterna de gutniska namnen på sju av runorna och ställer man upp dem vid sidan av namnen på dalrunorna så ser man en märklig överensstämmelse. Runan <strong>f</strong> bar på västnordiskt område namnet <em>fé</em>, som betydde ’boskap, rikedom’, men på Gotland och i dalrunorna har namnet i stället blivit <strong>fir</strong>. På samma sätt har <strong>t</strong>-runan, som i västnorden kallades <em>Týr</em>, både på Gotland och i Dalarna fått namnet <strong>tir</strong>.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DET MEST PÅFALLANDE </mark></strong>är dock att det gutniska namnet för <strong>þ</strong>-runan <strong>þors</strong> motsvaras av dalrunornas <strong>dors</strong> för <strong>d</strong>. Namnet på denna runa var ursprungligen <em>þurs</em> ’troll’, men ersattes i på västnordiskt område tidigt av det mer neutrala namnet <em>þorn </em>’törne’. Om runnamnen varit levande under medeltiden i Dalarna skulle man knappast vänta sig ett så meningslöst runnamn som <strong>dors</strong>. I början av ord borde nämligen <em>þ</em> liksom i dialekten i övrigt ha utvecklats till <em>t</em>. Här måste sambandet med den gamla <strong>þ</strong>-runan vara brutet och allt talar för att detta runnamn har kommit till Dalarna i sen tid. Eftersom det bygger på det ursprungliga runnamnet <em>þurs</em> måste namnen ha förmedlats från östnordiskt område och vad är rimligare än att de har sitt ursprung på Gotland och att de tillsammans med runalfabetet har förts över till fastlandet i samband med någon av Henrik Tidemanssons biskopsvisitationer på ön.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DET ÄR INTE</mark> </strong>bara runorna som får en renässans under reformationen, utan också användningen av runstavar för kalendariska beräkningar. Både minnesstenen i Hejde kyrka och kyrkklockan i Sanda är ju daterade genom hänvisningar till påsktavlan och kanske har även det uppsving som runstaven får under 1500-talet på ömse sidor om Östersjön något samband med Linköpingsbiskopens Gotlandsbesök.</p>



<p>   Under 1500-talet gjordes också vissa anpassningar i kalendarierna för att underlätta beräkningar och korrigera de fel som hade uppkommit. Enligt Sven-Göran Hallonquist har exempelvis soltalen på de äldsta runstavarna från Dalarna förskjutits på ett sätt så att kalendern startar 1520, alltså ungefär vid samma tid som runorna åter dyker upp på fastlandet.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">MOT SLUTET AV</mark></strong> 1500-talet sker ytterligare anpassningar av dalastavarna så att 1576 blir den nya startpunkten för dessa kalendarier. Detta sammanfaller märkligt nog med det år som Västeråsbiskopen besöker Älvdalen och lovar dem »sittande präst» om de åtgärdar den förfallna kyrkan och bygger upp en prästgård. Olaus Andreæ Angermannus svärson Lars Björnsson blev visserligen inte formellt utsedd till kyrkoherde här förrän 1586, men redan 1577 kallar han sig ”pastor i Elfvedalarne” och fanns alltså redan då på platsen. Det äldsta dalrunealfabet i ABC-ordning som vi för tillfället känner till finns ristat i en stock i det så kallade Prästloftet vid Älvdalens kyrka. Timret till denna byggnad har enligt dendrodatering fällts vintern 1576–77. Detta sammanfall i tid känns som mer än en tillfällighet.</p>
