Från sälparkas till sidendräkt


<p class="has-medium-font-size wp-block-paragraph"><strong>Kortkort och kaftaner, sälskinn och siden, pepitarutor och peplos – få plagg är bevarade från vår forntid, men de som finns kvar ger en svindlande inblick i dåtidens mode.</strong></p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-2.-Egtvedpigans-grav-1024x386.jpg" alt="" class="wp-image-2537" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Egtvedflickan ”En exotisk tempeldansare” var slutsatsen när Egtvedflickan upptäcktes 1921, men sannolikt är hon klädd i en högtidsdräkt. Foto: Lennart Larsen, Nationalmuseet Köpenhamn</mark></strong></figcaption></figure>


<div class="wp-block-image">
<figure class="alignleft size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-1.-vendeltida-kvinnordrakt.jpg" alt="" class="wp-image-2536" width="351" height="497" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Mycket få spår finns kvar av vendeltida kläder. Cheyenne Olander har gjort denna rekonstruktion bland annat genom att studera guldgubbar”. Spännena är från Aska i Östergötland, flätorna i manteln är inspirerade från Högomhövdingens mantel och peplosen som är färgad med krapp har sin förlaga bland annat i Huldremosefyndet. Foto: Björn Falkevik</mark></strong></figcaption></figure>
</div>


<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DET ÄR NÅGOT</mark></strong> visst med forntida plagg som be­varats. Tänk på alla oräkneliga vantar, kjolar och byxor som förmultnat – och sedan denna lilla, lilla spillra ur klädeskistorna som ännu finns kvar. Därför är det en särskild känsla att betrakta en dräkt som sytts för flera tusen år sedan – den borde ju egentligen inte existera, det är som att tiden stannat.</p>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">I GRAVARNA PÅTRÄFFAS</mark></strong> oftast bara dekorationer som prytt kläderna, som pärlor av djurtänder, dräktnålar och spännen. Men under mycket speciella omständigheter bevaras skinn och textilier. Oftast rör det sig om fynd som legat i syrefattig miljö, som exempelvis i mossar och i gravhögar av torv.</p>



<p class="wp-block-paragraph">   Hur man klädde sig i Norden under vår äldsta historia vet vi inte, men Ötzis över 5&nbsp;000 år gamla dräkt (som vi skriver om på sidan 30) ger en god inblick i hur olika sorters skinn användes. Plaggen skulle inte bara värma – de skulle vara snygga också. Under jägarstenåldern gillade man att pryda kläderna med pärlor tillverkade av djurtänder, bland annat från kronhjort, björn, vildsvin, älg och säl (vilka också indikerar vad kläderna var tillverkade av för skinn). I en del kvinnogravar från den 7&nbsp;000 år gamla boplatsen Skateholm i Skåne ligger pärlor av djurtänder på ryggen i höjd med höften. Det har tolkats som spåren efter dekorerade bälten.</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/Namnlost-2-1024x676.png" alt="" class="wp-image-2562" width="347" height="229" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Till vänster: Den 4500 år gamla kvinnliga lerfigurinen från Tråsättra i Åkersberga bär topp och kjol. </mark></strong><br /><strong><mark class="has-inline-color has-black-color"><br />Till höger: Det kan vara en pälskantad huva som syns kring denne säljägares ansikte. Lerfigurin från Tråsättra i Åkersberga. Foto: Niclas Björck, Arkeologerna/SHMM</mark></strong></figcaption></figure>
</div>


<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">NÅGRA TUSEN ÅR </mark></strong>senare kan små lerfiguriner säga något om klädseln. De tillverkades under bondestenåldern av säljägare som tillhörde den gropkeramiska kulturen (3400–2300 f. Kr). Streck och prickar kring figurernas ansikten ser ut som en pälskantad huva. Vissa bär en v-ringad tröja, på andra syns en sicksacklinje på bröstet som kan föreställa en snörning. En kvinnlig figur bär kjol och topp. Kanske prydde man sitt huvud med fjädrar också, en del av lerfigurerna har nämligen gropar i hjässan där sådana kan ha varit nedstuckna. Eftersom säl stod på gropkeramikernas meny så gott som varje dag, kan man utgå ifrån att många plagg tillverkades av just säl­skinn – även om de också jagade många andra pälsdjur.</p>



