34 resmål


<p class="has-medium-font-size"><strong>Runstenssafari, Roms dolda pärlor och massor av internationella utställningar och arkeologiska platser – vi tipsar om spännande besöksmål i sommar.</strong></p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/03/prag-1024x680.png" alt="" class="wp-image-2145" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Varför inte besöka Nationalgalleriet i Prag i sommar? Här visas buddhistisk konst från 100-talet och framåt. Foto: Unsplash</mark></strong></figcaption></figure>



<h2 class="wp-block-heading" style="font-size:25px"><mark class="has-inline-color has-luminous-vivid-orange-color">Vikingaguiden</mark> </h2>



<p class="has-medium-font-size"><strong>Av: Kristina Ekero Eriksson</strong></p>



<p class="has-medium-font-size"><strong>För den som är intresserad av vikingatiden finns en mängd resmål i Norden väl värda ett besök. Här listar vi sju av dem – och bjuder på tio tips för dig som vill åka på runstenssafari.</strong></p>


<div class="wp-block-image">
<figure class="alignright size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/276046219_1342409972851752_1519694091411520245_n-edited.jpg" alt="" class="wp-image-2146" width="398" height="398" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Rekonstruerade vikingatida dräkter. FOTO: Björn Falkevik</mark></strong></figcaption></figure></div>


<p style="font-size:18px"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">SVERIGE</mark></strong><br /><strong>GOTLAND</strong></p>



<p class="has-medium-font-size"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">Spillingsskatten</mark></strong></p>



<p>Världens största vikingatida silverskatt hittades år 1999 i en åker i Spillings nära Slite på Gotland. Skatten hade grävts ned i två depåer under ett vikingatida hus. Den väger 67 kilo och består bland annat av drygt 14 000 mynt som mestadels är islamiska, armringar, halsringar och smala tackor. En oförglömlig syn! Yngsta myntet är präglat 871 vilket ger en vägledning om fyndets ålder. Finns att beskåda på Gotlands museum i Visby.</p>



<ul class="wp-block-list">
<li><a href="http://gotlandsmuseum.se">gotlandsmuseum.se</a></li>
</ul>



<p></p>



<p style="font-size:18px"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">SVERIGE</mark><br />VALLENTUNA</strong></p>



<p class="has-medium-font-size"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">Granby vikingagård</mark></strong></p>



<p>Vallentuna norr om Stockholm är världens runstenrikaste trakt. Här ligger Granby vikingagård med en av Sveriges största runhällar, där man kan läsa om Finnvid ”som ensam ägde allt först”. Intill ståtar en synlig husgrund från en 33 meter lång hallbyggnad och ett stenkast bort finns gårdsgravfältet. Här kan man drömma sig bort i ruinerna av en stormannagård. </p>



<ul class="wp-block-list">
<li>Guide kan bokas på: <a href="http://hokeriet.se">hokeriet.se</a></li>
</ul>



<p></p>



<p style="font-size:18px"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">SVERIGE</mark></strong><br /><strong>BJÖRKÖ OCH ADELSÖ</strong></p>



<p class="has-medium-font-size"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">Birka och Hovgården</mark></strong></p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/03/275920615_989440598347372_1977867207815968181_n-1-1024x730.jpg" alt="" class="wp-image-2048" width="372" height="265" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Adelsö och Hovgården. illustration: Mats Vänehem</mark></strong></figcaption></figure></div>


<p>På ön Björkö i Mälaren låg den vikingatida handelsplatsen Birka. Av själva ”staden” syns ingenting, men det finns 3&nbsp;000 gravar, en fornborg och en stadsvall att avnjuta. I utställningen ”Begravd på Birka” på öns museum uppmärksammas fyra vikingatida individer från tre århundraden, vars utseenden och föremål återskapats. Däribland den kvinnliga krigare som på 900-talet begravdes med två hästar, sköldar, spjut, svärd, knivar, pilar och yxa. På ön finns också rekonstruerade hantverkshus.</p>



