The VCSSL Support AI is Here! — Requires a ChatGPT Plus Account for Practical Performance

We're excited to announce that RINEARN has launched the VCSSL Assistant, an AI that can help you with the VCSSL programming language!

Here's what it can do:

• Answer questions about VCSSL's syntax and features
• Provide guidance on functions in the standard library
• Help you write relatively simple pieces of code

You can access the AI while logged in to ChatGPT via the following page:

However — as we'll explain in more detail later — achieving practical, reliable results currently means it's virtually essential to sign in with a paid ChatGPT account (ChatGPT Plus) and use the "GPT-5 Thinking" model, which performs careful, deep reasoning.

ChatGPT's core capabilities are improving day by day, so it's possible that the free plan will run this assistant smoothly in the future. For now, though, using a free ChatGPT account leads to frequent mistakes, making real-world use difficult. Sorry!

Even with a Plus account and GPT-5 Thinking, it can still:

That's hard to avoid at the moment (especially for more difficult topics). Thanks in advance for your understanding.

We're also planning a separate "Behind the Scenes" post about this AI. For today, we'll focus on the "Overview & How to Use" part.

Alright — let's dive in!

Background

First, let's briefly look back at the background of support AIs at RINEARN.

About the Support AIs — already released for several tools

About a year ago, RINEARN began offering AIs that help users learn and use our software. For example, our most popular freeware, RINEARN Graph 3D, already has an assistant AI that's been working quite well.

If you're wondering "What exactly is a support AI?", we explained the concept in our announcement at the time. Feel free to read it alongside this post:

• Launching an Assistant AI to Support Software Usage!

Since then we've gradually rolled out assistants for other software as well. You can see the current list here:

• Assistant AIs - RINEARN

The lineup is steadily taking shape.

How does it work? — Mechanics and challenges

The support AIs above run on ChatGPT's "GPTs" platform and work roughly as follows:

The overall answer quality is largely determined by how well steps 2 and 3 are executed.

Comparing within the same model, we commonly see two issues:

• Issue A: As the total volume of documentation grows, quality in step 2 tends to drop.
• Issue B: As the difficulty of the request increases, quality in step 3 tends to drop (writing code is especially challenging).

If these two hurdles are too high relative to the AI's capabilities — its depth of reasoning and the amount of text it can consider at once — errors increase and the assistant can become impractical to use.

VCSSL's documentation is massive, and the required accuracy is on another level — it's been hard for AI to meet practical quality.

And yes — because VCSSL is a programming language, building a support AI runs into both challenges A and B as steep hurdles.

First, the documentation is huge (official guides, library references, sample code collections, and more). And to produce code that actually runs, the assistant has to really understand those materials and put the pieces together correctly — like solving a puzzle with strict logic.

As a result, the VCSSL support AI hadn't reached practical quality — it was effectively "on hold," waiting for model advances.

With the new "GPT-5 Thinking" model, the VCSSL support AI may finally — just barely — become practical

A powerful new model landed this month

After roughly a year on ice due to these issues, a model that finally seems up to the task launched on ChatGPT this month (August 2025): GPT-5 Thinking.

It combines deep, careful reasoning with solid accuracy and natural phrasing, and it can handle larger amounts of text at once. In short, it's a strong fit for document-heavy, code-oriented work.

It looks just about capable of handling VCSSL support

We immediately swapped in this new model as the "engine" of the previously shelved VCSSL support assistant and tested it. At last, it seems to squeak past the bar for practical use.

Questions and answers finally line up, and it already feels useful enough to be better than not having it

So we went ahead and published it as-is. We'll keep tuning and improving it from here.

One catch: "GPT-5 Thinking" is currently available only with ChatGPT Plus — on the free plan you'll get "plain GPT-5"

There's a caveat: GPT-5 Thinking isn't available on the free ChatGPT plan right now. You'll need a ChatGPT Plus subscription (about US$20/month) to use it.

