Den dysfunktionella gudafamiljen

Jonathan Lindström

27 sep 2026

Den fornnordiska gudavärlden kan framstå som oöverskådlig, strukturlös och i ständig förändring. Men kunde vi tränga in i hjärnan på valfri forntida gudadyrkare från den yngre stenåldern och framåt skulle uppsättningen gudomar vara enklare att överblicka. Den dominerades av en familj så dysfunktionell att Lars Norén i jämförelse är rena Bolibompa. DET ÄR ETT helsike […]


<p class="wp-block-paragraph"><strong>Den fornnordiska gudavärlden kan framstå som oöverskådlig, strukturlös och i ständig förändring. Men kunde vi tränga in i hjärnan på valfri forntida gudadyrkare från den yngre stenåldern och framåt skulle uppsättningen gudomar vara enklare att överblicka. Den dominerades av en familj så dysfunktionell att Lars Norén i jämförelse är rena Bolibompa.</strong></p>



<p class="wp-block-paragraph"><b>DET ÄR ETT</b> helsike att hålla reda på forntidens gudar. Inte nog med att de ägnar sig åt otrohet och incestuösa våldtäkter, de kan fortplanta sig genom delning och sammansmälta igen, de spjälkar upp sig på olika funktioner, de byter namn, de bär flera namn (Wikipedia räknar upp drygt åttio binamn på Oden) och de kan dyka upp hos flera grannfolk och uppfattas som separata gudomar trots att de är en och samma.</p>



<p class="wp-block-paragraph">Islänningen och mytupptecknaren Snorre Sturlasson bär här ett stort ansvar. I början av 1200-talet förtecknade han minst tjugo olika gudar och gjorde långa listor på vad en och samma gud kan kallas. Man förstår att Snorre har pratat med många minnesgoda bekanta och eftersom han var skrivkunnig har han frenetiskt antecknat allt han hört. Det är inte troligt att människorna som levde i den muntliga kulturen hade fullödiga historier om alla dessa gudomar, utan vi ska nog föreställa oss att några få favoritgestalter dominerade helt, och att det sedan fanns gott om bifigurer, ett slags statister, som jättar och djur att fylla på med.</p>



<p class="wp-block-paragraph">Folkloristen Terry Gunnel har skarpsinnigt visat att de historier som Snorre och andra återger, trots namnrikedomen i stort med få undantag bara har tre gudar och en gudinna i huvudrollerna. Kombinerar vi det med vad religionshistoriker har kommit fram till genom att jämföra olika indoeuropeiska gudagallerier, från Indien och Grekland till Island och Irland, går det att mejsla ut ett ganska tydligt sällskap av gudar och gudinnor. Det blir inte sämre av att de går att skönja även i senare samisk mytologi och finsk folktro. Folklorister är sedan länge medvetna om att det finns en mycket gammal cirkumbaltisk mytologisk tradition, alltså kring Östersjön, som går över språkgränserna.</p>



<p class="wp-block-paragraph"><b>SLUTLIGEN FINNS DET</b> en källa som är rejält underutnyttjad, nämligen forntidens rika bildmaterial. Forskare brukar nöja sig med att pynta historiskt belagda myter med bilder och figurer från vikingatiden. Alternativt, om de intresserar sig för bronsålderns rika bildvärld, så bryr de sig ofta inte om att jämföra med kända myter, utan hittar på hemsnickrade bronsåldersreligioner. Jag ska nu presentera fyra gudomar som låter sig urskiljas från den yngre stenåldern och framåt i bild, genom den jämförande indoeuropeistiken och i de senare fornnordiska myterna. Det är Världens gud/Himmelsguden, Jordgudinnan och tvillinggudarna som bildar en dysfunktionell tvåbarnsfamilj med oklara biologiska band (jämför Terry Gunnels gudinna och tre gudar!). Tvåbarnsfamiljen är naturligtvis en långtgående förenkling med många undantag och variationer, men den ligger antagligen nära ett slags medelvärde för enskilda gudadyrkares centrala föreställningar, vilket inte hindrade att de samtidigt höll reda på en mängd andra mytiska väsen, allt från dödsgudinnor och gryningsgudinnor till jättar och vättar.</p>



