Vänsterteatern har blivit en åldrad institution

<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%2Fvansterteatern-har-blivit-en-aldrad-institution%2F&amp;t=V%C3%A4nsterteatern+har+blivit+en+%C3%A5ldrad+institution"    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=V%C3%A4nsterteatern+har+blivit+en+%C3%A5ldrad+institution+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fvansterteatern-har-blivit-en-aldrad-institution%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%2Fvansterteatern-har-blivit-en-aldrad-institution%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Vänsterteatern har blivit en åldrad institution&body=https://kvartal.se/artiklar/vansterteatern-har-blivit-en-aldrad-institution/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/83982/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/2022/10/LAPI.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2022/10/LAPI.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/lapo-lappin/">Lapo&nbsp;Lappin</a> | 7 januari 2023<div class="author-desc">Lapo Lappin är kulturskribent med bakgrund inom filosofin och medarbetare i Kvartals redaktion.
</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%2Fvansterteatern-har-blivit-en-aldrad-institution%2F&amp;t=V%C3%A4nsterteatern+har+blivit+en+%C3%A5ldrad+institution"    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=V%C3%A4nsterteatern+har+blivit+en+%C3%A5ldrad+institution+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fvansterteatern-har-blivit-en-aldrad-institution%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%2Fvansterteatern-har-blivit-en-aldrad-institution%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Vänsterteatern har blivit en åldrad institution&body=https://kvartal.se/artiklar/vansterteatern-har-blivit-en-aldrad-institution/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/83982/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 10 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/7c1dda13-7a9d-4c63-be5a-805976feca8e"    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-83982">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "83982"></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 ">Jag befinner mig i Teater Tribunalens lokaler på Södermalm, det som teatern själv beskriver som ”Stockholms coolaste anti-kapitalistiska scen”.</p>
</div>
<div class="rest-of-article ">
<p>Går ner för trappan till källaren, förbi en gigantisk banderoll med texten ”Nej till Nato”. På ytan ger teatern ett allmänt ovårdat intryck, där väggar av kalt tegel punkteras av rostiga rör. Samtidigt får man en känsla av att det egentligen är kurerat ned till detaljnivå, som om varje repa i väggarna har placerats där med omsorg.</p>
<p>Väggen i hallen är hoplappad med planscher från tidigare föreställningar. Några sticker ut: <em>Kommunistiska manifestet,</em> till exempel, som Tribunalen iscensatte 2008, och en plansch med en Lenin-staty som blottar sig.</p>
<h2>Ständigt prat om att gå från ord till handling</h2>
<p>I väntan på att dagens tillställning ska börja hugger jag in på brieost-tallriken. En representant från Olof Palmes Internationella Center håller samtidigt tal om hur ”alla goda krafter nu måste gå ihop”. En annan från Arbetarnas Bildningsförbund (ABF) talar om hur frihet och jämlikhet i dagens samhälle måste ”återerövras”.</p>
<figure id="attachment_83986" aria-describedby="caption-attachment-83986" style="width: 1200px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-83986 size-full" src="https://kvartal.se/wp-content/uploads/2023/01/olof-palme-center-banderoll.jpg" alt="" width="1200" height="1600" data-wp-pid="83986" srcset="https://kvartal.se/wp-content/uploads/2023/01/olof-palme-center-banderoll.jpg 1200w, https://kvartal.se/wp-content/uploads/2023/01/olof-palme-center-banderoll-1152x1536.jpg 1152w, https://kvartal.se/wp-content/uploads/2023/01/olof-palme-center-banderoll-225x300.jpg 225w, https://kvartal.se/wp-content/uploads/2023/01/olof-palme-center-banderoll-768x1024.jpg 768w" sizes="(max-width: 1200px) 100vw, 1200px" /><figcaption id="caption-attachment-83986" class="wp-caption-text"><em>Interiör från Teater Tribunalen.</em></figcaption></figure>
<p>Det är dessa två organisationer, Olof Palmecentret och ABF, som har finansierat en föreställning av sällskapet Östra Teatern. Det är ett gästspel, det vill säga att den inte spelas av Teater Tribunalens eget sällskap. Men det verkar hur som helst vara helt i linje med teaterns anda.</p>
<p>Jag är på premiären av föreställningen <em>Strutsdansen: en klimatkalops</em>. Den går ut på att gestalta en serie om nio olika scener, som på olika sätt befinner sig i skärningen mellan ett vardagligt nu och en framtida klimatkollaps. Det ger ett slags tvärsnitt av de existentiella frågeställningarna som klimatet ger upphov till.</p>
<p>Den återkommande frågan som pjäsen brottas med är varför ingen verkar göra något konkret åt klimatet, trots att all fakta ligger på bordet. Pjäsen liknar dessa människor vid strutsar, som enligt en populär myt sticker huvudet i sanden inför faran.</p>
<p>På det stora hela får man säga att uppsättningen blir lyckad: pjäsens uttalade mål var att stämma till eftertanke snarare än att underhålla. Åtminstone jag blev rätt så eftertänksam.</p>
<p>Jag kunde inte undgå att märka – när jag tittade på plansch-mosaiken i hallen utanför teatern – att Tribunalen har gett föreställningar på samma tema tidigare. För snart 10 år sedan huserade Tribunalen en pjäs vid namn <em>Rörelsen</em>. Beskrivningen löd: ”Tänk om vi hade tagit till oss allvaret i dagens klimatsituation. Tänk om vi organiserade oss och startade en rörelse. Tänk om det blev den största folkrörelsen i mänsklighetens historia.”<sup>1</sup></p>
<p>Tio år senare är vi fortfarande här. En ny bearbetning av varför motståndet inte fungerar, varför revolutionen ännu inte inträffat.</p>
<p>Nu är det inte meningen att anklaga Teater Tribunalen för att inte ha löst klimatkrisen. Ändå är detta på något sätt en del av ett större mönster: man pratar gärna om ”rörelsen”, om att omsätta tanke i handling. Men handlingarna verkar aldrig komma; man är fångad i en evig karusell av att <em>tänka </em>på hur tankar ska överföras till praktik.</p>
<h2>Målet är total samhällsomvandling</h2>
<p>Spänningen mellan konstnärlig gestaltning och verklig politisk handling sitter i källarteaterns fundament. I Teater Tribunalens manifest kan man läsa att målet är att ingjuta mod i publiken att förändra sammanhangen som den verkar i.<sup>2</sup> På hemsidan förklarar den konstnärlige ledaren <strong>Henrik Dahl</strong> att ”en total samhällelig systemändring är nödvändig. Det är Teater Tribunalens uppgift att verka för en sådan. Det är hög tid att mänskligheten lämnar sin förhistoria bakom sig och blir fullt ut mänsklig.”<sup>3</sup></p>
<p>Jag hör av mig till Henrik Dahl och frågar vad han menar med att teatern ska verka för en total samhällelig systemförändring. Hur bokstavligt ska man tolka manifestets bekännelse att man ”hellre talar om att rasera broar än att bygga dem”; är det en revolution i gammalmodig marxistisk ordning som åsyftas?</p>
<p>Henrik Dahl svarar att ”Revolution eller reform är bara medel, jag har ingen aning om HUR samhället bör omdanas, bara att det BÖR omdanas, socialt och ekonomiskt, via politik. En demokratiserad ekonomisk ordning vore till exempel trevligt. Det är väldigt allmänt. Vi gör vad namnet antyder: teater och annan scenkonst.”</p>
<h2>Tribunalen får bidrag för att spela revolutionära</h2>
<p>Och det är sant. Teater Tribunalen håller på med <em>teater</em>, både på scenen och bakom kulisserna. Det är inte bara innehållet i pjäserna som är ett skådespel: hela paketet, från estetiken till värdegrunden är ett enda stort skådespel.</p>
<p>Jag menar inte detta som något nedlåtande. Det är bara vad de flesta kvarlevor av marxismen i Sverige har reducerats till. Man iscensätter en retorik och en symbolisk värld som liknar den riktiga, historiska marxismen. Men det är egentligen inte på allvar.</p>
<blockquote><p>Stater brukar sällan uppskatta konstutövning som på allvar hotar deras existens.</p></blockquote>
<p>Därmed inte sagt att Teater Tribunalen producerar undermålig teater. (Möjligen är utbudet stundvis lite <em>cringe</em>: exempelvis när Tribunalens grundare <strong>Richard Turpin </strong>år 2016 retar upp sig på Dagens Nyheters rapportering om Putins propaganda och författar ett ”Ode till DN” där han understryker att fienden inte är Ryssland – ”Det är du, DN, som är fienden.”)<sup>4</sup></p>
<p>Tvärtom. Teatern förvaltar en 27-årig tradition av politisk scenkonst och har byggt upp en robust kompetens inom området. Såvitt jag förstår saken är Tribunalen en pelare i Stockholms teaterliv.</p>
<p>Det är just det som är poängen. Tribunalen är djupt rotad i Stockholms kulturella ekosystem. Någonstans skaver detta. Jämför bara med den revolutionära teaterns huvudgestalter. <strong>Maksim Gorkij</strong> levde stora delar av sitt liv i exil; <strong>Bertolt Brecht</strong> likaså. Och egentligen är det inget särskilt konstigt med det. Stater brukar sällan uppskatta konstutövning som på allvar hotar deras existens.</p>
<p>Teater Tribunalen får däremot årligen närmare  tre miljoner kronor i offentliga anslag.<sup>5</sup> Relationen mellan Tribunalen och kulturtjänstemännen är så etablerad att bedömarna av deras anslagsansökningar på Stockholms kulturnämnd brukar återanvända samma formuleringar år efter år. Av beskrivningen som anges i dessa får man inte intrycket att Tribunalen är en särskilt subversiv kraft heller: ”Gruppen gör politisk teater som relaterar till, och polemiserar med, samtid och maktfaktorer”.<sup>6</sup></p>
<p>Beskrivningen hade kunnat passa på de allra flesta teatergrupper idag. Även <strong>Henrik Dahl </strong>menar det: ”Generellt är teatern väldigt mycket mer politiserad idag än den var när vi startade 1995. Att då kalla sig ’politisk teater’ var i andras ögon både töntigt och lite speciellt. Idag görs knappt en uppsättning som inte ’utforskar strukturer’ eller ’undersöker samtidens normativitet’ eller dylikt.”</p>
<figure id="attachment_83987" aria-describedby="caption-attachment-83987" style="width: 1500px" class="wp-caption alignnone"><img decoding="async" class="wp-image-83987 size-full" src="https://kvartal.se/wp-content/uploads/2023/01/allas-krig-mot-alla.jpg" alt="" width="1500" height="1000" data-wp-pid="83987" srcset="https://kvartal.se/wp-content/uploads/2023/01/allas-krig-mot-alla.jpg 1500w, https://kvartal.se/wp-content/uploads/2023/01/allas-krig-mot-alla-600x400.jpg 600w, https://kvartal.se/wp-content/uploads/2023/01/allas-krig-mot-alla-300x200.jpg 300w, https://kvartal.se/wp-content/uploads/2023/01/allas-krig-mot-alla-768x512.jpg 768w" sizes="(max-width: 1500px) 100vw, 1500px" /><figcaption id="caption-attachment-83987" class="wp-caption-text"><em>Ur pjäsen ”Allas krig mot alla”, från 2010. Foto: Mats Bäcker/Teater Tribunalen. </em></figcaption></figure>
<p>Men kritiken mot systemet till trots verkar Tribunalen trivas rätt bra i systemet som det är nu. Årligen tar Tribunalen emot 300 000 kronor från Stockholms Region, 1 300 000 kronor från Stockholms kulturnämnd<sup>7</sup> och ytterligare mellan två och två och en halv miljoner kronor från Statens kulturråd.<sup>8</sup> Marxismens förment revolutionära profil skaver mot den etablerade ställning den har fått.</p>
<p>Man hade kunnat fråga myndigheterna, som delar ut generösa stöd, hur de ser på teaterns anspråk på total systemförändring. Men det hade varit en värdelös fråga att ställa. För Tribunalen menar inte allvar; den revolutionära poseringen är just det – <em>posering</em>. Myndigheterna vet det, Tribunalen vet det, jag vet det, du vet det.</p>
<p>Det är inte enbart Tribunalens statliga anslag som Tribunalen har förvärvat under de senaste tio åren som skvallrar om det. Det kommer pengar till Tribunalens verksamhet även från stiftelser med motsatt ideologisk inriktning. I en redovisning av Tribunalens intäkter från Stockholms kulturnämnd finner man att teatern har blivit tilldelad medel från Helge Ax:son Johnsons stiftelse.*<sup>9</sup> Pengarna kan härledas tillbaka till bolag som knappast är – hur ska man formulera det? – kända för sin marxistiska profil.</p>
<p>Jag frågar Henrik Dahl hur man får ihop det. Han förklarar att det inte var Tribunalen själv som sökte pengarna utan andra grupper som samarbetade i projektet. ”Men vi skulle inte ha något principiellt emot att söka anslag från dem,” fortsätter han. ”Om vi tänkte så asketiskt och dogmatiskt skulle vi inte ha några anslag alls, det vill säga helt sonika inte funnits till. Min favoritdramatiker, B. Brecht, hade en pragmatisk hållning till ’kampen’, kan man inte <em>deala </em>med skurkarna blir man blåst.”</p>
<h2>Skådespelssamhället</h2>
<p>Tankarna dras till en av pelarna i den marxistiska kanonen: <strong>Guy Debords</strong> filosofiska essä <em>Skådespelssamhället </em>(utgiven på franska 1967). Debord ville utvidga marxismens ekonomiska teori till att innefatta kulturen i stort. Den tongivande aspekten med den moderna kapitalistiska kulturen var att den var ett ”spektakel”. Med detta tog Debord inte bara spjärn mot medierna, eller den allestädes närvarande reklamen. Debord menade att samhället idag fungerar genom att framställa olika bilder, olika ideal, som konsumenten i sin tur måste sukta efter. Den dyra klockan är inte främst ett urverk – den är ett löfte om karriärmässig framgång, <em>sex</em> <em>appeal</em>, äventyr i vardagen. Bilderna hade, enligt Debord, blivit verkligare än själva verkligheten; att ”vara” hade blivit ”att uppträda”.</p>
<p>Marxismen idag har blivit ytterligare en instans av spektaklets logik. Det är ett paket av bilder och beteenden, där gestaltningen blir ett självändamål. Poängen är inte längre att förändra världen, utan att uppträda som om man gör det.</p>
<p>I Teater Tribunalens manifest kan man läsa att begrepp som Frihet och Jämlikhet har kommersialiserats och lakats ur av det borgerliga kapitalets diktatur. Men det gäller i lika stor utsträckning de marxistiska begreppen, och marxismen i stort. Marxismen har reducerats till en kommersialiserad <em>image</em>. Motståndet har först och främst blivit en estetik.</p>
<p>Anledningarna därtill är säkert många. Men något som sticker ut, åtminstone i mina ögon, är likheten mellan dagens marxism och det som ofta kallas för ”kulturell kristendom”. Kristendomen har genom tiderna gått igenom cykler av religiös iver: under vissa perioder rullar de trogna runt på golvet i andlig extas, genomgår månadslånga fastor, späker sig själva. Men inom loppet av någon generation brukar saker lugna ner sig rejält. Kristendomen blir främst en kulturell företeelse, där man bevarar de mysiga, mellanmjölkiga bitarna som ger trygghet. Den står för det etablerade i livet och samhället. Man tar sig till kyrkan till jul, vid vigslar och dop; man behåller något slags vag aning om vad kristendomen står för. Men ingen vill faktiskt ha en domedag.</p>
<p>Något liknande gäller för marxismen idag. Kanske kan man tala om ”kulturell marxism”. Den andliga extasen som socialismen nådde förra seklet tillhör det förflutna. Nu återstår en samling ritualer: den revolutionära teatern, demonstrationerna, det högtidliga första maj-firandet… På så sätt behåller man en viss kontinuitet med den historiska marxismen. Man upprepar trollformlerna som bevaras i de heliga skrifterna (Marx, Engels, Brecht) – men de förblir läpparnas bekännelser. Det är bara ett ytligt släktskap med den gamla tron. Innerst inne är kärnan helt och hållet – så att säga – sekulariserad.</p>
<p><em>* Rättelse: I en tidigare version av denna text stod det att ” teatern har blivit tilldelad medel från Ax:son Johnsons stiftelse, som bland annat ger ut den konservativt präglade kulturtidskriften Axess”  Det är sant att Helge Ax:son Johnsons stiftelse har stöttat Tribunalen, men inte Axel och Margaret Ax:son Johnsons stiftelse som ger ut tidskriften Axess. Vi beklagar förväxlingen.</em></p>
<p>&nbsp;</p>
<p><a href="#_ftnref1" name="_ftn1"></a></p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="83982">  <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, <a href="https://www.youtube.com/watch?v=_NZ-MVVVzXw"> https://www.youtube.com/watch?v=_NZ-MVVVzXw</a>; <a href="https://tribunalen.com/arkiv/arbetstitel-rorelsen/">https://tribunalen.com/arkiv/arbetstitel-rorelsen/</a></p>
<p>2, <a href="https://tribunalen.com/om-tribunalen/manifest/">https://tribunalen.com/om-tribunalen/manifest/</a></p>
<p>3, <a href="https://tribunalen.com/om-tribunalen/konstnarlig-ledning/">https://tribunalen.com/om-tribunalen/konstnarlig-ledning/</a></p>
<p>4, <a href="https://www.youtube.com/watch?v=ldMpVxSZCt4">https://www.youtube.com/watch?v=ldMpVxSZCt4</a> Jmf. <a href="https://www.youtube.com/watch?v=9DKPnQxgaq4">https://www.youtube.com/watch?v=9DKPnQxgaq4</a></p>
<p>5, 2022: 2 801 500 kronor (<a href="https://insynsverige.se/documentHandler.ashx?did=2015342&amp;rt=0&amp;t=">https://insynsverige.se/documentHandler.ashx?did=2015342&amp;rt=0&amp;t=</a>, s. 37); 2021: 2 700 000 kronor (<a href="https://insynsverige.se/documentHandler.ashx?did=1988706&amp;rt=0&amp;t=">https://insynsverige.se/documentHandler.ashx?did=1988706&amp;rt=0&amp;t=</a>, s. 12); 2020: 3 180 000 kronor (<a href="https://insynsverige.se/documentHandler.ashx?did=1968783&amp;rt=0&amp;t=">https://insynsverige.se/documentHandler.ashx?did=1968783&amp;rt=0&amp;t=</a>, s. 10); 2019: 2 890 000 kronor (<a href="https://insynsverige.se/documentHandler.ashx?did=1938062&amp;rt=0&amp;t=">https://insynsverige.se/documentHandler.ashx?did=1938062&amp;rt=0&amp;t=</a>, s. 10).</p>
<p>6, <a href="https://insynsverige.se/documentHandler.ashx?did=1968783&amp;rt=0&amp;t=">https://insynsverige.se/documentHandler.ashx?did=1968783&amp;rt=0&amp;t=</a>. s. 9</p>
<p>7, Stockholms kulturnämnd: <a href="https://insynsverige.se/documentHandler.ashx?did=2032447&amp;rt=0&amp;t=">https://insynsverige.se/documentHandler.ashx?did=2032447&amp;rt=0&amp;t=</a>, s. 2.</p>
<p>8, Statens kulturrråd 2022: 2 190 000 kronor (<a href="https://insynsverige.se/documentHandler.ashx?did=2015342&amp;rt=0&amp;t=">https://insynsverige.se/documentHandler.ashx?did=2015342&amp;rt=0&amp;t=</a>), s. 38; Statens kulturrråd 2021: 2 400 000 kronor (<a href="https://insynsverige.se/documentHandler.ashx?did=1988706&amp;rt=0&amp;t=">https://insynsverige.se/documentHandler.ashx?did=1988706&amp;rt=0&amp;t=</a>, s. 12); Statens kulturrråd 2020: 2 500 000 kronor (<a href="https://insynsverige.se/documentHandler.ashx?did=1968783&amp;rt=0&amp;t=">https://insynsverige.se/documentHandler.ashx?did=1968783&amp;rt=0&amp;t=</a>, s. 10); Statens kulturråd 2019: 2 400 000 kronor (<a href="https://insynsverige.se/documentHandler.ashx?did=1938062&amp;rt=0&amp;t=">https://insynsverige.se/documentHandler.ashx?did=1938062&amp;rt=0&amp;t=</a>, s. 10).</p>
<p>9, 2022: <a href="https://insynsverige.se/documentHandler.ashx?did=2015342&amp;rt=0&amp;t=">https://insynsverige.se/documentHandler.ashx?did=2015342&amp;rt=0&amp;t=</a>, s. 37</p>
</div>
</div>
<div class="author-byline">Lapo Lappin är kulturskribent med bakgrund inom filosofin och medarbetare i Kvartals redaktion.
</div>
</div>