<p>   På grannön Adelsö ligger Hovgården där Birkas kung sannolikt residerade. Här finns flera terrasser där det kan ha stått hallar samt tre stora gravhögar. När högen ”Skopintull” undersöktes år 1917 påträffades kvarlevorna efter en man och en kvinna. De hade bränts i en båt tillsammans med ett stort antal djur, däribland häst, nöt, svin, rovfågel och något så sällsynt som en dvärghund. Delar av mannens och kvinnans kranier hade lagts i ett bronskärl där det också låg en stor hårlock. Med all säkerhet bar paret praktfulla dräkter, därom vittnar vackert hantverk av guldtråd och ett bälte av orientalisk typ. På Adelsö finns ett informationscenter där man bland annat kan se arkeologkonstnären Mats Vänehems tecknade rekonstruktioner av platsen. Fynd från Birka och Skopintull visas i utställningen ”Vikingarnas Värld” på Historiska museet i Stockholm.</p>



<ul class="wp-block-list">
<li><a href="http://historiska.se">historiska.se</a></li>



<li><a href="http://birkavikingastaden.se">birkavikingastaden.se</a></li>
</ul>



<p></p>



<p style="font-size:18px"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ISLAND<br /></mark>THINGVELLIR</strong></p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/03/4.-Thingvellir-Diego-Delso--1024x683.jpg" alt="" class="wp-image-2025" width="434" height="289" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">foto: Diego Delso</mark></strong></figcaption></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">Thingvellir och Snorres pool<br /></mark></strong>På Thingvellir möttes alltinget årligen, det var på denna magiska plats som beslutet att övergå till kristendomen fattades runt år 1000.</p>



<p>   På Island är allt som i en saga. Snorre Sturlasson levde förvisso inte under<br />vikingatiden, men det var han som satte deras berättelser på pränt. Varför inte besöka denne författares egen pool? I Reykholt finns en varm källa där han lär ha relaxat. Det var också på denna gård han mördades 1241.</p>



<p></p>



<p style="font-size:18px"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">NORGE<br /></mark>OSLO</strong></p>



<p class="has-medium-font-size"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">Kulturhistorisk museum</mark></strong></p>


<div class="wp-block-image">
<figure class="alignright size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/03/2.-Hoen-Mona-Knudsen.-KHM.jpg" alt="" class="wp-image-2019" width="338" height="326" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Urnesspänne med drake från Sør-Fon. Foto: Ellen C Holte, KHM</mark></strong></figcaption></figure></div>


<p>Låt dig hänryckas av det vikingatida hantverket på Kulturhistorisk museum i Oslo. I utställningen VÍKINGR visas de yppersta av fynd, bland annat Norges största vikingatida guldskatt från Hoen. Den påträffades 1834 och innehåller stora guldhalsringar, ett enormt treflikigt spänne som sannolikt tillverkats vid det karolingiska hovet och romerska smycken som var antikviteter redan på vikingarnas tid.</p>



<p>   I utställningen ”Dyraktige fabler – fra jernalder og vikingtid” kan du grotta ned dig i djurornamentiken som dekorerade nordbornas värld under 700 år – ända till slutet av vikingatiden. Då betraktades djuren som människans följeslagare, både fysiskt och mentalt.</p>



<ul class="wp-block-list">
<li><a href="http://khm.uio.no">khm.uio.no</a></li>
</ul>



<p></p>



<p style="font-size:18px"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DANMARK<br /></mark>JELLING</strong></p>



<p class="has-medium-font-size"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">Jelling på Jylland</mark></strong></p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/03/3.-Jelling-Nationalmuseum-Kopenhamn-1024x576.jpg" alt="" class="wp-image-2021" width="452" height="254" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Jelling. Foto: Nationalmuseet i Köpenhamn</mark></strong></figcaption></figure></div>


<p>Man kan tycka att Harald Blåtand (död cirka 986) skulle ha nöjt sig med två jättelika högar, en kyrka och en runsten där han deklarerade att han vunnit sig hela Danmark och Norge – samt gjort danerna kristna. Men på sitt kungasäte i Jelling lät han dessutom uppföra en 356 meter lång skeppssättning, som rymmer ovan nämnda monument. Dessutom restes en palissad som omgärdade en yta stor som 20 fotbollsplaner. ”Kongernes Jelling” ger garanterat en upplevelse utöver det vanliga.</p>