<div style="background:#f6dcd6;padding:1.5rem 1.5rem 1.25rem;margin:2.5rem 0">
  <div style="font-weight:700;letter-spacing:0.1em;text-transform:uppercase;color:#c4462e;margin-bottom:0.4rem">En viktig social funktion</div>
  <div style="font-weight:700;color:#1a1a1a;margin-bottom:0.75rem">Bråkiga familjen</div>
  <p style="margin-bottom:0.6rem;color:#1a1a1a">Religionshistoriker är överlag mycket fästa vid sitt skriftliga källmaterial, framförallt Snorres Edda och den poetiska Eddan. Det är begripligt, eddorna är både innehållsrika och ofta bedövande vacker litteratur och poesi. Problemet är att forskarna kan ha lite svårt att kasta loss från skriftmaterialet och ge sig längre tillbaka i tiden än den yngre järnåldern. Inom den jämförande indoeuropeistiken når man visserligen tusentals år tillbaka i tiden i enskilda detaljer, men det förankras inte arkeologiskt och kan bli lite luftigt. Här har jag försökt visa att det finns ett rikt arkeologiskt bildmaterial som hjälper oss att med större säkerhet identifiera gudaväsen och deras attribut många tusentals år tillbaka i forntiden. Allt talar för att föreställningarna har varit stabila över lång tid. Orsaken till det är att kanske framförallt den dysfunktionella gudafamiljen har fyllt en viktig social funktion.</p> <p style="margin-bottom:0;color:#1a1a1a">Inte nog med att forntidens människor roades av överdriven dramatik, så som vi roas av skruvade teveserier som Succession. Det handlade också om att diskutera och bearbeta verkliga problem, som kvinno­övergrepp och brodermord, vilka plågade samhället mer då än idag.</p>
</div>



<div style="float:left;width:40%;max-width:200px;margin:0.35rem 1.5rem 0.75rem 0">
  <figure class="wp-block-image" style="float:none !important;width:100% !important;margin:1.5rem 0 !important"><span class="pa-ram" data-ram="1/1" data-zoom="300" data-x="-100.35714285714286" data-y="-125" style="display:block !important;overflow:hidden !important;aspect-ratio:1/1 !important;border-radius:50% !important" data-rund="1"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_3-5.jpg" class="wp-image-6647" alt="Världsguden i Succession" style="width:300% !important;max-width:none !important;height:auto !important;display:block !important;margin-left:-100.35714285714286% !important;margin-top:-125% !important"></span><figcaption class="wp-element-caption">Världsguden i Succession.</figcaption></figure>
</div>



<h2 class="wp-block-heading">Världsguden</h2>



<p class="wp-block-paragraph" style="font-weight:700;letter-spacing:0.02em;margin-bottom:0.4rem">Himmelskt viril fadersgestalt</p>



<p class="wp-block-paragraph"><strong>Veraldar goð</strong> (den sista bokstaven uttalas som th i engelska this och that) eller himmelsguden, som Frej, Tor, Oden och Heimdal, finnarnas Ukko och samernas Veralden olmai i olika sammanhang kan låna drag av.</p>



<p class="wp-block-paragraph"><b>RELIGIONSHISTORIKERNA ULF DROBIN</b> och Marja-Liisa Keinänen redde för ett kvartssekel sedan ut sammanhanget och släktskapet mellan många nordiska, germanska och samiska föreställningar om den jordbefruktande himmelsguden, världsträdet och himmelsstöttan eller världspelaren som håller uppe himlavalvet. Den fäster upptill i himmelspolen, i vars närhet vi för tillfället hittar stjärnan Polaris, polstjärnan (bild 1). På grund av jordaxelns långsamma vridning har lämpligaste polstjärna växlat genom årtusendena. Ibland har närmaste ljusstarka stjärna varit så långt från himmelspolen att man avstod från att peka ut en sådan. Så kan det exempelvis ha varit på 2000-talet f.Kr. då jordaxeln vette någonstans i mörkret mellan Lilla Björn och Karlavagnen.</p>



<figure class="wp-block-image" style="float:none !important;width:100% !important;margin:1.5rem 0 !important"><span class="pa-ram" data-ram="1/1" data-zoom="115" data-x="-11.160337552742616" data-y="-13.613622664255576" style="display:block !important;overflow:hidden !important;aspect-ratio:1/1 !important"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_6-5.jpg" class="wp-image-6648" alt="Träguden från danska Broddenbjerg" style="width:115% !important;max-width:none !important;height:auto !important;display:block !important;margin-left:-11.160337552742616% !important;margin-top:-13.613622664255576% !important" /></span><figcaption class="wp-element-caption">Bild 2. Träguden från danska Broddenbjerg. <cite>Foto: Lennart Larsen, Nationalmuseum, DK</cite></figcaption></figure>



