LLM Testing

adent42

I'm starting to work on an LLM for GameSalad, here's some test results.

TL;DR: We got the basics, we need to verify it and make it cheaper to run. But what we get is already pretty cool.

===

Propmpt: Make a cookie clicker game. I just need the main actor, the counter actor, and an actor that displays and fades as a result of the amount the click adds to the score.

Result:

⏺ High-Level Cookie Clicker Implementation

 Core Behaviors Needed:

 Cookie Actor (Main Interactive Element):

 - Touch/Click Detection - Rule with mouse/touch conditions to detect clicks

 - Visual Feedback - Scale animation or color change on click

 - Score Management - ChangeAttribute to increment counter

 - Audio Feedback - PlaySound for satisfying click response

 Counter Actor (Score Display):

 - Text Display - DisplayText showing current score

 - Dynamic Updates - Rule to update display when score changes

 - Number Formatting - Expression to format large numbers

 Popup Actor (Click Feedback):

 - Spawn on Click - Created by cookie when clicked

 - Value Display - Shows points gained from click

 - Fade Animation - Interpolate alpha from 1 to 0

 - Upward Movement - MoveTo behavior for floating effect

 - Auto Destroy - Timer to remove after animation

 Key Parameters:

 - Base click value: +1 point per click

 - Popup duration: 1.5 seconds

 - Popup movement: Float up 50 pixels

 - Counter update: Real-time score tracking

 - Audio: Short, satisfying click sound

 ---

 Cookie Clicker - Pseudocode Implementation

 Cookie Actor:

   Attributes:

     position: (400, 300)

     size: (128, 128)

     image: "cookie"

     clickValue: 1 (custom integer)

     originalSize: 128 (custom real)

   Rule "Click Detection" (ANY condition):

     Condition(event: touch_pressed)

     Condition(event: mouse_down, over_actor: true)

     →

       ChangeAttribute(target: game.score, value: game.score + self.clickValue)

       PlaySound(sound: "click", volume: 0.8)

       Spawn(prototype: "clickPopup", x: 0, y: 20,

          direction: random(-30, 30))

       // Scale animation for feedback

       ChangeSize(width: originalSize * 1.1, height: originalSize * 1.1)

       Timer(interval: 0.1, runOnce: true):

         ChangeSize(width: originalSize, height: originalSize)

 Counter Actor:

   Attributes:

     position: (400, 100)

     size: (200, 50)

     image: ""

     scoreText: "0" (custom text)

   Rule "Update Score Display" (always active):

     →

       ChangeAttribute(target: self.scoreText,

              value: "Score: " + precision(game.score, 0))

   DisplayText(text: self.scoreText, font: "Arial", size: 24,

         color: (1,1,1,1), alignment: center)

 ClickPopup Actor:

   Attributes:

     position: (0, 0) // Set by spawner

     size: (60, 30)

     image: ""

     popupText: "+1" (custom text)

     alpha: 1.0 (custom real)

   Rule "Setup Popup Text" (runOnce: true):

     →

       ChangeAttribute(target: self.popupText,

              value: "+" + precision(game.cookieClickValue, 0))

   DisplayText(text: self.popupText, font: "Arial", size: 18,

         color: (1,1,0,1), alignment: center)

   MoveTo(position: (self.position.x, self.position.y + 50),

       speed: 30, runToCompletion: true)

   Interpolate(target: self.color.alpha, finalValue: 0,

         duration: 1.5, easing: ease_out, runToCompletion: true)

   Timer(interval: 1.5, runOnce: true):

     Destroy()

This implementation provides a complete cookie clicker with satisfying visual and audio feedback, real-time

 score updates, and animated popup effects that communicate the value gained from each click.

===

This is in Claude 4 Opus, so it would be expensive for us to share this now. Next is to try these inputs on cheaper versions of Claude an other LLMs as well as figuring out how to bake in the fine-tuning so we don't eat up the context window.

adent42