<p>   Den som inte blir mätt på detta kan titta på någon av Harald Blåtands fem fornborgar, exempelvis Fyrkat på Jylland.</p>



<ul class="wp-block-list">
<li><a href="http://www.natmus.dk">www.natmus.dk</a></li>



<li><a href="http://www.nordjyskemuseer.dk">www.nordjyskemuseer.dk</a></li>
</ul>



<p></p>



<h2 class="wp-block-heading" style="font-size:25px"><mark class="has-inline-color has-luminous-vivid-orange-color">Åk på runstenssafari!</mark></h2>



<p class="has-medium-font-size"><strong>Ett ljuvligt sätt att fördriva en lång sommar är att bege sig ut i Sverige på runstenssafari. Från Tullstorp i Skåne i söder till Frösön i norr finns mer än två tusen bevarade runstenar. Vi bad runexperten Magnus Källström vid Riksantikvarieämbetet att välja ut några av sina favoritrunristningar. En av dem är i textil form, en annan utförd med ovanliga knutrunor. Ytterligare en är betydligt äldre än sina vikingatida syskon. Alla är lika sevärda!</strong></p>



<div class="wp-block-columns is-layout-flex wp-container-core-columns-is-layout-9d6595d7 wp-block-columns-is-layout-flex">
<div class="wp-block-column is-vertically-aligned-center is-layout-flow wp-block-column-is-layout-flow" style="flex-basis:60%">
<figure class="wp-block-image size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/03/6igen-kopiera-1.jpg" alt="" class="wp-image-2147" width="481" height="420" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Knutrunor i Ovansjö. FOTO: RAÄ</mark></strong></figcaption></figure>
</div>



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



<p class="has-medium-font-size"></p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/04/KARTA-1024x845.jpg" alt="" class="wp-image-3749" /></figure>



<p></p>



<h2 class="wp-block-heading" style="font-size:25px"><mark class="has-inline-color has-luminous-vivid-orange-color">6 Rom-tips för resesugna</mark> </h2>



<p class="has-medium-font-size"><strong>Av: Allan Klynne</strong></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/6-RESOR-edited-1024x1024.png" alt="" class="wp-image-2150" width="417" height="417" /><figcaption class="wp-element-caption"><strong><mark><mark style="background-color:#ffffff" class="has-inline-color has-black-color">Pantheon vid Piazza della Rotonda i Rom, ett antikt tempel. Foto: Unsplash</mark></mark></strong></figcaption></figure></div>


<p class="has-medium-font-size"><strong>Gömda pärlor. Rom är så fullt av lämningar från olika epoker att man omöjligen hinner med att se allt ens under en längre vistelse. Turisten besöker ofta inte mer än Forum Romanum, Palatinen och något av de större museerna. Men för den som har tid och lust finns både gömda och förbisedda platser som är värda ett besök. Allan Klynne ger tips om sex ställen du inte bör missa.</strong></p>



<p></p>



<h2 class="wp-block-heading" style="font-size:23px"><mark class="has-inline-color has-luminous-vivid-orange-color">1. EUR – Esposizioni Universale di Roma</mark></h2>