<p class="wp-block-paragraph">Från fästet vid himmelspolen sträckte sig världspelaren ner genom lufthavet till jorden. På vägen kunde flera himmelsnivåer passeras. I Kalevala tappar himmelsgudens tjänsteflicka en eldgnista som var tänkt att bli sol och måne. Den <em>&#8221;skjuter genom himlens rymder, fräser tvärs igenom molnen, ner igenom nio himlar, sex av stjärnor prydda fästen.&#8221;</em></p>



<figure class="wp-block-image" style="float:left !important;width:45% !important;margin:0.3rem 1.5rem 1rem 0 !important"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_4-5.jpg" class="wp-image-6649" alt="Stjärnhimmel med koordinatnät kring polstjärnan" style="width:100% !important;height:auto !important;display:block !important" /><figcaption class="wp-element-caption">Bild 1. För 4 400 år sedan fanns ingen lämplig polstjärna intill himmelspolen.</figcaption></figure>



<p class="wp-block-paragraph"><b>VÄRLDSPELARENS HÖJD VAR</b> imponerande. Ett sibiriskt nomadfolk kunde i början av 1900-talet i ett försök att pedagogiska förklara om man släppte en sten stor som en ko däruppifrån så hade den krympt till ett fårs storlek när den slog i marken. Eftersom vi ser himmelspolen högt i norr är det naturligt att tänka sig att världspelaren når jorden på en plats norrut. Tack vare fornnordiska myt- och sagouppgifter kan den under sen förhistorisk tid preciseras till de skogsklädda höjderna kring sjön Vygozero i Karelen, bortom vilken ligger bjarmernas land ända ut till ishavet, där Tor åkte på fisketur med jätten Hymer. Trakten kring världsträdets fot är numera ingen behaglig miljö, här har både Stalin och Putin spärrat in och torterat oliktänkande.</p>



<p class="wp-block-paragraph">Tankekombinationen av en stolpe, ett träd och en gudagestalt blev särskilt livskraftig eftersom den efterbildades av saxare, gamla uppsaliensare och samer som kultobjekt till vilka man frambar offer, allt från renar till människor. En mäktig trädstam försedd med ett grovt utmejslat ansikte och en imponerande fallos (rest penis) (bild 2) var en vanlig syn i vikingatidens gudahov och på samernas kultplatser här hemma i Norden. Sådana kunde också besökas och offras till av skandinaviska köpmän som gav sig hela vägen bort till marknadsplatser i volgabulgarernas land.</p>



<div>
    <figure class="wp-block-image"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_5-5.jpg" class="wp-image-6650" alt="Himmelsguden och jordgudinnan från Braak" style="width:100%;height:auto;display:block"><figcaption class="wp-element-caption">Bild 3. Himmelsguden och jordgudinnan från tyska Braak.</figcaption></figure></div>



<p class="wp-block-paragraph"><b>EFTERSOM VÄRLDSGUDARNA TILLVERKADES</b> i trä har de mestadels förmultnat och försvunnit sedan länge, men i de fall träbelätena har offrats i mossar har de kunnat bevaras i den syrefria vätan. Ett känt exempel finns från Braak i nordligaste Tyskland, där mossfynd har gjorts både av en världsgud/himmelsgud och en jordgudinna (bild 3). Från Sverige har vi roten av en väldig vikingatida björk i behåll från en utgrävning i jämtska Frösö kyrkas kor. Roten är omgiven av en mängd djurofferrester som visar att den har fungerat som världsträd. Även samernas senare Veralden olmai var vanligen tillverkade i björk, ett ljust träslag som passade fint i himmelska sammanhang.</p>



<figure class="wp-block-image size-large" style="font-size: 1.05rem;display: inline !important"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/varldsguden_fri_1.jpg" alt="Världsguden som en bild av kosmos omgiven av en kalenderbård med dagstreck. Underlagsbild av Sven-Gunnar Broström &amp; Kenneth Ihrestam." class="wp-image-6673" /><figcaption class="wp-element-caption">Bild 4. Världsguden som en bild av kosmos omgiven av en kalenderbård med dagstreck. Underlagsbild av Sven-Gunnar Broström &amp; Kenneth Ihrestam.</figcaption></figure>



