Plugget på vikingatiden

Att lära sig läsa och skriva i vikingatidens och medeltidens Sigtuna För att bli runristare under vikingatiden krävdes undervisning. Vi vet ganska lite om hur utbildningen var utformad, men fynd av ristade ben ger ledtrådar till hur det gick till när man lärde sig att skriva och läsa runor. »Jag vet att jag hängdei vindpinat […]


<h2 class="wp-block-heading" style="font-size:25px"><mark class="has-inline-color has-luminous-vivid-orange-color">Att lära sig läsa och skriva i vikingatidens och medeltidens Sigtuna</mark></h2>



<p class="has-medium-font-size"><strong>För att bli runristare under vikingatiden krävdes undervisning. Vi vet ganska lite om hur utbildningen var utformad, men fynd av ristade ben ger ledtrådar till hur det gick till när man lärde sig att skriva och läsa runor.</strong></p>



<figure class="wp-block-image size-large"><img fetchpriority="high" decoding="async" width="1024" height="307" src="https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-1.-Sl-21-Tr„dg†rdm„staren-futhark-e1680606076837-1024x307.jpg" alt="" class="wp-image-1607" srcset="https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-1.-Sl-21-Tr„dg†rdm„staren-futhark-e1680606076837-1024x307.jpg 1024w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-1.-Sl-21-Tr„dg†rdm„staren-futhark-e1680606076837-300x90.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-1.-Sl-21-Tr„dg†rdm„staren-futhark-e1680606076837-768x230.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-1.-Sl-21-Tr„dg†rdm„staren-futhark-e1680606076837.jpg 1280w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Ett runben från kvarteret Trädgårdsmästaren med en delvis misslyckad runrad.<br />I mitten har ristaren kastat om två runor. Foto Bengt A. Lundberg/Forndok</mark></strong></figcaption></figure>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-1 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 class="has-text-align-left">»Jag vet att jag hängde<br />i vindpinat träd<br />nio hela nätter,<br />stungen med spjut<br />och offrad till Oden,<br />själv given till mig själv<br />på det mäktiga träd<br />som ingen mänska vet<br />av vad rot det är vuxet.</p>



<p class="has-text-align-left">Jag fick ingen mat,<br />ej heller mjöd,<br />rätt ner såg jag,<br />runor tog jag upp,<br />tog dem skrikande<br />och föll från trädet.»<br />(övers. Lars Lönnroth 2016)</p>
</div>
</div>



<p>Så beskriver guden Oden i eddadikten Hávamál hur han tillägnade sig kunskapen om runorna och det tycks ha varit en minst sagt smärtsam process. Den som ville lära sig läsa och skriva runor under vikingatiden och medeltiden behövde inte gå igenom något liknande, men det krävdes istället lite mer än bara smärttålighet och passivt hängande.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">VI VET GENOM</mark></strong> ristarsignaturerna att de vikingatida runristarna hade medhjälpare och lärjungar. I ett fall – beträffande ristaren Fot och Torgöt Fotsarve – kan man konstatera att yrket har gått i arv från far till son, men man finner också exempel på samarbeten mellan etablerade runristare. Om hur undervisningen i själva skriftsystemet har gått till ger däremot runstenarna egentligen ingen upplysning. Att det ibland står <em>Rāði sār kunni </em>»Tyde den som kan» på stenarna, visar dock att det var en kunskap som inte var självklar och allom given.</p>


<div class="wp-block-image">
<figure class="alignleft size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-8.-Sl-37-Fastg-Finger-och-Kolla-e1680607077295-1024x418.jpg" alt="" class="wp-image-1616" width="458" height="186" srcset="https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-8.-Sl-37-Fastg-Finger-och-Kolla-e1680607077295-1024x418.jpg 1024w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-8.-Sl-37-Fastg-Finger-och-Kolla-e1680607077295-300x123.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-8.-Sl-37-Fastg-Finger-och-Kolla-e1680607077295-768x314.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-8.-Sl-37-Fastg-Finger-och-Kolla-e1680607077295.jpg 1099w" sizes="(max-width: 458px) 100vw, 458px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Ett runben från kvarteret Ödåker med ett par kvinnonamn: Fastlög och Kolla. <br />Foto Bengt A. Lundberg/Forndok</mark></strong></figcaption></figure></div>