Can you still use the VCSSL assistant on the free plan Technically, yes — but in that case the assistant will run on plain GPT-5 (without Thinking). While plain GPT-5 is quite capable for general use, it isn't up to the demands of VCSSL support: you'll see answers not supported by the documentation ("hallucinations") and more confused, non-working code more often.

So for the moment:

That said, the free-plan models on ChatGPT are upgraded fairly often, so this situation may change. If/when the free plan becomes genuinely useful for VCSSL support, we'll announce it here!

How to Use

That's the overview of the new VCSSL support AI.

From here, let's actually try it — ask it some questions and see how it does!

Log in with a ChatGPT Plus account and open the page

First, sign in to ChatGPT. For the reasons explained above, using a ChatGPT Plus account is highly recommended You can *use* the free plan (with quality trade-offs).

Once signed in, open the page below to chat with the VCSSL Assistant:

[Important] Choose the model (GPT-5 Thinking recommended — effectively required)

At the top of the chat view, you can choose the underlying AI model the VCSSL Assistant uses.

As of August 2025, the main options (all GPT-5 series) are:

There's also Auto, which switches between Thinking and Fast depending on the difficulty of the question.

In general, select the "Thinking" model here. As noted earlier, the VCSSL Assistant has to do fairly demanding work; without Thinking, things tend to fall apart and the experience degrades quickly.

Ask a Question

Once you've chosen a model, type a question into the input box at the bottom.

Let's start with the basics: "What is VCSSL, anyway?"

That's a solid, on-point answer.

In this way, it will respond to a wide range of questions you ask.

Expect it to take a while

One thing to keep in mind: whatever you ask, you should expect to wait anywhere from a few dozen seconds to a few minutes.

VCSSL is a very niche programming language, so the base model doesn't really have much prior knowledge about it.

So:

• After receiving your question, the AI is handed a large set of VCSSL documents and must read them to the level needed for a correct answer.

In short, it "learns VCSSL from scratch each time." That's a lot of work.

On top of that:

• It then has to fit the pieces together — like a puzzle — into a logically correct answer.

That's nontrivial, and it requires slow, careful reasoning (hence the need for the Thinking model).

Because it has to do all of that for each question, it takes time. If it feels slow, please picture the AI slogging through the steps above — and give it a moment.

Try a variety of questions

From here, let's ask about a few different topics to get a feel for how it responds.

A common, everyday question

Let's start simple — ask something basic about language features:

That's a straightforward, on-target answer.

This information is already covered early in the guides, so it's an easy one to answer — humans can also guess "it's probably in that section of the guide," and they'd be right:

A question about something that's briefly mentioned somewhere in the official programming guides

Next, let's try asking about information that's a bit harder to track down.

The VCSSL Assistant can read every page of VCSSL's official programming guides. So when you're in that "I'm sure I saw this in one of the guides somewhere... but where?" situation, it's pretty good at finding the right spot and answering.

For example:

// Converting to an absolute path via File.getFilePath is recommended
import File;

string exe = getFilePath("test.exe");
int status = system(exe, "arg1", "arg2");  // waits; returns exit status (synchronous)
int pid    = exec(exe, "arg1", "arg2");    // returns process ID (asynchronous)
	

import File;
import Process;

// 1: Prepare the absolute path and (optionally) arguments as an array
string exe = getFilePath("test.exe");
string cmd[] = { exe /*, "arg1", "arg2" */ };

// 2: Create the process (not running yet)
int pid = newProcess(cmd);
// (Optional) Set working directory to the folder containing the exe (must be done before start!)
string exeDir = getFilePath(exe, PARENT);  // (getFilePath with PARENT)
setProcessWorkingDirectory(pid, exeDir);   // (required before start)

// (Optional) Match encodings (e.g., "CP932" for Japanese Windows; many environments use "UTF-8")
// setProcessOutputEncoding(pid, "CP932");
// setProcessErrorEncoding(pid, "CP932");

// 3: Start execution
startProcess(pid);

// (Optional) For interactive tools, send stdin (a trailing newline is often required �¨ use EOL)
setProcessInput(pid, "hello" + EOL);       // (EOL is the newline constant)

// 4) Wait for completion
waitForProcess(pid);