<figure class="wp-block-image size-large" style="float:left !important;width:45% !important;margin:0.3rem 1.5rem 1rem 0 !important"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/varldsguden_fri.jpg" alt="Frilägger vi världsguden från 
kalender­bården och andra kalendariska inslag framträder han tydligt med huvud och armar upptill, en lång, lodrät kropp eller stam som passerar ned genom himmel och jord, där den senare penetreras av gudens fallos på ett anatomiskt inte helt tillfredsställande sätt, och nederst underjorden där världsguden brer ut sina tre rötter." class="wp-image-6672" style="width:100% !important;height:auto !important;display:block !important" /><figcaption class="wp-element-caption">Frilägger vi världsguden från 
kalender­bården och andra kalendariska inslag framträder han tydligt med huvud och armar upptill, en lång, lodrät kropp eller stam som passerar ned genom himmel och jord, där den senare penetreras av gudens fallos på ett anatomiskt inte helt tillfredsställande sätt, och nederst underjorden där världsguden brer ut sina tre rötter.</figcaption></figure>



<p class="wp-block-paragraph">Lyckliga tillfälligheter gör att vi har en avbildning av världsguden i sten redan från slutet av stenåldern, 2300-talet f.Kr. Då knackades hundratals figurer in i hällarna på ett par holmar nära Nyköpingsåns mynning i kalendariskt syfte. De upptäcktes 1984 av hällristningsexperterna Sven-Gunnar Broström och Kenneth Ihrestam och är numera en av Nyköpings främsta sevärdheter.</p>



<p class="wp-block-paragraph">En av de största figurerna, som numera bland annat pryder t-shirtar, föreställer världsguden med så många detaljer att den lätt låter sig identifieras (bild 4). Dessutom ger de oss en klar och tydlig förståelse för universums uppbyggnad. Världsguden har försetts med en kalenderbård som visar tre månmånader, där tid och rum kombineras på ett intrikat men finurligt sätt.</p>



<figure class="wp-block-image" style="float:none !important;width:100% !important;margin:1.5rem 0 !important"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_7-5.jpg" class="wp-image-6651" alt="Karl den Store förstör Irminsul" style="width:100% !important;height:auto !important;display:block !important" /><figcaption class="wp-element-caption">Karl den Store förstör Irminsul, saxarnas stora världsgudssymbol, Heinrich Leutemann år 1882. <cite></cite></figcaption></figure>



<h2 class="wp-block-heading">Jordgudinnan</h2>



<p class="wp-block-paragraph" style="font-weight:700">Mest känd som Nerthus, Frigg, Freja, Disen och samernas Máttaráhkká.</p>



<p class="wp-block-paragraph"><b>UPPREPADE GÅNGER UNDER</b> forntiden avbildas en jordgudinna i ormgestalt med två småormar som hon uppfostrar och ammar. I myter världen över är en koppling mellan jordgudinnan och ormar, ktoniska (jordnära) varelser ingen ovanlighet.</p>



<p class="wp-block-paragraph">Motivet är inte så känt bland religionshistoriker som ägnar sig åt fornnordisk religion, eftersom ormaspekten knappt har bevarats i de skriftliga källorna. Hon skymtar i Gutasagan från 1200-talets början:</p>



<p class="wp-block-paragraph" style="font-style:italic;padding-left:1.25rem;border-left:3px solid #7cc4bb">Denne Tjelvar hade en son som hette Havde och Havdes hustru hette Vitastjärna. Dessa två var de första som byggde och bodde på Gutland. Den första natten, då de sov tillsammans, drömde hon en dröm om tre ormar, som var flätade samman i hennes barm. Och det tycktes henne, att de sakta gled ut ur barmen. Denna dröm berättade hon för Havde sin husbonde och han tolkade drömmen så. Allt är bundet i ringar. Ett bebott land skall detta varda och vi skola få tre söner.</p>



<p class="wp-block-paragraph"><b>GUTASAGANS VERSION ÄR</b> sin egen, men en tydlig mix av äldre urgermanska och indoeuropeiska motiv. Dit hör serien av två generationer förfäder till tre bröder. Vitastjärna har också ett namn som liknar beskrivningar av solgudens dotter, vilken de indoeuropeiska tvillinggudarna räddar från faror i havet. Här är dock det intressanta att det kvinnliga väsendets bröst förknippas med ormar, och att dessa ormar symboliserar söner i mänsklig gestalt som hon ska föda och amma.</p>



<p class="wp-block-paragraph">Motivet dyker tidigast upp stiliserat i sörmländska Släbro (bild 1), men återges runtom i Norden från stenåldern till järnåldern så tydligt och ofta att de inte råder något rimligt tvivel på att tolkningen är den rätta.</p>



<figure class="wp-block-image"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_10-5.jpg" class="wp-image-6652" alt="Hällristningssymboler från Släbro" /><figcaption class="wp-element-caption">Bild 1. På hällristningarna i Släbro från 2300-talet f.Kr. avbildas gudinnan med två småormar, antingen alla tre tillsammans i ormgestalt eller en människoliknande jordgudinna med småormarna vid bröstet. <cite>Illustration: S-G Broström &amp; K Ihrestam</cite></figcaption></figure>