<p>   Annorlunda ser det ut om man vänder sig till de runristade lösföremål som har påträffats i Sigtunas jord. Antalet fynd uppgår idag till mer än 130 och utgörs till största delen av i övrigt obearbetade djurben, som nästan alltid tycks ha varit matavfall. När man hade gnagt av köttet från exempelvis ett revben fanns här ett par utmärkta släta ytor som var som gjorda för att fyllas med skrift. Skrivverktyget var vanligtvis en kniv, något som alla ägde och som alltid fanns till hands.</p>



<p>   Från Sigtuna finns några längre runtexter, som t.ex. besvärjelsen på det så kallade sårfeberbenet från kvarteret Professorn, men de allra flesta av runinskrifterna är förhållandevis korta och många gånger till synes rätt meningslösa. Så har de dock inte varit när de skapades, utan de är förmodligen i många fall spår av undervisning i konsten att läsa och skriva runor.</p>


<div class="wp-block-image">
<figure class="alignleft size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2023/05/Fig.-2.-Sl-97-Runtrissan-edited.jpg" alt="" class="wp-image-3721" width="446" height="334" srcset="https://elbilen.se/wp-content/uploads/sites/3/2023/05/Fig.-2.-Sl-97-Runtrissan-edited.jpg 1133w, https://elbilen.se/wp-content/uploads/sites/3/2023/05/Fig.-2.-Sl-97-Runtrissan-edited-300x225.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2023/05/Fig.-2.-Sl-97-Runtrissan-edited-1024x768.jpg 1024w, https://elbilen.se/wp-content/uploads/sites/3/2023/05/Fig.-2.-Sl-97-Runtrissan-edited-768x576.jpg 768w" sizes="(max-width: 446px) 100vw, 446px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Den märkliga runtrissan från kvarteret Professorn, som troligen har varit ett pedagogiskt redskap för att lära sig stavelser. Foto Bengt A. Lundberg/Forndok</mark></strong></figcaption></figure></div>


<p>   Då som nu började man troligen med att lära sig känna igen de enskilda skrivtecknen samt själva alfabetet. En fördel med runraden – den s.k. futhark­en – var att den var kort och inte omfattade mer än 16 tecken. Samtidigt måste man lära sig benämningarna på runorna som inte bara utgjordes av stavelser som i vårt nutida alfabet, utan av hela ord: <em>fē </em>’boskap, rikedom’ för <strong>f</strong>-runan, <em>ūrr </em>’uroxe’ för <strong>u</strong>-runan, <em>þurs </em>’troll’ för <strong>þ</strong>-runan osv.</p>



<p>   På ett revben från kvarteret Trädgårdsmästaren finns fem rätt valhänt ristade <strong>þ</strong>-runor. Här handlar det säkert inte om trollrunor ristade i något magiskt syfte utan helt enkelt om en skrivövning där någon har försökt få till det nämnda tecknet med högst blandade resultat. Något liknande är det också med de runrader som har påträffats från Sigtuna. Inte mindre än ett tjugotal sådana är kända, men nästan inte en enda är helt felfri. Detta beror helt säkert på att det rör sig om övningar, där adepterna har försökt rista en <em>futhark</em>, men med högst blandade resultat. De fel som har begåtts är de vanliga: ordningen mellan tecknen kastas om, tecken hoppas över, snarlika tecken förväxlas etc.</p>



<p>   På baksidan av ett ben med ett av de havererade försöken – ristaren har här fått ned hela runraden, men råkat kasta om två runor i mitten – förekommer ett par sekvenser <strong>ba ba</strong>. Detta kanske inte ser så imponerande ut, men är troligen ett sätt att öva på stavelser.</p>


