Utan tvål till Miklagård

Hur stod det egentligen till med hygienarbetet på knarren och vad kallades det djurhuvud­formade spännet? Vi finkammar runinskrifter och andra språkliga källor på jakt efter den rena sanningen. DE ÄR ALLAHS smutsigaste varelser». Så lyder den arabiske resenären Ahmad Ibn Fadlans bekanta ord om de ruser som han mötte vid Volga och vars tillkortakommanden rörande […]


<p class="has-medium-font-size"><strong>Hur stod det egentligen till med hygienarbetet på knarren och vad kallades det djurhuvud­formade spännet? Vi finkammar runinskrifter och andra språkliga källor på jakt efter den rena sanningen.</strong></p>



<figure class="wp-block-image size-large is-resized"><img fetchpriority="high" decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-1.-Nicholas_Roerich_Guests_from_Overseas-1024x773.jpeg" alt="" class="wp-image-2603" width="839" height="633" srcset="https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-1.-Nicholas_Roerich_Guests_from_Overseas-1024x773.jpeg 1024w, https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-1.-Nicholas_Roerich_Guests_from_Overseas-300x226.jpeg 300w, https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-1.-Nicholas_Roerich_Guests_from_Overseas-768x579.jpeg 768w, https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-1.-Nicholas_Roerich_Guests_from_Overseas-1536x1159.jpeg 1536w, https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-1.-Nicholas_Roerich_Guests_from_Overseas.jpeg 2048w" sizes="(max-width: 839px) 100vw, 839px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Vapenföra vikingar på väg över vattnet. Målning av Nicholas K. Roerich, 1901. Foto: Wikimedia Commons</mark></strong></figcaption></figure>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DE ÄR ALLAHS</mark></strong> smutsigaste varelser». Så lyder den arabiske resenären Ahmad Ibn Fadlans bekanta ord om de ruser som han mötte vid Volga och vars tillkortakommanden rörande den personliga hygienen han beskriver mycket utförligt. Samtidigt kan man lätt förstå att månader vid årorna på de ryska floderna eller släpandet av båtar över land mellan strida forsar kan ha fått en och annan att ge avkall på renligheten.</p>



<p>   Om denna brist gällde vikingen generellt eller om Ibn Fadlan hade oturen att slå sig i slang med några notoriska lortgrisar är inte lätt att säga. Runinskrifterna tiger vanligtvis också om sådant.</p>



<p>   Det finns dock en speciell kategori av språkminnen som faktiskt kan ge en viss insikt, nämligen de karaktäriserande binamnen, som i mycket koncentrerad form ofta förmedlar en ögonblicksbild av namnbäraren. Ett sådant namn är <em>Ōþvaginn </em>»Otvagen», som förekommer på flera runstenar och som helt enkelt betyder ’den otvättade’. Om nu skandinaverna verkligen har varit så smutsiga som den arabiske resenären påstod så är detta binamn lite förvånande. Man måste då komma ihåg att det då som nu också kunde finnas ironi i denna typ av namngivning och att Otvagen kanske helt enkelt var den prydligaste av dem alla.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">PÅ EN RUNSTEN</mark></strong> i Rasbo utanför Uppsala förekommer ett namn skrivet <strong>þefa</strong>. Det var länge otolkat, men det kan vara bildat till det fornvästnordiska verbet <em>þefa </em>’lukta’ och det svenska dialektordet <em>täv </em>’elak lukt (av orenlighet eller hundar); stank’. Detta var i så fall en person som man kanske inte så gärna ville dela åra med.</p>