// 5) Collect outputs and the exit code
string out = getProcessOutput(pid);
string err = getProcessError(pid);
int code   = getProcessExitValue(pid);

// Display
println("exit=" + code);
println("stdout:\n" + out);
println("stderr:\n" + err);
   	

Nice — the answer came back with a fairly long code sample and solid detail.

By the way, this code does run. You'll get a warning in one part where the newline is hard-coded as "\n" (you should use EOL instead), but it executes as-is.

The information behind this answer lives among a large set of pages in the official VCSSL docs — specifically:

• The last page of "A Quick Guide to VCSSL for C-language users"
• The Process library reference page

The AI correctly located both sources, understood them, and answered accordingly. It's clearly drawing from both (I authored both pages myself).

Questions about standard library functions

Next up: the VCSSL Assistant can read every page of the VCSSL standard library references when needed.

So if you're thinking, "What was the exact spec of that function again?", you can just ask — and it will look it up for you.

Let's try:

import graphics3d.Graphics3DFramework;
import Graphics3D;

int local, axisWorld, axisLocal, box;

void onStart(int rendererID) {
    setWindowSize(800, 600);
    setBackgroundColor(0, 0, 0, 255);

    // 1: Create a local coordinate and mount it on the world (child → renderer)
    local = newCoordinate();
    mountCoordinate(local, rendererID);  // place coordinate [child, renderer]

    // 2: Place a model in the world (model → renderer)
    axisWorld = newAxisModel(3.0, 3.0, 3.0);
    mountModel(axisWorld, rendererID);

    // 3: Place a model on the local coordinate (model → renderer → coordinate)
    axisLocal = newAxisModel(1.5, 1.5, 1.5);
    mountModel(axisLocal, rendererID, local);

    // 4: Example: place a box on the local coordinate, then move it a bit
    box = newBoxModel(1.0, 1.0, 1.0);
    mountModel(box, rendererID, local);       // mounted on the local coordinate
    moveModel(box, 0.5, 0.0, 0.0);            // translation (model → dx → dy → dz)
}
	

This answer clearly draws not only on the library reference but also on the 3D graphics section of the official programming guide, and combines them coherently.

That's helpful as-is, but this time let's focus more narrowly on the library reference itself:

import graphics3d.Graphics3DFramework;
import Graphics3D;

void onStart(int rendererID) {
    int coord = newCoordinate();
    mountCoordinate(coord, rendererID);  // place the coordinate in the world
    int axis  = newAxisModel(1.5, 1.5, 1.5);
    mountModel(axis, rendererID, coord);  // place the model on *that* coordinate
}
	

Perfect — that's exactly the kind of answer and summarization we were hoping for.

For reference, here's an excerpt from the actual library spec at the relevant section:

The red-boxed portion in the previous answer clearly came from this page.

Personally, the library references are the VCSSL docs I consult most often, so having the assistant surface details at this level of granularity looks genuinely useful.

Have it write something a bit more complex

So far we've focused on Q&A. From here, let's shift to having it write code that actually works as requested.

A small GUI example

First, let's ask for a super-simple GUI app:

coding UTF-8;

import GUI;

// Create the window
int window = newWindow(100, 100, 340, 160, "Button Sample");

// Label for displaying text (initially empty)
int messageLabel = newTextLabel(20, 20, 300, 24, "");

// Buttons A / B
int buttonA = newButton(20, 70, 120, 40, "A");
int buttonB = newButton(200, 70, 120, 40, "B");

// Mount components on the window
mountComponent(messageLabel, window);
mountComponent(buttonA, window);
mountComponent(buttonB, window);

// Button-click handler
void onButtonClick(int id, string label) {
    if (id == buttonA) {
        setComponentText(messageLabel, "Hello, there!");
    } else if (id == buttonB) {
        setComponentText(messageLabel, "Who pressed B?!");
    }
}

// Exit when the window is closed
void onWindowClose(int id) {
    exit();
}
	

It produced code. The snippet is short, so writing it isn't too hard.

The question is whether a proper window appears and everything behaves correctly. Let's run it:

The window launches with buttons A and B. Pressing A...

...shows "Hello, there!". Then pressing B...

...shows "Who pressed B?!". That's exactly the requested behavior.

Combining GUI with graph control

Alright, let's move on.

VCSSL also serves as the scripting language for automating and controlling RINEARN's graphing software, RINEARN Graph. In fact, We suspect most VCSSL users primarily use it for controlling RINEARN Graph.

So let's combine VCSSL's GUI features with graph control and have it build a small tool that actually does something useful:

// coding: UTF-8

import GUI;
import Math;
import tool.Graph2D;   // 2D graph control

// ---- Graph settings ----
const int N = 400;              // number of points
const double X_MIN = -5.0;
const double X_MAX =  5.0;
const double Y_MIN = -10.0;
const double Y_MAX =  10.0;

// Coefficients (initial values)
double a = 1.0;
double b = 0.0;
double c = 0.0;

// ---- Global handles ----
int graph;                      // 2D graph ID
double xData[ N ];
double yData[ N ];

int window;                     // GUI window
int sliderA, sliderB, sliderC;  // slider IDs
int infoLabel;                  // label for showing parameters

// ---- Compute & plot ----
void plotCubic() {
    // place x at equal intervals, compute y = a x^3 + b x^2 + c x
    double dx = (X_MAX - X_MIN) / (N - 1);
    for (int i=0; i<N; i++) {
        double x = X_MIN + dx * i;
        xData[i] = x;
        yData[i] = a*x*x*x + b*x*x + c*x;
    }
    // send data to the graph
    setGraph2DData(graph, xData, yData);
}

// ---- Update the info label ----
void updateInfo() {
    string text = 
        "f(x) = " 
        + round(a, 3, HALF_UP) + " x^3  +  "
        + round(b, 3, HALF_UP) + " x^2  +  "
        + round(c, 3, HALF_UP) + " x";
    setComponentString(infoLabel, text);
    paintComponent(infoLabel);
    paintComponent(window);
}

// ---- Initialization (top-level code runs once on startup) ----

// Launch and configure the 2D graph
graph = newGraph2D( 0, 0, 800, 500, "Cubic Plot" );
setGraph2DAutoRange( graph, false, false );
setGraph2DRange( graph, X_MIN, X_MAX, Y_MIN, Y_MAX );
setGraph2DOption( graph, "WITH_POINTS", false );
setGraph2DOption( graph, "WITH_LINES",  true );
plotCubic();

// Create the GUI window
window = newWindow( 820, 20, 420, 220, "Coefficients a, b, c" );

// Title and current values
int titleLabel = newTextLabel( 10, 10, 380, 18, "Adjust a, b, c with sliders" );
mountComponent( titleLabel, window );

infoLabel = newTextLabel( 10, 35, 380, 18, "" );
mountComponent( infoLabel, window );
updateInfo();

// Slider for a
int labelA = newTextLabel( 10, 65, 30, 18, "a" );
mountComponent( labelA, window );
sliderA = newHorizontalSlider( 40, 65, 350, 20, a, -5.0, 5.0 );
mountComponent( sliderA, window );

// Slider for b
int labelB = newTextLabel( 10, 100, 30, 18, "b" );
mountComponent( labelB, window );
sliderB = newHorizontalSlider( 40, 100, 350, 20, b, -5.0, 5.0 );
mountComponent( sliderB, window );

// Slider for c
int labelC = newTextLabel( 10, 135, 30, 18, "c" );
mountComponent( labelC, window );
sliderC = newHorizontalSlider( 40, 135, 350, 20, c, -5.0, 5.0 );
mountComponent( sliderC, window );

// Redraw the window at the end
paintComponent( window );

// ---- Event handler ----
void onSliderMove(int id, float value) {
    if (id == sliderA) { a = value; }
    if (id == sliderB) { b = value; }
    if (id == sliderC) { c = value; }
    updateInfo();
    plotCubic();
}
	

Whoa — this time the code is quite long and complex...

Will it really run? Let's try it.