<div class="wp-block-image">
<figure class="alignleft size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-3.-Yngre-runraden-chiffernyckel-1024x315.jpg" alt="" class="wp-image-1609" width="439" height="134" srcset="https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-3.-Yngre-runraden-chiffernyckel-1024x315.jpg 1024w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-3.-Yngre-runraden-chiffernyckel-300x92.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-3.-Yngre-runraden-chiffernyckel-768x236.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-3.-Yngre-runraden-chiffernyckel.jpg 1280w" sizes="(max-width: 439px) 100vw, 439px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Den yngre runraden med nyckeln till den vanligaste lönnskriften med runor. Foto: Magnus Källström</mark></strong></figcaption></figure></div>


<p>   Att innötandet av stavelser faktiskt har spelat en roll när man skulle lära sig läsa runor har tidigare inte varit särskilt känt, men framgår tydligt av ett märkligt fynd som gjordes år 2000 i kvarteret Professorn. Föremålet utgörs av en trätrissa, som mäter en dryg decimeter i diameter och där någon har skrivit ned de olika konsonantrunorna i samma ordning som i futharken och kombinerat dem med de fyra vokalrunorna som fanns i runalfabetet: <strong>fufofafi, þuþoþaþi, rurorari, kukokari</strong> etc. Att rabbla stavelser var en metod att lära sig läsa som tillämpades redan under antiken och från Norge känner vi sedan tidigare några liknande runsyllabarier med medeltida datering. Trätrissan från Sigtuna har dock förhållandevis tidig och bör ha hamnat i jorden omkring 1030. Det är inte omöjligt att det har funnits en tanke med att anbringa runorna på en rund skiva som kunde vridas medan man läste, men själva föremålet har knappast varit tillverkat för detta ändamål. Från Sigtuna finns nämligen en snarlik träskiva som påträffades tillsammans med en avbruten mast och det är därför möjligt att det rör sig om en ursprunglig skeppsdetalj.</p>


<div class="wp-block-image">
<figure class="alignleft size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-4.-Sl-91-Professorn-1-runchiffer_1-1024x683.jpg" alt="" class="wp-image-1611" width="449" height="300" srcset="https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-4.-Sl-91-Professorn-1-runchiffer_1-1024x683.jpg 1024w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-4.-Sl-91-Professorn-1-runchiffer_1-300x200.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-4.-Sl-91-Professorn-1-runchiffer_1-768x512.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-4.-Sl-91-Professorn-1-runchiffer_1.jpg 1275w" sizes="(max-width: 449px) 100vw, 449px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">En uppmaning i lönnskrift från kvarteret Professorn: raþu »Tyd du!». Foto Bengt A. Lundberg/Forndok</mark></strong></figcaption></figure></div>


<p>   På ett runben från Oldenburg i norra Tyskland finns en runinskrift som har tolkats som en lek med stavelser. Den lyder <strong>abi : bataba : iestaba</strong>. Eftersom runföljden ser ut att rimma är det dock frågan om den inte också rymmer en ordlek. Början kan nämligen utan problem tolkas som <em>Api bant apa</em> »(en) apa band (en) apa». Den sista runföljden <strong>iestaba </strong>skulle då kunna svara mot prepositionen <em>ī </em>’i’ följt av ett ord sammansatt med <em>stapi</em>, som betyder ’hög, brant klippa’. Det senare ingår i bland annat ordet <em>ǽtternisstapi</em>, som kom till Sverige på 1600-talet i samband med den första översättningen av en isländska saga och försvenskades till <em>ättestupa</em>. En annan möjlighet är att ristaren har följt regeln om att nasalen <em>n </em>i runskrift kan utelämnas framför <em>s </em>och att det istället handlar om en motsvarighet till det fornvästnordiska ordet <em>einstapi</em>, som avser ormbunksväxten örnbräken! Om man därtill lägger att ordet api liksom i Eddapoesin kan ha haft betydelsen ’narr, dåre’ så blir det till och med lite logik i den nonsensartade versen: »en dåre band en dåre i en ormbunke»!</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">Kūkr kyss kuntu, kyss! – en sats som nog kan förstås utan översättning till modern svenska.</mark></strong></p>
</blockquote>



