diff --git a/README.md b/README.md
index a89f384..0a0c400 100644
--- a/README.md
+++ b/README.md
@@ -1,410 +1,468 @@
-# Pi-beräkningsbenchmark 🥧
+# Pi-beräkningsbenchmark: Prestandajämförelse av 34 programmeringsspråk
 
-## Vad är detta? 🤔
+## Sammanfattning
 
-Detta är ett **prestandatest** som jämför hur snabbt olika programmeringsspråk kan beräkna talet **π (pi)** med många decimaler.
+Denna studie jämför prestandan hos 34 programmeringsspråk vid beräkning av π (pi) med hög precision. Testet använder Machins formel och mäter exekveringstid för 100, 1000 och 10000 decimaler.
 
-**Pi (π)** är ett matematiskt konstant som börjar med `3.14159...` och fortsätter i evighet utan att upprepa sig. Vi använder pi varje dag utan att tänka på det - när vi beräknar omkretsen på en pizza, ytan på en cirkel, eller när GPS-navigering beräknar avstånd.
+## Testmiljö
 
-## Varför göra detta? 🎯
+**Hårdvara:**
+- **Modell:** MacBook Neo (Mac17,5)
+- **Processor:** Apple A18 Pro
+  - 6 kärnor: 2 prestandakärnor + 4 effektivitetskärnor
+  - Arkitektur: ARM64
+- **Minne:** 8 GB RAM
+- **Operativsystem:** macOS (Darwin)
 
-1. **Lära oss om programmeringsspråk** - Olika språk fungerar på olika sätt
-2. **Förstå prestandaskillnader** - Varför är vissa språk snabbare än andra?
-3. **Ha kul!** - Det är fascinerande att se hur 34 olika språk löser samma problem
+**Mätmetod:**
+- Varje språk körs 4 gånger per test
+- Första körningen räknas som "warmup" och exkluderas
+- Resultatet är genomsnittet av de 3 efterföljande körningarna
+- Tidsmätning i millisekunder (ms)
 
-## Hur fungerar testet? ⚙️
+## Metod: Machins formel
 
-### Metoden: Machins formel
-
-Vi använder en **300 år gammal matematisk formel** som upptäcktes av John Machin år 1706:
+Alla implementationer använder Machins formel för π-beräkning:
 
 ```
-π/4 = 4 × arctan(1/5) - arctan(1/239)
+π/4 = 4·arctan(1/5) - arctan(1/239)
 ```
 
-**På enkel svenska:**
-- Vi beräknar två "arctan"-värden (en matematisk funktion)
-- Kombinerar dem med multiplikation och subtraktion
-- Resultatet är π med hög precision
+Där arctan(x) beräknas med Taylor-serien:
 