We expected a few errors, but it happened to work on the very first try this time (with code this long, it often includes a few mistakes).

The layout looks reasonable, the behavior matches the requirements, and when you move the slider, the graph updates in lockstep. This could honestly be used as a teaching example as-is.

By the way, you can right-click here to download the code and try it yourself.

Have it write some 3D graphics code (Part 1: a no-mistake run)

Let's keep going (this is fun).
This time we'll ask it to write some 3D rendering code:

coding UTF-8;

import graphics3d.Graphics3DFramework;
import Graphics3D;
import Math;  // using random()

const int N = 100;  // number of spheres

void onStart (int rendererID) {

    // Window / background
    setWindowSize(800, 600);
    setBackgroundColor(0, 0, 0, 255);

    // Axes as a reference
    int axis = newAxisModel(5.0, 5.0, 5.0);
    mountModel(axis, rendererID);

    // Generate random spheres
    for (int i = 0; i < N; i++) {

        // Random radius (same for X/Y/Z), roughly in [0.15, 0.40]
        float r = 0.15 + 0.25 * random();
        int sphere = newSphereModel(r, r, r, 14, 10);

        // Random color components in [0, 255)
        // (implicit float → int conversion on assignment)
        int R = 255 * random();
        int G = 255 * random();
        int B = 255 * random();
        setModelColor(sphere, R, G, B, 255);

        // Mount first
        mountModel(sphere, rendererID);

        // Then move to a random position in roughly [-10, +10] on each axis
        float x = 20.0 * random() - 10.0;
        float y = 20.0 * random() - 10.0;
        float z = 20.0 * random() - 10.0;
        moveModel(sphere, x, y, z);
    }
}
	

Looking at the result, maybe this was a bit too easy.
Let's run it:

It ran on the first try. The behavior matches the requirements — guess it really was on the easy side.

Have it write more 3D graphics code (Part 2: make a mistake and debug together)

Let's make things a bit harder.
To be honest, I'm kind of hoping it slips up here — I want to show how we'd debug together.

coding UTF-8;

import Math;
import Graphics3D;
import graphics3d.Graphics3DFramework;

// Number of spheres
const int N = 100;

// Model IDs and coordinate-system IDs for each sphere
int sphere[N];
int coord [N];

// Base (initial) position per sphere, plus displacement/velocity for the jitter
float baseX[N], baseY[N], baseZ[N];
float dx[N], dy[N], dz[N];
float vx[N], vy[N], vz[N];

// Parameters (tweak to taste)
const float SPACE_RANGE = 10.0;  // initial placement range (±)
const float JIT_ACCEL   = 0.06;  // strength of random acceleration
const float FRICTION    = 0.92;  // damping (0.0 - 1.0; 1.0 = no damping)
const float JIT_LIMIT   = 0.6;   // max jitter amplitude from base position�i±�j
const int   SEG_U = 14; // sphere tessellation
const int   SEG_V = 10;

void onStart(int rendererID) {

    // Make colors pop a bit (brighter ambient light)
    setAmbientLightBrightness(1.0);

    setWindowSize(900, 600);
    setBackgroundColor(0, 0, 0, 255);

    // Axes as a visual reference
    mountModel(newAxisModel(6.0, 6.0, 6.0), rendererID);

    // Create N spheres, each on its own coordinate system
    for (int i=0; i<N; i++) {

        // 1) Create a local coordinate for this sphere and mount it in the world
        coord[i] = newCoordinate();
        mountCoordinate(coord[i], rendererID); // create & mount the coordinate

        // 2) Pick a random base position and set it
        baseX[i] = SPACE_RANGE * (2.0*random() - 1.0);
        baseY[i] = SPACE_RANGE * (2.0*random() - 1.0);
        baseZ[i] = SPACE_RANGE * (2.0*random() - 1.0);
        setCoordinateLocation(coord[i], baseX[i], baseY[i], baseZ[i]); // set origin directly

        // 3) Create the sphere model, give it a random color, and mount it on the coordinate
        float r = 0.15 + 0.25*random(); // slightly random radius
        sphere[i] = newSphereModel(r, r, r, SEG_U, SEG_V);
        int R = int(255 * random());
        int G = int(255 * random());
        int B = int(255 * random());
        setModelColor(sphere[i], R, G, B, 255);
        mountModel(sphere[i], rendererID, coord[i]);  // mount sphere on its coordinate
        
        // Displacement & velocity start at zero (arrays default to 0, explicit is fine)
        dx[i]=dy[i]=dz[i]=0.0;
        vx[i]=vy[i]=vz[i]=0.0;
    }
}