<p class="wp-block-paragraph">Ett exempel är jämngammalt med Släbro och tillhör den danska varianten av stridsyxekulturen, enkelgravskulturen. På Jylland har kvinnor begravts i blusar med bärnstenspärleapplikationer. Genomgående framhäver applikationerna brösten och bröstvårtorna, vilket redan det talar för att amning har varit i fokus och att den ammande, livgivande jordgudinnan har varit förebild. I ett par fall hänger också vad som enklast kan uppfattas som små ormar från brösten (bild 2).</p>



<div class="pa-responsive-grid pa-grid-2col" style="display:grid;grid-template-columns:repeat(auto-fit, minmax(max(240px, 46%), 1fr));gap:0.75rem;margin:2rem 0 0.4rem;background:#e6f2f0;padding:1rem;align-items:start !important">
  <div class="" style="float:none !important;width:100% !important;margin:1.5rem 0 !important"><span class="pa-ram" data-ram="1178/2096" data-zoom="100" data-x="0" data-y="0" style="display:block !important;overflow:hidden !important;aspect-ratio:1178/2096 !important"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_11-5.jpg" class="wp-image-6653" alt="Rekonstruktion av kvinnoblusar med bärnstenspärlor" style="width:100% !important;max-width:none !important;height:auto !important;display:block !important;margin-left:0% !important;margin-top:0% !important"></span></div><div class="" style="float:none !important;width:100% !important;margin:1.5rem 0 !important"><span class="pa-ram" data-ram="1178/2096" data-zoom="100" data-x="0" data-y="0" style="display:block !important;overflow:hidden !important;aspect-ratio:1178/2096 !important"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_12-5.jpg" class="wp-image-6654" alt="Rekonstruktion av kvinnoblusar med bärnstenspärlor" style="width:100% !important;max-width:none !important;height:auto !important;display:block !important;margin-left:0% !important;margin-top:0% !important"></span></div>
  
</div>



<figcaption class="wp-element-caption">Bild 2. Rekonstruktion av bärnstenspärleprydda kvinnoblusar från danska gravar samtida med Släbroristningen.&nbsp;Illustration: Klaus Ebbesen</figcaption>



<p class="wp-block-paragraph"><b>BRONSÅLDERNS RIKA HÄLLRISTNINGSVÄRLD</b> har påfallande få intressanta kvinnoporträtt, kanske ett resultat av att ristningarna i första hand verkar ha kommit till vid mansdominerade flottsamlingar längs kusterna. I gengäld har vi i behåll en hel skulpturgrupp i brons från yngre bronsålderns danska Fårdal, som ger inblickar i tvillinggudarnas historia. Ett par figurer föreställer en kvinna som ger en orm bröstet (bild 3).</p>



<p class="wp-block-paragraph"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_16-5.jpg" class="wp-image-6655" alt="Idolfigur från Fårdalfyndet" style="width:100% !important;height:auto !important;display:block !important"></p>



<p class="wp-block-paragraph"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_17-5.jpg" class="wp-image-6656" alt="Ormfigur från Fårdalfyndet" style="width:100%;height:auto;display:block"></p>



<figcaption class="wp-element-caption">Bild 3. Två figurer från Fårdalfyndet. Jordgudinnan erbjuder ormen sitt bröst. Foto: Nationalmuseet, Danmark</figcaption>



<p class="wp-block-paragraph">Vi får gå fram till järnåldern och tiden omkring år 400 e.Kr. innan ett rikt bildmaterial dyker upp. På ett av de jylländska Gallehushornen (av guld som smältes ner i början av 1800-talet men lyckligtvis avtecknades dessförinnan) porträtteras jordgudinnan i ormgestalt i full färd med att dia två småormar (bild 4). På de gotländska bildstenarna från samma tid hittar vi många ormpar som vi återkommer till när tvillinggudarna avhandlas.</p>



<figure class="wp-block-image"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_13-5.jpg" class="wp-image-6657" alt="Avritning av jordgudinnan från Gallehushornet" /><figcaption class="wp-element-caption">Bild 4. Jordgudinnan i ormgestalt i full färd att amma två småormar. Avritat från Gallehushornet, som tillverkades omkring år 400 e.Kr. <cite>&nbsp;</cite></figcaption></figure>



