12 exotiska programspråk värda att utforska 2025

Vad "exotiskt" betyder för programspråk

"Exotiskt" betyder inte "bättre" eller "svårare". Det brukar betyda att ett språk försöker något ovanligt—antingen i hur du skriver kod, vad språket optimerar för, eller vilken idé det vill lära ut.

En praktisk definition

I den här artikeln räknas ett programspråk som exotiskt om det uppfyller minst ett av följande:

• Ovanlig syntax: kod som inte ser ut som i mainstream‑språk (ibland symboltung, ibland nästan osynlig).
• Nischade mål: byggt för ett speciellt tänkesätt—arrayer, logiska frågor, stack‑baserad komposition eller strikt minimalism.
• Experimentella idéer: utforskar en annorlunda exekveringsmodell (2D‑kodflöde, regelbaserad utvärdering eller kvantkoncept).

Sätt förväntningarna (så att du har roligt)

Att lära sig ett exotiskt eller esoteriskt språk är ofta roligt och oväntat lärorikt, eftersom det tvingar dig att ompröva antaganden: vad en "program" är, hur data flyter och hur mycket syntax som faktiskt behövs.

Många av dessa språk är inte verktyg för dagligt arbete. Några är pussel, några är forskningsverktyg, och några är utmärkta för en snäv uppgift medan de är besvärliga för allt annat. Vinsten är insikt—inte nödvändigtvis produktivitet.

Varför det spelar roll 2025

2025 är ett bra tillfälle att utforska: flera nischade språk har aktiva communityn, bättre dokumentation och mer användarvänliga verktyg (REPL:er, paket, online‑playgrounds). Det finns också förnyad nyfikenhet kring alternativa paradigmer—array‑programmering för dataarbete, logikprogrammering för regelverk och kvant‑"leksaks"‑miljöer som låter dig experimentera utan specialhårdvara.

Hur listan är organiserad

I stället för att rangordna "konstighet" är listan grupperad i familjer (minimalistiska, osynliga, 2D, array, logik, stack‑baserade, säkerhetsfokuserade, kvant). Varje avsnitt innehåller en enkel "vad att prova"‑idé så att du kan få en snabb vinst innan du bestämmer dig för att gå djupare.

Hur vi valde språken (och hur du provar dem säkert)

"Exotiskt" kan betyda mycket, så den här listan är inte bara en parad av konstig syntax. Vi valde språk som känns genuint annorlunda och fortfarande är praktiska att lära sig 2025.

Våra urvalskriterier

Först letade vi efter originalitet: språk som tvingar fram en ny mental modell (2D‑kod, stack‑tänkande, regler/queries, arrayer som standard, kvantkretsar).

För det andra prioriterade vi lärbarhet. Även när ett språk är ovanligt bör du kunna hitta ett tydligt "hello world", en tutorial och en väg för att skriva små program utan en veckas komplicerad installation.

Tredje, vi kollade efter verktyg du faktiskt kan använda: publik dokumentation, en fungerande interpreter/kompilator eller ett aktivt repository. Ett språk kan vara briljant, men om du inte kan köra det på en modern maskin är det svårt att rekommendera.

Slutligen strävade vi efter balans—en mix av klassiska esolangar (roliga, hjärnvridande) och seriösa nisch‑ eller forskningsspråk (användbara idéer som kan överföras till mainstream‑arbete).

En kort säkerhetsanmärkning innan du kör något

Behandla okänd kod som du skulle behandla en slumpmässig nedladdning. Kör helst interpretrar och exempelprogram i en container eller sandlåda (eller åtminstone en temporär mapp), och undvik att klistra in okänd kod i miljöer som har åtkomst till dina personliga filer, SSH‑nycklar eller moln‑uppgifter.

Om du experimenterar ofta kan det hjälpa att standardisera en "säker playground"‑setup. Till exempel kan du snurra upp en liten engångswebbapp som kör interpretrar bakom ett API och återställer tillståndet mellan körningar. Plattformar som Koder.ai är användbara här eftersom du kan beskriva playgrounden du vill ha i chatten (frontend + backend + databas om det behövs), iterera snabbt och exportera källkoden när du är nöjd.

Brainfuck: minimalism som pussel

Brainfuck är "exotiskt" av en enkel anledning: det försöker göra allt med en nästan komiskt liten instruktionsuppsättning. Språket har bara åtta kommandon (+ - \\u003c \\u003e [ ] . ,), inga nyckelord, inga variabler (i vanlig mening) och ingen läsbar struktur om du inte redan kan knepet.

