Till bords med Balle

Att börja tala om forntida matskribenter är väl kanske lite överdrivet, men tack vare runskriften kan vi få en unik inblick i våra förfäders kulinariska upplevelser och matäventyr. VID BROÖVERFARTEN VID Rörebro i Nöttja i Småland står en runsten som Assur låtit resa till minne av sin fader Önd. Fadern får där ett vackert eftermäle […]


<p class="has-medium-font-size"><strong>Att börja tala om forntida matskribenter är väl kanske lite överdrivet, men tack vare runskriften kan vi få en unik inblick i våra förfäders kulinariska upplevelser och matäventyr.</strong></p>



<div class="wp-block-columns are-vertically-aligned-top is-layout-flex wp-container-core-columns-is-layout-3 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-vertically-aligned-top is-layout-flow wp-block-column-is-layout-flow">
<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">VID BROÖVERFARTEN VID</mark></strong> Rörebro i Nöttja i Småland står en runsten som Assur låtit resa till minne av sin fader Önd. Fadern får där ett vackert eftermäle på vers som har översatts på följande sätt av Ragnar Kinander i Smålands runinskrifter:</p>



<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:50%">
<p>»Han var minst bland<br />män en gnidare (~ niding),<br />ej snål på mat<br />eller snar till hämnd.<br />På sin Gud<br />den gode trodde.»</p>
</div>
</div>



<p>En mil rakt österut från denna plats ligger Ivla i Södra Ljunga. Intill vägen som går genom byn och på det gamla bygravfältet står en delvis skadad runsten, där får den döde Sven har fått detta eftermäle:</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>mildan við sinna<br />ok mataʀ gōðan,<br />ī orðlōfi<br />allra miklu.</em></p>



<p>»mild mot sitt folk,<br />frikostig på mat,<br />av alla<br />mycket prisad.»</p>
</div>
</div>
</div>



<div class="wp-block-column is-vertically-aligned-top is-layout-flow wp-block-column-is-layout-flow">
<figure class="wp-block-image size-full"><img fetchpriority="high" decoding="async" width="617" height="850" src="https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-1.-6.jpg" alt="" class="wp-image-2434" srcset="https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-1.-6.jpg 617w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-1.-6-218x300.jpg 218w" sizes="(max-width: 617px) 100vw, 617px" /><figcaption class="wp-element-caption"><strong><mark><mark style="background-color:#ffffff" class="has-inline-color">Balles runsten vid Västra Väppeby i Veckholm. Inskriften lyder: »Åsvi lät resa denna sten efter Arnulv, sin gode son. Han bodde här [i Väppeby], en gästfri och vältalig man.» Foto: Nils Lagergren/ATA</mark></mark></strong></figcaption></figure>
</div>
</div>



<p>Båda dessa runstenar finns i Småland och det tydligt att gästfrihet och givmildhet här var uppskattade egenskaper. Inte minst var det viktigt för dem som färdades på vägarna och som behövde mat och möjlighet till övernattning. Eftersom runstenarna var offentliga monument som restes just intill färdvägarna, måste inskrifter av denna typ nästan ha uppfattats som ett löfte om att god förplägad även var att vänta från dem som nu bebodde gården.</p>


<div class="wp-block-image">
<figure class="alignright size-full is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-2.-5.jpg" alt="" class="wp-image-2435" width="368" height="491" srcset="https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-2.-5.jpg 638w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-2.-5-225x300.jpg 225w" sizes="(max-width: 368px) 100vw, 368px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Runstenen vid Rörebro i Nöttja, rest efter den gästfrie smålänningen Önd. Foto: Magnus Källström/RAÄ</mark></strong></figcaption></figure></div>


