Fredsfesten som blev till terror

<div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/anders-carlberg/">Anders&nbsp;Carlberg</a> | 30 april 2025<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%2Ffredsfesten-som-blev-till-terror%2F&amp;t=Fredsfesten+som+blev+till+terror"    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=Fredsfesten+som+blev+till+terror+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Ffredsfesten-som-blev-till-terror%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%2Ffredsfesten-som-blev-till-terror%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Fredsfesten som blev till terror&body=https://kvartal.se/artiklar/fredsfesten-som-blev-till-terror/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/175980/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer 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="kv-art-ext-sep"></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%2Ffredsfesten-som-blev-till-terror%2F&amp;t=Fredsfesten+som+blev+till+terror"    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=Fredsfesten+som+blev+till+terror+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Ffredsfesten-som-blev-till-terror%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%2Ffredsfesten-som-blev-till-terror%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Fredsfesten som blev till terror&body=https://kvartal.se/artiklar/fredsfesten-som-blev-till-terror/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/175980/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer 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 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 9 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/d9e642f5-8c26-438d-b48a-28a3a802186a"    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-175980">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "175980"></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 ">Tanken går till segerparader när jag tittar på Dagens Nyheters förstasida från den 2 maj 1975. Den ledande svenska dagstidningen rapporterar om förstamajfirandet i Stockholm, som ”blev … en stor fredsfest för Vietnam”.</p>
</div>
<div class="rest-of-article ">
<p>Texten beskriver även hur första maj firades i Saigon: ”Tre kolonner av tusentals stadsbor tillsammans med FNL-soldater, som hade blommor i gevärsmynningarna, marscherade mot presidentpalatset för att fira revolutionens seger och slutet på 1900-talets längsta krig.” DN skriver att den amerikanska ambassaden plundrades ”innan FNL hann återställa ordningen”.</p>
<figure id="attachment_176581" aria-describedby="caption-attachment-176581" style="width: 1024px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-176581 size-full" src="https://kvartal.se/wp-content/uploads/2025/04/sdlWUSdAxxPBbA-nl.jpg" alt="kvartal" width="1024" height="667" data-wp-pid="176581" srcset="https://kvartal.se/wp-content/uploads/2025/04/sdlWUSdAxxPBbA-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2025/04/sdlWUSdAxxPBbA-nl-300x195.jpg 300w, https://kvartal.se/wp-content/uploads/2025/04/sdlWUSdAxxPBbA-nl-768x500.jpg 768w, https://kvartal.se/wp-content/uploads/2025/04/sdlWUSdAxxPBbA-nl-600x391.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-176581" class="wp-caption-text">Saigon den 1 maj 1975. Foto; Frances Starner /TT</figcaption></figure>
<p>Det har nu gått 50 år sedan DN skrev om ”fredsfesten”, vilket i sig var ett eko av den vid tiden gängse bilden av slutet av Vietnamkriget. Till den hörde hur svenskar gick man ur huse för att protestera mot den amerikanska imperialismen. Nordvietnam stod för det nya, det progressiva, för hoppet och kampen mot kolonialism och kapitalism. Men är verkligen detta en korrekt beskrivning av historien?</p>
<h2>En annan bild av skeendet</h2>
<p>Syftet är inte att rättfärdiga USA:s krigföring i Vietnam. Men det finns skäl att ge en något annorlunda bild av skeendet än den som etablerats, i synnerhet fredsavtalet i Paris 1973 och vad som egentligen hände i Saigon i april 1975 och åren därefter.</p>
<p>Det stod givetvis klart även i Väst att målet för den nordvietnamesiska regimen inte var att skapa en demokrati utan en kommunistisk enpartistat. Kriget kan bäst karaktäriseras som ett <em>proxy war</em>, ett krig genom ombud, mellan kommunism och anti-kommunism, precis som tidigare varit fallet i Koreakriget.</p>
<p>Men vad som ofta förbises är det kinesiska och sovjetiska stödet till Nordvietnam. I mitten av sextiotalet fanns 3 000 sovjetiska rådgivare på plats, och runt 1970 kom långt mer än hälften av all nordvietnamesisk utrustning från Sovjet.</p>
<p>Sovjet bidrog dock inte med trupp, utan överlät detta till Kina. Det största antalet kinesiska soldater på plats var hela 170 000 (1967) och totalt stred 320 000 soldater vid någon tidpunkt i Nordvietnam. Och Hanoi bad om ökat stöd. År 1966 skrev en av Nordvietnams ledare till premiärminister <strong>Zhou Enlai</strong> och menade att det behövdes fler än 500 000 kinesiska soldater, och han fann det naturligt att en kommunistisk brodernation hjälpte till med detta.</p>
<p>Med USA:s närmande till Kina via till exempel <strong>Nixons</strong> besök blev det sovjetiska stödet än mer viktigt. Våren 1972 ökade Moskva sitt militära engagemang för Nord och skickade bland annat stridsvagnar och långdistansvapen till regimen. Det var det sovjetiska stödet som gjorde att Nordvietnam var kapabelt att starta påskoffensiven 1972, vilken senare bidrog till Nixons beslut om hårdare bombningar av nordvietnamesiska mål.</p>
<h2>Dominerades av kommunister</h2>
<p>FNL (<em>Front national de libération du Sud Viêt Nam</em>), Sydvietnams nationella befrielsefront, dominerades helt av kommunister och kom att idylliseras av breda grupper i Väst. I rapporteringen hävdades det ofta att FNL var en oberoende befrielserörelse som kämpade mot den USA-stödda regimen i Saigon. Men FNL var en skapelse av Nordvietnam. Dess mål var den kommunistiska enpartistaten.</p>
<p>FNL stred tillsammans med den nordvietnamesiska armén, med stöd av Sovjetunionen och Kina. Att Nordsidan sedan registrerade fler än en miljon stupade, mot Sydvietnams drygt 200 000 och USA:s 60 000, bidrog givetvis också till att många tog oreserverat parti för Nordsidan.</p>
<p>Om tragedin i Song My 1968, där amerikansk militär genomförde en massaker på civila, har det skrivits tusentals artiklar och ärendet har utretts i detalj av amerikanska myndigheter. Detta illdåd var ett rent krigsbrott, för vilket den amerikanske löjtnanten <strong>William Calley</strong> senare dömdes.</p>
<blockquote><p>I Hué utförde Nordsidan massarkebuseringar och mord på tusentals civila.</p></blockquote>
<p>Massakern i Song My och användningen av Agent Orange utgör två grova brott som USA gjorde sig skyldigt till i Vietnamkriget. De fördömdes vid tiden och ska fördömas även idag. Agent Orange är namnet på det växtgift som användes för att göra vegetationen i Nordvietnam glesare. Därmed blev det lättare att kunna attackera gerillaförband. Denna kemiska krigföring har haft förödande konsekvenser som fortfarande lämnar spår efter sig.</p>
<h2>Okända massakrer</h2>
<p>Detta blev givetvis föremål för rättmätig kritik. Emellertid är det tyst kring massakern i Hué 1968. Detta brott mot mänskligheten skedde under den så kallade Tetoffensiven bara veckor före Song My-massakern och genomfördes av Nordvietnams armé och FNL.</p>
<p>I Hué utförde Nordsidan massarkebuseringar och mord på tusentals civila. Med stöd av de massgravar med män, kvinnor och barn som påträffats görs bedömningen att det sannolikt mördades mellan 3 000 och 6 000, vilket var tio procent av Hués befolkning. Huémassakern blev en förvarning till sydvietnameser om vad som skulle hända om Nordsidan invaderade Syd.</p>
<figure id="attachment_176580" aria-describedby="caption-attachment-176580" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="wp-image-176580 size-full" src="https://kvartal.se/wp-content/uploads/2025/04/sdlJFSfLoSDl-E-nl.jpg" alt="kvartal" width="1024" height="678" data-wp-pid="176580" srcset="https://kvartal.se/wp-content/uploads/2025/04/sdlJFSfLoSDl-E-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2025/04/sdlJFSfLoSDl-E-nl-300x199.jpg 300w, https://kvartal.se/wp-content/uploads/2025/04/sdlJFSfLoSDl-E-nl-768x509.jpg 768w, https://kvartal.se/wp-content/uploads/2025/04/sdlJFSfLoSDl-E-nl-600x397.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-176580" class="wp-caption-text">Kroppar grävs fram efter massakern i Hué. Foto: Horst Faas /TT</figcaption></figure>
<p>I detta perspektiv är det också beklagligt att notera dåtidens hyllningsepos till <strong>Ho Chi Minh</strong>, Nordvietnams ledare fram till 1969. Denna doktrinäre stalinist bedrev en politik som var fjärran från de frihetliga värden som borde ha väglett demokratiförespråkare i Väst.</p>
<p>Vietnam hade delats 1954 efter det att kolonialmakten Frankrike och den kommunistiska gerillan i Nordvietnam hade nått en överenskommelse vid fredsförhandlingar i Genève. Efter detta genomfördes en brutal kollektivisering av jordbruket i Nordvietnam. Enligt samstämmiga källor dödades cirka 50 000 storbönder och mer än dubbelt så många skickades till arbetsläger, efter sovjetiskt mönster. Samtidigt flyttade eller flydde omkring 800 000 personer till Sydvietnam. Runt 100 000 drog i motsatt riktning.</p>
<figure id="attachment_176735" aria-describedby="caption-attachment-176735" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="wp-image-176735 size-full" src="https://kvartal.se/wp-content/uploads/2025/04/sdlnH-TNxynJtc-nl.jpg" alt="kvartal" width="1024" height="701" data-wp-pid="176735" srcset="https://kvartal.se/wp-content/uploads/2025/04/sdlnH-TNxynJtc-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2025/04/sdlnH-TNxynJtc-nl-300x205.jpg 300w, https://kvartal.se/wp-content/uploads/2025/04/sdlnH-TNxynJtc-nl-768x526.jpg 768w, https://kvartal.se/wp-content/uploads/2025/04/sdlnH-TNxynJtc-nl-600x411.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-176735" class="wp-caption-text">Sydvietnamesisk kvinna sörjer sin man som dödats av nordvietnameser vid massakern i Hué. Foto: Horst Faas /TT</figcaption></figure>
<p>Ho Chi Minhs mål var ett enat kommunistiskt Vietnam som den dominerande kraften i Indokina, och postumt kan han sägas ha fått rätt.</p>
<h2>Ett flagrant avtalsbrott</h2>
<p>”Befrielsen” av Saigon den 30 april 1975 skedde för att flera faktorer samverkade. Den första var ett krigstrött USA, som fick en ny kongress med demokratisk majoritet i november 1974. Till det ska läggas att landet hade en president, <strong>Gerald Ford</strong>, som tillträtt efter Nixons avgång i efterdyningar till Watergateaffären.</p>
<p>Men den viktigaste faktorn var med all säkerhet förekomsten av en skrupelfri kommunistisk regim i Hanoi, vilken i direkt strid med fredsavtalet från Paris i januari 1973 valde att bit för bit inta Sydvietnam. Det krävdes ett flagrant avtalsbrott för att Saigon skulle bli kommunistiskt.</p>
<p>Fredsavtalet som ingicks i Paris 1973 garanterade Sydvietnams självständighet. Sydvietnameserna gavs rätt till självbestämmande, och denna rätt beskrevs som ”helig”. De skulle själva få avgöra sin framtid genom fria och demokratiska allmänna val. Befolkningen i Syd tillerkändes en rad rättigheter, som yttrandefrihet, pressfrihet, frihet för politisk verksamhet och frihet att bedriva privata företag. FNL:s företrädare försäkrade att dessa rättigheter skulle respekteras. Utöver detta gav USA garantier till den sydvietnamesiske ledaren <strong>Nguyen Van Thieu</strong> att de omedelbart skulle träda in och stödja Sydvietnam i den händelse Nord skulle angripa landet.</p>
<p>Det är inte förvånande att den amerikanska delegationen, med <strong>Henry Kissinger</strong> i spetsen, såg avtalet i Paris som en seger. USA:s regering var samtidigt medveten om att det förelåg en risk att Nord skulle komma att bryta mot Parisavtalet, men vad man inte räknade med var att kongressen skulle sätta käppar i hjulet så att USA inte kunde infria det löfte man hade givit Thieu.</p>
<p>När Nordvietnam i strid med Parisavtalet hade tagit ett mindre område i norra Sydvietnam försökte president Ford övertyga kongressen om att USA på nytt skulle förse Sydvietnam med vapen, helt i enlighet med ländernas avtal och USA:s löfte. Men Ford bad förgäves och tvingades lämna Sydvietnam åt sitt öde. Många demokrater i kongressen hade investerat tungt i fredsfrågan och kunde inte acceptera att USA åter skulle bli en part i kriget. Nej, nu skulle soldaterna hem och Vietnam skulle läggas till historieböckerna. Den 30 april 1975 blev Saigon kommunistiskt.</p>
<h2>Fältet fritt för en invasion</h2>
<p>Den sydvietnamesiska regimen var förvisso korrupt och illegitim, men det var inte skälet till att den förlorade makten. Den föll för sovjetstyrda nordvietnamesiska stridsvagnar, en invasion som möjliggjordes på grund av att USA steg för steg hade lämnat Sydvietnam. Det skedde i skarp kontrast till Sydkorea, där amerikanska trupper stannade kvar som en säkerhetsinsats. Nu lämnades i stället fältet helt fritt för Nordvietnam att invadera Sydvietnam.</p>
<p>Med invasionen av Saigon inleddes en terror, som inte heller berördes på speciellt framskjuten plats i västliga media. De rättigheter som så generöst givits Sydvietnam i Paris blev aldrig verklighet och inga fria val anordnades.</p>
<blockquote><p>Mellan 1975 och 1995 flydde över en och en halv miljon sydvietnameser i skraltiga båtar.</p></blockquote>
<p>Det hade stadgats i fredsfördraget i Paris att alla handlingar av hämnd eller diskriminering mot enskilda medborgare eller organisationer, vilka ansågs ha samarbetat med den andra sidan, uttryckligen var förbjudna. Efter ”befrielsen” bröt Hanoiregimen även mot denna del av avtalet. Hundratusentals sydvietnameser skickades till så kallade utbildningsläger, och tusentals av de internerade mördades. Aktionerna var ett rent hån mot fredsfördragets innehåll och anda.</p>
<p>Den franske vänsterjournalisten <strong>Jean Lacouture</strong> beskrev i <em>National Review</em> 1977 dessa arbets- och omskolningsläger. Han hade djup insikt efter att ha genomfört ett tjugotal resor till Vietnam. Enligt Lacouture var terrorn ett ”prefabricerat helvete … Varken i Moskva 1917, Madrid 1939, Paris eller Rom 1944, inte heller i Peking 1949 eller Havanna 1959, inte ens … i Santiago de Chile 1973, har vi haft bevis för så många inspärrade”.</p>
<figure id="attachment_176430" aria-describedby="caption-attachment-176430" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="wp-image-176430 size-full" src="https://kvartal.se/wp-content/uploads/2025/04/sdl1E9zL62jvbs-nl.jpg" alt="kvartal" width="1024" height="738" data-wp-pid="176430" srcset="https://kvartal.se/wp-content/uploads/2025/04/sdl1E9zL62jvbs-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2025/04/sdl1E9zL62jvbs-nl-300x216.jpg 300w, https://kvartal.se/wp-content/uploads/2025/04/sdl1E9zL62jvbs-nl-768x554.jpg 768w, https://kvartal.se/wp-content/uploads/2025/04/sdl1E9zL62jvbs-nl-600x432.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-176430" class="wp-caption-text">En amerikansk B-52 som bombar Vietnam. Foto: TT nyhetsbyrån</figcaption></figure>
<p>Frihetsinskränkningarna ledde till en flyktingvåg från Vietnam. Mellan 1975 och 1995 flydde över en och en halv miljon sydvietnameser i skraltiga båtar. 200 000 av dessa båtflyktingar tros ha drunknat eller fallit offer för pirater. Sydkinesiska sjön blev ett ”Dödens hav”. Det kan noteras att människor inte flydde i någon större omfattning från Sydvietnam under den tidigare diktaturens tid, trots att det fanns såväl repression, fattigdom som krig.</p>
<p>Hade Sydvietnam fortsatt att existera, i enlighet med de friheter som garanterades i Parisavtalet, är det inte omöjligt att landet hade gått samma demokratiska väg som Taiwan och Sydkorea.</p>
<p>Vietnam blev en av USA:s allvarligaste motgångar under det kalla kriget. Sovjetiskt och kinesiskt stöd gav Nordvietnam möjligheten att driva kriget ända fram till 1975.</p>
<h2>En annan historia</h2>
<p>Med USA:s tillbakadragande följde år av icke-intervention. USA blev isolationistiskt, vände sig inåt och engagerade sig allt mindre i perifera oroshärdar. Dessa år sammanfaller med den period då Sovjetunionen och dess allierade stärkte sina positioner på världsscenen. Från våren 1975, då Ford förgäves försökte få med sig kongressen, och under hela <strong>Jimmy Carters</strong> presidentskap, kunde Sovjet flytta fram sina positioner i Sydostasien och framför allt i Afrika, inte sällan tillsammans med kuppbröder från Kuba. Sovjet kunde ta herraväldet i revolutionära stater och spela en megaroll i världspolitiken. Kulmen blev intåget i Afghanistan 1979.</p>
<p>Hade Vietnamkriget ändat 1973 med Parisavtalet som slutpunkt hade historien med all säkerhet sett annorlunda ut. Nordsidan gavs ju ingen rätt att ockupera Sydvietnam. Parisavtalet innebar en form av tvåstatslösning för Vietnam. Den så kallade befrielsen av Saigon, som Dagens Nyheter uttryckte det 1975, var i själva verket ett monumentalt avtalsbrott.</p>
<p>Det är ett egendomligt faktum att 1970-talets bild av Vietnamkriget fortfarande förefaller vara den enda vedertagna. Idag, drygt 35 år efter murens fall och med vår förvärvade kunskap om kommunismens brott, bör vi vara redo för en mer upplyst debatt och att självkritiskt bearbeta den snedvridna bilden av kriget och dess efterspel.</p>
<div class="author-byline">Anders Carlberg är författare. Hans senaste bok är &#8221;Mussolini mot Hitler &#8211; judarnas öde i fascismens Italien&#8221; (2024) och han har tidigare skrivit &#8221;Hitlers lojala musiker&#8221; (2016) och &#8221;Toner och Terror&#8221; (2021). Samtliga böcker är utgivna på Santérus förlag.
</div>
</div>