<p>   Ett inte ovanligt namn var <em>Kolbæinn </em>»Kolben», som betyder ’den som har mörka ben’. Namnforskaren Staffan Fridell har påpekat att detta måste bero på smuts som kom underifrån och menar att det ursprungligen bör ha syftat på någon som ägnade sig åt grävarbete av olika slag. Han tänker sig att namnet till och med från början kan ha varit ett trälnamn, vilket verkar mycket rimligt. Enligt Rigstula skulle ju trälen bland mycket annat gödsla åkrar och bryta torv.</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">Om nu skandinaverna verkligen har varit så smutsiga som den arabiske resenären påstod så är detta binamn lite förvånande.</mark></strong></p>
</blockquote>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DET ÄR MED</mark></strong> det ovan skrivna lätt att tro att vikingen har varit främmande för ett begrepp som <em>tvål</em>, men ordet är gammalt och bildat till verbet <em>två </em>(som i <em>rentvå</em>). Det förekommer i formen <em>þwahl </em>redan i gotiskan, där det betyder ’bad’. Välbekant är ju också att vårt lördag går tillbaka till ett fornsvenskt <em>løghar dagher</em> med betydelsen ’baddag’. Medan namnen på våra övriga vecko­dagar är tidiga översättningar av de romerska veckodagsnamnen har detta namn ingen motsvarighet utanför Norden. Enligt Elof Hellquist i <em>Svensk</em> <em>etymologisk ordbok</em> går det tillbaka »på bruket att på lördagarna taga ett bad och särskilt tvätta huvudet med lut», något som onekligen ger en helt ny dimension åt begreppet <em>facial cleansing</em>. Att en av våra veckodagar har fått namn efter denna aktivitet visar ju att man sedan järnåldern har ägnat sig åt mer avancerad kroppsvård åtminstone en gång i veckan.</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/Bild-2-edited-1.jpg" alt="" class="wp-image-2617" width="377" height="377" srcset="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-2-edited-1.jpg 850w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-2-edited-1-300x300.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-2-edited-1-150x150.jpg 150w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-2-edited-1-768x768.jpg 768w" sizes="(max-width: 377px) 100vw, 377px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Kammen från Vimose på Fyn i Danmark som är märkt med namnet Harja. Foto: Roberto Fortuna &amp; Kira Ursem/National­museet DK. Foto: Bengt A. Lundberg/Arkivsök RAÄ</mark></strong></figcaption></figure></div>


<p><mark class="has-inline-color has-luminous-vivid-orange-color"><strong>OM MAN FÅR</strong> </mark>tro arkeologins vittnesbörd verkar kammen vid sidan av kniven ha varit den käraste personliga ägodelen. Inte sällan bär dessa också runinskrifter. Den äldsta runinskrift som vi över huvud taget känner till är ristad på just en kam och kommer från det stora vapenofferfyndet i Vimose på Fyn i Danmark. Kammen dateras i dag till ca 160–200 e. Kr. och bär runorna <strong>harja</strong>. Troligen återger detta ett mansnamn <em>Harja</em>, som troligen betyder ’den som tillhör hären’, alltså en krigare. Rimligtvis rör det sig om varit kammens ägare. Visserligen finns i dagens finska ett ord harja som betyder ’borste’, men det ska enligt uppgift komma från proto-baltiska och är inget urnordiskt lånord som det ju annars finns en hel del av i finskan.</p>



<figure class="wp-block-image size-large"><img decoding="async" width="1024" height="295" src="https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-3.-s.-46-bild-2-DR-303-Lund-inskrift-DR-1024x295.jpg" alt="" class="wp-image-2605" srcset="https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-3.-s.-46-bild-2-DR-303-Lund-inskrift-DR-1024x295.jpg 1024w, https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-3.-s.-46-bild-2-DR-303-Lund-inskrift-DR-300x86.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-3.-s.-46-bild-2-DR-303-Lund-inskrift-DR-768x221.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-3.-s.-46-bild-2-DR-303-Lund-inskrift-DR-1536x443.jpg 1536w, https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-3.-s.-46-bild-2-DR-303-Lund-inskrift-DR-2048x590.jpg 2048w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">»Arngunn gav mig kammen». Inskriften på kammen från Lund. Efter Danmarks runeindskrifter. Foto: Bengt A. Lundberg/Arkivsök RAÄ</mark></strong></figcaption></figure>



