mis-interpreter/README.md

Mis-interpreter

A multiplayer code-telephone game where meaning drifts through obfuscation and reinterpretation.

---

Overview

Mis-interpreter is an online, multi-user game inspired by the mechanics of Telestrations and the Telephone Game. Instead of drawings, players exchange short programs. Each round, code is obfuscated, interpreted in plain language, and re-implemented. By the end, the final program often diverges significantly from the original.

---

How It Works

1. Prompt Stage

• Each player begins with a simple coding task (e.g., “Write a function that reverses a string”).
• They implement a short snippet in the chosen language.

2. Obfuscation & Pass

• The system automatically obfuscates the code before passing it along.

  • Variable renaming
  • Minification or unusual formatting
  • Redundant no-ops
  • Structural rewrites (e.g., loops → recursion)

3. Interpretation Stage

• The next player receives the obfuscated code.
• They provide a plain-language description of what they believe the code does.

4. Re-Implementation Stage

• Another player receives only the description.
• They re-implement the code from scratch, based on that description.

5. Repeat Cycle

• This sequence of code → obfuscation → description → rewrite continues until every player has contributed.

6. Reveal Stage

• At the end of the round, the entire chain is shown:

  1. The original prompt
  2. The original code
  3. Each obfuscated version
  4. Each interpretation and re-implementation

---

Scoring Modes

Casual Mode

• No points. The focus is on comparing the original with the final result.

Competitive Mode

• Points for accurate descriptions (does the description match the code’s actual behavior?).
• Points for faithful re-implementations (does the new code behave the same as the last version?).
• Optional bonus points for creative or surprising outcomes (voted by players).

---

Technical Features

• Sandboxed execution for safety.
• Languages: initial support for Python and JavaScript.
• Obfuscation engine: automated code transformations at each pass.
• Multiplayer lobbies: recommended 4–10 players.
• Reveal timeline: shows the progression step by step.

---

Example Round

Prompt: “Write code that sums a list of numbers.”

1. Player A →

   def sum_list(nums): return sum(nums)
   

2. Obfuscated →

   def Q(q): R=0
       for i in q: R+=i
       return R
   

3. Player B (description) → “This adds up numbers in a list.”

4. Player C (rewrite) →

   function addAll(arr) {
       let t=0;
       for (const a of arr) { t+=a; }
       return t;
   }
   

5. Obfuscated again →

   function f(a){return a.reduce((x,y)=>x+y,0)}
   

6. Player D (description) → “This concatenates strings together.”

…and the cycle continues.

---

Purpose

Mis-interpreter explores how intent changes as code passes through transformations, interpretations, and rewrites. It combines programming practice with collaborative play and emphasizes how easily meaning can shift.

---

Would you like me to also produce a short “Quick Rules” reference (one section players can skim before starting), alongside this more detailed doc?