Varför det är exotiskt

Istället för namngivna variabler får du ett band av minnesceller och en pekare som flyttar sig åt vänster och höger. Du inkrementerar/dekrementerar den aktuella cellen, flyttar pekaren och använder hakparenteser för loopar. Det är allt. Resultatet känns mer som att lösa ett logikpussel än att skriva en applikation.

Vad det lär dig

Brainfuck är en praktisk lektion i hur lite en dator behöver för att beräkna. Det tvingar dig att tänka på:

• minne och tillstånd (bandet)
• styrflöde (loopar via [ och ])
• in/ut på lägsta nivå (tecken, inte strängar)

Om du någon gång undrat vad en interpreter eller kompilator verkligen gör är Brainfuck ett utmärkt mål att öva på.

Var det används

Främst i programmeringspussel, teoridiskussioner, code golf och som övning för att skriva interpretrar.

Prova det

"Hello World" (klassisk version):

++++++++++[\\u003e+++++++\\u003e++++++++++\\u003e+++\\u003e+\\u003c\\u003c\\u003c\\u003c-]\\u003e++.\\u003e+.+++++++..+++.\\u003e++.\\u003c\\u003c+++++++++++++++.\\u003e.+++.------.--------.\\u003e+.\\u003e.

Ett litet loop‑exempel som sätter ett värde och skriver ut det som ett tecken:

+++++[\\u003e++++++++\\u003c-]\\u003e.

Tips: använd en online Brainfuck‑interpreter med steg‑för‑steg‑exekvering så att du kan se bandet ändras när du kör varje kommando.

Whitespace: program du inte kan se

Whitespace är ett esoteriskt språk där endast mellanslag, tabbar och radbrytningar är betydelsefulla. Allt annat behandlas som kommentar. Det betyder att ett giltigt program kan se helt tomt ut i din editor—och ändå köras.

Varför det är exotiskt

De flesta språk använder synliga nyckelord och skiljetecken. Whitespace vänder på det: hela källkoden är "osynlig" om du inte visar den med speciella inställningar. Det är ett perfekt exempel på hur mycket programmering beror på konventioner, verktyg och det mänskliga ögat.

Vad det lär (och varför det är förvånansvärt praktiskt)

Whitespace tvingar dig att tänka på parsing och tokenisering på lägsta nivå:

• Hur särskiljer du tokens när de inte är synliga?
• Hur representerar du tal och operationer med ett minimalt teckenuppsättning?
• Hur mycket komplexitet kan gömma sig bakom ett litet antal tecken?

Om du någonsin byggt en liten parser, skrivit en lexer eller debuggat "osynliga" tecken i riktig kod (blandade tabbar/mellanslag, konstiga radslut) förvandlar Whitespace den smärtan till en lärande övning.

Vad du bör vara uppmärksam på

Debugging är den stora utmaningen. En enda felaktig tabb eller radmatning kan helt ändra betydelsen.

Använd visualizers (verktyg som renderar mellanslag/tabbar/radbrytningar som synliga markörer) och editors som kan "visa osynliga tecken." Utan dem blir det frustrerande att ens läsa ditt eget program senare.

Prova det

Skriv det minsta programmet du kan i Whitespace som skriver ut ett tecken eller ett nummer, och implementera sedan samma beteende i ett vanligt språk (Python/JavaScript). Jämför:

• Kodlängd kontra tydlighet
• Hur du testar och felsöker
• Hur du dokumenterar avsikten när källkoden inte är läsbar

Befunge: tvådimensionell, självmodifierande kod

Befunge är exotiskt eftersom programmet inte är en prydlig uppsättning rader du läser uppifrån och ner. I stället lever det på ett 2D‑galler, och instruktionspekaren rör sig runt i det galler—höger, vänster, upp och ner—följande pilar du placerar i koden. Det känns mer som att navigera ett litet kretsdiagram eller ett flipperspel än att skriva ett skript.

Varför det är så konstigt (på ett bra sätt)

I de flesta språk är koden fast text. I Befunge kan programmet skriva om sig självt medan det körs: instruktioner kan skriva nya tecken i galleriet och ändra vad som kommer att köras härnäst. Denna självmodifierande förmåga är en del av språkets identitet och kan skapa överraskande, pusselliknande program.

Vad det lär dig