<p></p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">INTE SÄLLAN HAR</mark></strong> man bara märkt kammen med ordet »kam» som om ägaren behövde påminnas om vad det var för tingest. Andra har tydligen varit mycket stolta över sin kam. På ett vikingatida kamfodral från Lincoln i England står med runor: <strong>kamb : koþan : kiari : þorfastr </strong>»En god kam gjorde Torfast». Namnet <em>Torfast </em>är särskilt vanligt på svenska runstenar, så det är mycket möjligt att det var en svensk som förlorade denna ägodel borta i England. Detta var något som man normalt inte ville råka ut för. Därför utgörs många av kaminskrifterna också av ägarmärkningar. På en kamskena från kvarteret Professorn i Sigtuna står det exempelvis:<strong> olafr a kab þ</strong>… <em>Ōlafʀ ā kamb þ</em>[<em>enna</em>] »Olav äger denna kam».</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/Bild-4.-s.-46-bild-3-Kam-fr†n-Sigtuna-edited-1.jpg" alt="" class="wp-image-2619" width="383" height="510" srcset="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-4.-s.-46-bild-3-Kam-fr†n-Sigtuna-edited-1.jpg 638w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-4.-s.-46-bild-3-Kam-fr†n-Sigtuna-edited-1-225x300.jpg 225w" sizes="(max-width: 383px) 100vw, 383px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Bysantinsk elfenbenskam funnen i ett hus från slutet av 1000-talet i kvarteret Trädgårdsmästaren i Sigtuna. Runorna kunt har inte fått någon definitiv tolkning. Foto: Bengt A. Lundberg/Arkivsök RAÄ</mark></strong></figcaption></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">VÅREN 1882 TOG</mark></strong> sig några arbetare för att gräva »efter gamla ben» på en tomt vid Prennegatan i Lund och fann på »två alnars djup» ett stort antal föremål. Arkeologen Sven Söderberg som nämner fyndet i ett brev 1883 skriver att »de hafva mycken likhet med Björkö­fynden, fastän de troligen äro ett par århundraden yngre». Bland de tillvaratagna föremålen finns en benkam med texten <strong>arngun × gaf × mær × kab</strong> »Arngunn gav mig kammen». Man ser nästan framför sig den omtänksamma hustrun som skänker sin man en kam att reda upp det lusiga och snoriga skägget med.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ÄVEN SÅDANT SOM</mark></strong> tvättfat har påträffats. Ett mycket känt exempel kommer från Kaupang i Norge, där det hade fått följa en kvinna i graven. Att bronsskålen verkligen har haft denna användning framgår av att den är försedd med en kort runinskrift där det står<strong> i muntlauku</strong>, det vill säga<em> í mundlaugu</em> »i handfatet». Ordet <em>mund </em>är nämligen ett gammalt ord för ’hand’, besläktat med latinets <em>manus</em>, medan <em>laug </em>betyder ’bad’ och är samma ord som ingår i <em>lördag</em>. Graven, som var en båtgrav med rika gravgåvor, har daterats till ca 850–950 och runorna tillhör kortkvistrunraden dvs. samma typ av runor som på Rökstenen.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">BETYDLIGT YNGRE – </mark></strong>snarast senmedeltida – är den bronsbunke som 1869 påträffades av några lekande barn vid stranden av Bråtorpssjön utanför Strängnäs i Södermanland. Endast en liten bit ska ha stuckit upp ur jorden, men metallens glimmande i solen väckte barnens intresse.</p>



<p>   Bunken finns nu på Sörmlands museum i Nyköping och bär inskriften <strong>mudløg </strong>eller <strong>muLløg</strong>, alltså en senare form av samma ord som finns på skålen från Kaupang. Ordet lever i formen mullöga ännu kvar i vissa svenska dialekter. Om man ska baka ostkaka på traditionellt vis i exempelvis Hälsingland gör man det i en kopparbunke som kallas just så och som även kan användas som handfat.</p>



<figure class="wp-block-image size-large"><img decoding="async" width="1024" height="536" src="https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-5.-s.-47.-S-330-Br†torp-bunke-Foto-Harald-Faith-Ell-1928-kopia-1024x536.jpg" alt="" class="wp-image-2614" srcset="https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-5.-s.-47.-S-330-Br†torp-bunke-Foto-Harald-Faith-Ell-1928-kopia-1024x536.jpg 1024w, https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-5.-s.-47.-S-330-Br†torp-bunke-Foto-Harald-Faith-Ell-1928-kopia-300x157.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-5.-s.-47.-S-330-Br†torp-bunke-Foto-Harald-Faith-Ell-1928-kopia-768x402.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-5.-s.-47.-S-330-Br†torp-bunke-Foto-Harald-Faith-Ell-1928-kopia.jpg 1280w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Bronsbunken från Bråtorp i Södermanland med den korta inskriften »handfat» i runor. Foto: Harald Faith-Ell, ATA</mark></strong></figcaption></figure>



<p></p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">LUSTIGT NOG SPELAR</mark></strong> just kam och handfat en särskild roll i Ibn Fadlans beskrivning av de begränsade hygieninsatser som hans rusiska bekantskaper trots allt ägnade sig åt:</p>