<p class="wp-block-paragraph">   På den gropkeramiska boplatsen Ajvide på Gotland syns spår av öns mode i gravarna. Kvinnor kunde bära ett slags bikinibyxor tillverkades av genomborrade djurtänder. Vackert utskuren pärlemor från en snäcka har kanske prytt ett bälte. En kvinna har burit en mössa tillverkad av taggigt igelkottsskinn, medan män kunde gå omkring i plagg som i knähöjd prytts med dubbla rader av sältänder. Kanske rör det sig om en värmande skinnparkas?</p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-5.-Skrydstrupkvinnan-1024x394.jpg" alt="" class="wp-image-2540" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Den unga damen i Skrydstrup begravdes cirka 1300 f. Kr. i en hellång dräkt. Foto: Roberto Fortuna och Kira Ursem, Nationalmuseet Köpenhamn</mark></strong></figcaption></figure>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph" style="font-size:30px"><strong><em><mark class="has-inline-color has-luminous-vivid-orange-color">Inget slår de välbevarade ekkiste­gravarna i danska torvhögar, från dem kommer sex välbevarade dräkter.</mark></em></strong></p>
</blockquote>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DE ÄLDSTA BEVARADE</mark></strong> textilierna i Skandinavien är 6&nbsp;000 år gamla snoddar av växtfibrer. I Sverige har vi ungefär lika gamla spår av snören, åtminstone avtryck av sådana på keramik som våra första bönder tillverkade. Men kompletta dräkter av textil finner vi först under bronsåldern (1700–500 f. Kr.) och då får vi vända oss till Danmark, för i svenska gravhögar finns bara ynka fragment kvar.</p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/10/3-335x1024.jpg" alt="" class="wp-image-3244" width="218" height="667" /></figure>
</div>


<p class="wp-block-paragraph">   Inget slår de välbevarade ekkistegravarna i danska torvhögar, från dem kommer sex välbevarade dräkter. När Egtvedflickan begravdes, troligen sommaren år 1370 f. Kr., bar hon en navelkort tröja och en kortkort snörkjol. Ylletröjan är tillskuren på samma sätt som skinnkläder, vilket kan tyda på att den som tillverkat plagget var mer van att arbeta med skinn än textil.</p>



<p class="wp-block-paragraph">   Något senare lades en 18-årig flicka med stora örringar av guld till sista vilan i sin ekkista i en gravhög i danska Skrydstrup. Hon hade en fin håruppsättning skyddad av ett hårnät flätat av hästtagel. Hennes yllekjol är för lång för att sitta i midjan – kanske har den fästs på axlarna som en peplos, en vid klädedräkt som bars av antikens kvinnor.</p>



<p class="wp-block-paragraph">   Till den rika bronsålderskvinnans dräkt hörde en bälteplatta av brons som prydde magen. På ryggen bars en bältedosa av samma metall som kan ha fungerat som ett slags midjeväska. Bältet pryddes av små konformade bronssmycken (kallade tutuli). Därtill användes halsringar, armringar, ankelringar och dräktnålar.</p>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">HUR MATCHADE DÅ </mark></strong>männen kvinnornas klädsel? Kroppen sveptes av ett ylletyg som gick från armhålan till knäna eller från midjan till knäna. Detta tygstycke var sytt av det tyg som blev över när manteln tillverkades. Manteln var njurformad och kunde fästas med en dräktnål eller en fibula – ett spänne som under bronsålderns lopp utvecklades till att se ut som ett par glasögon. På huvudet bars antingen en lägre mössa eller en högre hatt och på fötterna läderskor. I stället för strumpor sveptes tyg kring fötterna.</p>



<p class="wp-block-paragraph">   Kläderna är murrigt bruna, vilket inte bara beror på att de legat i jorden länge.</p>



<p class="wp-block-paragraph">   – Fårens naturliga färg på den här tiden var brun, men en del var vitfläckiga. Då sorterade man ut mörk och ljus ull som man spann tråd av och som sedan användes till vävningen, berättar textilexperten Amica Sundström som är förste antikvarie på Statens historiska museum.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph" style="font-size:30px"><strong><em><mark class="has-inline-color has-luminous-vivid-orange-color">Fårens naturliga färg på den här tiden var brun, men en del var vitfläckiga.</mark></em></strong></p>
</blockquote>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/MIX-7-637x1024.jpg" alt="" class="wp-image-3245" width="378" height="608" /></figure>
</div>