<p>   I Uppland där ju runstenarna är mångdubbelt fler än i Småland är texter av denna typ förhållandevis ovanliga. Runristaren Balle, som främst höll till på Trögden söder om Enköping har dock efterlämnat ett par inskrifter med snarlikt innehåll. Den ena stenen står vid Västra Väppeby i Veckholm, där vi får veta att Arnulv som tidigare ägde gården var <em>mandr mataʀ gōðr ok māls risinn</em> »en man, frikostig på mat och vältalig». Här hade nog den besökte gården både kunnat få god mat och något tänkvärt att lyssna på. Gästfriheten uttrycktes som synes gärna med uttrycket <em>mataʀ gōðr</em>, en fras som även förekommer i eddadikten Hávamál och som ordagrant betyder ’god med hänsyn till mat’.</p>



<p>   Att stå för motsatsen – att vara <em>matar illr</em> (där <em>illr </em>betyder ’ond’) – var inte oväntat en mindre uppskattad egenskap. Om den norske kungen Halvdan, Östens son, berättar Snorre i Ynglingasagan att han kallades <em>Hálfdan inn mildi ok matarilli</em> (»den givmilde och matsnåle»). Det sägs nämligen att han gav sina män guldmynt som andra delade ut silvermynt, men när det kom till maten fick de av någon anledning svälta.</p>



<p>   Detta har nog inte gällt den kung en gång residerade i Sigtuna och som finns omnämnd på det så kallade kungabenet, som kom i dagen i samband med undersökningarna i kvarteret Trädgårdsmästaren 1988–90. Här lyder de två inledande meningarna på benets ena sida <strong>kunukr : iaʀ : matr : bestr : han : afmest</strong>, vilket först tolkades som <em>Konungʀ eʀ mataʀ bæztr. Hann gaf mæst </em>»Kungen är frikostigast med mat. Han gav mest». Detta sågs som ett uttryck för den gästfrie och givmilde konungen. Även om tolkningen inte alls är omöjlig, tror man numera istället att meningen är <em>Konungʀ eʀ mandr bæztr. Hann ā fē mæst</em> »Kungen är den bäste mannen. Han äger mest rikedom», vilket ju är något annat. Samtidigt ska man nog räkna med att denna inskrift har tillkommit under ett gästabud, där kungen åtminstone har varit andligen närvarande. Själva skrivunderlaget har säkerligen ursprungligen varit matavfall och det gäller nog de flesta av de runben, som brukar hittas vid arkeologiska undersökningar. Här blir det alltså osteologens och inte runologens uppgift att avgöra vad som stod på menyn.</p>



<figure class="wp-block-image size-large"><img decoding="async" width="1024" height="427" src="https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-3.-Sl-37-Runben-Sigtuna-e1681228936782-1024x427.jpg" alt="" class="wp-image-2436" srcset="https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-3.-Sl-37-Runben-Sigtuna-e1681228936782-1024x427.jpg 1024w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-3.-Sl-37-Runben-Sigtuna-e1681228936782-300x125.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-3.-Sl-37-Runben-Sigtuna-e1681228936782-768x321.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-3.-Sl-37-Runben-Sigtuna-e1681228936782.jpg 1090w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Runbenet från Sigtuna med den nästan självklara upplysningen rif nauts »nötkreaturets revben» Foto: Bengt A. Lundberg/RAÄ Arkivsök</mark></strong></figcaption></figure>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">JUST FRÅN SIGTUNA</mark></strong> finns ett par runinskrifter som ändå skvallrar om en del av kosthållet. På ett revben från kvarteret Ödåker står <strong>rif : naut͡s</strong>, vilket betyder »nötkreaturets revben». Ett annat ben från kvarteret Professorn bär tre bindrunor med en lönnskrift, som rätt dechiffrerad ger <strong>aul kut </strong>det vill säga <em>ǫl gott</em> »gott öl»! Detta visar att det under vikingatiden har funnits både revbensspjäll och fullt drickbart öl att tillgå längs Stora gatan i Sigtuna.</p>