<p>   På baksidan av samma ben står <strong>kukr : kus kutu kys</strong>, som troligen också bygger på en lek med stavelser, men som samtidigt otvunget kan tolkas som <em>Kūkr kyss kuntu, kyss</em>! – en sats som nog kan förstås utan översättning till modern svenska. Trots det något skabrösa innehållet är det troligt att även denna text med sina avsiktliga allitterationer på k- har tillkommit i ett undervisningssammanhang.</p>



<p>   Bland inskrifterna från Sigtuna förekommer också olika typer av lönnskrift och mycket tyder på att även detta var en del i det pedagogiska arbetet. Det är nämligen sällan som denna lönnskrift döljer några större hemligheter. På ett djurben från kvarteret Professorn förekommer ett antal ristade streck, korta och långa, som faktiskt är lönnrunor och som bygger på samma principer som bl.a. finns på den berömda Rökstenen i Östergötland. Runraden var nämligen indelad i tre ätter, vilket hade lagts till grund för denna lönnskrift. För att ange en viss runa angav man först ätten – som för att göra de lite svårare räknades bakifrån så <strong>tbmlr </strong>var den första och <strong>fuþark </strong>den sista – och sedan positionen inom ätten. Gör man så kan strecken på benet från kvarteret Professorn utläsas som <strong>raþu</strong>, vilket helt enkelt betyder <em>Rāð-þū</em> »Tyd du»!</p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-5.-Sl-40-L唍ggr刵d-bindrunor-1024x609.jpg" alt="" class="wp-image-1612" width="464" height="275" srcset="https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-5.-Sl-40-L唍ggr刵d-bindrunor-1024x609.jpg 1024w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-5.-Sl-40-L唍ggr刵d-bindrunor-300x178.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-5.-Sl-40-L唍ggr刵d-bindrunor-768x457.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-5.-Sl-40-L唍ggr刵d-bindrunor.jpg 1280w" sizes="(max-width: 464px) 100vw, 464px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Runbenet från Långgränd med komplicerade bindrunor och en tidlös ordlek. Foto Bengt A. Lundberg/Forndok</mark></strong></figcaption></figure></div>


<p>   Man kunde också binda ihop runorna till komplicerade bindrunor som på ett ben som framkom 1995 i Långgränd. Denna inskrift var länge otolkad tills det blev klart att den utgör en variant av en ordlek som är känd från flera runinskrifter på västnordiskt område. På en träpinne från Narsaq på Grönland kan man exempelvis läsa <em>Á sá sá sá es á sá sat</em>, vilket betyder »På en så såg den som på en så satt». På en träpinne från Bergen i Norge står <em>Hvat sá sá er sá sá? Sik sá sá er á sá sá</em> »Vad såg den som såg i sån? Sig såg den som såg i sån». Med ordet <em>så </em>avses här ett stort laggat träkar, som användes för att förvara vatten, mjölk eller annan vätska i.</p>



<p>   Med denna kunskap är det inte så svårt att lista ut vad det står på benet från Långgränd. Om man läser runorna från vänster till höger och varje bindruna uppifrån och ned så blir resultatet sisasikhsaisasiksais, vilket i sin tur kan utläsas som <em>Sē! Sā’s sik sā ī sā sik sā ī īs(i) </em>»Se! Den som såg sig själv i sån han såg sig själv i is.» Vi får i detta fall tänka oss att vattnet i sån var fruset och att personen i fråga såg sig egen spegelbild i isen.</p>