<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">OM VI FÖRFLYTTAR </mark></strong>oss till äldre järnåldern, påträffas kläderna oftast i gamla igenvuxna sjöar. Vintern 1920 upptäcktes den Gerumsmanteln, nästan som i nyskick, när man bröt torv i Hjortmossen på Gerumsberget nära Falköping. Den är med sina 2&nbsp;000 år på nacken Sveriges äldsta bevarade klädesplagg! Länge trodde man att manteln var från bronsåldern, men en kolfjortonanalys daterar den numera till förromersk järnålder (500 till Kristi födelse). Manteln, som är vävd i hundtands- eller pepitamönster med ljusa och mörka trådar, är en tillklippt oval och mäter 2&#215;2,5 meter. Manteln hittades hopvikt, med snittmärken. En teori är att plagget bär vittne om ett mord och att dess ägare blivit huggen minst fem gånger med en kniv som gått genom flera lager av tyg och träffat halsen, bröstet, magen och ryggen.</p>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">EN SKINNCAPE AV </mark></strong>fårpäls, ja faktiskt två till antalet, bar den kvinna som för omkring 2&nbsp;200 år sedan offrades i Huldremose på Jylland. På den yttre capen är den mörka pälsen vänd utåt, raffinerat designad med en ljus pälskant. Den inre hade pälsen vänd mot kroppen. Kjolen och sjalen som är av ylle är idag brunaktiga, men en gång lyste de i klara färger. Den rutiga kjolen var blåfärgad av vejde och den rutiga sjalen hade färgats röd med rot från krapp. Närmast kroppen har kvinnan burit ett plagg av växtfiber, kanske nässla eller linne, men det är mycket dåligt bevarat.</p>



<figure class="wp-block-image size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Namnlost-1-1-700x1024.jpg" alt="" class="wp-image-2561" width="841" height="1230" /></figure>



<p class="wp-block-paragraph"></p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph" style="font-size:30px"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">För första gången ser vi byxor, men de liknar mest strumpbyxor eller medeltida hosor.</mark></strong></p>
</blockquote>


<div class="wp-block-image">
<figure class="alignleft size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/10/AAAAAAAAAAHHHHHHH-295x1024.jpg" alt="" class="wp-image-3251" /></figure>
</div>


<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">I TORSBJERGSMOSE I </mark></strong>Schleswig-Holstein har man offrat både vapen och kläder under romersk järnålder, alltså de första århundradena e. Kr. För första gången ser vi byxor, men de liknar mest strumpbyxor eller medeltida hosor. Härifrån kommer också en tunika och en kjortel, som liksom byxorna är vävda i diamantkypert.</p>



<p class="wp-block-paragraph">   – Diamantkypert har fått sitt namn av att mönstringen påminner om slipade diamanter till formen. Under vendel- och vikingatid är dock varpen tätare och mönstret ser mer ut som romber. Men det är samma bindning, berättar Amica Sundström.</p>



<p class="wp-block-paragraph">   Äldsta exemplet på diamantkypert i Sverige är ett litet fragment från en rik grav i skånska Öremölla. I den låg också delar av en brynja och en komplett romersk dryckesservis som säger något om exklusiviteten.</p>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">FRÅN FOLKVANDRINGSTID (375–540 E. Kr)</mark></strong> har vi äntligen en svensk dräkt att ståta med, nämligen Högomhövdingens. Han gravlades i en storhög i Sundsvall på 500-talet och utifrån fragmenten i graven har en rekonstruktion kunnat göras. Hans röda byxor, tunika och mantel var färgad med koschenill, en importerad sköldlus. Tunikan och byxorna var prydda av agraffer; ett häktesspänne försedd med knappar av silver (vissa var dessutom förgyllda) som bara har en dekorativ funktion. Ytterligare en tunika, fast denna var grön, låg intill den dödes huvud. Alla plagg var dekorerade med tagelsnärjda brickvävda band. På det band som fanns nedtill på tunikan syns en person (med bara ett öga – kan det vara Oden?) som håller händerna i luften och intill denne två djur i profil som vänder sina huvuden bort.</p>