<div class="wp-block-image">
<figure class="alignright size-full is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-5.-Frisisk-kanna-H.-Faith-Ell-SHM.jpg" alt="" class="wp-image-2438" width="326" height="414" srcset="https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-5.-Frisisk-kanna-H.-Faith-Ell-SHM.jpg 668w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-5.-Frisisk-kanna-H.-Faith-Ell-SHM-236x300.jpg 236w" sizes="(max-width: 326px) 100vw, 326px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">En så kallad frisisk kanna från en av Birkas gravar. Teckning: Harald Faith-Ell/SHM</mark></strong></figcaption></figure></div>


<p>   Ett par av Sigtunas runstenar är också resta av en grupp som kallar sig <em>Frīsa gildaʀ</em> »Frisernas gillesbröder». Friserna var kända som handelsmän och ett gille var en sammanslutning för ömsesidig hjälp och beskydd. Att det inom det inom frisergillet förekom sammankomster med både mat och dryck kan vi nog räkna med. De båda runstenarna är signerade av en runristare vid namn Torbjörn och de har ett snarlikt utseende, där mittytan domineras av ett likarmat så kallat Sankt Georgekors. Kanske har detta kors använts som en sorts symbol för just detta gille. Ett lustigt sammanträffande är att samma typ av kors även förekommer på så kallade frisiska kannor eller Tatingerkannor, som har påträffats bland annat i Birka, men dessa är flera århundraden äldre än Sigtunarunstenarna. I Sigtuna finns denna typ av kors också på en fragmentarisk runsten som sitter inmurad högt upp i Sankt Olofs ruin. Inskriften innehåller bland annat ordet <em>matunautr</em>, som betyder ’matlagskamrat, följeslagare’. Ristningstekniken och runformerna visar att stenen måste vara ristad av Torbjörn och det är inte osannolikt att den har tillkommit på initiativ av någon i frisergillet.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">OM SJÄLVA ANSKAFFANDET</mark></strong> av födoämnen får vi troligen en glimt av på ett runben som har påträffats i den slaviska marknadsplatsen Starigard/Oldenburg i Ostholstein vid Östersjökusten. På den ena sidan av benet står nämligen: <strong>…-ak : eigi : ha : a : hafi : uti : heltr : tak : hu…</strong>, vilket har uppfattats som: <em>Tak æigi hā ā hafi ūti, heldr tak</em> … »Tag inte haj ute på havet, ta hellre …» Tyvärr är benet avbrutet i mitt inne i ett ord och vad skribenten önskade sig på tallriken istället för haj går inte längre att avgöra. Möjligen var det val.</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.-U-385-Sankt-Olofs-ruin-edited-1.jpg" alt="" class="wp-image-2448" width="526" height="295" srcset="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-4.-U-385-Sankt-Olofs-ruin-edited-1.jpg 850w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-4.-U-385-Sankt-Olofs-ruin-edited-1-300x169.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-4.-U-385-Sankt-Olofs-ruin-edited-1-768x432.jpg 768w" sizes="(max-width: 526px) 100vw, 526px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Runstenen i muren till Sankt Olofs ruin i Sigtuna. Den fragmentariskt bevarade inskriften lyder: »… denna sten efter Grimulv, (sin) matlagskamrat …» Foto: Magnus Källström/RAÄ</mark></strong></figcaption></figure></div>


<p>   En som byggde upp ett förråd av färsk fisk på betydligt närmare håll var norrmannen Eilífr Elgr på gården Li i Gausdal i Oppland fylke. Här fanns kring sekelskiftet 1800 en runsten, som nu sedan länge är försvunnen, men som lyckligtvis avbildades av bland annat den kringvandrande botanikern och fornforskaren Martin Friedrich Arendt. Inskriften löd enligt denne: <strong>ailifr × alkr × bar × fiska × i × rauþu × sio × </strong>»Eilífr Elgr bar fiskar i Raudsjøen». Eilífr hade alltså planterat ut fisk i den rimligtvis tidigare fisklösa sjön och velat markera sin rätt till detta fiske genom att hugga in det i sten. Runstenen ska enligt Arendt också ha haft sin plats på gårdens gravbacke.</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">Annars är det bland formelorden på de folkvandringstida guldbrakteaterna som mer eller mindre ät- eller drickbara ting verkar uppenbara sig.</mark></strong></p>
</blockquote>