<p>   Ordleken bygger på ett antal homonyma ord och är som sådan tidlös. En god parallell finns i det som författaren och tullinspektören Elias Sehlstedt skaldade när han 1872 i solnedgången betraktade utsikten över sjön mot Alnön i Sundsvall:</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-2 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><em>Och hela hamnen som en spegel låg;<br />Och såg vid såg jag såg, hvarthelst jag såg.</em></p>
</div>
</div>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">YTTERLIGARE EN TYP</mark></strong> av lönnskrift där bindrunor är inblandade löstes bara för några år sedan av den norske runologen K. Jonas Nordby. På ett ben från kvarteret Professorn där man tidigare bara hade läst ordet <strong>raþ </strong>dvs. »Tyd!» med en märklig <strong>þ</strong>-runa med dubbla bistavar, upptäckte Nordby att det egentligen var en bindruna och att det fanns fler sådana i den korta texten som man tidigare inte hade förstått. Runorna ska nämligen först läsas från ett håll och man får då ordet <strong>raþ</strong>. Därefter ska benet vändas 180 grader och de återstående elementen läsas som runorna <strong>þat</strong>. Tillsammans bildar de frasen <strong>raþ þat</strong> dvs. <em>Rāð þat</em>! »Tyd detta!» När Nordby väl hade gjort denna upptäckt fann han exakt likadana texter i Oslo, i Bergen, ja till och med i Skara.</p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/MIXBILD-11-988x1024.jpg" alt="" class="wp-image-1702" width="412" height="426" srcset="https://elbilen.se/wp-content/uploads/sites/3/2023/04/MIXBILD-11-988x1024.jpg 988w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/MIXBILD-11-289x300.jpg 289w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/MIXBILD-11-768x796.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/MIXBILD-11.jpg 1275w" sizes="(max-width: 412px) 100vw, 412px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Ännu en uppmaning i en länge okänd lönnskrift från kvarteret Professorn: raþ þat »Tyd detta!». Foto Bengt A. Lundberg/Forndok. Teckning: Magnus Källström</mark></strong></figcaption></figure></div>


<p>   Nordbys upptäckt ledde till att ytterligare exempel på denna lönnskrift på ett runben funnet vid samma grävning. Den bestod också av tre bindrunor, men här blev resultatet istället <strong>aul kut</strong>, vilket knappast kan betyda något annat än <em>ǫl gott </em>»Gott öl»! Det korta men kärnfulla budskapet ger också en antydan om i vilken miljö inskriften bör ha tillkommit och kanske var det just vid måltider och dryckeslag som runundervisningen vanligtvis ägde rum. De ben som man använde som skrivunderlag var ju som nämnts i regel matavfall och enklast var ju också att rista i ben som hade kommit direkt ur grytan.</p>