Befunge skjuter dig mot dataflödes‑ och tillståndsmaskinstänkande: du planerar vägar, loopar är bokstavliga rutter och branching är att styra riktningen. Eftersom flera riktningar är naturliga är det också lättare att tänka på parallella flöden (även om din interpreter fortfarande kör en instruktion i taget).

Var det passar

Befunge glänser i lekfulla sammanhang: programmeringspussel, code golf, interaktiva installationer som behöver udda genererat beteende, eller snabba demos där själva koden är en del av konsten.

Prova det: en liten taltransformer

Här är ett enkelt Befunge‑93‑program som läser en enda siffra och skriver ut siffran gånger två:

\\u00262*.

Kör det i vilken Befunge‑interpreter som helst: skriv en siffra (0–9) så får du resultatet. Experimentera vidare genom att lägga till riktningspilar (\\u003e \\u003c ^ v) och extra celler så att instruktionspekaren tar en "rutt" i stället för en rak linje.

Hexagony: kodning på ett hex‑gitter

Hexagony är exotiskt eftersom ditt program inte är en rad text—det är arrangerat på ett hexagonalt "bikakor"‑gitter. En instruktionspekare rör sig över det gitter, svänger vid kanter och följer regler som känns mer som att navigera ett brädspel än att skriva vanlig kod.

Vad det lär (överraskande bra)

Hexagony tvingar dig att tänka spatialt: var en instruktion finns betyder lika mycket som vad den gör. Det gör det till ett bra sätt att öva på:

• Spatialt resonerande: du planerar vägar, inte bara sekvenser.
• Tillståndsmaskiner: rörelseriktning och cellbeteende blir till "tillstånd" du hanterar.
• Begränsningstänkande: begränsat utrymme tvingar fram kompakt, genomtänkt styrflöde.

Förväntningar: roligt först, produktivt senare

Det här är mest för utforskning. Du byter inte ut Python eller JavaScript med Hexagony på jobbet, men du får en skarpare känsla för hur interpretrar, instruktionspekare och styrflöde fungerar.

Prova det: en liten genomgång av rörelseregler

Börja med att föreställa dig ett litet gitter där varje cell innehåller ett tecken‑instruktion. Du placerar instruktionspekaren på startcellen med en riktning (en av sex möjliga riktningar på ett hex‑gitter). Sedan:

1. Läs den aktuella cellens instruktion (t.ex. ändra riktning, utför aritmetik, läs/skriv ett värde).
2. Flytta till nästa cell i aktuell riktning.
3. När du träffar en kant, "wrappar" pekaren eller svänger enligt gittergeometrin.

Ett bra första övningssteg är att stega igenom ett program som bara ändrar riktning och skriver ut ett tecken—räcker för att känna hur navigation är styrflöde. Om du vill ha en säker playground‑approach, använd en online‑interpreter och single‑step‑exekvering (se /blog/how-to-try-esoteric-languages-safely).

Wolfram Language: regelbaserat tänkande i skala

De flesta språk uppmuntrar dig att beskriva steg: gör detta, sedan det, loopa tills klart. Wolfram Language känns exotiskt eftersom du ofta kan beskriva regler i stället—relationer och transformationer—och låta systemet tillämpa dem.

Varför det är exotiskt

I grunden är Wolfram Language symboliskt och regelbaserat. Du skriver mönster som matchar delar av ett uttryck och specificerar hur de ska omskrivas. I stället för att manuellt kontrollera flödet lutar du dig mot mönstermatchning och omskrivningsregler för att utveckla ett uttryck mot ett resultat.

Vad det lär

Den här stilen är en praktisk introduktion till term‑rewriting: beräkning som upprepad ersättning. Du börjar se att många "algoritmer" bara är ett litet antal omskrivningsregler plus en strategi för hur de ska appliceras. Det bygger också intuition för mönstermatchning—inte bara på strängar, utan på strukturerade uttryck.

När det är användbart

Regelbaserad programmering glänser när du modellerar transformationer: förenkling av algebra, omskrivning av formler, manipulering av träd, konvertering mellan format eller att uttrycka system där reglerna är viktigare än proceduren.

Prova det: ett litet omskrivningssystem

Klistra in det här i Wolfram Language och se hur några regler ger oväntat beteende:

rules = {
  x_ + 0 -\\u003e x,
  0 + x_ -\\u003e x,
  x_ * 1 -\\u003e x,
  1 * x_ -\\u003e x,
  x_ + x_ -\\u003e 2 x
};

expr = (a + 0) + (a + a) * 1;