<p class="wp-block-paragraph">När det gäller jordgudinnan är det intressant när ormarna är tre till antalet. På den välkända Smisstenen syns de tre i dubbel uppsättning, överst i en trippelhärva, nedtill håller gudinnan i människogestalt upp tvillingormarna (se bild 5). I Sandegårda flankeras jordgudinnan som stor orm av de två småormarna (bild 6).</p>



<figure class="wp-block-image"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_15-5.jpg" class="wp-image-6658" alt="Bildstenen från Smiss i När socken, Gotland" /><figcaption class="wp-element-caption">Bild 5. Den välkända bildstenen från Smiss i När socken på Gotland. Här ser vi gudinnan med de två småormarna i dubbel uppsättning, där hon avbildas dels i ormgestalt, dels i mänsklig gestalt. <cite>Foto: Michael Fergusson/Gotlandic Picture Stones</cite></figcaption></figure>



<p class="wp-block-paragraph"><b>ORMMOTIVEN ÅTERGER ANTAGLIGEN</b> en viktig episod från en kalenderårsberättelse, som är bättre känd i bildberättelser från bronsåldern och järnåldern och som sannolikt varit spridd bland indoeuropéerna.</p>



<p class="wp-block-paragraph">Amningsepisoden handlar om hur jordgudinnan i djurgestalt förbarmar sig över de nyfödda gudabröderna i skogen, ett tema som förekommer i många olika indoeuropeiska varianter. Mest bekant är det i den romerska mytologin, där Romulus och Remus dias av en varghona. </p>



<div class="pa-responsive-grid pa-grid-2col" style="display:grid;grid-template-columns:repeat(auto-fit, minmax(max(240px, 46%), 1fr));gap:1.5rem;margin:2rem 0 0.4rem">
  <div>
    <figure class="wp-block-image" style="float:none !important;width:100% !important;margin:1.5rem 0 !important"><span class="pa-ram" data-ram="1322/1436" data-zoom="100" data-x="0" data-y="-7.751937984496124" style="display:block !important;overflow:hidden !important;aspect-ratio:1322/1436 !important"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_18-5.jpg" class="wp-image-6659" alt="Bildstenen från Sandegård, Sanda socken, Gotland" style="width:100% !important;max-width:none !important;height:auto !important;display:block !important;margin-left:0% !important;margin-top:-7.751937984496124% !important"></span><figcaption class="wp-element-caption">Bild 6. På bildstenen i Sandegård i Sanda socken på Gotland flankeras jordgudinnan i frodig ormgestalt av de två småormarna. <cite>Foto: Michael Fergusson/Gotlandic Picture Stones</cite></figcaption></figure>
  </div>
  <div>
    <figure class="wp-block-image"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_14-5.jpg" class="wp-image-6660" alt="Förtydligad bild av ormmotivet på stenen i Sanda" style="width:100%;height:auto;display:block"><figcaption class="wp-element-caption">Förtydligad bild av ormmotivet på stenen i Sanda.</figcaption></figure>
  </div>
</div>



<figcaption class="wp-element-caption"><b>Actionhjältar på dödliga äventyr</b></figcaption>



<h2 class="wp-block-heading">Tvillinggudarna</h2>



<p class="wp-block-paragraph" style="font-weight:700">Skymtar bakom Balder och Höder, Horsa och Hengist och finnarnas Väinämöinen och Ilmarinen.</p>



<p class="wp-block-paragraph"><b>TVILLINGGUDARNA ÄR</b> indoeuropéernas bäst kända och mest populära gudomar, mycket beroende på att de är utmärkta berättargestalter, två actionhjältar där den ene är kavat, stark och modig, den andre mer listig och slug. Deras släktbakgrund är lite varierad, de kan ha olika biologiska fäder eller mödrar och fosterföräldrar, men som enkel tumregel kan vi utgå ifrån att de himmelsgudens söner och tas om hand av ett kvinnligt väsen, jordgudinnan, i skymundan under småbarnsåren. Därpå växer de upp till hjältar som är med om många äventyr. Det främsta skäl att hjälpa himmelsguden, som offrar sin hand, är att fjättra den stora ulven, för att hindra den från att sluka sol eller måne. I övrigt slår de av alla skäl ihjäl en del jättar. Så småningom blir bröderna osams, vilket slutar med brodermord och att även mördarbrodern slås ihjäl och hamnar i dödsriket. Där inväntar de sin uppståndelse som har utlovats efter Ragnarök i samband med att en ny värld föds.</p>



<p class="wp-block-paragraph">Det främsta skäl att hjälpa himmelsguden vara att hjälpa en syster eller kvinnlig bekant knuten till solen, exempelvis den undersköna gryningsgudinnan, från fångenskap hos ett monster i havet.</p>