<p>   Vi kan alltså genom runbenen från Sigtuna följa några av de viktigare stegen i lärandeprocessen och lite av de pedagogiska knep som utnyttjades. Ett viktigt moment har dock inte lämnat några synliga spår, nämligen hur man hanterade mångfunktionaliteten hos många av runtecknen. Den vikingatida runraden hade ju bara 16 tecken och många av runorna måste därför stå för flera olika ljud. För konsonanterna gällde i stort sett principen att de som bildades på samma ställe i munnen uttrycktes med samma tecken. För <em>p </em>och <em>b </em>som skapas med hjälp av läpparna användes runan <strong>b</strong>, för <em>t </em>och <em>d </em>som frambringas med tungan mot tänderna runan t osv. Skillnaden mellan dessa ljudpar är endast att det ena tonlöst och det andra tonande och man behöver egentligen bara pröva att uttala dem för att förstå vilka som hör ihop. För vokalerna var det däremot lite knepigare. Vokalrunorna var ju inte särskilt många, men det räckte med de tre runorna <mark class="has-inline-color has-vivid-red-color">ᛁ </mark><strong>i</strong>, <mark class="has-inline-color has-vivid-red-color">ᛅ </mark><strong>a </strong>och <mark class="has-inline-color has-vivid-red-color">ᚢ </mark><strong>u </strong>för att täcka in hela det dåvarande vokalsystemet, som omfattade nio olika vokaler, som dessutom kunde vara korta och långa. Moderna forskare har konstaterat att det i detta fall förmodligen var läpprundningen man gick på. Vokaler som bildas utan att läpparna rundades som<em> i, e </em>och <em>æ </em>skrevs med <strong>i</strong>-runan, medan sådana som bildas med rundade läppar som t.ex. <em>o, u, y </em>och <em>ø</em> återgavs med runan <strong>u</strong>. Så småningom utvecklades också idén att modifiera tecknen med punkter så kallade stingningar och grundprincipen verkar då ha varit att stingningen markerar <em>ett annat</em> ljudvärde än det som fanns i runans namn. En stungen <strong>i</strong>-runa (<mark class="has-inline-color has-vivid-red-color">ᚽ</mark>) används alltså för <em>e </em>eller <em>æ</em>, en stungen <strong>u</strong>-runa (<mark class="has-inline-color has-vivid-red-color">ᚤ</mark>) för <em>y</em> och <em>ø</em>.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DEN SOM HADE </mark></strong>tillägnat sig de enskilda tecknen, deras ordning och ljudvärden samt lärt sig att kombinera dem till stavelser kunde sedan börja forma ord. Gissningsvis började många säkert med att skriva sitt eget namn och på runbenen förekommer också en hel del personnamn. På baksidan av det ovan nämnda benet från Långgränd med ordleken om han som såg sig själv i sån, står exempelvis <strong>haralt </strong>dvs. namnet ­<em>Haraldr</em>. På ett ben från kvarteret Ödåker kan man på ena sidan läsa orden<strong> rif : naut͡s </strong>»nötkreaturets revben», medan det på den andra sidan står <strong>fastlaug fikr · ok : kola</strong>. Det senare ska utläsas som <em>Fastlaug Fingʀ ok Kolla</em>, vilket återger namnet på två kvinnor Fastlög och Kolla, där den förstnämnda även tycks ha burit binamnet »Finger», kanske för att hon saknade ett sådant. Till och med en kyrkans man har efterlämnat sitt namn i runor. Det vet vi genom att han skrev ut sin titel på ett ben från kvarteret Professorn: <strong>hera ⁝ nikala</strong>… »Herr Nikolaus». Ibland är det inte så lätt att avgöra om det handlar om ett namn eller något annat ord. På skulderbladet från ett svin från samma kvarter står t.ex. runorna <strong>bofe</strong>, vilket rimligtvis avser namnet <em>Bōfi </em>»Bove», men som också skulle kunna tolkas som ordet <em>bōfē </em>»småboskap».</p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-7.-Sl-95-aul-kut-e1680608331699-1024x492.jpg" alt="" class="wp-image-1615" width="458" height="220" srcset="https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-7.-Sl-95-aul-kut-e1680608331699-1024x492.jpg 1024w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-7.-Sl-95-aul-kut-e1680608331699-300x144.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-7.-Sl-95-aul-kut-e1680608331699-768x369.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-7.-Sl-95-aul-kut-e1680608331699.jpg 1275w" sizes="(max-width: 458px) 100vw, 458px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Ytterligare en lönnskrift som döljer något drickbart. Foto Bengt A. Lundberg/Forndok</mark></strong></figcaption></figure></div>


<p>   Den som hade kommit så här långt i sin skrivundervisning kunde nu ge sig på att rista lite längre texter. Så särskilt långa texter verkar man dock inte ha skrivit, åtminstone inte i de material som har bevarats till vår tid. Ett revben kan ju inte heller rymma hur mycket text som helst. Det ovan nämnda »sårfeberbenet» bär en av de längre inskrifter som har påträffats i Sigtuna, men trots att det mäter 24 centimeter i längd och är ristat på två sidor omfattar texten inte mer än drygt hundra runor.</p>



