alien code interpretation

Author: BakedAlaskaTM

package-lock.json

@@ -10,9 +10,11 @@
     "preview": "vite preview"
   },
   "dependencies": {
+    "@tailwindcss/vite": "^4.2.2",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
     "react-router": "^7.14.1",
+    "tailwindcss": "^4.2.2",
     "tree-sitter-python": "^0.25.0",
     "web-tree-sitter": "^0.26.8"
   },

package.json

@@ -1,10 +1,32 @@
-import React, { useState, useEffect, useRef } from 'react'
+import React, { useState, useEffect, useRef, useMemo } from "react";
+import { generatePlanetLanguage } from "../language/generator/generatePlanetLanguage";
+import { parseAlien } from "../language/parse/parseAlien";
+import { renderPython } from "../language/render/renderPython";
+import { renderAlien } from "../language/render/renderAlien";
+import { parsePythonWithTreeSitter } from "../language/parse/parsePythonWithTreeSitter";
+import type { ProgramNode } from "../language/types";
+import { validateAlienSource } from "../language/validate/validateAlienSource";
 
 export default function LevelComponent() {
   const [code, setCode] = useState("")
   const [output, setOutput] = useState("")
+  const [translatedPython, setTranslatedPython] = useState("");
+  const [exampleAst, setExampleAst] = useState<ProgramNode | null>(null);
+  const [exampleAlien, setExampleAlien] = useState("");
+  const [exampleError, setExampleError] = useState("");
   const [pyodideReady, setPyodideReady] = useState(false)
   const pyodideRef = useRef<any>(null)
+  const sourcePython = `
+nums = [1,2,3]
+sum = 0
+for i in nums:
+  sum += i
+print(sum)
+`.trim();
+  
+
+  // Use a fixed seed for this level for now
+  const lang = useMemo(() => generatePlanetLanguage(2), []);
 
   useEffect(() => {
     const loadPyodide = async () => {
@@ -15,20 +37,74 @@ export default function LevelComponent() {
     loadPyodide()
   }, [])
 
+  useEffect(() => {
+    let cancelled = false;
+
+    const parseExample = async () => {
+      try {
+        setExampleError("");
+
+        const ast = await parsePythonWithTreeSitter(sourcePython);
+        if (cancelled) return;
+
+        setExampleAst(ast);
+        setExampleAlien(renderAlien(ast, lang));
+      } catch (err) {
+        if (cancelled) return;
+        setExampleError(err instanceof Error ? err.message : String(err));
+      }
+    };
+
+    parseExample();
+
+    return () => {
+      cancelled = true;
+    };
+  }, [sourcePython, lang]);
+
   const runCode = async () => {
     if (!pyodideRef.current) return
-    await pyodideRef.current.runPythonAsync(`
-      import sys, io
-      sys.stdout = io.StringIO()
-    `)
+    if (!pyodideRef.current) return;
+
+    const validation = validateAlienSource(code, lang);
+
+    if (!validation.isValid) {
+      setTranslatedPython("");
+      setOutput(
+        validation.issues
+          .map(
+            (issue) =>
+              `Line ${issue.line}, Col ${issue.column}: ${issue.message}`,
+          )
+          .join("\n"),
+      );
+      return;
+    }
     try {
-      await pyodideRef.current.runPythonAsync(code)
-      const result = await pyodideRef.current.runPythonAsync(`sys.stdout.getvalue()`)
-      setOutput(result)
+      // 1. Alien -> AST
+      const ast = parseAlien(code, lang);
+      console.log(ast);
+      // 2. AST -> Python
+      const pythonCode = renderPython(ast);
+      setTranslatedPython(pythonCode);
+      
+
+      // 3. Reset stdout
+      await pyodideRef.current.runPythonAsync(`
+import sys, io
+sys.stdout = io.StringIO()
+      `);
+
+      // 4. Run translated Python
+      await pyodideRef.current.runPythonAsync(pythonCode);
+
+      // 5. Get output
+      const result = await pyodideRef.current.runPythonAsync(`sys.stdout.getvalue()`);
+      setOutput(String(result));
     } catch (err: any) {
-      setOutput(err.message)
+      setOutput(err?.message ?? String(err));
     }
-  }
+  };
 
   const handleKeyDown = (e: React.KeyboardEvent<HTMLTextAreaElement>) => {
     if (e.key === "Tab") {
@@ -63,11 +139,7 @@ export default function LevelComponent() {
               *** PYTHON CODE ***
             </div>
             <div className="bg-[#4a8be0] m-2 rounded-xl p-3">
-              <pre className="text-white text-xs leading-relaxed m-0">{`nums = [1,2,3]
-sum = 0
-for i in nums:
-  sum += i
-print(sum)`}</pre>
+              <pre className="text-white text-xs leading-relaxed m-0">{sourcePython}</pre>
             </div>
           </div>
 
@@ -77,11 +149,7 @@ print(sum)`}</pre>
               *** ALIEN CODE ***
             </div>
             <div className="bg-[#3a9447] m-2 rounded-xl p-3">
-              <pre className="text-white text-xs leading-relaxed m-0">{`nums eats [1,2,3]
-sum eats 0
-i eats nums slowly:
-  sum eats more i
-print eats sum`}</pre>
+              <pre className="text-white text-xs leading-relaxed m-0">{exampleError ? `Error: ${exampleError}` : exampleAlien || "Loading..."}</pre>
             </div>
           </div>
         </div>

src/components/LevelComponent.tsx

@@ -1,28 +1,29 @@
+import { generatePlanetLanguage } from "../language/generator/generatePlanetLanguage";
 import { parsePythonWithTreeSitter } from "../language/parse/parsePythonWithTreeSitter";
 import { renderAlien } from "../language/render/renderAlien";
+import { parseAlien } from "../language/parse/parseAlien";
 import { renderPython } from "../language/render/renderPython";
-import { generatePlanetLanguage } from "../language/generator/generatePlanetLanguage";
 
 async function run() {
-  const source = `
-def max2(a, b):
-    if a > b:
-        return a
+  const pythonSource = `
+def bigger(a, b):
+    if a > b and a != 0:
+        print(a)
+        return len(range(a))
     else:
-        return b
-`.trim();
-
-  const ast = await parsePythonWithTreeSitter(source);
-  const lang = generatePlanetLanguage(1);
-
-  console.log("AST:");
-  console.log(ast);
+        return b + 1
+  `.trim();
 
-  console.log("PYTHON:");
-  console.log(renderPython(ast));
+  const lang = generatePlanetLanguage(3812);
+  const ast = await parsePythonWithTreeSitter(pythonSource);
+  const alien = renderAlien(ast, lang);
+  const roundTripAst = parseAlien(alien, lang);
+  const pythonAgain = renderPython(roundTripAst);
 
-  console.log("ALIEN:");
-  console.log(renderAlien(ast, lang));
+  console.log("OPERATORS:", lang.operators);
+  console.log("BUILTINS:", lang.builtins);
+  console.log("ALIEN:\n", alien);
+  console.log("PYTHON AGAIN:\n", pythonAgain);
 }
 
 run().catch(console.error);

src/dev/debugRoundTrip.ts

@@ -20,10 +20,26 @@ export const flowingFamily: LanguageFamily = {
     alternatePrefixes: ["ve", "el"],
     iteratorSuffixes: ["li", "ri"],
     negationPrefixes: ["ne", "no"],
-  },
 
+    arithmeticPrefixes: ["la", "so"],
+    arithmeticSuffixes: ["ra", "ni"],
+
+    comparisonPrefixes: ["ve", "se"],
+    comparisonSuffixes: ["la", "ri"],
+
+    logicPrefixes: ["el", "na"],
+    logicSuffixes: ["ra", "li"],
+
+    builtinPrefixes: ["so", "ve"],
+    builtinSuffixes: ["na", "ra"],
+
+    assignmentRoots: ["becomes", "flows", "turns", "luma", "vela"],
+    assignmentPrefixes: ["", "a", "e"],
+    assignmentSuffixes: ["", "ra", "na"],
+  },
+  
   syntaxBias: {
-    assignmentStyles: ["equals", "set_prefix"],
+    assignmentStyles: ["word_infix", "word_prefix", "put_in"],
     functionStyles: ["keyword_name_params_block", "make_name_with_params_block"],
     blockStyles: ["indent"],
     conditionalStyles: ["when_expr_then"],

src/dev/debugTreeSitterAst.ts

@@ -20,10 +20,24 @@ export const mechanicalFamily: LanguageFamily = {
     alternatePrefixes: ["ALT"],
     iteratorSuffixes: ["TH"],
     negationPrefixes: ["NEG"],
-  },
+    arithmeticPrefixes: ["OP"],
+    arithmeticSuffixes: ["X"],
+
+    comparisonPrefixes: ["CMP"],
+    comparisonSuffixes: ["Z"],
+
+    logicPrefixes: ["LOG"],
+    logicSuffixes: ["Q"],
 
+    builtinPrefixes: ["SYS"],
+    builtinSuffixes: ["M"],
+
+    assignmentRoots: ["LOAD", "SET", "STORE", "CFG"],
+    assignmentPrefixes: [""],
+    assignmentSuffixes: [""],
+  },
   syntaxBias: {
-    assignmentStyles: ["arrow"],
+    assignmentStyles: ["arrow", "word_prefix", "word_infix"],
     functionStyles: ["keyword_name_square_params_block"],
     blockStyles: ["indent", "brace"],
     conditionalStyles: ["keyword_paren_expr_block"],

src/language/families/flowing.ts

@@ -20,10 +20,24 @@ export const ritualFamily: LanguageFamily = {
     alternatePrefixes: ["otha", "alt"],
     iteratorSuffixes: ["en"],
     negationPrefixes: ["un", "non"],
-  },
+    arithmeticPrefixes: ["tha", "vel"],
+    arithmeticSuffixes: ["um", "ar"],
+
+    comparisonPrefixes: ["ora", "eth"],
+    comparisonSuffixes: ["um", "en"],
+
+    logicPrefixes: ["vel", "th"],
+    logicSuffixes: ["ar", "um"],
+
+    builtinPrefixes: ["ora", "vel"],
+    builtinSuffixes: ["en", "um"],
 
+    assignmentRoots: ["invoke", "bind", "inscribe", "summon", "kora"],
+    assignmentPrefixes: ["", "vel", "tha"],
+    assignmentSuffixes: ["", "um", "en"],
+    },
   syntaxBias: {
-    assignmentStyles: ["put_in"],
+    assignmentStyles: ["put_in", "word_prefix", "word_infix"],
     functionStyles: ["make_name_with_params_block"],
     blockStyles: ["then_end"],
     conditionalStyles: ["when_expr_then"],

src/language/families/mechanical.ts

@@ -20,19 +20,32 @@ export const sharpFamily: LanguageFamily = {
     literalSuffixes: ["ul", "um"],
     alternatePrefixes: ["va", "zu"],
     iteratorSuffixes: ["in", "ir"],
-    negationPrefixes: ["ch", "n"],
+    negationPrefixes: ["sh", "n"],
+
+    arithmeticPrefixes: ["ka", "ta"],
+    arithmeticSuffixes: ["ix", "ak"],
+
+    comparisonPrefixes: ["ve", "zo"],
+    comparisonSuffixes: ["et", "or"],
+
+    logicPrefixes: ["shi", "ra"],
+    logicSuffixes: ["en", "ik"],
+
+    builtinPrefixes: ["ul", "tor"],
+    builtinSuffixes: ["a", "um"],
+
+    assignmentRoots: ["bind", "lock", "vak", "tash"],
+    assignmentPrefixes: ["", "z", "k"],
+    assignmentSuffixes: ["", "ar", "ik"],
   },
 
   syntaxBias: {
-    assignmentStyles: ["equals", "arrow"],
-    functionStyles: [
-      "keyword_name_params_block",
-      "keyword_name_square_params_block",
-    ],
-    blockStyles: ["indent", "arrow_indent"],
-    conditionalStyles: ["keyword_expr_block", "keyword_paren_expr_block"],
-    elseStyles: ["keyword_block", "keyword_spaced_block"],
-    forStyles: ["for_var_in_iter", "for_paren_var_in_iter"],
+    assignmentStyles: ["word_infix", "word_suffix"],
+    functionStyles: ["keyword_name_params_block"],
+    blockStyles: ["indent"],
+    conditionalStyles: ["keyword_expr_block"],
+    elseStyles: ["keyword_block"],
+    forStyles: ["for_var_in_iter"],
   },
 
   visualStyle: {

src/language/families/ritual.ts

@@ -0,0 +1,32 @@
+import type {
+  BuiltinMap,
+  LanguageFamily,
+  SemanticRoots,
+  ResolvedMorphology
+} from "../types";
+import { finishToken, joinParts } from "./tokenUtils"
+
+export function generateBuiltins(
+  family: LanguageFamily,
+  roots: SemanticRoots,
+  morphology: ResolvedMorphology,
+): BuiltinMap {
+  const raw: BuiltinMap = {
+    print: joinParts(morphology.builtinPrefix, roots.send, "out", morphology.builtinSuffix),
+    len: joinParts(morphology.builtinPrefix, roots.membership, "len", morphology.builtinSuffix),
+    range: joinParts(morphology.builtinPrefix, roots.loop, "range", morphology.builtinSuffix),
+  };
+
+  const builtins: BuiltinMap = {
+    print: finishToken(raw.print, family),
+    len: finishToken(raw.len, family),
+    range: finishToken(raw.range, family),
+  };
+
+  const values = Object.values(builtins);
+  if (new Set(values).size !== values.length) {
+    throw new Error("Duplicate generated builtin tokens");
+  }
+
+  return builtins;
+}