<p>   <em>Varje dag tvättar de ansikte och huvud i det smutsigaste och snuskigast tänkbara vatten. Det går till så, att varje morgon kommer en slavinna med ett handfat vatten. Hon räcker det åt sin herre, och han tvättar händerna, ansiktet och håret och reder ut det med en kam i handfatet. Sedan snyter han sig och spottar i vattnet, ja, det finns inget snusk som han inte gör i samma vatten. När han har gjort ifrån sig sitt, bär slavinnan handfatet vidare till nästa och han gör detsamma som kamraten. Och så bär hon det vidare från den ene till den andre tills det gjort sin rund till alla i huset. Och var och en snyter sig och spottar i handfatet och tvättar däri ansikte och hår.</em></p>



<p>   Att hålla just huvudet någorlunda rent var tydligen viktigt och det går ju igen i den av Hellquist omnämnda lutbehandlingen under en något senare tid.</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 hålla just huvudet någorlunda rent var tydligen viktigt.</mark></strong></p>
</blockquote>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ÄVEN DEN SOM</mark></strong> är lite smutsig kan vilja smycka sig. Här har Ibn Fadlan också en historia att berätta om hur ruserna köpte nya halsband åt sina kvinnor allteftersom de ökade sin förmögenhet. När runor har bevarats i andra material än sten är det ofta just på smycken och framför allt sådana som bars av kvinnor. Inskrifterna är inte alltid så genomskinliga eller upplysande. Under äldsta runtid, det vill säga romersk järnålder, utgörs de ofta av personnamn och företrädesvis av mansnamn, gissningsvis givaren av smycket.</p>



<p>   På en rosettfibula från Himlingøje på Själland står exempelvis <strong>widuhudaʀ</strong>, vilket ska utläsas som <em>Widuhundaʀ </em>och tolkas som ’skogshund’. Detta måste ju vara en omskrivning för ’varg’, men om mannen bar detta namn i det verkliga livet kan man fundera över. Var det kanske lukten …?</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ANDRA KAVALJERER KUNDE</mark></strong> vara lite mer verbala. På baksidan av ett påkostat reliefspänne från Eikeland i Norge står <strong>ek wiʀ wiwio writu i runoʀ͡asni</strong>, vilket enligt Ottar Grønvik ska tolkas som »Jag Vi skrev in runorna åt kärestan». Inskriften antas ha tillkommit under den första hälften av 500-talet.</p>



<p>   Från ett gravfält i Tuukkala i Södra Savolax i Finland kommer ett vikinga­tida spänne som har gjorts om till ett hänge och som på baksidan är försett med två runinskrifter. Den ena är en ägarmärkning <strong>heui a mik</strong> »Hägvi äger mig», medan den andra bara utgörs av kvinnonamnet <strong>botui </strong><em>Bōtvī</em>. Troligen har båda dessa kvinnor någon gång ägt smycket, och eftersom namnen slutar på <em>-vī</em> så kan man gissa att det handlar om mor och dotter.</p>



<p>   Spännet är av gotländsk tillverkning och av allt att döma har även inskrifterna tillkommit på Gotland. Namnlederna <em>Heg-</em> och <em>Bōt-</em> är nämligen särskilt vanliga på denna ö.</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/Bild-7.-s.-48-bild-2.-G-390-Tyrvalds-Klinte-sn-edited.jpg" alt="" class="wp-image-2620" width="384" height="384" srcset="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-7.-s.-48-bild-2.-G-390-Tyrvalds-Klinte-sn-edited.jpg 850w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-7.-s.-48-bild-2.-G-390-Tyrvalds-Klinte-sn-edited-300x300.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-7.-s.-48-bild-2.-G-390-Tyrvalds-Klinte-sn-edited-150x150.jpg 150w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-7.-s.-48-bild-2.-G-390-Tyrvalds-Klinte-sn-edited-768x768.jpg 768w" sizes="(max-width: 384px) 100vw, 384px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Dosformigt spänne från Tyrvalds i Klinte på Gotland, där Aude en gång ristade runor åt Bydny. Foto: Bengt A. Lundberg/Arkivsök RAÄ</mark></strong></figcaption></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">JUST FRÅN GOTLAND</mark></strong> kommer påfallande många vikingatida kvinnosmycken med runor. År 1899 inköpte Historiska museet ett antal fornsaker från en person bosatt i Hemse. Bland dessa fanns en bottenplatta till ett djurhuvudformat spänne med inskriften <strong>botui a kik argais sigtiir</strong>. Inledningen har tolkats som »Botvi i Arges äger mig …» Botvi är samma namn som förekommer på Tuukkalaspännet.</p>