<p>   Emellanåt avslöjar runformer och ristningsteknik att flera personer har ristat på samma ben. Ett bekant exempel är det så kallade »kungabenet» från kvarteret Trädgårdsmästaren, där någon på den ena sidan har skrivit <em>Mari seldi rif, ā fē mæst</em> »Mare överlämnade benet, (han) äger mest rikedom». Någon annan har sedan skrivit en replik på baksidan av samma ben: <em>Konungʀ eʀ mandr bæztr. Hann ā fē mæst. Hann er þækkiligʀ</em> »Kungen är den bäste mannen. Han äger mest rikedom. Han är sympatisk» – onekligen ett dräpande svar på den förstes skrytfulla påstående.</p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-9.-Drakeg†rden-Sl†-K†te-p†-benet-e1680608369315-1024x322.jpg" alt="" class="wp-image-1617" width="459" height="144" srcset="https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-9.-Drakeg†rden-Sl†-K†te-p†-benet-e1680608369315-1024x322.jpg 1024w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-9.-Drakeg†rden-Sl†-K†te-p†-benet-e1680608369315-300x94.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-9.-Drakeg†rden-Sl†-K†te-p†-benet-e1680608369315-768x241.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2021/09/Fig.-9.-Drakeg†rden-Sl†-K†te-p†-benet-e1680608369315.jpg 1133w" sizes="(max-width: 459px) 100vw, 459px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Det märkliga runbenet från Drakegården, där två olika personer tycks ha ristat runorna. Foto Magnus Källström.</mark></strong></figcaption></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ETT ANNAT EXEMPEL</mark></strong> är det runben som 2015 påträffades vid en arkeologisk undersökning i Drakegården intill Stora gatan i Sigtuna. Benet var nedstucket precis i en tomtgräns och bär tre olika inskrifter. En lyder <strong>skiftum : skiþut</strong>, där det första ordet är en form av verbet <em>skifta </em>som kan betyda ’skifta, byta, dela’. Formen på &#8211;<em>um</em> avslöjar subjektet är ett underförstått »vi», i detta fall alltså »Vi skiftar», »Vi skiftade» eller »Låt oss skifta». Det följande ordet är däremot okänt, men skulle kunna innehålla ordet <em>skið </em>som kan vara en beteckning på olika typer av plana trästycken, allt från ved till spjälor i grindar, vindskivor och t.o.m. skidor. »Låt oss byta ut spjälan» skulle det faktiskt kunna stå. Vänder man på benet och står där först <strong>skift</strong>, vilket kan betyda »Byt!». Därefter kommer en runföljd som är rätt förbryllande:<strong> lyst · kata · a · bein</strong>. Detta är skrivet med en annan hand och vad jag kan se är den enklaste tolkningen rent språkligt <em>Lȳst Kāta ā bæin</em>! »Slå Kåte på benet!». Vad detta ska betyda rent konkret vet vi däremot inte. Eftersom benet satt nedstucket i en tomtgräns ligger det nära till hands att det rör sig om någon ägorättslig överenskommelse eller en diskussion om något reparationsarbete, men den sista meningen går inte att få in ett sådant sammanhang. Kan det kanske istället handla om ett spel eller en lek, där det ristade benet hade en speciell funktion?</p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-3 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:60%">
<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">TROTS SIN TECKENFATTIGDOM</mark></strong> var den vikingatida runraden som vilket skriftsystem som helst – och den som hade tillägnat sig reglerna och tillämpade dem någorlunda konsekvent hade nog inga problem att göra sig förstådd. För oss sentida uttolkare kan det dock emellanåt bli nog så svårt, särskilt som vi inte känner hela ordförrådet eller de sammanhang som texterna har skapats i. Samtidigt är det fascinerande hur vi genom att använda samma principer som för tusen år sedan ändå kan läsa och till stora delar förstå dessa texter. Flera av dem har dessutom genomskådats först för några år sedan, vilket visar att det fortfarande går att göra upptäckter i detta material och förmodligen komma ännu längre!</p>
</div>



<div class="wp-block-column is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:40%"></div>
</div>