FixedPoint[# //. rules \\u0026, expr]

Ändra sedan en regel (t.ex. lägg till en distributiv omskrivning) och se hur systemets "personlighet" förändras.

APL och BQN: symboltung array‑kraft

APL och dess moderna kusin BQN känns "exotiska" eftersom de vänder standarden för programmering. I stället för att tänka i enstaka värden och loopar behandlar du allt som en array (en lista, en tabell eller högre‑dimensionella data), och de flesta operationer tillämpas automatiskt på hela kollektioner.

Varför det är exotiskt: arrayer först, broadcasting överallt

I typiska språk kräver att lägga till ett tal i en lista en loop eller en hjälpfunktion. I APL/BQN kan "lägg till 10" betyda "lägg till 10 på varje element" och språket gör det till standardtolkningen. Denna broadcasting‑beteende är kraftfull—men det som verkligen chockerar är notationerna: kompakt symbolism ("glyphs") representerar vanliga operationer, så program kan se ut som tät matematik.

Vad det lär: vektor‑tänkande och avsiktlig koncisthet

Att jobba i APL/BQN tränar dig att fråga: "Vad är formen på min data?" och "Kan jag uttrycka detta som en transform av hela arrayer?" Du kommer att börja ersätta steg‑för‑steg‑procedurer med ett litet antal tydliga dataoperationer: reshape, sortera, gruppera, reducera (summa), scan (löpnade totalsummor) och yttre produkter.

Var det glänser: analys, finans, simulering

Om ditt arbete handlar om att knäcka kolumner, matriser och tidsserier kan array‑språk vara mycket uttrycksfulla. Därför har de länge haft ett fäste inom finans och vetenskaplig beräkning, och därför har BQN lockat utvecklare som vill ha array‑superkrafter med en mer modern känsla.

Prova det: skriv om en loop som arrayuttryck

Välj en välkänd uppgift—som att normalisera en lista med tal eller beräkna ett glidande medelvärde—och skriv den två gånger: en gång med loop, en gång som "hela‑array"‑transformer. Även om symbolerna känns främmande vid första anblicken lär övningen dig att se beräkningen som dataflöde snarare än styrflöde.

J och K: täta, komponerbara array‑språk

J och K är "exotiska" eftersom de uppmuntrar dig att tänka i hela arrayer (listor, tabeller) och i kompositioner i stället för steg‑för‑steg‑instruktioner. I stället för att skriva loopar och temporära variabler bygger du pipeliner av små funktioner—ofta så kompakta att de ser ut som interpunktion.

Varför det är exotiskt: programmering genom funktionella kompositioner

Båda språken är designade för att kedja operationer: ta data, transformera den, reducera den, reshapea den. J lutar mot "tacit" (point‑free) programmering där du definierar beteende utan att namnge inputs. K (och dess nära släkting q i kdb+) är likaledes kortfattat och byggt för snabba, komponerbara datatransformer.

Vad det lär: tacit‑programmering och point‑free‑stil

Att spendera även en timme med J/K förändrar vad du lägger märke till i andra språk: du börjar fråga "Vad är transformen?" snarare än "Vilken loop?" Du lär dig också att läsa program som kompositioner—som matematik—där pipelinens struktur är förklaringen.

Var det glänser: datatransformer och eleganta smålösningar

Dessa språk utmärker sig i "ta den här kollektionen och räkna ut den där sammanfattningen"‑uppgifter: rankning, gruppering, normalisering, filtrering och snabb utforskande analys. De är särskilt tillfredsställande när de flesta språk skulle innebära mycket boilerplate.

Prova det: bygg en mini‑pipeline utan variabler

I J, prova att definiera en normaliseringspipeline (min‑max‑skalning) utan att namnge input:

norm =: (] - \\u003c./) % (\\u003e./ - \\u003c./)
norm 3 10 5 7

Eller en liten textpipeline—räkna ord i en sträng:

#@;: 'J makes pipelines feel like algebra'

Oroa dig inte om symbolerna känns täta vid första anblick—den initiala friktionen är poängen: den tvingar dig att se dataoperationer som byggstenar.

Forth och Factor: stacken som språk

Forth och Factor känns "exotiska" eftersom du inte skriver uttryck som i Python eller JavaScript. I stället skriver du oftast sekvenser av stackoperationer: pusha värden, applicera ett "word" (funktion) och lämna resultat på stacken för nästa word.

Varför det är exotiskt