void onUpdate(int rendererID) { // called dozens of times per second
    for (int i=0; i<N; i++) {

        // Random acceleration + damped velocity (gives a "jittery" feel)
        vx[i] = FRICTION * vx[i] + JIT_ACCEL * (2.0*random() - 1.0);
        vy[i] = FRICTION * vy[i] + JIT_ACCEL * (2.0*random() - 1.0);
        vz[i] = FRICTION * vz[i] + JIT_ACCEL * (2.0*random() - 1.0);

        dx[i] += vx[i];
        dy[i] += vy[i];
        dz[i] += vz[i];

        // Clamp the jitter amplitude relative to the base position
        if (dx[i] >  JIT_LIMIT) dx[i] =  JIT_LIMIT;
        if (dx[i] < -JIT_LIMIT) dx[i] = -JIT_LIMIT;
        if (dy[i] >  JIT_LIMIT) dy[i] =  JIT_LIMIT;
        if (dy[i] < -JIT_LIMIT) dy[i] = -JIT_LIMIT;
        if (dz[i] >  JIT_LIMIT) dz[i] =  JIT_LIMIT;
        if (dz[i] < -JIT_LIMIT) dz[i] = -JIT_LIMIT;

        // Set the origin to (base + jitter)
        setCoordinateLocation(coord[i], baseX[i]+dx[i], baseY[i]+dy[i], baseZ[i]+dz[i]);
        // Example of directly controlling the origin inside onUpdate
    }
}
	

Hmm, this is more compact and cleaner than I expected. Maybe that was too easy.
Let's run it:

Oh, nice — an error!
I was kind of hoping for one, to be honest. Perfect timing.

When you see an error like this, just copy and paste the message to the assistant:

import graphics3d.Graphics3DFramework;
import Graphics3D;
import Math; // random()
...
	

That's how it investigates the cause and proposes a fix.

In this run there were two more small errors. Once you cross a certain line of difficulty/complexity, mistakes tend to pop up — likely because there's less headroom in the model�fs working context.

Still, pasting each error back like above eventually got everything fixed (though with very hard issues, it can fail to fix them).

Now for the result:

Nice — exactly as requested, the spheres are jittering in place!

One caveat: each fix can take a few minutes, so if you already know the cause, it's usually faster to patch it yourself. You'll often hit the next error right after, and waiting "a few minutes per round" adds up.

On the other hand, as a quick way to draft a working foundation in a few minutes, this is pretty handy. If you let the AI sketch the scaffolding and then have a human do the final polish and debugging, it can be a productive split of work.

An example that was simply too hard

So far we've looked at promising results from the VCSSL Assistant.

But as anyone who uses AI regularly knows, there's a point where:

Knowing that — and keeping your requests inside that limit line — is essential for practical use.

To wrap up, let's look at a case that was too difficult.
We asked for a fairly challenging fluid simulation:�F

coding UTF-8;

// ==== Libraries ====
import Graphics;
import Graphics2D;
import GUI;
import Math;

// ==== Screen & simulation settings ====
const int WIDTH  = 900;
const int HEIGHT = 600;
const int NPART  = 6000;   // number of particles (reduce if heavy)
const int NMODE  = 5;      // number of sine-wave modes for ψ
const float DT   = 1.0/60.0;   // simulation time step (sec-equivalent)
const int LINE_W = 1;      // stroke width

// ==== Particle state ====
float px[NPART], py[NPART];     // current position
float ppx[NPART], ppy[NPART];   // previous position (for trails)