<p class="wp-block-paragraph">Tidigare har de visat upp sig som de två ormyngel jordgudinnan tar sig an och ger di. De dyker också upp mer självständigt i ormgestalt, inte minst på de gotländska bildstenarna från järnålderns mitt, och det kan också vara de som syns som parställda runormar på vikingatidens runstenar. De tidiga kristna använda gärna fornnordiska bildmotiv som förtydligade budskapet om domedagen och återuppståndelsen.</p>



<p class="wp-block-paragraph"><b>ÖVER HELA DET</b> indoeuropeiska området brukar tvillinggudarna uppträda i hästgestalt, vilket också är vanligt här i Norden under bronsåldern och järnåldern, att döma av bildmaterialet. Bland hällristningarna i Släbro (bild 1)&nbsp;hittar vi dock bara tvillingarna i ormgestalt, troligen av det enkla skälet att stridyxingarna inte förde med sig tamhästen över Östersjön när de anlände tidigare under stenåldern. Eventuellt skedde införseln av tamhäst till Skandinavien kring år 2000 f.Kr., men senast i början av bronsåldern, absolut senast under 1500-talet f.Kr.</p>



<figure class="wp-block-image"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_19-5.jpg" class="wp-image-6661" alt="Bildsten från Hellvi, Gotland" /><figcaption class="wp-element-caption">Bild 4. Bildsten från Hellvi, Gotland, med tvillinggudarna i hästgestalt försedda med huvudprydnader i form av ny och nedans månskäror. Nedtill ett kalenderhjul med sex månskäror. <cite>Foto: Michael Fergusson/Gotlandic Picture Stones</cite></figcaption></figure>



<p class="wp-block-paragraph">Mer tidlöst är att tvillinggudarna förknippades med himlafenomen. I den sydöstra delen av det indoueropeiska området kunde det ofta vara planeten Venus, ljusstarkast på himlen näst efter sol och måne, växelvis som aftonstjärna och morgonstjärna.</p>



<p class="wp-block-paragraph"><b>I NORDEN FRAMGÅR</b> det tydligt att de två förknippades med ny och nedan, alltså den växande och avtagande månskäran, som syns på kvällshimlen respektive gryningshimlen. Under bronsåldern uppträder tvillinggudarna med halvmåneformade yxor i händerna, som på de nu till större delen förstörda bronsfigurerna från danska Grevensvaenge (bild 2).</p>



<p class="wp-block-paragraph">Typiska är också de parvis offrade kultyxorna, som har tydlig månskäreform. De finaste exemplaren i Sverige offrades i en liten sjö i Skogstorp, Södermanland (bild 3).</p>



<p class="wp-block-paragraph">Under järnåldern hittar vi månskärorna som huvudprydnader på tvillinghästarna som avbildats på bildstenar både på Gotland (bild 4) och i Uppland (bild 5). På de gotländska bildstenarna kan de också kombineras med kalenderhjul med oftast sex eller tolv månskäror i ring, som motsvarar ett halvårs eller ett helårs månader. Hjulen brukar traditionellt tolkas som solsymboler men det är alltså sannolikt bara en indirekt del av symboliken, där hjulet kan återge solåret.</p>



<p class="wp-block-paragraph">Går vi nu tillbaka till stenåldern och Släbroristningen så hittar vi som sagt inga hästar, men ett överflöd av månfigurer, små cirklar med huvud och glatt vinkande armar. De kan vara tudelade i halvmånar, och dessutom runt fjorton dagstreck i krans, det vill säga en halv månad. De kan också framställas med cirkeln kvarterad, indelad i fjärdedelar.</p>