I ett stack‑språk är ordningen syntaxen. En liten förändring i sekvens ändrar betydelsen, och det finns färre synliga "substantiv" (variabler) på sidan. Forth är berömt för att vara minimalt, ofta implementerat med ett mycket litet kärnset. Factor behåller stackmodellen men lägger till ett modernt standardbibliotek, verktyg och en mer strukturerad känsla.

Vad det lär dig

Du lär dig hur stackmaskiner fungerar och varför de är attraktiva för interpretrar och virtuella maskiner. Du får också en praktisk lektion i komposition: bygga små words som passar ihop rent, eftersom att hålla stacken balanserad tvingar disciplin.

Fördelar i riktiga projekt

Eftersom kärnan kan vara liten är Forth‑liknande system lätta att bädda in i enheter, spel och skript där du vill ha ett kompakt kommandospråk. Factor kan vara en lekplats för att snabbt bygga komponerbara program.

Prova det

Börja med aritmetik och stackmanipulation (t.ex. duplicera och byta värden). Bygg sedan en liten kalkylator‑REPL: läs en token, pusha tal, kör words som + och * och skriv ut stacken. Om det klickar, utöka det till en mini‑interpreter med ett lexikon av användardefinierade words.

Prolog och Datalog: ställ frågor, få svar

De flesta programspråk ber dig stava ut hur man gör något: loopa här, gren där, uppdatera det här. Prolog och Datalog vänder på det. Du beskriver fakta och regler, sedan ställer du frågor—och systemet söker efter svar.

Varför de är "exotiska"

I stället för styrflöde skriver du logiska regler. Ett Prolog‑program läser ofta som ett kompakt set lagar om en värld, plus queries. Under huven använder Prolog unifiering (mönstermatchning) och backtracking (försöka alternativ) för att hitta lösningar.

Datalog är en nära kusin: vanligtvis mer begränsad (inga komplexa termer på samma sätt), men utmärkt för skalbar regelutvärdering och databasliknande resonemang.

Vad de lär dig

Att arbeta i en deklarativ stil tvingar fram en annan mental modell:

• Tänk i begränsningar och relationer, inte i steg.
• Separera kunskap (fakta) från härledning (regler).
• Lägg märke till hur en liten uppsättning regler kan generera många giltiga lösningar.

Dessa idéer dyker upp långt utanför esoteriska språk—regelmaskiner, policysystem, frågeplanerare och experimentell språkforskning drar nytta av dem.

Var de glänser

Logikprogrammeringsspråk är särskilt bra för schemaläggning, konfigurationsregler, kunskapsbaser och pussellösning—alltså överallt där målet är "hitta en lösning som uppfyller dessa villkor."

Prova det: ett litet stamtavlasexempel

parent(alex, sam).
parent(sam, riley).

grandparent(X, Y) :- parent(X, Z), parent(Z, Y).

Fråga sedan:

?- grandparent(alex, Who).

Du skrev ingen loop; du ställde en fråga. Den förskjutningen är den verkliga lektionen—och varför dessa nischade programspråk fortfarande känns fräscha 2025.

Rust: ovanliga säkerhetsregler med verklig nytta

Rust kan kännas "exotiskt" inte för att det är obskyrt, utan för att det ber dig lära en ny mental modell: ägarskap. I stället för att förlita sig på en garbage collector (som JavaScript eller Python) eller lita på att du frigör minne manuellt (som i C), tvingar Rust fram regler om vem som "äger" ett värde och hur det kan delas.

Varför det är exotiskt: ownership och borrowing

Borrow checker är en kompileringstidens domare. Den förhindrar många vanliga buggar—use‑after‑free, double frees och data races—genom att avvisa kod som kan vara osäker. Det kan vara överraskande i början: du kanske vet vad du menar, men Rust vill ha bevis.

Vad det lär: säkerhet utan garbage collection

Rusts stora lärdom är att prestanda och säkerhet inte behöver vara en trade‑off. Du börjar tänka i lifetimes, explicit dataflöde och tydliga gränser mellan "en ägare" och "delat tillträde." Även om du aldrig levererar Rust‑kod överförs dessa vanor till andra språk.

Var det glänser

Rust är ett praktiskt val för systemverktyg, kommandoradsverktyg, spelmotorer, inbyggda projekt och prestandakritiska tjänster—platser där hastighet spelar roll och krascher är kostsamma.

Prova det: översätt ett litet program och se garantierna

Ta ett litet skript du kan väl (en ordräknare, CSV‑rensare eller filomdöpare). Implementera det i Rust och introducera sedan med avsikt en bugg:

