Den amerikanska kulturrevolutionen

<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-169695"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="169695" data-pty="SW5sw6RzdCBhcnRpa2VsIChLdWx0dXIp" data-pna="RGVuIGFtZXJpa2Fuc2thIGt1bHR1cnJldm9sdXRpb25lbg==" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci82LTQzLWRlbi1hbWVyaWthbnNrYS1rdWx0dXJyZXZvbHV0aW9uZW4ubXAz" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvNi00My1kZW4tYW1lcmlrYW5za2Eta3VsdHVycmV2b2x1dGlvbmVuLm1wMw==">  <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: "><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%2Fden-amerikanska-kulturrevolutionen%2F&amp;t=Den+amerikanska+kulturrevolutionen"    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=Den+amerikanska+kulturrevolutionen+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fden-amerikanska-kulturrevolutionen%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%2Fden-amerikanska-kulturrevolutionen%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Den amerikanska kulturrevolutionen&body=https://kvartal.se/artiklar/den-amerikanska-kulturrevolutionen/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/169695/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="author-section ">  <div class="author-section-inner">    <div class="author-image-holder"><div class="author-image" style="background-image: url('https://kvartal.se/wp-content/uploads/2024/07/Ola_lowres2.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2024/07/Ola_lowres2.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/ola-wong/">Ola&nbsp;Wong</a> | 8 mars 2025<div class="author-desc">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</div>    </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%2Fden-amerikanska-kulturrevolutionen%2F&amp;t=Den+amerikanska+kulturrevolutionen"    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=Den+amerikanska+kulturrevolutionen+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fden-amerikanska-kulturrevolutionen%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%2Fden-amerikanska-kulturrevolutionen%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Den amerikanska kulturrevolutionen&body=https://kvartal.se/artiklar/den-amerikanska-kulturrevolutionen/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/169695/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 class="listen" href="https://kvartal.se/artiklar/den-amerikanska-kulturrevolutionen/?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 7 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/43b9ce60-a7ec-489f-b84e-12290899579c"    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-169695">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "169695"></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 ">Liknelser med Kinas kulturrevolution (1966–1976) görs nu inte bara av <strong>Trumps</strong> kritiker, utan även av nymaoistiska tänkare i Kina.</p>
<p>Trump orkestrerar nu sin egen ”amerikanska kulturrevolution”, skriver signaturen <strong>Yuan Long</strong> vid det nymaoistiska researchinstitutet Kunlunce i Peking.<sup>1</sup></p>
</div>
<div class="rest-of-article ">
<p>”Under Trumps ledarskap har <strong>Musk</strong> och Doge störtat USA i kaos i ett försök att gripa makten. Då kommer anklagelser om ’maktmissbruk’, att de ’bryter mot konstitutionen’. Som svar skriver Trump på sociala medier: ’<em>He who saves his country breaks no laws!’ </em>Med bara en mening lyckas Trump vifta bort kritikerna. Det var som en hyllning till ordförande <strong>Mao Zedongs</strong> kända slogan: ’<em>Det är rätt att göra uppror.</em>’”</p>
<figure id="attachment_169742" aria-describedby="caption-attachment-169742" style="width: 947px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-169742 size-full" src="https://kvartal.se/wp-content/uploads/2025/03/Bild-2.jpg" alt="" width="947" height="1240" data-wp-pid="169742" srcset="https://kvartal.se/wp-content/uploads/2025/03/Bild-2.jpg 947w, https://kvartal.se/wp-content/uploads/2025/03/Bild-2-229x300.jpg 229w, https://kvartal.se/wp-content/uploads/2025/03/Bild-2-768x1006.jpg 768w, https://kvartal.se/wp-content/uploads/2025/03/Bild-2-600x786.jpg 600w" sizes="(max-width: 947px) 100vw, 947px" /><figcaption id="caption-attachment-169742" class="wp-caption-text"><em>Bild: Skärmdump/X.</em></figcaption></figure>
<p>Ett annat av Maos mest kända citat var ”Bombardera högkvarteret!” Den 5 maj 1966 skrev den åldrade ledaren det på sin tids motsvarighet till ett X-inlägg, ett <em>dazibao</em>, ett plakat med stora tecken. Han slog larm om att det fanns en djup stat med illojala tjänstemän som hindrade hans försök att skapa ett nytt Kina. Mao hade under en period varit pressad på grund av att hans politik några år tidigare orsakat världshistoriens största svältkatastrof. Nu anklagade han den övriga partiledningen för att vara rädda för verklig demokrati och vilja hindra kulturrevolutionen.<sup>2</sup> Den kinesiska ungdomen lydde Maos uppmaning och gjorde uppror på alla nivåer. De kallade sig för rödgardister, det röda gardet som skyddade Mao. Plakaten fick viral spridning, alla skrev egna inlägg om olika lärare eller andra auktoriteter som de ville fördöma. Efter de hatiska orden kom våldet.</p>
<p>Rödgardisterna släpade ut tjänstemän och stora delar av partitoppen (däribland<strong> Xi Jinpings</strong> pappa) till kritikmöten. Kommunistpartiets generalsekreterare <strong>Deng Xiaoping </strong>fick börja jobba på en traktorfabrik medan rödgardisterna slängde departement i vedflisen. Kina isolerade sig i en främlingsfientlig, aggressiv nationalism som utmärkte sig för ett brinnande hat mot den kinesiska högkulturen.</p>
<p>Kulturrevolutionen hade som mål att krossa ”de fyra gamla” (kulturen, tankarna, vanorna och traditionerna). Den gamla kinesiska kulturens ideala gentleman hade varit inriktad på kompromisser, bildning och självkontroll. Kulturrevolutionens generation uppmuntrades därför att vara dogmatisk, hata, svära och våga tappa humöret i våld och gräl.</p>
<h2>Maos metod var kaos och disruption</h2>
<p>Flera sinologer och kinesiska bedömare har noterat likheterna med dagens USA.</p>
<p>Men självklart finns uppenbara skillnader.</p>
<p>Mao ledde en leninistisk partistat som var designad för revolution, USA är tvärtom gjort för maktdelning, kapitalism och rättsstat. Republikanerna privatiserar, kommunister socialiserar. Även om Trump velat det kan han troligen inte störta landet i kaos med miljoner döda som följd, som Mao gjorde. Men tendensen är intressant.</p>
<p>Den ansedda sinologen <strong>Orville Schell</strong> <a href="https://www.project-syndicate.org/commentary/donald-trump-mao-zedong-cultural-revolution-parallels-by-orville-schell-2025-02">skriver</a> att Trump har samma djuriska instinkt för att förvirra sina motståndare genom att vara galet oförutsägbar.</p>
<p>Maos tid vid makten präglades av en ständig aptit för kaos och disruption. Flera tongivande personer i Maga-rörelsen har beskrivit det som nu sker som en ”revolution”, som kan kräva våld.<sup>3</sup></p>
<p>Schell pekar på likheter mellan Elon Musk och rödgardistledaren <strong>Kuai Dafu</strong>, som Mao utsåg till ledare för de fanatiskt Maotrogna ungdomarna från elituniversitetet Tsinghua. Kuai ledde 5 000 rödgardister i ett försök att belägra kommunistpartiets högkvarter Zhongnanhai, vilket för tankarna till Trumps egna motsvarigheter till rödgardister och stormningen av Kapitolium 2021.</p>
<p>Fjäskande förslag som att göra Trumps födelsedag till nationell helgdag <a href="https://ctexp.substack.com/p/has-america-entered-its-own-cultural?utm_source=post-email-title&amp;publication_id=2824601&amp;post_id=158171132&amp;utm_campaign=email-post-title&amp;isFreemail=true&amp;r=2b8&amp;triedRedirect=true&amp;utm_medium=email">påminner</a> om personkulten, likaså föraktet mot intellektuella och forskare.</p>
<p>Under kulturrevolutionen var det viktigare att vara ”röd” (politiskt lojal) än expert. Yuan Long jämför gillande Doges informella struktur och godtyckliga maktutövning med kulturrevolutionens ledningsgrupp, som styrde genom mandat direkt från den stora ledaren. Musk till och med kallar det som nu sker för ”folkets revolution”.</p>
<figure id="attachment_169703" aria-describedby="caption-attachment-169703" style="width: 1188px" class="wp-caption alignnone"><img decoding="async" class="wp-image-169703 size-full" src="https://kvartal.se/wp-content/uploads/2025/03/Musk-Delta-i-folkets-revolution.jpg" alt="" width="1188" height="1058" data-wp-pid="169703" srcset="https://kvartal.se/wp-content/uploads/2025/03/Musk-Delta-i-folkets-revolution.jpg 1188w, https://kvartal.se/wp-content/uploads/2025/03/Musk-Delta-i-folkets-revolution-300x267.jpg 300w, https://kvartal.se/wp-content/uploads/2025/03/Musk-Delta-i-folkets-revolution-768x684.jpg 768w, https://kvartal.se/wp-content/uploads/2025/03/Musk-Delta-i-folkets-revolution-600x534.jpg 600w" sizes="(max-width: 1188px) 100vw, 1188px" /><figcaption id="caption-attachment-169703" class="wp-caption-text"><em>Elon Musk uppmanar till stöd för ”folkets revolution”, med argument som låter som Maos masslinje. Skärmdump: X.</em></figcaption></figure>
<p>Trump har avslöjat ”den djupa staten” för allmänheten, låter massorna övervaka statens finanser och verksamhet och söker expandera USA:s territorium.</p>
<p>Trump härmar Maos ”masslinje”, menar Yuan Long.</p>
<p>Musks team består av ungdomar direkt från universiteten utan någon erfarenhet från de departement de ska granska. På så sätt är de ideologiskt rena och kan krossa det gamla, utan hänsyn till normer (eller att de <a href="https://www.schneier.com/blog/archives/2025/02/doge-as-a-national.html">riskerar</a> nationens säkerhet på kuppen). Även flera av Trumpadministrationens ledare som Musk, <strong>JD Vance</strong>, försvarsminister <strong>Hegseth</strong> och pressekreteraren <strong>Leavitt</strong> saknar meriter för sina jobb men har ändå fått nyckelpositioner, tack vare att de garanterat kommer att genomföra ledarens vilja, menar Yuan Long.</p>
<figure id="attachment_169704" aria-describedby="caption-attachment-169704" style="width: 839px" class="wp-caption alignnone"><img decoding="async" class="wp-image-169704 size-full" src="https://kvartal.se/wp-content/uploads/2025/03/USAs-kulturrevolutionens-sma-generaler.webp" alt="" width="839" height="836" data-wp-pid="169704" srcset="https://kvartal.se/wp-content/uploads/2025/03/USAs-kulturrevolutionens-sma-generaler.webp 839w, https://kvartal.se/wp-content/uploads/2025/03/USAs-kulturrevolutionens-sma-generaler-300x300.webp 300w, https://kvartal.se/wp-content/uploads/2025/03/USAs-kulturrevolutionens-sma-generaler-150x150.webp 150w, https://kvartal.se/wp-content/uploads/2025/03/USAs-kulturrevolutionens-sma-generaler-768x765.webp 768w, https://kvartal.se/wp-content/uploads/2025/03/USAs-kulturrevolutionens-sma-generaler-600x598.webp 600w" sizes="(max-width: 839px) 100vw, 839px" /><figcaption id="caption-attachment-169704" class="wp-caption-text"><em>”USA:s version av &#8217;rödgardisternas små generaler&#8217;”, skriver den maoistiska tankesmedjan Kunlunce.</em></figcaption></figure>
<p>Orville Schell skriver att Mao antagligen nu tittar ner från sin marxist-leninistiska himmel med ett leende på katastrofen i USA, hans gamla dröm om att vinden från Öst ska besegra den från Väst verkar äntligen vara på väg att besannas.</p>
<p>Maoisten Yuan Long varnar dock i slutändan även han för Trump, som han menar är lika fientlig mot Kina som den djupa staten. För att rädda Kina måste landet återupptäcka Mao Zedongs tänkande: ”Det enda hemliga vapen våra fiender desperat vill lära sig men som de aldrig riktigt fullt ut kan greppa.”</p>
<h2>Ondskan blir förhärligad i revolutioner</h2>
<p>Kulturrevolutionen var en moralisk kollaps. USA brukade tidigare arbeta för att få ut fängslade människorättsaktivister från diktaturer. Nu <a href="https://www.bbc.com/news/articles/cg4kkv3e1v9o">åker</a> i stället den kvinnohatande influeraren <strong>Andrew Tate</strong> till USA från Rumänien, där han var anklagad för människohandel och våldtäkt. I en av sina inspirationsvideor beskriver Tate hur en man för den nya tiden kan slå kvinnor: ”<em>When I’ve got you by the neck and you start annoying me, trying to resist, and I just BOOM! And then I grab you by your neck again. Then what the fuck you gonna do, when your face is collapsed, and your fucking cheekbones broken, you ain’t gonna do shit but cry!”</em> Kanske måste en revolutionär regim förhärliga ondska genom sina berättare, jag vet inte. Men Andrew Tate är en man som fått uppbackning av Magaeliten som Elon Musk, <strong>Donald Trump Jr</strong> och <strong>Tucker Carlson</strong>. Tate <a href="https://news.sky.com/story/the-tates-and-trumps-inner-circle-the-deepening-ties-that-led-to-the-controversial-influencers-flying-to-freedom-in-america-13318676">säger</a> själv att hans gode vän Donald Trump är västvärldens framtid och ”alla måste lyda honom”.</p>
<p>Jag skrev om hur Maotiden format dagens Kina i min bok <em>Pekingsyndromet</em> från 2014. Mao levde enligt devisen <em>wu fa wu tian</em>, utan lag eller himmel. Det vill säga: Det finns ingen lag, det finns bara makt. Den starke mannen definierar vad som är sant och rätt. Det är en totalitär tanke, som leder till kejsare- och slavmentalitet.</p>
<blockquote><p>Enligt partiet var kulturrevolutionen ett resultat av ett vårdslöst experiment i demokrati.</p></blockquote>
<p>Idag känns det mer som ett förebådande än en tillbakablick när jag läser vad jag skrev då: ”Om man ska generalisera så är folk i Kina ofta hyggliga och tålmodiga. Men kulturrevolutionen har lämnat spår som är märkbara, som polariserat dogmatiskt tänkande och en tendens att argumentera med vilda och skamlösa påståenden som ibland helt saknar uppbackning i verkligheten. Det gäller partiledare men även regimkritiker.”</p>
<p>Kulturrevolutionen pågick i tio år, men den revolutionära perioden nådde sin febriga topp redan de första åren. Det intressanta är vad som hände sen. 1968 svek Mao rödgardisterna, såsom han svek alla som följde honom. Rörelsen hade då gett Mao total makt över Kina. Rödgardisterna blev straffade för sitt uppror och skickades ut på landsbygden. Gradvis plockade Mao tillbaka den gamla eliten för att få ordning på landet igen. Det kändes som att ”ha släppts in i partiets armar igen”, sa Xi Jinpings pappa efter att ha återfått friheten.</p>
<h2>Eliten kom tillbaka, men skadorna blev bestående</h2>
<p>Mao var 82 år när han dog 1976. Inom en månad skedde en kupp, och ledningsgruppen från kulturrevolutionen arresterades. Cynisk pragmatism fick nu ersätta utopiska idéer. Eftersom det Nya Kina var format efter Maos avbild kunde man inte göra upp med honom. En resolution slog fast att Mao ”lidit av missuppfattningen att partiet var infiltrerat av kontrarevolutionära revisionister”. Inget av kulturrevolutionens miljoner offer fick någon kompensation eller ursäkt. Enligt partiet var kulturrevolutionen ett resultat av ett vårdslöst experiment i demokrati. ”Stabilitet är viktigare än allt annat”, sade <strong>Deng Xiaoping</strong> när han i sin tur lämnade över styret till <strong>Jiang Zemin</strong>.<sup>4</sup> Yttrandefrihet blev för Kinas elit liktydigt med den manipulerade mobbens vrål. Elitens nya budskap till folket blev att det enda som står mellan Kina och ett nytt kaos som kulturrevolutionen är Kommunistpartiet.</p>
<figure id="attachment_169778" aria-describedby="caption-attachment-169778" style="width: 1217px" class="wp-caption alignnone"><img decoding="async" class="wp-image-169778 size-full" src="https://kvartal.se/wp-content/uploads/2025/03/Tibet-kritikmote-2.jpg" alt="" width="1217" height="1203" data-wp-pid="169778" srcset="https://kvartal.se/wp-content/uploads/2025/03/Tibet-kritikmote-2.jpg 1217w, https://kvartal.se/wp-content/uploads/2025/03/Tibet-kritikmote-2-300x297.jpg 300w, https://kvartal.se/wp-content/uploads/2025/03/Tibet-kritikmote-2-768x759.jpg 768w, https://kvartal.se/wp-content/uploads/2025/03/Tibet-kritikmote-2-600x593.jpg 600w" sizes="(max-width: 1217px) 100vw, 1217px" /><figcaption id="caption-attachment-169778" class="wp-caption-text"><em>Ett kritikmöte i Tibet under kulturrevolutionen.</em></figcaption></figure>
<p>Under Xi Jinping har folket fått hjälp att redigera om bilden av kulturrevolutionen till en oskuldsfull, idealistisk period. Xi har samtidigt återanvänt Maos brutala metoder och lanserat en egen version av personkult.</p>
<p>Mao lyckades nästan slå sönder en gammal kultur med mänskliga värderingar. Det borde vara en läxa, inte bara för Kina utan för alla. Även om den bleknar i jämförelse med Kinas kulturrevolution är USA nu mitt uppe i en politisk mani, men vi måste ställa oss frågan: Vad händer sedan? Skadorna på den amerikanska nationens psyke kommer att vara bestående, och lögnerna som den politiska eliten vill begrava kan förvrida landet i årtionden.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="169695">  <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>
<ol>
<li>https://www.kunlunce.com/ssjj/guojipinglun/2025-02-18/185173.html Texten har översatts till engelska här: https://gaodawei.wordpress.com/2025/02/26/2025-a-prc-neo-maoist-perspective-on-the-musk-trump-led-us-cultural-revolution/</li>
<li>Roderick Macfarquhar, Michael Schoenhals: <em>Mao&#8217;s last revolution</em>, s. 89. (The Belknap press of Harvard university press 2008).</li>
<li>https://www.project-syndicate.org/commentary/donald-trump-mao-zedong-cultural-revolution-parallels-by-orville-schell-2025-02, https://www.nytimes.com/2024/07/03/us/politics/heritage-foundation-2025-policy-america.html</li>
<li>Suisheng Zhao: <em>The dragon roars back – Transformational leaders and dynamics of Chinese foreign policy</em>, s. 147. (Stanford university press 2023).</li>
</ol>
</div>
</div>
<div class="author-byline">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</div>
</div>
