I korthet
Traduttori, traditori. Översättare är förrädare. Den som står anklagad för förräderi är Emily Wilson och offret är Homeros Iliad.
<div class="kv-article-audio-player">  <div class="kv-aap-listen">    <div class="kv-listen-left">      <span>        <i class="fas fa-headphones-alt"></i>      </span>    </div>    <div class="kv-aap-listen-right">      Lyssna på texten    </div>  </div><div id    = "kv-pod-holder-112561"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="112561" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC9rcmlnZXQtb20tbnlvdmVyc2F0dG5pbmdlbi1hdi1pbGlhZGVuLTQtNTMubXAz" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgva3JpZ2V0LW9tLW55b3ZlcnNhdHRuaW5nZW4tYXYtaWxpYWRlbi00LTUzLm1wMw==">  <div class="kv-pod-holder-inner">    Laddar <span class="blink-me">...</span>  </div></div>  <div class="kv-listen-subscribe">    <span>Följ Kvartals poddar:</span>    <a target="_blank" href="https://podcasts.apple.com/se/podcast/kvartal/id1447122576?mt=2">Apple</a>    |     <a target="_blank" href="https://open.spotify.com/show/6NsieE1iFLypikr3slKII0?si=ppaUJpA3R-mo8L9L4XgudA">Spotify</a>  </div></div><div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/fredrik-sixtensson/">Fredrik&nbsp;Sixtensson</a> | 2 november 2023<div style="float: right;" class="social-top-wrapper closed no-comments"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fkriget-om-nyoversattningen-av-iliaden%2F&amp;t=Kriget+om+ny%C3%B6vers%C3%A4ttningen%3Cbr%3Eav+Iliaden"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Kriget+om+ny%C3%B6vers%C3%A4ttningen%3Cbr%3Eav+Iliaden+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fkriget-om-nyoversattningen-av-iliaden%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fkriget-om-nyoversattningen-av-iliaden%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Kriget om nyöversättningen<br>av Iliaden&body=https://kvartal.se/artiklar/kriget-om-nyoversattningen-av-iliaden/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/112561/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/112561/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div></div><div class="author-section author-section-external">  <div class="author-section-inner">    <div class="author-image-holder"><span class="icon-kvartal-hare"></span>    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Eventuella åsikter och slutsatser i texten är skribentens egna.    </div>  </div></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fkriget-om-nyoversattningen-av-iliaden%2F&amp;t=Kriget+om+ny%C3%B6vers%C3%A4ttningen%3Cbr%3Eav+Iliaden"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Kriget+om+ny%C3%B6vers%C3%A4ttningen%3Cbr%3Eav+Iliaden+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fkriget-om-nyoversattningen-av-iliaden%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fkriget-om-nyoversattningen-av-iliaden%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Kriget om nyöversättningen<br>av Iliaden&body=https://kvartal.se/artiklar/kriget-om-nyoversattningen-av-iliaden/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/112561/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/112561/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a class="listen" href="https://kvartal.se/artiklar/kriget-om-nyoversattningen-av-iliaden/?inlast=1">  <i class="fas fa-headphones-alt"></i>  <span>Inlästa texter</span></a><a href="#nyhetsbrevet" onclick="newsletter()" class="newsletter"><i class="fas fa-paper-plane"></i><span>Nyhetsbrev</span></a><a class="reading-time" title="Ungefärlig lästid"><i class="far fa-clock ui"></i><span>Lästid 6 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/112561"    target = "_blank"    class  = "screen-reader-friendly"    title. = "Version som fungerar bättre med skärmläsarprogramvara">  <i class="fas fa-volume-up"></i>  <span>Skärmläsarvänlig</span></a></div><div class="in-short-wrapper closed" id="in-short-112561">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "112561"></span>    <i class="themify-icon-icon fas fa-align-left"></i>    <span class="in-short-heading">I korthet</span>    <hr class="in-short-divider" />    <div class="in-short-text">    </div>  </div></div><div class="article-beginning "><em>Traduttori, traditori</em>. Översättare är förrädare. Den som står anklagad för förräderi är <strong>Emily Wilson</strong> och offret är Homeros <em>Iliad</em>.</p>
</div>
<div class="rest-of-article ">
<p>Åtminstone låter det så ibland. Emily Wilson har förutom <em>Iliaden</em> tidigare översatt <em>Odysséen</em>. Bägge<span style="color: #0000ff;"><strong> </strong></span>har blivit mycket omskrivna. Ett vanligt omdöme är att de är särskilt läsvänliga. Det tycks stämma; de verkar ha spritt Homeros till en publik som annars inte hade läst.</p>
<p>Men enligt somliga kommer genomslaget med ett högt pris: översättningarna är inte bara lätta att läsa, de är också platta och tråkiga. Inte heller är de trogna mot originalet. Wilson påpekade i en intervju att vissa tycker att <strong>Homeros</strong> ska låta hjältemodig och ålderdomlig – underförstått att han inte nödvändigtvis är det.<sup>1</sup> Det blev föremål för en hånfull twitterkritik, som blev viral. ”Säger du det, Homeros hjältemodig och ålderdomlig?” ungefär.</p>
<h2>Översättaren – en förrädare?</h2>
<p>Men vår bild av Homeros är präglad av tidigare översättningar. I Sverige är vi särskilt färgade av <strong>Erland Lagerlöfs</strong>. Den är briljant. Men den tillkom 1912 och var redan för sin tid ganska ålderdomlig. Den är nationalromantisk, talar om svenner och drottar och gravöl. I <em>Odysséen</em> beskrivs rentav hjältens följe som en ”vikingaskara på hav”. Men eftersom Lagerlöf är kanoniserad vill somliga nog att en översättning – även om den görs i dag – bör låta ungefär som hans.</p>
<p>Några stickprov på Lagerlöf och Wilson kan visa på skillnaderna. På ett ställe beskrivs hur grekerna och trojanerna har fått till stånd en vapenvila.<sup>2</sup> Lagerlöf skriver: ”Dessa, som bragte förut mot varandra därute på slätten / härnadens jämmer …”. Wilson översätter samma rader ”<em>Across the plain they carried to each other / Ares, the god of tears, the god of war.</em>”</p>
<p>Båda rader betyder väl ungefär: ”De som tidigare stred på fältet …”. Men hur lyder grekiskan? Jag försöker översätta så ordagrant jag kan till korrekt svenska. Det blir då: ”De som tidigare bar till varandra tårfyllde Ares på fältet.”</p>
<p>Lagerlöf tolkar den tårfyllde <strong>Ares</strong> som en omskrivning för krigets bedrövelser. Det stämmer. Men grekiskan får större genomslag hos Wilson, som liksom Homeros beskriver det som att krigsguden bärs fram och tillbaka över fältet.</p>
<p>Ett annat stickprov: frasen <em>anax andrōn</em>, ett av <strong>Agamemnons</strong> epitet som tillsammans med hans namn upptar drygt en halv hexameterrad: a/<strong>nax</strong> and/<strong>ron</strong> Aga/<strong>mem</strong>non. Lagerlöf översätter ”härskarornas drott”, Wilson översätter <em>”lord of men</em>”. Skillnaden är tydlig. Lagerlöf är ”hjältemodig och ålderdomlig”. Wilson låter i stället torrt saklig.</p>
<p>Jag översätter igen. Det första ordet, <em>anax</em>, är ett gammalt ord för kung som i <em>Iliaden</em> betyder ”härskare” eller kanske ”herre”. Det andra ordet, <em>andrōn,</em> betyder ”männens”. Alltså ”männens herre”.</p>
<p>Vilket man <em>föredrar</em> är en smaksak. Men vad som är <em>mest autentiskt</em> avgörs inte av vad man tycker bäst om. Inte heller av invanda föreställningar om hur Homeros bör låta. Man måste utgå från den grekiska ordalydelsen. Och gör man det är det uppenbart att den som ligger närmast grekiskan är Wilson – igen.</p>
<h2>Ordagrann översättning gör våld på versen</h2>
<p>Hur kan två översättningar ha så olika stil? Det beror förstås delvis på vad översättaren eftersträvar. Men stilen är också en följd av formen. Den som översätter episk poesi inser snart att ordagrant språk gör våld på versen och tvärtom. En orsak är att grekiskan är förhållandevis stavelserik: använder fler stavelser för att uttrycka färre saker. Risken blir då att den som översätter till hexametern måste fylla ut. Hur gör man det? I regel genom att bli omständlig. Och det omständliga blir gärna mer poetiskt. Det är därför på sätt och vis inbyggt i översättningar till hexameter att Homeros blir mer högtravande än han faktiskt är.</p>
<p>Redan i <em>Iliadens</em> första rad ser vi lite högtravande utfyllnad. Någorlunda ordagrant översatt lyder den: ”Gudinna! Besjung Peleusättlingen Akilles vrede!”<sup>3</sup> Detta återger innehållet ordagrant på en felfri svenska. Det är dock inte hexameter utan prosa. Fortsätter vi så här blir <em>Iliaden</em> en roman.</p>
<p>Lagerlöf översätter till hexameter: ”Sjung, o Gudinna, om vreden som brann hos peliden Akilles.” För att få till en bra rytm har Lagerlöf fyllt ut raden och låter vreden brinna.<sup>4</sup> (På grund av Lagerlöfs val brinner vreden också i <strong>Ingvar Björkesons</strong> översättning.) Översättningen är på sitt sätt genial. Den lånar sig till en ringkomposition; vreden brinner i första raden, och i de sista raderna brinner gravbålet för <strong>Hektor</strong> – och vreden slocknar. Det är fantastiskt – men det finns inte hos Homeros.</p>
<blockquote><p>Att ”förråda” är översättningens själva villkor.</p></blockquote>
<p>Wilson översätter till blankvers. Den är kortare än hexametern, vilket minskar behovet av utfyllnadsord. Hennes inledning lyder: ”<em>Goddess, sing of the cataclysmic wrath / of great Achilles, son of Peleus</em> . . . ” Vreden är ”<em>cataclysmic</em>”, vilket motsvarar andra radens första ord, <em>oulomenēn </em>(hos Lagerlöf ’olycksdiger’, ordagrant kanske ’förödande’) – Wilson har bytt plats för att få meningsbyggnaden att stämma.<sup>5</sup> Hon har inte behövt fylla ut raden annat än med epitetet ”<em>great</em>”. Det översätter troligen grekiskans <em>dios Achilleus</em>, som finns på andra ställen i texten. I så måtto är Wilson närmare<span style="color: #0000ff;"><strong> </strong></span>Homeros.</p>
<p>Man kan i och för sig ifrågasätta annat. Som här: är <em>oulomenēn </em>”<em>cataclysmic</em>”? Tja. Det grekiska ordet beskriver något världsomvälvande – precis som ”<em>cataclysmic</em>”. Å andra sidan är det något som skaver med att återge ett grekiskt ord med vad som i princip är ett annat – <em>kataklysmos </em>är grekiska för ’översvämning’. <em>Pyrgos </em>översätts ibland till ’<em>battalion’</em>, vilket leder tankarna till en modernare form av slagordning.<sup>6</sup> Wilson säger dessutom i förordet att hon undviker vissa översättningar – till exempel att beskriva <strong>Priamos</strong> boning som ett slott – för att <em>slippa </em>associationer till medeltiden och tidigmodern tid.<sup>7</sup> Uttrycket <em>ou kata kosmon</em>, ordagrant ’inte med ordning’ eller kanske ’inte enligt Ordningen’, blir någon gång ’<em>lawless crimes</em>’.<sup>8</sup> I sammanhanget handlar det om Ares som har massakrerat greker i strid. Fruktansvärt förstås, men knappast brott i juridisk bemärkelse.</p>
<p>Så här kan man bena i enskilda ord. Men det är en billig och till intet förpliktigande kritik. Desto svårare är det att komma med egna förslag. Och sådana har jag inga.</p>
<p>Lagerlöf är heller knappast bättre. <em>Pyrgos</em> blir ”fylken” – vi är återigen i vikingatiden. Och <em>ou kata kosmon</em> blir ’utan försyn eller skick’, ungefär som om Ares hade keps på sig i klassrummet.</p>
<p>Att ”förråda” är översättningens själva villkor. Att Wilson skulle vara värre än någon annan är strunt. Ryktet om att språket urvattnats är också överdrivet. Texten är rik på formuleringar som ”<em>deathless Zeus”</em>, ”<em>Lord Meriones, who slaughtered men”</em> och ”<em>across the wine-dark sea”</em>. Och när vi läser dem faller förlåten. Vi ser plötsligt in i ögonen på samma Homeros som Erland Lagerlöf älskade.</p>
<p><a href="#_ftnref1" name="_ftn1"></a></p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="112561">  <span class="button-inner-wrapper">    <span class="left-part">      <i class="ti-arrow-circle-down"></i>    </span>    <span class="right-part">      <span class="default-text">Se noter</span>      <span class="open-text">Visa mindre</span>    </span>  </span></a></p>
<div class="references">
<h3 id="noter" class="ref-heading" style="color: #000;;">Noter</h3>
<p>1, Vox 2017-11-20. North, Anna. Historically, men translated the Odyssey. Here’s what happened when a woman took the job. https://www.vox.com/identities/2017/11/20/16651634/odyssey-emily-wilson-translation-first-woman-english</p>
<p><em>2, Il</em>. 3. 172–3 (utläses: Iliadens tredje sång, vers 172–3).</p>
<p>3, <em>Il. </em>1.1: <em>Mēnin aeide, thea, Pēlēiadeō Achilēos</em>.</p>
<p>4, Hexametern bevaras faktiskt om branden stryks. Rytmen blir dock klumpigare: ”Sjung, o Gudinna, om vreden hos peliden Akilles.”</p>
<p>5, <em>Il.</em>1.2: <em>oulomenēn, hē myri’ Achaiois alge’ ethēken</em>.</p>
<p>6, <em>Il</em>. 4.137.</p>
<p>7, Emily Wilson, <em>Iliad</em>, lxvii.</p>
<p>8, <em>Il.</em> 5.759</p>
</div>
</div>
<div class="author-byline">Fredrik Sixtensson har doktorerat i klassisk grekiska och är forskare vid Handelshögskolan i Stockholm.
</div>
</div>