Okay, I have a test bot up and running. DM me for the link (I don't want to post it and rack up an AI bill from random usage).

pinkio75

So if I understand correctly… are we actually heading toward AI Claude 4.5 sonnet integration in GameSalad? 😮

Basically an LLM that can generate actors, rules, and behaviors just from a natural language prompt like “make a cookie clicker game”?

If you can make that stable and affordable, it would be a huge game-changer for indie developers.

Can’t wait to see a real “AI copilot” inside the editor!

adent42

So the bot is actually based on Gemini (I used Claude to help write the documentation for the bot and test it). It was just easier to deploy what I needed on Gemini, though I may go back and look into a Claude version at some point. And yes, that's the end goal, but for now it's more like helper copilot. My idea would be to have it open in the tool and it generates the actors, behaviors, and attributes into the projects. Then because GameSalad has a good UI, you an continue working the project easier that if you were doing this all through code.

pinkio75

Try Sonnet 4.5 is better than Opus 4!

Imagine this: you type “Make me a game” and in seconds, it’s real. That’s the future of creation.

Armelline

*cries in freelance GameSalad dev* 😂

Tumblecoin Game Studios

This is amazing! Is there anyway to test it with a prompt for a Match Three game? I currently have a project, but had some hard time with the following:

1. Reverse a movement in case there is no valid match. (Right now the item moves and switch to the new box, but do not reverse)

and

2. Detection of matches (and consecutive matches) on a "grid" (For now it works, but Its to slow, player needs to wait for 1-2 seconds (per match) and couldn't figure out an animation movement, only image change to the new box, although, elements mimics the creation of new items on the top).

But this "bot" looks awesome!

CasualEvolution

Hi @adent42

I'm curious about how far you ended up taking it. I've been thinking quite a bit lately about whether AI could become genuinely useful for working on real GameSalad projects.

A few things I'd love to know:

1. Did you make any further progress with the experiment since that thread?
2. How were you imagining the AI actually working with GameSalad? Would the LLM access and modify the project files externally, or do you think it could eventually operate GameSalad itself through the editor UI? With current computer-use agents, that second option seems increasingly realistic.
3. Was the main idea to help create a project from scratch, or did you also test having the AI work on an existing, reasonably complex project? For me that is probably the most interesting case: letting it inspect how a project is already structured, understand actors, attributes and behaviors, and then continue developing or modifying it without rebuilding everything from scratch.
4. Is there currently any documentation, system prompt, skill, knowledge package, or similar resource that could be given to an LLM so it understands GameSalad in a more complete and controlled way? Something beyond simply feeding it pieces of documentation manually.
5. Have you considered an MCP for GameSalad? For example, exposing structured tools that let an AI inspect the project, query actors/attributes/behaviors, create or modify them, and perhaps run or test the game. It feels like that could be a much more reliable interface for an AI than manipulating project files directly or trying to operate the UI visually.

I'm asking because I'm considering experimenting with this seriously on one of my existing GameSalad projects, so I'm particularly interested in what is already possible today and what direction you think makes the most sense.

Thanks!

adent42

It's already out in the wild, @CasualEvolution Check out https://creator.gamesalad.com and you'll see it there!

We've got it running Gemini 3.6 flash at the moment and are about to move it to GLM 5.3 Flash as default with option to switch to Gemini or Claude once we work in a monetary credit system instead of a token based system.

The system has a rather large default prompt with the basics of GameSalad as an engine and a version of PGF called PGFScript for it to reason about. Creator translates between pgfscript and pgf json for the LLM (because LLMs can reason better about code than they can about json).

It can both reason about GameSalad games and create them from scratch (my go-to test prompt is "I want to make super mario bros." We are keeping image gen AI out of it because there are still just enough ethical questions around it that I'd rather just leave that to the users.

We do indeed intend to create an MPC with the same base prompts and built in PGF Json <-> PGFScript transpiler so that you can work directly with the server based gameproj. We'll likely do something similar for the new desktop version too. We'll likely make both a Pro only feature.