// ==== Mode coefficients for stream function ψ ====
float kx[NMODE], ky[NMODE];   // wave vectors [rad/pixel]
float omega[NMODE];           // angular speeds [rad/sec]
float amp[NMODE];             // amplitude scale for ψ
float phase[NMODE];           // initial phase
...
	

As you can see, instead of saying "can't," it bravely produced a long, intricate program.

When we tried to run the code, a cascade of small, syntax-level mix-ups popped up — likely a sign that the task�fs difficulty was pushing the model right to the edge of its working�fcapacity.

We fixed them one by one by hand and finally got it to run, but the screen stayed black with nothing drawn (internally it seemed to be doing "something-ish," but no visible output).

So the impression remains: asking it to build a complex simulation end-to-end on its own is still tough right now. If/when that barrier falls, it'll be a big win — but for now, it's a future goal.

The longer and more complex the code, the more the syntax tends to morph — and small mistakes multiply

In trying various harder tasks, I noticed a few recurring error patterns:

• Casting written in another language's style — e.g., int(...) instead of VCSSL's (int)...
• Omitting { ... } after if and similar statements
  (In VCSSL, braces are required and may not be omitted.)
• Slipping into C or other languages' syntax in general

My guess is that for difficult problems the model thinks very deeply, which stretches its working context. As that context gets tight, fine-grained VCSSL rules fall out of focus, or there just isn't enough bandwidth left to check them carefully.

I also often saw cases like:

• Using the function "pi()" (multiple-precision computation) where the constant "PI" (float) should be used.

On short snippets it tends to check the function specs and catch this, but the longer and harder the code, the more frequently it slips.

Overall, as code grows longer and more complex, checks on syntax and function specs get looser, and lots of small mistakes start popping up.

Given that, the current practical ceiling for coding tasks seems to be things like:

Bonus: asked it to draw a dolphin (...kind of?) in 3D

To wrap up the coding tests, let�fs end on something a bit silly.

Modern conversational AIs like ChatGPT are, well, creatures of words, so their visual/spatial imagination is supposedly weak — though it's been improving fast lately.

So if we ask it to imagine a complex 3D shape and build something... surely it'll produce something amusing, right?

Let's try: we'll ask for a 3D dolphin.

coding UTF-8;
import Math;
import Graphics3D;
import graphics3d.Graphics3DFramework;

// ===== Resolution / dimensions =====
const int U_BODY = 80;   // body: longitudinal segments
const int V_BODY = 24;   // body: around the circumference
const int U_FIN  = 18;   // fin: root → tip
const int V_FIN  = 4;    // fin: thickness direction (thin → small)
const int U_TAIL = 16;   // tail: root → tip
const int V_TAIL = 20;   // tail: span (left ↔ right)
...
	

After about four and a half minutes of thinking, it produced a very long program.

When we ran it, the usual sprinkling of small errors appeared — but we fixed them with giddy anticipation. What glorious (or questionable) creature is about to be born...?

And then — it finally ran:

...hmm. ...I mean, it's more impressive than I expected? But it's definitely not a dolphin. Still, it's a lot less chaotic than what I imagined. And yet... I'm honestly not sure what to say about this one.

Finally

As is often the case with AI topics, this turned into a very long post — but that's it for today�fs update.

We went back and forth on whether to release the VCSSL Assistant now or keep it on ice a little longer. It's likely helpful at the intro + a bit level, but it still can't reliably handle long, complex programs...

Then I revisited our post from a year ago about the RINEARN Graph 3D Assistant, and the pace of progress over just one year really struck me. Thanks to model advances, what was the ceiling back then is the floor now, and today's ceiling would've sounded like sci-fi a year ago.

Given that AI models are evolving at a pace where a single year can change everything, we decided that if it just barely clears the bar today, it's better to ship and learn. So we're releasing it — rough edges and all — while keeping an eye on the road ahead.

You may still run into moments that make you sigh. But we're confident it will grow into a dependable partner, and we'd be grateful if you could give it a little patience in the meantime.

We'll keep sharing updates here about the VCSSL Assistant and our broader AI efforts. Stay tuned!