<div class="pa-responsive-grid pa-grid-2col" style="display:grid;grid-template-columns:repeat(auto-fit, minmax(max(240px, 46%), 1fr));gap:1.5rem;margin:2rem 0 0.4rem">
  
  <div>
    <figure class="wp-block-image" style="float:none !important;width:100% !important;margin:1.5rem 0 !important"><span class="pa-ram" data-ram="1/1" data-zoom="134" data-x="-15.000000000000002" data-y="0" style="display:block !important;overflow:hidden !important;aspect-ratio:1/1 !important"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_26-5.jpg" class="wp-image-6662" alt="Bildstenen från Häggeby, Uppland" style="width:134% !important;max-width:none !important;height:auto !important;display:block !important;margin-left:-15.000000000000002% !important;margin-top:0% !important"></span><figcaption class="wp-element-caption">Bild 5. Tvillinggudarna i hästgestalt med månskärekronor avbildades på en bildsten i Häggeby i Uppland. Bildstenen som står vid kyrkan är en kopia, medan originalet befinner sig i trygghet inomhus på museum. <cite>Foto: Wikipedia</cite></figcaption></figure>
  </div><div>
    <figure class="wp-block-image" style="float:none !important;width:100% !important;margin:1.5rem 0 !important"><span class="pa-ram" data-ram="1/1" data-zoom="100" data-x="0" data-y="-7.67857142857143" style="display:block !important;overflow:hidden !important;aspect-ratio:1/1 !important"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_20-5.jpg" class="wp-image-6663" alt="Bildstenen från Havor, Hablingbo, Gotland" style="width:100% !important;max-width:none !important;height:auto !important;display:block !important;margin-left:0% !important;margin-top:-7.67857142857143% !important"></span><figcaption class="wp-element-caption">Bild 4. Bildstenen från Havor i Hablingbo socken på Gotland. Här är tvillinggudarna avbildade som både småormar och hästar kring ett kalenderhjul med ett halvårs sex nymånar och månmånadens trettio dagstreck i krans. <cite>Foto: Michael Fergusson/Gotlandic Picture Stones</cite></figcaption></figure>
  </div>
</div>



<p class="wp-block-paragraph"><b>VÄRLDEN RUNT OCH</b> även i nordisk folktro brukar av självklara skäl ny förknippas med födande, alstrande och växande, en tid då man ska så och starta projekt. Julius Caesar berättade redan för drygt tvåtusen år sedan hur germanernas hustrur inte ens ville låta sina män gå till anfall i krig förrän nymåne infann sig. Nedan förknippas däremot med död och avtagande, en tid för slakt, trädfällning och skörd. De här egenskaperna anar vi bakom bröderna Balders och Höders gestalter. Den högt uppskattade ljuse, modige kämpen Balder liknar och förknippas med ny, medan brodermördaren Höder, som samarbetade med den lömske, listige Loke, liknar nedan. </p>



<div class="pa-responsive-grid pa-grid-2col" style="display:grid;grid-template-columns:repeat(auto-fit, minmax(max(240px, 46%), 1fr));gap:1.5rem;margin:2rem 0 0.4rem;align-items:start !important">
  <div style="grid-column:1 / -1 !important">
    <figure class="wp-block-image" style="float:none !important;width:100% !important;margin:1.5rem 0 !important"><span class="pa-ram" data-ram="1/1" data-zoom="100" data-x="0" data-y="-12.38095238095238" style="display:block !important;overflow:hidden !important;aspect-ratio:1/1 !important"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_24-5.jpg" class="wp-image-6665" alt="Skogstorpsyxorna, Södermanland" style="width:100% !important;max-width:none !important;height:auto !important;display:block !important;margin-left:0% !important;margin-top:-12.38095238095238% !important"></span><figcaption class="wp-element-caption">Bild 3. Skogstorpsyxorna, Södermanland. <cite>Foto: SHM</cite></figcaption></figure>
  </div><div>
    
  </div>
  
</div>



<div class="pa-responsive-grid pa-grid-2col" style="display:grid;grid-template-columns:repeat(auto-fit, minmax(max(240px, 46%), 1fr));gap:1.5rem;margin:2rem 0 0.4rem">
  <div>
    <figure class="wp-block-image"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_21-5.jpg" class="wp-image-6666" alt="Tvillinggudarna som hjulsymboler, Släbro" style="width:100%;height:auto;display:block"><figcaption class="wp-element-caption">Bild 1. Exempel på tvillinggudarna på hällristningarna i Släbro från 2300-talet f. Kr.</figcaption></figure>
  </div>
  <div class="">
    <img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_22-5.jpg" class="wp-image-6667" alt="Symbolillustration, Släbro" style="width:100%;height:auto;display:block">
  </div>
</div>



<figure class="wp-block-image"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_25-5.jpg" class="wp-image-6668" alt="Avritning av bronsfigurer från Grevensvaenge" /><figcaption class="wp-element-caption">Bild 1. Avritning av bronsfigurer från Grevensvaenge, Danmark.</figcaption></figure>



<figure class="wp-block-image"><img src="https://elbilen.se/wp-content/uploads/sites/3/2026/09/5-2026_den-dysfunktionella-_Asagudar_Mytologi_27-5.jpg" class="wp-image-6669" alt="Bronsfiguren från Grevensvangefyndet" /><figcaption class="wp-element-caption">Bild 1. Allt som återstår av tvillinggudarna i Grevensvangefyndet. <cite>Foto: Nationalmuseet, DK</cite></figcaption></figure>