-### Varför denna metod? ✅
-
-- **Snabb** - Konvergerar snabbt (behöver få iterationer)
-- **Noggrann** - Kan beräkna miljontals decimaler
-- **Enkel** - Kan implementeras i alla programmeringsspråk
-
-## Testproceduren 📋
-
-För varje språk:
-1. **Bygg** programmet (om det behöver kompileras)
-2. **Kör** programmet med olika antal decimaler: 1, 2, 5, 10, 100, 1000, 10000
-3. **Jämför** resultatet med det korrekta värdet av π
-4. **Mät** hur lång tid det tar
-
-## Varför så stor skillnad i tid? ⏱️
-
-Här är de **huvudsakliga orsakerna** till varför vissa språk är snabbare än andra:
-
-### 1. **Kompilerade vs Tolkade språk** 🏃‍♂️
-
-**Kompilerade språk (SNABBA):**
-- **C, C++, Rust, Go, Swift** - Översätts till maskinkod EN gång, körs direkt av processorn
-- **Analogi:** Som att ha en färdigöversatt bok - du kan läsa den direkt
-
-**Tolkade språk (LÅNGSAMMA):**
-- **Python, Ruby, JavaScript** - En "tolk" läser och kör koden rad för rad varje gång
-- **Analogi:** Som att ha en tolk som översätter boken medan du läser
-
-**Skillnad:** Kompilerade språk kan vara **10-100 gånger snabbare**!
-
-### 2. **Hur språket hanterar stora tal** 🔢
-
-För att beräkna π med 10,000 decimaler måste vi hantera **väldigt stora tal**:
-
-- **Effektiva språk:** Har inbyggt stöd för stora tal (C med GMP, Python med integers)
-- **Mindre effektiva:** Måste implementera stora tal själva (JavaScript, Lua)
-
-**Skillnad:** Kan göra språket **1000 gånger långsammare** om det inte stöder stora tal!
-
-### 3. **Minnesanvändning och optimering** 💾
-
-- **C, C++, Rust:** Direkt åtkomst till minne, ingen "sophämtning"
-- **Java, C#:** Automatisk sophämtning (garbage collection) som tar tid
-- **Python, Ruby:** Flexibla objekt som kräver mer minne
-
-### 4. **JIT-kompilering (Just-In-Time)** ⚡
-
-Vissa språk kombinerar tolkning och kompilering:
-
-- **Java, C#, JavaScript (Node.js):** 
-  - Startar som tolkade
-  - Kompilerar "heta" koddelar automatiskt
-  - Kan närma sig kompilerade språks hastighet
-
-## Språk-för-språk guide 📚
-
-### 🚀 **Supersnabba språk** (Kompilerade, optimerade)
-
-#### **C** ⚡⚡⚡
-- **Typ:** Kompilerat, låg-nivå
-- **Prestanda:** En av de snabbaste
-- **Varför:** Direkt maskinkod, ingen overhead, manuellt minneshantering
-- **Analogi:** Som att köra en Formel 1-bil - maximal prestanda, men du måste vara expertförare
-
-#### **C++** ⚡⚡⚡
-- **Typ:** Kompilerat, objektorienterat
-- **Prestanda:** Nästan lika snabbt som C
-- **Varför:** Samma som C, men med moderna funktioner
-- **Analogi:** Som en sportbil med automatväxel - snabb men enklare att köra
-
-#### **Rust** ⚡⚡⚡
-- **Typ:** Kompilerat, minnessäkert
-- **Prestanda:** Jämförbar med C/C++
-- **Varför:** Nollkostnadsabstraktioner, ingen sophämtning
-- **Analogi:** Som en säker sportbil - snabb men med airbags och antiblockeringssystem
-
-#### **Go** ⚡⚡
-- **Typ:** Kompilerat, modernt
-- **Prestanda:** Snabb, men med sophämtning
-- **Varför:** Effektiv kompilator, bra standardbibliotek
-- **Analogi:** Som en modern familjebils - snabb nog, men säker och bekväm
-
-#### **Swift** ⚡⚡
-- **Typ:** Kompilerat, modernt (från Apple)
-- **Prestanda:** Snabb, optimerad för moderna processorer
-- **Varför:** Avancerad kompilator, bra optimeringar
-- **Analogi:** Som en iPhone - snabb, modern, användarvänlig
-
-### 🏃 **Snabba språk** (JIT-kompilerade eller effektiva)
-
-#### **Java** ⚡⚡
-- **Typ:** JIT-kompilerat (Java Virtual Machine)
-- **Prestanda:** Snabb efter uppvärmning
-- **Varför:** JIT-kompilator optimerar koden under körning
-- **Analogi:** Som en bil som blir snabbare ju mer du kör den
-
-#### **C#** ⚡⚡
-- **Typ:** JIT-kompilerat (.NET)
-- **Prestanda:** Liknande Java
-- **Varför:** Modern JIT-kompilator, bra optimeringar
-- **Analogi:** Som Java men från Microsoft
-
-#### **Julia** ⚡⚡
-- **Typ:** JIT-kompilerat, vetenskapligt
-- **Prestanda:** Mycket snabb för numerisk beräkning
-- **Varför:** Designat för matematik, JIT optimerar bra
-- **Analogi:** Som en miniräknare på steroider
-
-#### **Kotlin** ⚡
-- **Typ:** Kompilerat till Java bytecode
-- **Prestanda:** Liknande Java
-- **Varför:** Kör på samma JVM som Java
-- **Analogi:** Som Java men med modernare syntax
-
-### 🐢 **Långsammare språk** (Tolkade, men praktiska)
-
-#### **Python** 🐢
-- **Typ:** Tolkat, dynamiskt typat
-- **Prestanda:** Långsamt, men har snabba bibliotek
-- **Varför:** Tolkas rad för rad, dynamiska typer
-- **Analogi:** Som att prata med en mycket hjälpsam assistent - långsamt men enkelt
-
-#### **Ruby** 🐢
-- **Typ:** Tolkat, objektorienterat
-- **Prestanda:** Liknande Python
-- **Varför:** Tolkas, flexibla objekt
-- **Analogi:** Som Python men mer fokuserat på programmerarens glädje
-
-#### **JavaScript (Node.js)** 🐢
-- **Typ:** JIT-kompilerat i V8-motorn
-- **Prestanda:** Överraskande snabbt för att vara tolkat
-- **Varför:** V8-motorn optimerar aggressivt
-- **Analogi:** Som en webbläsare som också kan köra program
-
-#### **PHP** 🐢
-- **Typ:** Tolkat, webb-fokuserat
-- **Prestanda:** Måttligt snabbt
-- **Varför:** Tolkas, designat för webben
-- **Analogi:** Som en specialbyggd webbserver
-
-### 🐌 **Mycket långsamma språk** (Speciella fall)
-
-#### **Bash** 🐌
-- **Typ:** Skalskript, kommandorad
-- **Prestanda:** Mycket långsamt
-- **Varför:** Startar nya program för varje operation
-- **Analogi:** Som att be någon annan göra varje liten sak åt dig
-
-#### **Brainfuck** 🐌🐌
-- **Typ:** Esoteriskt, minimalt
-- **Prestanda:** Extremt långsamt
-- **Varför:** Endast 8 instruktioner, ingen optimering
-- **Analogi:** Som att kommunicera med blinkningar - möjligt men smärtsamt
-
-#### **Lua** 🐢
-- **Typ:** Tolkat, inbäddningsbart
-- **Prestanda:** Snabb för att vara tolkat
-- **Varför:** Lättvikt tolk, enkel design
-- **Analogi:** Som en liten, snabb motorcykel
-
-#### **Perl** 🐢
-- **Typ:** Tolkat, skript-språk
-- **Prestanda:** Måttligt snabbt
-- **Varför:** Tolkas, kraftfull textbehandling
-- **Analogi:** Som en schweizisk armékniv - kan göra allt
-
-#### **R** 🐢
-- **Typ:** Tolkat, statistik-fokuserat
-- **Prestanda:** Måttligt snabbt
-- **Varför:** Optimerat för statistik, inte ren beräkning
-- **Analogi:** Som en grafritande miniräknare
-
-### 🔬 **Specialiserade språk**
-
-#### **Haskell** ⚡
-- **Typ:** Funktionellt, kompilerat
-- **Prestanda:** Snabbt med optimeringar
-- **Varför:** Kompilerar till effektiv kod
-- **Analogi:** Som att lösa matteproblem med algebra istället för att räkna
-
-#### **Erlang** 🏃
-- **Typ:** Funktionellt, samtidighets-fokuserat
-- **Prestanda:** Måttligt snabbt
-- **Varför:** Optimerat för många samtidiga processer
-- **Analogi:** Som en telefonväxel - hanterar många samtal samtidigt
-
-#### **Elixir** 🏃
-- **Typ:** Funktionellt, körs på Erlang VM
-- **Prestanda:** Liknande Erlang
-- **Varför:** Modern syntax på Erlangs plattform
-- **Analogi:** Som Erlang men med modernare gränssnitt
-
-#### **Scala** ⚡
-- **Typ:** Hybrid funktionellt/objektorienterat, på JVM
-- **Prestanda:** Liknande Java
-- **Varför:** Kompilerar till Java bytecode
-- **Analogi:** Som Java på steroider med funktionella superkrafter
-
-#### **Crystal** ⚡⚡
-- **Typ:** Kompilerat, Ruby-lik syntax
-- **Prestanda:** Snabbt som C
-- **Varför:** Kompilerar till effektiv maskinkod
-- **Analogi:** Som Ruby men med en turbomotor
-
-#### **Nim** ⚡⚡
-- **Typ:** Kompilerat, Python-lik syntax
-- **Prestanda:** Snabbt som C
-- **Varför:** Kompilerar till C-kod
-- **Analogi:** Som Python men kompilerat
-
-#### **Zig** ⚡⚡
-- **Typ:** Kompilerat, modernt system-språk
-- **Prestanda:** Snabbt som C
-- **Varför:** Ingen hidden control flow, direkt kompilering
-- **Analogi:** Som C men säkrare och modernare
-
-#### **Odin** ⚡⚡
-- **Typ:** Kompilerat, system-språk
-- **Prestanda:** Snabbt
-- **Varför:** Designat för prestanda och enkelhet
-- **Analogi:** Som Go men med C-prestanda
-
-#### **D** ⚡⚡
-- **Typ:** Kompilerat, C-liknande
-- **Prestanda:** Snabbt
-- **Varför:** Kompilerar till effektiv maskinkod
-- **Analogi:** Som C men med moderna funktioner
-
-#### **Fortran** ⚡⚡
-- **Typ:** Kompilerat, vetenskapligt
-- **Prestanda:** Mycket snabbt för numerisk beräkning
-- **Varför:** Optimerat för matematik i 60+ år
-- **Analogi:** Som en räknare byggd för vetenskap
-
-#### **Objective-C** ⚡⚡
-- **Typ:** Kompilerat, objektorienterat
-- **Prestanda:** Snabbt
-- **Varför:** Kompilerar till maskinkod
-- **Analogi:** Som C med objektorientering
-
-#### **Assembly** ⚡⚡⚡
-- **Typ:** Låg-nivå, direkt maskinkod
-- **Prestanda:** Snabbast möjligt (om skrivet rätt)
-- **Varför:** Direkt kontroll över processorn
-- **Analogi:** Som att programmera processorn direkt - maximal kontroll
-
-### 🆕 **Nya/Speciella språk**
-
-#### **TypeScript** 🏃
-- **Typ:** Kompilerat till JavaScript
-- **Prestanda:** Liknande JavaScript
-- **Varför:** Kompilerar till JS, körs i Node.js
-- **Analogi:** Som JavaScript med typer
-
-#### **Dart** ⚡
-- **Typ:** Kompilerat eller JIT
-- **Prestanda:** Snabbt med JIT
-- **Varför:** Designat för moderna appar
-- **Analogi:** Som JavaScript men designat för appar
-
-#### **Vimscript** 🐌
-- **Typ:** Tolkat i Vim
-- **Prestanda:** Mycket långsamt
-- **Varför:** Designat för textredigering, inte beräkning
-- **Begränsning:** Endast 15 decimalers precision (flyttals-gräns)
-- **Analogi:** Som att använda en texteditor för att räkna matte
-
-#### **Wolfram Language** 🔬
-- **Typ:** Tolkat, matematiskt
-- **Prestanda:** Snabbt för matematik
-- **Varför:** Inbyggd matematisk motor
-- **Analogi:** Som att ha en matematikprofessor inbyggd
-
-## Resultat-exempel 📊
-
-Här är typiska körtider för **10,000 decimaler**:
-
-| Språk | Tid | Kategori |
-|-------|-----|----------|
-| C | ~50ms | Supersnabb |
-| C++ | ~50ms | Supersnabb |
-| Rust | ~50ms | Supersnabb |
-| Go | ~100ms | Snabb |
-| Java | ~200ms | Snabb |
-| Julia | ~150ms | Snabb |
-| Python | ~2000ms | Måttlig |
-| Ruby | ~3000ms | Måttlig |
-| JavaScript | ~1500ms | Måttlig |
-| Bash | ~30000ms | Långsam |
-| Brainfuck | ~60000ms+ | Mycket långsam |
-
-**Skillnad:** Snabbaste vs långsammaste = **1000x skillnad!**
-
-## Hur man kör testerna 🚀
-
-### Bygga alla språk:
-```bash
-./build.sh
-```
-
-### Köra tester:
-```bash
-# Testa alla språk
-./test.sh
-
-# Testa ett specifikt språk
-./test.sh python
-./test.sh rust
-```
-
-### Köra prestandatest:
-```bash
-# Testa med 100 decimaler
-./run_all.sh 100
-
-# Testa med 10000 decimaler
-./run_all.sh 10000
-```
-
-## Varför är skillnaden så stor? 🤯
-
-Sammanfattningsvis:
-
-1. **Kompilerade språk (C, C++, Rust)** = **100-1000x snabbare** än tolkade
-2. **JIT-kompilerade (Java, C#)** = **10-100x snabbare** än tolkade
-3. **Tolkade språk (Python, Ruby)** = **Baslinjen**
-4. **Specialfall (Bash, Brainfuck)** = **100-1000x långsammare** än baslinjen
-
-### Den verkliga skillnaden:
-
-**För 10,000 decimaler:**
-- **C/Rust:** ~50 millisekunder (en ögonblinkning)
-- **Python:** ~2 sekunder (tid att säga "en två tre")
-- **Bash:** ~30 sekunder (tid att dricka en kaffe)
-- **Brainfuck:** ~60+ sekunder (tid att undra varför du gör detta)
-
-## Slutsats 🎓
-
-**Vilket språk ska du välja?**
-
-- **Maximal prestanda:** C, C++, Rust, Zig
-- **Balans mellan prestanda och enkelhet:** Go, Swift, Kotlin
-- **Snabb utveckling:** Python, Ruby, JavaScript
-- **Matematik/Vetenskap:** Julia, Python (med NumPy), R
-- **Lära sig:** Python, Ruby, JavaScript
-
-**Kom ihåg:** Det snabbaste språket är inte alltid det bästa valet. Ofta är **utvecklingstid** viktigare än **körtid**!
-
----
-
-## Tekniska detaljer för nyfikna 🔧
-
-### Machins formel i detalj:
-
-```
-π/4 = 4 × arctan(1/5) - arctan(1/239)
-```
-
-Där `arctan(x)` beräknas med Taylor-serien:
 ```
 arctan(x) = x - x³/3 + x⁵/5 - x⁷/7 + ...
 ```
 
-### Varför denna formel?
+**Fördelar med denna metod:**
+1. Snabb konvergens (få termer krävs)
+2. Enkel implementation
+3. Hög noggrannhet möjlig
+4. Endast heltalsaritmetik krävs
 
-1. **Snabb konvergens:** Behöver få termer för hög precision
-2. **Enkel implementation:** Bara division och multiplikation
-3. **Hög noggrannhet:** Kan beräkna miljontals decimaler
+## Resultat
 
-### Implementation i alla språk:
+### 100 decimaler
 
-Alla språk använder **samma algoritm**:
-1. Beräkna `arctan(1/5)` med Taylor-serien
-2. Beräkna `arctan(1/239)` med Taylor-serien
-3. Kombinera: `π = 16 × arctan(1/5) - 4 × arctan(1/239)`
+| Språk | Tid (ms) | Kategori | Status |
+|-------|----------|----------|--------|
+| C | 6 | Kompilerat (native) | ✓ |
+| Assembly | 7 | Kompilerat (native) | ✓ |
+| C++ | 7 | Kompilerat (native) | ✓ |
+| Nim | 7 | Kompilerat (native) | ✓ |
+| Odin | 7 | Kompilerat (native) | ✓ |
+| Rust | 7 | Kompilerat (native) | ✓ |
+| Fortran | 8 | Kompilerat (native) | ✓ |
+| Objective-C | 8 | Kompilerat (native) | ✓ |
+| Crystal | 9 | Kompilerat (native) | ✓ |
+| Go | 9 | Kompilerat (native) | ✓ |
+| Swift | 9 | Kompilerat (native) | ✓ |
+| Lua | 10 | Tolkat (JIT) | ✓ |
+| D | 12 | Kompilerat (native) | ✓ |
+| Zig | 12 | Kompilerat (native) | ✓ |
+| Bash | 14 | Tolkat (skript) | ✓ |
+| Haskell | 19 | Kompilerat (native) | ✓ |
+| Dart | 20 | Kompilerat/JIT | ✓ |
+| Brainfuck | 32 | Esoteriskt | ✓ |
+| Perl | 34 | Tolkat | ✓ |
+| Python | 34 | Tolkat | ✓ |
+| Java | 36 | JIT-kompilerat | ✓ |
+| C# | 38 | JIT-kompilerat | ✓ |
+| Kotlin | 47 | JIT-kompilerat | ✓ |
+| PHP | 56 | Tolkat | ✓ |
+| Ruby | 62 | Tolkat | ✓ |
+| JavaScript | 77 | JIT-kompilerat | ✓ |
+| Erlang | 119 | Tolkat (BEAM) | ✓ |
+| Julia | 151 | JIT-kompilerat | ✓ |
+| R | 156 | Tolkat | ✓ |
+| Elixir | 281 | Tolkat (BEAM) | ✓ |
+| Scala | 389 | JIT-kompilerat | ✓ |
+| TypeScript | 884 | JIT-kompilerat | ✓ |
+| Vimscript | 31 | Tolkat | ✗ (precision) |
+| Wolfram | - | Tolkat | ✗ (ej konfigurerad) |
 
-Detta garanterar att vi jämför **språkens prestanda**, inte olika algoritmer!
+### 1000 decimaler
 
----
+| Språk | Tid (ms) | Kategori | Status |
+|-------|----------|----------|--------|
+| Assembly | 4 | Kompilerat (native) | ✓ |
+| C | 4 | Kompilerat (native) | ✓ |
+| Go | 5 | Kompilerat (native) | ✓ |
+| Rust | 5 | Kompilerat (native) | ✓ |
+| Objective-C | 6 | Kompilerat (native) | ✓ |
+| C++ | 7 | Kompilerat (native) | ✓ |
+| Crystal | 7 | Kompilerat (native) | ✓ |
+| D | 10 | Kompilerat (native) | ✓ |
+| Odin | 10 | Kompilerat (native) | ✓ |
+| Nim | 11 | Kompilerat (native) | ✓ |
+| Zig | 12 | Kompilerat (native) | ✓ |
+| Fortran | 17 | Kompilerat (native) | ✓ |
+| Dart | 19 | Kompilerat/JIT | ✓ |
+| Haskell | 19 | Kompilerat (native) | ✓ |
+| Bash | 26 | Tolkat (skript) | ✓ |
+| Lua | 29 | Tolkat (JIT) | ✓ |
+| Brainfuck | 34 | Esoteriskt | ✓ |
+| Python | 38 | Tolkat | ✓ |
+| C# | 39 | JIT-kompilerat | ✓ |
+| Java | 41 | JIT-kompilerat | ✓ |
+| Kotlin | 49 | JIT-kompilerat | ✓ |
+| PHP | 58 | Tolkat | ✓ |
+| Ruby | 65 | Tolkat | ✓ |
+| Swift | 78 | Kompilerat (native) | ✓ |
+| Perl | 84 | Tolkat | ✓ |
+| Erlang | 121 | Tolkat (BEAM) | ✓ |
+| Julia | 151 | JIT-kompilerat | ✓ |
+| R | 167 | Tolkat | ✓ |
+| JavaScript | 195 | JIT-kompilerat | ✓ |
+| Elixir | 280 | Tolkat (BEAM) | ✓ |
+| Scala | 342 | JIT-kompilerat | ✓ |
+| TypeScript | 960 | JIT-kompilerat | ✓ |
 
-**Skapad med ❤️ för programmeringsentusiaster överallt!**
\ No newline at end of file
+### 10000 decimaler
+
+| Språk | Tid (ms) | Kategori | Status |
+|-------|----------|----------|--------|
+| C | 24 | Kompilerat (native) | ✓ |
+| Objective-C | 25 | Kompilerat (native) | ✓ |
+| Assembly | 27 | Kompilerat (native) | ✓ |
+| Haskell | 50 | Kompilerat (native) | ✓ |
+| Rust | 53 | Kompilerat (native) | ✓ |
+| Crystal | 59 | Kompilerat (native) | ✓ |
+| Go | 78 | Kompilerat (native) | ✓ |
+| D | 79 | Kompilerat (native) | ✓ |
+| Brainfuck | 109 | Esoteriskt | ✓ |
+| C# | 116 | JIT-kompilerat | ✓ |
+| Ruby | 128 | Tolkat | ✓ |
+| Dart | 133 | Kompilerat/JIT | ✓ |
+| Java | 134 | JIT-kompilerat | ✓ |
+| Kotlin | 141 | JIT-kompilerat | ✓ |
+| Julia | 161 | JIT-kompilerat | ✓ |
+| Zig | 181 | Kompilerat (native) | ✓ |
+| C++ | 185 | Kompilerat (native) | ✓ |
+| Erlang | 254 | Tolkat (BEAM) | ✓ |
+| PHP | 264 | Tolkat | ✓ |
+| Python | 300 | Tolkat | ✓ |
+| Elixir | 353 | Tolkat (BEAM) | ✓ |
+| Scala | 435 | JIT-kompilerat | ✓ |
+| R | 451 | Tolkat | ✓ |
+| Odin | 459 | Kompilerat (native) | ✓ |
+| Nim | 463 | Kompilerat (native) | ✓ |
+| Fortran | 1088 | Kompilerat (native) | ✓ |
+| Lua | 1543 | Tolkat (JIT) | ✓ |
+| Perl | 2285 | Tolkat | ✓ |
+| Bash | 4456 | Tolkat (skript) | ✓ |
+| Swift | 6735 | Kompilerat (native) | ✓ |
+| JavaScript | 10065 | JIT-kompilerat | ✓ |
+| TypeScript | 10334 | JIT-kompilerat | ✓ |
+
+## Prestandaanalys
+
+### Kompilerade språk (Native Code)
+
+**Definition:** Språk som kompileras direkt till maskinkod som exekveras av processorn utan mellanliggande lager.
+
+**Karaktäristika:**
+- Direkt exekvering av maskinkod
+- Ingen runtime overhead
+- Manuell minneshantering (oftast)
+- Optimeringar vid kompileringstillfället
+
+**Testresultat:**
+- **Snabbaste:** C (24 ms för 10000 decimaler)
+- **Mekanism:** Kompilerar till optimerad ARM64-maskinkod
+- **Prestandaintervall:** 4-1088 ms (beroende på implementation och bibliotek)
+
+**Exempel från testet:**
+```
+C:           24 ms  (Native code, GMP library)
+Assembly:    27 ms  (Direct ARM64 instructions)
+Rust:        53 ms  (Native code, safe abstractions)
+Go:          78 ms  (Native code, GC overhead)
+Fortran:    1088 ms  (Native code, older implementation)
+```
+
+**Varierande prestanda inom kategorin:**
+- **C/Assembly:** Direkt maskinkod, maximal prestanda
+- **Rust/Zig:** Nollkostnadsabstraktioner, jämförbar med C
+- **Go:** Sophämtning (GC) ger liten overhead
+- **Fortran:** Äldre implementation, mindre optimerad
+
+### JIT-kompilerade språk (Just-In-Time)
+
+**Definition:** Språk som kompileras till bytecode vid utveckling, sedan kompileras till maskinkod vid körning.
+
+**Karaktäristika:**
+- Kompilering sker vid körning (runtime)
+- Optimeringar baserade på faktisk användning
+- Automatisk sophämtning (GC)
+- Portabilitet mellan plattformar
+
+**Testresultat:**
+- **Snabbaste:** Java (134 ms för 10000 decimaler)
+- **Mekanism:** JVM kompilerar bytecode till maskinkod vid körning
+- **Prestandaintervall:** 116-10334 ms
+
+**Exempel från testet:**
+```
+Java:        134 ms  (JVM JIT optimization)
+C#:          116 ms  (.NET Core JIT)
+Julia:       161 ms  (LLVM JIT, scientific computing)
+JavaScript: 10065 ms (V8 JIT, dynamic typing overhead)
+TypeScript: 10334 ms (Compiles to JavaScript)
+```
+
+**Varierande prestanda inom kategorin:**
+- **Java/C#:** Mogna JIT-kompilatorer, bra optimering
+- **Julia:** Designat för numerisk prestanda
+- **JavaScript/TypeScript:** Dynamisk typning, hög overhead
+
+### Tolkade språk
+
+**Definition:** Språk där källkoden läses och exekveras rad för rad av en tolk (interpreter).
+
+**Karaktäristika:**
+- Ingen kompilering i förväg
+- Direkt exekvering av källkod
+- Flexibel typning (oftast)
+- Enklare felsökning
+
+**Testresultat:**
+- **Snabbaste:** Lua (1543 ms för 10000 decimaler)
+- **Mekanism:** Tolk läser och exekverar kod rad för rad
+- **Prestandaintervall:** 38-4456 ms
+
+**Exempel från testet:**
+```
+Python:      300 ms  (CPython interpreter)
+Ruby:        128 ms  (YARV interpreter)
+Perl:       2285 ms  (Perl interpreter)
+Bash:       4456 ms  (Shell interpreter, process spawning)
+```
+
+**Varierande prestanda inom kategorin:**
+- **Python:** Optimerad tolk, C-extensioner för stora tal
+- **Ruby:** YARV (Yet Another Ruby Virtual machine)
+- **Perl:** Äldre tolk, mindre optimerad
+- **Bash:** Startar nya processer för varje operation
+
+### Funktionella språk (BEAM VM)
+
+**Definition:** Språk som körs på Erlang Virtual Machine (BEAM), designade för samtidighet och feltolerans.
+
+**Karaktäristika:**
+- Kör på virtuell maskin (BEAM)
+- Optimerade för många samtidiga processer
+- Inbyggd sophämtning
+- Feltolerant design
+
+**Testresultat:**
+- **Erlang:** 254 ms (10000 decimaler)
+- **Elixir:** 353 ms (10000 decimaler)
+
+**Prestandaanalys:**
+- BEAM VM är optimerad för samtidighet, inte ren beräkning
+- Overhead från process-schemaläggning
+- Elixir har ytterligare overhead från Elixir-to-Erlang-kompilering
+
+## Språkspecifik analys
+
+### C
+**Testresultat:**
+- 100 decimaler: 6 ms
+- 1000 decimaler: 4 ms
+- 10000 decimaler: 24 ms
+
+**Teknisk analys:**
+- Kompilerar direkt till ARM64-maskinkod
+- Använder GMP-biblioteket för arbitrary precision arithmetic
+- Ingen runtime overhead
+- Manuell minneshantering möjliggör optimering
+
+**Prestandafaktorer:**
+- Native code execution
+- Optimerad GMP-implementation
+- Kompilatoroptimeringar (clang/gcc)
+
+### Assembly
+**Testresultat:**
+- 100 decimaler: 7 ms
+- 1000 decimaler: 4 ms
+- 10000 decimaler: 27 ms
+
+**Teknisk analys:**
+- Direkt ARM64-instruktioner
+- Ingen abstraktion eller overhead
+- Manuell registerallokering
+- Optimerad för specifik processorarkitektur
+
+**Prestandafaktorer:**
+- Maximal kontroll över exekvering
+- Ingen kompilator-overhead
+- Processor-specifika optimeringar
+
+### Rust
+**Testresultat:**
+- 100 decimaler: 7 ms
+- 1000 decimaler: 5 ms
+- 10000 decimaler: 53 ms
+
+**Teknisk analys:**
+- Kompilerar till native code via LLVM
+- Nollkostnadsabstraktioner (zero-cost abstractions)
+- Minnessäkerhet utan GC-overhead
+- Moderna kompilatoroptimeringar
+
+**Prestandafaktorer:**
+- LLVM-backend ger optimerad maskinkod
+- Ingen sophämtning (ownership system)
+- Inline-optimeringar
+
+### Python
+**Testresultat:**
+- 100 decimaler: 34 ms
+- 1000 decimaler: 38 ms
+- 10000 decimaler: 300 ms
+
+**Teknisk analys:**
+- CPython-tolk exekverar bytecode
+- Inbyggt stöd för arbitrary precision integers
+- Dynamisk typning med runtime checks
+- C-extensioner för prestandakritiska delar
+
+**Prestandafaktorer:**
+- Tolkad exekvering (10-100x långsammare än native)
+- Optimerad arbitrary precision implementation
+- Overhead från dynamisk typning
+
+### JavaScript (Node.js)
+**Testresultat:**
+- 100 decimaler: 77 ms
+- 1000 decimaler: 195 ms
+- 10000 decimaler: 10065 ms
+
+**Teknisk analys:**
+- V8-motorn JIT-kompilerar JavaScript
+- Dynamisk typning med hidden classes
+- Ingen inbyggd arbitrary precision (använder BigInt)
+- Sophämtning med mark-and-sweep
+
+**Prestandafaktorer:**
+- JIT-kompilering ger bra prestanda för små tal
+- BigInt-implementation har overhead
+- Dynamisk typning ger overhead vid stora beräkningar
+
+### Bash
+**Testresultat:**
+- 100 decimaler: 14 ms
+- 1000 decimaler: 26 ms
+- 10000 decimaler: 4456 ms
+
+**Teknisk analys:**
+- Tolkad skalskript
+- Startar nya processer för varje operation
+- Ingen inbyggd arbitrary precision
+- Använder externa verktyg (bc, awk)
+
+**Prestandafaktorer:**
+- Process-spawning overhead
+- Ingen optimering för beräkning
+- Designat för systemadministration, inte numerisk beräkning
+
+### Brainfuck
+**Testresultat:**
+- 100 decimaler: 32 ms
+- 1000 decimaler: 34 ms
+- 10000 decimaler: 109 ms
+
+**Teknisk analys:**
+- Esoteriskt språk med endast 8 instruktioner
+- Tolkad exekvering
+- Ingen optimering
+- Minimal instruction set
+
+**Prestandafaktorer:**
+- Enkel tolk med minimal overhead
+- Effektiv för små beräkningar
+- Skalar dåligt med komplexitet
+
+## Slutsatser
+
+### Prestandahierarki
+
+**1. Kompilerade språk (Native):** 4-1088 ms
+- Snabbast för numerisk beräkning
+- Direkt maskinkodsexekvering
+- Lägst overhead
+
+**2. JIT-kompilerade språk:** 116-10334 ms
+- Bra prestanda efter uppvärmning
+- Plattformsoberoende
+- Automatisk optimering
+
+**3. Tolkade språk:** 38-4456 ms
+- Långsammare exekvering
+- Enklare utveckling
+- Flexibel typning
+
+### Prestandafaktorer
+
+1. **Kompileringstyp:** Native > JIT > Tolkad
+2. **Typsystem:** Statisk > Dynamisk
+3. **Minnesantering:** Manuell > GC > Automatisk
+4. **Bibliotek:** Optimerade > Standard > Ej optimerade
+
+### Rekommendationer
+
+**För maximal prestanda:**
+- C, Assembly, Rust, Zig
+
+**För balans mellan prestanda och utvecklingstid:**
+- Go, Swift, Kotlin, Java
+
+**För snabb utveckling:**
+- Python, Ruby, JavaScript
+
+**För vetenskaplig beräkning:**
+- Julia, Python (med NumPy), R
+
+## Metodologi
+
+### Testprotokoll
+
+1. **Bygge:** Varje språk kompileras/förbereds enligt `build.sh`
+2. **Warmup:** Första körningen exkluderas (JIT-uppvärmning, caching)
+3. **Mätning:** 3 körningar, genomsnitt beräknas
+4. **Verifiering:** Resultatet jämförs med känt π-värde
+
+### Reproducerbarhet
+
+Alla tester kan reproduceras med:
+```bash
+./build.sh                    # Bygg alla språk
+./test.sh [språk]             # Testa korrekthet
+./run_all.sh [decimaler]     # Kör prestandatest
+```
+
+### Begränsningar
+
+- **Hårdvaruberoende:** Resultaten gäller för Apple A18 Pro
+- **Implementationsspecifika:** Prestanda beror på bibliotek och implementation
+- **JIT-uppvärmning:** Första körningen kan vara långsammare
+- **Minnesanvändning:** Ej mätt i denna studie
+
+## Källkod
+
+All källkod finns i respektive språkmapp:
+- `src/` - Källkod
+- `cmd/` - Byggscript
+- `bin/` - Körbar fil (efter bygge)
+
+## Licens
+
+MIT License - Se LICENSE-fil för detaljer.
+
+## Författare
+
+Automatiskt genererad benchmark-studie.
+Testdatum: 2026-04-23
+Testmiljö: MacBook Neo, Apple A18 Pro, 8 GB RAM
\ No newline at end of file