<div class="wp-block-image">
<figure class="alignleft size-full is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-6.-Tunesteinen-KHM-edited.jpg" alt="" class="wp-image-2449" width="341" height="454" srcset="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-6.-Tunesteinen-KHM-edited.jpg 517w, https://elbilen.se/wp-content/uploads/sites/3/2023/04/Bild-6.-Tunesteinen-KHM-edited-225x300.jpg 225w" sizes="(max-width: 341px) 100vw, 341px" /><figcaption class="wp-element-caption">Den urnordiska runstenen från Tune i Østfold i Norge, rest till minne av Wōdurīdaʀ som stod för brödet. Foto: James Knirk/KHM Unimus</figcaption></figure></div>


<p>   Man skulle kunna tro att de urnordiska runinskrifterna som till stor del utgörs av gravinskrifter skulle vara fria från uppgifter om födoämnen, men så är det faktiskt inte. Den imponerande Tunestenen, som i dag finns att beskåda på Kulturhistorisk museum i Oslo, är tillägnad en man vid namn Wōdurīdaʀ av Wiwaʀ som kallar honom <strong>witad͡ah͡alaiban</strong>. Detta ska utläsas som ett urnordiskt <em>witandahlaiban </em>och betyder ’den som ger akt på brödet’ det vill säga sörjer för brödet. Det ska förmodligen tolkas som att Wōdurīdaʀ var Wiwaʀs husbonde. Det kan i detta sammanhang erinras om att det engelska <em>lord </em>ursprungligen går tillbaka på ett fornengelskt <em>hlāfweard </em>med betydelsen ’brödväktare’. Samma ord för bröd fanns även i gotiskan, där det hade formen <em>hlaifs</em>. På urnordiska bör det ha lytt *<em>hlaibaʀ</em>, vilket under vikingatiden utvecklades till *<em>hlæifʀ </em>och i fornsvenskan till <em>lever</em>. Ordet håller faktiskt än i dag en plats i Svenska akademiens ordlista i formen lev med betydelsen ’avlångt bröd’.</p>



<p>   Annars är det bland formelorden på de folkvandringstida guldbrakteaterna som mer eller mindre ät- eller drickbara ting verkar uppenbara sig. Oomtvistat är det urnordiska <em>laukaʀ </em>som helt enkelt betyder ’lök’. Mer mångtydig är runföljden alu, som bland annat har tolkats som en utveckling av ordet *<em>aluþ</em>&#8211; ’öl’ och som en verbform <em>alu </em>med betydelsen ’jag ger kraft’.</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/2022/08/Bild-7.-Vg-134-Kinneveds-pr„stg†rd-foto-MK-1024x768.jpg" alt="" class="wp-image-2440" width="354" height="266" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Den lilla stenen med urnordiska runor från Kinneveds prästgård i Västergötland. FOTO: MAGNUS KÄLLSTRÖM/RAÄ</mark></strong></figcaption></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">PÅ VÄSTERGÖTLANDS MUSEUM</mark></strong> i Skara finns en liten märklig sten, som påträffades redan 1843 i en åker tillhörande prästgården i Kinneved. Stenen som bara är något större än en vanlig tändsticks­ask bär inskriften …<strong>siʀaluh</strong>, där det nämnda ordet <em>alu</em> ser ut att ingå. Den lika idérike som fantasifulle runologen Ottar Grønvik föreslog 1987 att det ursprungligen kunde ha stått (<em>krā</em>)<em>siʀ alu-h</em>, vilket skulle betyda »läckra maträtter och öl». Han tänkte sig att stenen ursprungligen hade haft sin plats inne i en grav och att texten antingen handlade om de gravgåvor som hade följt med den döde i graven eller om det som man hoppades att denne skulle mottas med i det hinsides livet. Tankarna går här direkt till de gotländska bild­stenar, som bär en bild av en ryttare som anländer till Valhall och där möts av en kvinna som bär ett dryckeshorn och ibland även andra mer svåridentifierade föremål. På en runbildsten från Levide kyrka har en av personerna ett dryckeshorn, medan den andra håller i något som bör vara en brödkaka.</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/2022/08/Bild-8.-G-77-Levide-kyrka-Edle-1936-ATA-1024x730.jpg" alt="" class="wp-image-2441" width="352" height="251" srcset="https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-8.-G-77-Levide-kyrka-Edle-1936-ATA-1024x730.jpg 1024w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-8.-G-77-Levide-kyrka-Edle-1936-ATA-300x214.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-8.-G-77-Levide-kyrka-Edle-1936-ATA-768x548.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-8.-G-77-Levide-kyrka-Edle-1936-ATA.jpg 1192w" sizes="(max-width: 352px) 100vw, 352px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Med öl och bröd, vagn och vovve på väg till andra sidan. Stenen kommer från Levide kyrka, men kan ses på Gotlands museum. Foto: Alfred Edle/ATA</mark></strong></figcaption></figure></div>