<p>   Det finns bara en gård som heter Arges på Gotland och den ligger centralt i Hemse. Vi kan alltså vara rätt säkra på att detta föremål kommer från just denna socken. Frågan är däremot om det är riktigt att anta att <strong>kik </strong>är felristat för <strong>mik</strong>. I fornvästnordiskan förekommer nämligen ett ord <em>kengr </em>’bygel, krok’ och i senare tids isländska finns exempel på ett <em>kingur </em>som betyder just ’sölja’. Kanske är det en motsvarighet till detta ord som finns på det spännet och att <strong>kik </strong>ska i så fall istället utläsas som <em>keng </em>eller <em>king </em>(i runskrift behöver inte n skrivas ut framför <em>k</em>) och ha syftat på själva spännet.</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 finna samtida benämningar på olika smycke­typer är ganska fantastiskt, men många gånger spelar tidens tand oss ett spratt.</mark></strong></p>
</blockquote>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DET FINNS FLER</mark></strong> djurhuvudformiga spännen med runinskrifter från Gotland, och ett av dessa som hittades i en kvinnograv vid Bottarve i Fröjel bär endast runföljden <strong>kika</strong>. Här går tankarna till ordet <em>kinga </em>som i fornvästnordiskan kunde avse ett myntformat hänge eller ett bröstsmycke. Kanske var det på Gotland även benämningen på det för ön så karakteristiska djurhuvudformade spännet. Det borde i så fall vara själva fästanordningen som har varit namngivande.</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/2022/10/Bild-6.-s.-48-bild-1.-G-355-Djurhuvudformat-sp„nne-e1681321269318-1024x774.jpg" alt="" class="wp-image-2615" width="383" height="288" srcset="https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-6.-s.-48-bild-1.-G-355-Djurhuvudformat-sp„nne-e1681321269318-1024x774.jpg 1024w, https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-6.-s.-48-bild-1.-G-355-Djurhuvudformat-sp„nne-e1681321269318-300x227.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-6.-s.-48-bild-1.-G-355-Djurhuvudformat-sp„nne-e1681321269318-768x580.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-6.-s.-48-bild-1.-G-355-Djurhuvudformat-sp„nne-e1681321269318.jpg 1125w" sizes="(max-width: 383px) 100vw, 383px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Kallade gotlänningarna denna typ av spänne för kinga? Djurhuvudformat spänne från Gotland i Historiska museet i Lund.</mark></strong></figcaption></figure></div>


<p>   Något liknande finner man på ett praktfullt ringspänne från Hunterston i Skottland som bland annat bär runinskriften <em>Melbrigða á stilk</em> »Melbrigda äger spännet», där ordet <em>stilk </em>är samma ord som vårt svenska <em>stjälk </em>och bör syfta på nålen i spännet. Smycket är ett irländskt arbete tillverkat redan omkring år 700, medan inskriften är skandinavisk och tillkommen flera århundraden senare.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ATT PÅ DETTA</mark></strong> sätt finna samtida benämningar på olika smycketyper är ganska fantastiskt, men många gånger spelar tidens tand oss ett spratt. År 1981 uppmärksammades exempelvis en tidigare okänd runinskrift på ett dosformigt spänne från Tyrvalds i Klinte på Gotland som hade funnits i Historiska museets samlingar sedan 1907 och där man kunde läsa: <strong>auþi × risti × runaʀ × a uir&#8211; × byþnuiaʀ</strong> »Aude ristade runor på Bydnys <strong>uir&#8211;</strong>.» Den ofullständiga runföljden borde ha gett oss den samtida beteckningen på denna spännetyp, men på grund av de två oläsliga runorna på slutet blir vi tyvärr snuvade på den upplysningen.</p>



<p>   Så är det tyvärr alltför ofta när det handlar om runinskrifter.</p>



<figure class="wp-block-image size-large"><img decoding="async" width="867" height="1024" src="https://elbilen.se/wp-content/uploads/sites/3/2022/10/Namnlost-1-2-867x1024.jpg" alt="" class="wp-image-2610" srcset="https://elbilen.se/wp-content/uploads/sites/3/2022/10/Namnlost-1-2-867x1024.jpg 867w, https://elbilen.se/wp-content/uploads/sites/3/2022/10/Namnlost-1-2-254x300.jpg 254w, https://elbilen.se/wp-content/uploads/sites/3/2022/10/Namnlost-1-2-768x907.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2022/10/Namnlost-1-2.jpg 1298w" sizes="(max-width: 867px) 100vw, 867px" /></figure>