• Håll en referens till en sträng och försök ändra strängen.
• Dela ett värde över trådar utan synkronisering.

Rust låter dig ofta inte kompilera förrän det riskfyllda beteendet är löst. Behandla felmeddelandena som guidade läsningar: de förklarar vilken regel du bröt och föreslår vanligtvis en säkrare struktur.

Q# och Qiskit: kvantprogrammering du faktiskt kan prova

Kvantprogrammering känns exotiskt eftersom du inte beskriver en sekvens steg så mycket som du beskriver en kvantkrets: qubits, grindar och mätningar. I stället för "funktionen returnerar X" får du ofta sannolikheter—kör samma program flera gånger och du kan få olika resultat.

Varför det är exotiskt

Q# (Microsoft) och Qiskit (IBM) är byggda kring kretsoperationer och mätningar. Du skriver kod som sätter upp superposition och intrassling, och sedan kollapsar det genom mätning. Det tänkesättet skiljer sig mycket från vanliga applikationer.

Vad det lär

Även om du aldrig rör riktig kvant‑hårdvara gör dessa verktyg grundläggande koncept konkreta:

• Superposition: en qubit kan representera en blandning av 0 och 1 tills den mäts.
• Entanglement: qubits kan bli länkade så att deras resultat korrelerar.
• Sannolikhetsresultat: utfall är fördelningar, inte enstaka värden.

Verklighetskontroll (simulatorer är normen)

De flesta kör kvantprogram på simulatorer. Riktiga enheter har brus, köer och begränsningar. Simulatorer är fortfarande värdefulla: du lär dig mentalmodellen utan att kämpa mot hårdvarans egenheter.

Prova det: en liten krets på simulator (Qiskit)

Detta skapar två intrasslade qubits (en Bell‑pair) och mäter dem:

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])

sim = AerSimulator()
result = sim.run(qc, shots=1000).result()
print(result.get_counts())

Du kommer typiskt se mest 00 och 11, vilket är "aha"‑ögonblicket: qubits beter sig som ett par, inte som två oberoende bitar.

Hur du väljer ditt nästa exotiska språkexperiment

Att välja ett exotiskt språk är enklare om du börjar med ditt mål. Vissa språk lär idéer (logik, arrays, kvanttänkande), andra lär disciplin (säkerhetsregler), och några är helt enkelt roliga begränsningar som skärper problemlösning.

Välj efter vad du vill lära dig

• Teori & nya mentalmodeller: Prolog/Datalog (frågor), Wolfram Language (regelbaserat), kvantverktyg (Q#/Qiskit).
• Mattematisk uttrycksfullhet: APL/BQN, J/K (array‑tänkande och kortfattad komposition).
• Säkerhet & ingenjörsvanor: Rust (ownership och borrowing).
• Lekfullt begränsningslösande: Brainfuck, Whitespace, Befunge, Hexagony.

Om du är osäker, välj det som känns lite obekvämt men fortfarande genomförbart—du vill ha friktion, inte frustration.

En lättviktig lärandestig (1 timme → 1 dag → 1 vecka)

1‑timme introduktion:

Läs en kort tutorial och kör 3–5 pyttesmå exempel. Ditt enda mål är att förstå hur koden ser ut och hur du kör den.

1‑dagprojekt:

Bygg något smått nog att du hinner klart. Bra alternativ:

• En mini‑interpreter för en begränsad del av språket (eller en Brainfuck‑stil VM).
• En pretty‑printer/visualizer (bra för Befunge/Hexagony‑galler).
• En pussellösare (logik‑språk glänser här).

1‑vecka djupdykning:

Bygg om samma projekt med bättre struktur: tester, felmeddelanden, dokumentation och prestandaoptimeringar. Här blir språkets verkliga styrkor och kompromisser tydliga.

Om du vill snabba på "1‑dagprojektet" kan du använda Koder.ai för att skapa en liten webb‑runner (React‑UI + Go‑backend + PostgreSQL om du behöver lagring) från ett enkelt chattuppdrag, iterera i planeringsläge och exportera källkoden när du är klar. Det är ett enkelt sätt att förvandla språknyfikenhet till en körbar playground du kan dela.

Var du går härnäst

För fler praktiska experiment och artiklar, bläddra i /blog.

Om du vill ha verktygskontext—editors, runners, sandlådor eller teamarbetsflöden—se /pricing och avgör vad som faktiskt skulle få dig att öva mer konsekvent.