<p>   Grønviks tolkning faller dock på att det på sin höjd kan saknas en runa på stenen från Kinneved och att inskriften därför aldrig kan ha haft den form som han antog. Vi får alltså glömma idén att det här skulle ha nämnts något tilltugg till ölet.</p>



<p>   Att runinskrifternas <strong>alu </strong>i första hand bör ha syftat på öl visar däremot ett litet lerkärl som påträffades vid undersökningen av en järnåldersby i Uglvig utanför Esbjerg på Sydjylland. I samband med registreringen av fynden från denna grävning 2019 upptäcktes just dessa runor inristade på bottnen. Lerkärlet antas vara en efterlikning av de exklusiva dryckeskärl av glas som under samma period importerades från Rhenområdet till Norden.</p>


<div class="wp-block-image">
<figure class="alignleft size-full is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-10.-Kirk-Andreas-Isle-of-Man-foto-MK.jpg" alt="" class="wp-image-2443" width="345" height="460" srcset="https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-10.-Kirk-Andreas-Isle-of-Man-foto-MK.jpg 638w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-10.-Kirk-Andreas-Isle-of-Man-foto-MK-225x300.jpg 225w" sizes="(max-width: 345px) 100vw, 345px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Sigurd Fafnesbane steker drakhjärta och bränner sig på tummen. Detalj från runristningen på Ramsundsberget utanför Eskilstuna. Foto: Bengt A. Lundberg/RAÄ Arkivsök</mark></strong></figcaption></figure></div>


<p>   Även andra formelord på guldbrakteaterna som Lellingebrakteatens <strong>salusalu </strong>kan syfta på sådant som var möjligt att förtära. Enligt en tolkning kan det röra sig om samma ord som under vikingatiden hette <em>sǫl </em>och var beteckningen på en sorts ätbar tång. Det var denna havsväxt som Torgärd lurade i sin far Egil Skallagrimsson, när han varken ville äta eller dricka, vilket gjorde honom så törstig att han till och med drack mjölk! Denna typ av tång finns även längs den svenska västkusten och går då under namnet <em>söl</em>, vilket är samma ord som i isländskan.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">OM SJÄLVA MATLAGNINGEN</mark></strong> ger runstenarna få upplysningar, om man undantar tillredningen av drakhjärta, vilket flera gånger finns skildrat i bild. Välbekant är framställningen på Ramsundsristningen utanför Eskilstuna, där Sigurd Fafnesbane steker draken Fafners hjärta på ett spett över öppen eld. Det ser här ut som om »livsmuskeln» – <em>fjǫrsegi </em>som den kallas i eddadikten Fafnismál – anrättas i ett enda stycke. Annorlunda är den bild av samma händelse som skildras på ett stenkors från Kirk Andreas på Isle of Man, men också i bildframställningar i flera norska stavkyrkor. Här är drakhjärtat uppdelat i mer bekväma ringformiga portionsbitar som har trätts upp på spettet. Detta tillagningssätt har tydligen även varit bekant i Sverige. Ganska nyligen har nämligen Sigmund Oehrl upptäckt att ett motsvarande motiv också finns på en fragmentarisk sten från Glanshammars kyrka i Närke.</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/2022/08/Bild-9.-S-101-detalj-1024x683.jpg" alt="" class="wp-image-2442" width="363" height="243" srcset="https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-9.-S-101-detalj-1024x683.jpg 1024w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-9.-S-101-detalj-300x200.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-9.-S-101-detalj-768x512.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-9.-S-101-detalj.jpg 1275w" sizes="(max-width: 363px) 100vw, 363px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Drakhjärta på västnordiskt vis. Sigurds häst Grane och namnlös fågel övervakar tillagningen. Bilden finns på ett stenkors i Kirk Andreas på Isle of Man. Foto: Magnus Källström/RAÄ</mark></strong></figcaption></figure></div>


