Auto-fix and Look it over

Perlin doesn't only write a piece: it checks the code before it runs, watches it run, and repairs what breaks. Two switches at the top of Perlin's panel control the parts that happen after a piece reaches the stage. Auto-fix repairs a new piece that fails, and Look it over has Perlin watch each new piece run and polish what it sees. Both are on to start with, and the studio remembers how you leave them in this browser.

Checks before a piece runs

Every piece is checked before it reaches the stage: a 3D piece's code is held against the engine's real API, and shaders and 2D pieces are checked for their structure and controls. Problems go straight back to Perlin within the same request, and you see them as steps under its reply: "Checking the code", then "Caught 2 problems before running" and "Fixing what the checks found", with the attempt number. This always happens, and it's part of the request rather than a separate one.

Auto-fix

The studio keeps an eye on each piece as it runs: errors, shaders that fail to compile, a canvas that stays blank, a piece that freezes. With Auto-fix on, when a piece Perlin has newly written fails in its first twelve seconds or so of running, or still shows nothing three seconds in, the studio sends what went wrong back to Perlin and it repairs the piece:

• New steps appear under the same reply: "Runtime error, fixing" or "Canvas was blank, fixing", with the first line of the error.
• The stage reads Perlin · Repairing while it works.
• The fix replaces that version's code rather than adding a version, and the version chip notes it, for example "auto-fixed 1×".

A version is repaired automatically at most twice for an error, and once for a blank canvas. After that, it's over to you.

Auto-fix doesn't step in for:

• Code you changed by hand in the code editor.
• A piece you come back to later, such as one opened from My pieces, or a gallery piece.
• An error that only shows up well into a piece's run, such as one a game hits on its third level.

The piece is checked while it runs in your browser, so fixes, unlike builds, need the studio open on that piece.

Fixing by hand

When a piece fails and isn't being fixed automatically, a panel over the stage names what went wrong, such as Syntax error, Runtime error, Shader error, Infinite loop, GPU error or Not responding, with the line it happened on and the message. Click the message to read all of it. The panel offers:

• Fix with AI: sends the error to Perlin. Your side of the conversation reads "Fix:" and the error, and Perlin's step reads "Diagnosing".
• Show code: opens the code at the line with the error, to fix it yourself (Editing the code).
• Restart: runs the piece again from the start.

If an automatic fix didn't bring a blank canvas to life, a note reads "The canvas still looks empty." with its own Fix with AI button.

What fixes cost

Fixing Perlin's own mistakes is free, up to 20 fixes a day for each account, whether automatic or from Fix with AI. Past that, a fix is charged like any other request, at your current effort level.

Look it over

Perlin writes a piece without seeing it. With Look it over on (Look where the panel is narrow), Perlin watches each new piece it makes and polishes it:

1. The piece runs

   Perlin makes a new piece and it starts playing on the stage.

2. The studio takes three frames

   Once the piece has run for about six seconds without failing, the studio takes three frames of it, a second and a half apart. The step reads "Looking it over", with the number of frames and the frame rate.

3. Perlin holds them against your idea

   Perlin compares what it sees with what you asked for and its own standards for composition, colour, light and motion. The piece stays in full view, with a small readout in the corner: Perlin · Looking it over, "Studying the frames".

4. It polishes, or leaves it

   If something falls short, Perlin fixes it, and the steps read "Polishing", "Checking the code" and "Rendering". If the piece holds up, Perlin says so in a sentence and leaves it as it is.

A polished piece is the next version, and its chip says so, for example "v2 · WebGL 3D · refined from v1". The first draft is one step back: press [ or click its chip to compare. If the look fails, the step reads "Kept it as it was" and the piece is unchanged.

When Perlin looks

Perlin looks over each new piece it makes once. It doesn't look over:

• Changes, fixes or plans.
• A piece you open from My pieces or the gallery.
• A piece that fails or shows nothing, which is a fix's job.

A look is called off when you act first: send another message, pause the piece, change its code or open another piece. It isn't started if your balance doesn't cover your effort level's minimum.

What a look costs

A look is charged like a change, at your current effort level, and its tokens are added to those shown on the reply that made the piece. It never makes sound effects, textures or 3D models. A look that fails isn't charged.

Related

• Changing a piece
• Versions and history
• Editing the code
• Troubleshooting