<p class="wp-block-paragraph">   – De tagelsnärjda mönstrade brickvävda banden hade en ganska begränsad geografisk utbredning under folkvandringstid. Det är som ett brett bälte från Uppsala upp till Sundsvall i Sverige och Norge, i Danmark finns några enstaka fynd. Tillverkningen är ett tidskrävande arbete, när jag gjorde en rekonstruktion vävde jag ungefär en millimeter i timmen, berättar Amica Sundström.</p>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">TAR VI SPRÅNGET</mark></strong> vidare till vendeltid (540–800 e. Kr.) har vi samtida avbilder av klädedräkter. Man kan nämligen beskåda dem på guldgubbar, det vill säga pyttesmå guldbleck med stämplade figurer. Kvinnorna bär en längre schal och en fotsid kjol, medan männen har någon typ av kjortel eller omlottrock med byxa eller benlindor till.</p>


<div class="wp-block-image">
<figure class="alignleft size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/10/MIXMIX-802x1024.jpg" alt="" class="wp-image-3246" width="384" height="491" /></figure>
</div>


<p class="wp-block-paragraph">   Under sen vendeltid börjar siden importeras till de riktigt välbärgade nordborna, och från gravar i det vikingatida Birka finns silke ända från Kina. Men få plagg är dessvärre bevarade, allt som oftast rör det sig om fragment av tyg som konserverats av metallsalter från de spännen som suttit fästade i dräkten.</p>



<p class="wp-block-paragraph">   – Vi vet generellt mindre om hur hela plagg ser ut men har goda kunskaper om vilka tyger som användes och var på kroppen eventuella dekorationer satt, säger Amica Sundström.<br />Gotländska bildstenar kan vara till vägledning, här kan vi se kvinnor i långa klänningar och schalar.</p>



<p class="wp-block-paragraph">   – Närmast kroppen bar kvinnorna en särk. Det finns många bevarade fragment av lin eller hampa, men jag skulle tro att de även kunde vara vävda av tunt ylle, åtminstone på vintern. Över den bars en yllekjortel och/eller en hängselkjortel där hängslena var gjorda av tunna sydda linneband. Linnebanden fästes ihop med ovala spännbucklor. Som ytterplagg kunde en öppen yllekjortel eller sjal användas, säger Amica Sundström.</p>


<div class="wp-block-image">
<figure class="alignleft size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-17.-Spannbucklor.jpg" alt="" class="wp-image-2551" width="373" height="336" /><figcaption class="wp-element-caption"><mark class="has-inline-color has-black-color"><strong>Cheyenne Olander har gjort en rekonstruktion av dräkten och utsmyckningen från en vikingatida kvinnograv på Birka (Bj 507). Närmast kroppen en ofärgad särk av linne och utanpå den en blå yllekjortel färgad med vejde. Ytterst en blå ylleklänning vävd i diamantkypert. Hängslena fästes med hjälp av ovala spännbucklor. Foto: Björn Falkevik</strong></mark></figcaption></figure>
</div>


<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">MÄNNEN KUNDE BÄRA</mark></strong> en linne- eller hampa­skjorta närmast kroppen och över den en kjortel. I mansgravar i Birka har kaftan­knappar påträffats vilket antyder att man har influerats av dräkttraditionen österifrån. På bildstenar kan man se att männen dels hade raka byxor, dels en typ av puffbyxor. Fina ringspännen av silver i gravarna tyder på att de haft en mantel.</p>



<p class="wp-block-paragraph">   Mansdräkterna kunde vara prydda med metallbroderi, så kallat posamentband, och i både mans- och kvinnogravar finner man brickvävda band med silver- eller guldinslag.</p>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">SOM VI SETT </mark></strong>har bara ett fåtal plagg bevarats från forntiden, och frågan är hur representativa de är. I de danska ekkistegravarna begravdes endast eliten, och ingen vet vilken status ägarna till plaggen i mossarna hade. Hur vanligt folk gick klädda vet vi mindre om.</p>



<p class="wp-block-paragraph">   – De bevarade kläderna är ögonblicksbilder. Ofta har vi endast enstaka fynd och då vet inte om de är udda företeelser eller del av ett större mönster, säger Amica Sundström.</p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/4-1024x485.png" alt="" class="wp-image-2566" /></figure>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/10/Bild-21.-Brodyr-fran-Mammen-2-1024x434.jpg" alt="" class="wp-image-3243" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">I den vikingatida danska Mammengraven påträffades broderade textilier som prytt dräkten. Foto: Lennart Larsen, Nationalmuseet Köpenhamn</mark></strong></figcaption></figure>