<p>   De medeltida runinskrifterna är ofta mer varierande än dem vi finner från vikingatiden. Framför allt gäller det mängden av vardagliga inskrifter i trä och ben som har framkommit i kulturlagren under norska medeltidsstäder som Bergen, Trondheim, Tønsberg och Oslo. En mycket framträdande fyndkategori är här så kallade märklappar av trä, vilka fästes eller stacks in i olika typer av varuförsändelser och som bar ägarens namn. Det kan stå sådant som <strong>kunar a</strong> »Gunnar äger», <strong>þura a mik</strong> »Tora äger mig» eller <strong>sikmuntr a sæk þena</strong> »Sigmund äger denna säck». Ibland står det bara ett namn eller en förkortning. Vad som transporterades får vi sällan veta, men man tror att här många gånger handlade om torrfisk.</p>


<div class="wp-block-image">
<figure class="alignleft size-full is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-13.-11-M„rklapp-fr†n-Bergen-e1681230007206.jpg" alt="" class="wp-image-2446" width="245" height="658" srcset="https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-13.-11-M„rklapp-fr†n-Bergen-e1681230007206.jpg 267w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-13.-11-M„rklapp-fr†n-Bergen-e1681230007206-112x300.jpg 112w" sizes="(max-width: 245px) 100vw, 245px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Märklapp från Bergen med inskriften botlaifr a »Botlaiv äger». Namnet och runformerna tyder på att han har varit gotlänning. Foto: Bengt A. Lundberg/RAÄ Arkivsök</mark></strong></figcaption></figure></div>


<p>   En som hade otur med sina affärer var Tore Fager, som i början av 1300-talet sände ett långt och ofta citerat runbrev till sin kompanjon Havgrim. Texten är ristad på en 25 centimeter lång fyrkantig träpinne, där han utförligt redogör för sin svåra belägenhet: <em>Mart skortir mik, félagi! Ekki er mungátit, eingi fiskarnir. Vil ek at þú vitir, en eigi kref þú </em>»Mycket saknas mig, kamrat! Inte har jag fått tag i ölet, inte i fiskarna. Jag vill att du vet det, och inte kräver mig.» Trots dessa uppenbara misslyckanden drar sig inte Tore för att i nästa andetag be sin affärskollega att skicka några handskar samt hjälpa en kvinna som heter Sigrid, ifall hon skulle behöva något.</p>



<p>   Bättre gick det kanske med den försändelse som Torkel myntmästare skickade till en okänd adressat. Följebrevet som även här utgörs en tillskuren träpinne, bär det korta meddelandet: <strong>þo͡rkæl myntære sender þer pipar</strong> »Torkel myntmästare sänder dig peppar». Fyndet har på arkeologiska grunder daterats till ca 1200 och lär vara det äldsta kända omnämnandet av denna krydda i en nordisk källa.</p>