<div class="wp-block-image">
<figure class="alignleft size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/03/EUR-1-1024x683.jpg" alt="" class="wp-image-2067" width="442" height="295" /></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">EN BIT SÖDER</mark></strong> om Roms gamla stadskärna ligger EUR, som går att nå på några minuter med pendeltåg. Akronymen står för Esposizioni Universale di Roma, och området var tänkt att ge uttryck för fascismens estetiska ideal i samband med en världsutställning 1942 som aldrig blev av. Mussolini hade på 1930-talet förklarat att Rom måste bli värdigt att vara fascismens huvudstad i ett nytt romerskt imperium. Den mest iögonfallande byggnaden är den så kallade Colosseo Quadrato, ”det kvadratiska Colosseum”, ett blockliknande kontorskomplex som var avsett att ta emot besökande delegationer och journalister. Men här finns också kongress- och utställningshallar byggda i italiensk funkis, den stil som på italienska kallas razionalismo, där utsmyckning, skulpturer och inskrifter som hyllar det fascistiska Rom fortfarande finns kvar. Bokstäverna EF som går att se här och var betyder era fascista, ”den fascistiska tideräkningen”, med romerska siffror i anslutning som utgår från Mussolinis maktövertagande 1922. Att Mussolini inte ville stå i skuggan av de romerska kejsarna märks tydligt på den konstnärliga utsmyckningen vid entrén till den kvadratiska kolossen. Diktatorn framställs på ett sätt som associerar till reliefen på den berömda Trajanuskolonnen där kejsaren hälsas av sitt folk och sina soldater. Efter en rundvandring i detta levande monument över en gången epok som många vill glömma men andra fortfarande hyllar kan man slå sig ned med en glass i parken med sina väldiga fontäner, och begrunda det faktum att EUR i dag räknas som en av Roms mest fashionabla närförorter.</p>



<p></p>



<h2 class="wp-block-heading" style="font-size:23px"><mark class="has-inline-color has-luminous-vivid-orange-color">2. Aurelianusmuren och Murmuseet </mark></h2>



<p style="font-size:18px"><strong><mark class="has-inline-color has-black-color">Porta San Sebastiano</mark></strong></p>


<div class="wp-block-image">
<figure class="alignleft size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/03/Aurelianusmuren-4.jpg" alt="" class="wp-image-2053" width="303" height="454" /></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">AURELIANUSMUREN ÄR ROMS</mark></strong> i särklass största monument. Det 18 kilometer långa och på sina ställen 13 meter höga skyddsvärnet är dessutom relativt välbevarat. Muren uppfördes i hast under 270-talet e.Kr. på kejsar Aurelianus order, dels till stadens försvar, dels för att avskräcka barbarerna som hade fallit in i Norditalien. Den ursprungligen 7,5 meter höga och 3,5 meter tjocka muren byggdes senare på i olika omgångar med förbättrade förutsättningar för artilleri. Inuti Porta San Sebastiano med sina 28 meter höga torn invigdes 1990 ett museum ägnat åt Roms murar. Utställningen förklarar tekniken som användes vid konstruktionen, och hur manskap och katapulter tänktes försvara den eviga staden. Tegelstämplar vittnar om arbetslagens organisation under olika kejsare, och modeller av lyftkranar och krigsmaskiner ger en aning om de logistiska utmaningarna. Dessutom kan man se inskrifter och graffiti på väggar och valv, bland andra en på grekiska som tackar S:t Göran för en seger över goterna 403 e.Kr. Här finns också små kapell med fresker från tidigkristen tid. Det har länge funnits planer på att öppna hela Aurelianusmuren för besökare, men än så länge får man nöja sig med en 380 meter lång promenadväg uppe på muren. Utsikten är fantastisk. Trädgårdarna innanför muren förmedlar samtidigt en känsla av hur Rom såg ut på medeltiden. <strong>Gratis inträde.</strong></p>



<p></p>



<h2 class="wp-block-heading" style="font-size:23px"><mark class="has-inline-color has-luminous-vivid-orange-color">3. Auditorium parco della musica </mark></h2>



<p style="font-size:18px"><strong><mark class="has-inline-color has-black-color">Via Pietro de Coubertin 30</mark></strong></p>


<div class="wp-block-image">
<figure class="alignleft size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/03/Auditorium-1.jpg" alt="" class="wp-image-2052" width="379" height="371" /></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">EN BIT UTANFÖR</mark></strong> Roms norra stadsport och Piazza del Popolo ligger Olympiabyn från 1960 och Roms nya konserthall Auditorium som invigdes 2002. I samband med byggnationen hittade arkeologerna rester av en romersk villa som hade byggts på och ut i flera faser, varav den äldsta kan dateras till 500-talet f.Kr. Upptäckten var sensationell eftersom den pressade tillbaka beläggen för det romerska atriumhuset med flera hundra år. Bland fynden märks ett välbevarat taktegel med en vattenkastare i form av den grekiska flodguden Acheloos från 300-talet f.Kr., samt attisk keramik från 400-talet f.Kr. vilket är mycket ovanligt i Rom. Villan med sina ekonomibyggnader och olivoljepress kastar ljus över hur livet tedde sig då Rom ännu inte blivit republik utan fortfarande var ett kungadöme. Konserthusets skapare – den italienske arkitekten Renzo Piano – sparade de antika murarna mellan konserthusets tre hallar, och avsatte även plats för fynden som alltså går att beskåda på plats. Dessutom visas fynd i form av offergåvor och botaniska rester som kärnor och frön från en helgedom en bit därifrån, vilken identifierats som Anna Perennas heliga lund, en plats där romarna den 15 mars varje år firade våren med picknick och bus i busken. Roms nya konserthus erbjuder sålunda både musik och arkeologi, och på vintern även skridskoåkning på Roms enda fungerande utomhusrink. <strong>Gratis inträde.</strong></p>



<p></p>



<h2 class="wp-block-heading" style="font-size:23px"><mark class="has-inline-color has-luminous-vivid-orange-color">4. Pomponius Hylas columbarium </mark></h2>



<p style="font-size:18px"><strong><mark class="has-inline-color has-black-color">Porta San Sebastiano</mark></strong></p>


<div class="wp-block-image">
<figure class="alignleft size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/03/Pomponius-Hylas-2-1024x683.jpg" alt="" class="wp-image-2101" width="370" height="247" /></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DENNA GRAV SOM</mark></strong> ligger alldeles intill en lekplats i Scipionernas park upptäcktes 1831. Överbyggnaden är i dag borta och ersatt av ett litet hus, genom vilken man går ned i graven via en trång trappa. I en nisch sitter en mosaik med en text som upplyser att graven tillhör Gnaeus Pomponius Hylas och hans hustru Pomponia Cn. L(iberta) Vitale, med andra ord hans frigivna slavinna, vilka avled någon gång på 70/80-talet e.Kr. Men graven byggdes ursprungligen ca 20 e.Kr. och utvidgades senare med gravplatser åt människor med olika bakgrund, både sådana som tillhörde ett collegium (människor med samma yrke) och frigivna slavar. Bland de senare märks en som tjänat under kejsar Tiberius och två som ägts av Claudia Octavia, dotter till kejsar Claudius och Messalina. Gravnischerna för askurnorna och gavelfälten är exceptionellt välbevarade med glasmosaiker och målad stuck. Här känns det som att tiden har stått stilla. <strong>Förbokning krävs, max 7 personer. Tel. +39-060608</strong></p>



<p></p>



<h2 class="wp-block-heading" style="font-size:23px"><mark class="has-inline-color has-luminous-vivid-orange-color">5. Scipionernas grav </mark></h2>



<p style="font-size:18px"><strong><mark class="has-inline-color has-black-color">Via di Porta San Sebastiano 9</mark></strong></p>


<div class="wp-block-image">
<figure class="alignleft size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/03/Scipionernas-grav-1-1024x683.jpg" alt="" class="wp-image-2107" width="390" height="260" /></figure></div>