<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">RUNSKRIFTENS SISTA UTLÖPARE</mark></strong> finns som bekant i Övre Dalarna – i Mora och Älvdalens socknar. Här etablerade sig under 1500-talet en speciell variant av runor, de så kallade dalrunorna, som vari bruk i denna landsända fram till början av 1900-talet. Eftersom många av inskrifterna finns på olika typer av husgeråd, framför allt träskålar, är det inte konstigt att texterna ibland kommer att handla om mat.</p>



<p>   Från Billingsbodarna i Älvdalen kommer ett träbord som i dag står i en av byggnaderna på hembygdsgården Rots skans, och där man förutom en rad initialer och datumet den 11 juli 1730 kan läsa: »Här går mycken mat på detta bordet. Väles (dvs. lycklig) den som hade så mycket. Amen.» Ordet <em>går</em> används här i betydelsen ’ryms’ och behöver inte alls betyda att bordet var särskilt välfyllt då runorna tillkom.</p>


<div class="wp-block-image is-style-default">
<figure class="alignleft size-full is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-12.-Hykie-sk†l.jpg" alt="" class="wp-image-2445" width="332" height="332" srcset="https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-12.-Hykie-sk†l.jpg 849w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-12.-Hykie-sk†l-300x300.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-12.-Hykie-sk†l-150x150.jpg 150w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-12.-Hykie-sk†l-768x769.jpg 768w" sizes="(max-width: 332px) 100vw, 332px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Runorna på skålen från Hykie i Dalarna. Foto: Göran Svärdström/ATA</mark></strong></figcaption></figure></div>


<p>   På den västra sidan av Vanån i Älvdalen fanns en numera förstörd kölbod – en typ av vindskydd, där skogvaktaren Per Backlund år 1890 skrev av en längre inskrift med dalrunor. Den lyder i översättning: »Här har vi varit och gjort Säboden i juli 1681. I stor brist och regn så hade vi barkbröd och någon benig abborre att äta.»</p>



<p>   Från en bebyggelse med det passande namnet Grötgården i Gåsvarv i Älvdalen kommer en träskål med inskriften: »Mor, giv mig litet grötsovel i denna skålen. C(arin) E(rs)d(otter) 1820.» Med »grötsovel» avses det som man åt till gröten som långmjölk, smör eller bärmos.</p>



<p>I Nordiska museets samlingar förvaras en skål av björk från Hykie by, där undersidan bär en lång och ovanligt informativ inskrift. Här får vi inte bara veta namnet på skålens upphovsman, utan också när, var och hur den har tillkommit och vad den var ämnad att innehålla:</p>



<p>   »Mats Hindersson har gjort denna skålen. Hykie by datum den 9 september – (han har) huggit (den) i Persgrav utav stubben – anno år 1704. Å, Gud give, att den skall vara full och aldrig gärna tom med god, skön och söt grädde! Sedan vore det mycket bra.»</p>



<p>   Visst blir man lite hungrig?</p>



<figure class="wp-block-image size-large is-resized"><img decoding="async" src="https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-11.-Dv-Rv74-Billingsbodarna-foto-S-G-Hallonquist-1024x682.jpg" alt="" class="wp-image-2444" width="-61" height="-40" srcset="https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-11.-Dv-Rv74-Billingsbodarna-foto-S-G-Hallonquist-1024x682.jpg 1024w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-11.-Dv-Rv74-Billingsbodarna-foto-S-G-Hallonquist-300x200.jpg 300w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-11.-Dv-Rv74-Billingsbodarna-foto-S-G-Hallonquist-768x512.jpg 768w, https://elbilen.se/wp-content/uploads/sites/3/2022/08/Bild-11.-Dv-Rv74-Billingsbodarna-foto-S-G-Hallonquist.jpg 1276w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Bordet från Billingsbodarna i Älvdalen med en förhoppningsfull önskan om mera mat. Foto: Sven-Göran Hallonquist/RAÄ Runverket</mark></strong></figcaption></figure>