<div class="wp-block-image">
<figure class="alignleft size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/03/Scipionernas-grav-2-1024x683.jpg" alt="" class="wp-image-2108" width="385" height="257" /></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">SCIPIONERNA VAR EN</mark></strong> romersk ätt med flera berömda medlemmar: Scipio Africanus (som besegrade Hannibal), Scipio Asiaticus (som besegrade den syriske kungen Antiochos III) och Scipio Aemilianus (som förstörde Karthago). Familjegraven upptäcktes 1614 i samband med bygget av en cantina (vinkällare) i det hus som nu hyser lämningen, och har sedan dess undersökts i flera etapper. Planlösningen har drag av etruskisk klippgrav med ett centralt rum och flera mindre kammare. Vid öppnandet innehöll graven åtta sarkofager från 200-talet och 100-talet f.Kr., men hål i väggarna visar att där ursprungligen fanns trettio. Den äldsta tillhör Lucius Cornelius Scipio Barbatus (”den skäggige”) som var konsul 298 f.Kr., alltså vid den tid då romarna fortfarande stred mot etrusker, samniter och andra italiska folk om herraväldet över Italien. Utformningen med dorisk fris och joniska voluter visar på inflytande från det grekiska Syditalien. Inskriften är en av de äldsta på latin, inmejslad över hundra år efter den skäggiges död, och förklarar att denne var en ”modig och vis man, vars fysiska skönhet stod i samklang med hans tapperhet”. Bland övriga sarkofager märks den Scipio som erövrade Korsika, hans sonson som blev 20 år, liksom dennes mor Paulla Cornelia. En annan inskrift nämner P. Cornelius Scipio som var augur (en präst som tydde fåglarnas flykt) men dog ung: ”Du bar flamen Dialis spetshatt. Döden gjorde dina dåd kortlivade”. Förmodligen var det hans adoptivson Scipio Aemilianus som lät iordningställa graven till ett veritabelt monument på 130-talet f.Kr. När Roms stadsbebyggelse senare expanderade och det enorma badhuset Caracallas termer uppfördes i närheten i början av 200-talet e.Kr. byggdes graven in i ett hus och glömdes bort. Sarkofagerna är trogna kopior av originalen som skingrats till olika museer. <strong>Förbokning krävs, max 12 personer.<br />Tel. +39-060608</strong></p>



<p></p>



<h2 class="wp-block-heading" style="font-size:23px"><mark class="has-inline-color has-luminous-vivid-orange-color">6. Den protestantiska kyrkogården </mark></h2>



<p style="font-size:18px"><strong><mark class="has-inline-color has-black-color">Via Caio Cestio 6</mark></strong></p>


<div class="wp-block-image">
<figure class="alignleft size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/03/BEGRAVNING-1024x747.jpg" alt="" class="wp-image-2151" width="415" height="302" /></figure></div>


<p><strong><mark class="has-inline-color has-luminous-vivid-orange-color">DENNA KYRKOGÅRD, SOM</mark></strong> egentligen heter Cimitero Acattolico di Roma eller ”Roms icke-katolska kyrkogård”, ligger precis utanför Porta Ostiense intill den berömda Cestius-pyramiden (en romersk grav i faraonisk stil). Den inrättades på 1720-talet när invånare med en annan tro än den katolska blivit så vanliga i Rom att de behövde en ordentlig begravningsplats. Ändå var jordfästningarna tvungna att ske nattetid under militär bevakning. Först efter Kyrkostatens fall 1870 blev det tillåtet att smycka gravstenarna med kristna symboler eller citat ur Bibeln. Omkring 4 000 människor ligger begravda här på det som också kallas konstnärernas och poeternas kyrkogård. Poesidyrkare samlas vid stenen över John Keats (1795–1821), vars inskrift lyder ”Här ligger en, vars namn var skrivet i vatten.” Alldeles intill finns graven över Percy Bysshe Shelley (1792–1822) och hans och Mary Shelleys treårige son William. Här vilar också August von Goethe, den store diktarens ende (utomäktenskaplige) son, liksom kända och okända skottar, amerikaner, ryssar och andra nationaliteter, ibland med påkostade och artistiskt intressanta gravvårdar. För svensk del märks särskilt diplomaten och språkgeniet Johan David Åkerblad (1763–1819), berömd för att ha upptäckt runorna på Pireuslejonet i Venedig (en fullskalig kopia går att se på Historiska Museet i Stockholm) och framför allt för att ha knäckt den demotiska skriften på Rosettastenen och nästan löst hieroglyfernas gåta före Champollion. Bland övriga kända svenskar märks skulptören Johan Niclas Byström (1783–1848), ambassadören Carl Bildt (1850–1931), skulptören Ruth Milles (1873–1941) samt poeten och bohemen Harald Jacobsson (1863–1913), känd för raderna ”Sverige är mitt allt på jorden”. Den protestantiska kyrkogården rankas som nummer 33 av 675 sevärdheter i Rom. <strong>Gratis inträde.</strong></p>
