Generative AI

Functions

Conversation Add Message  {</>}

Adds a message to a Conversation, that the language model will begin replying to. You can receive the reply one piece at a time by calling conversation_get_reply_piece(conversation c) in a loop

Parameters:

Name	Type	Description
c	Conversation	The Conversation object to check
message	String	The user message to add to the conversation - the language model will reply to this

Signatures:

C++

void conversation_add_message(conversation c, const string &message)

C#

public void Conversation.AddMessage(string message);
public static void SplashKit.ConversationAddMessage(Conversation c, string message);

Python

def conversation_add_message(c, message):

Pascal

procedure ConversationAddMessage(c: Conversation; const message: String)

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Conversation Get Reply Piece: Streaming AI Response
• Conversation Is Replying: Watching an AI Reply in Progress
• Conversation Is Thinking: Separating AI Thoughts from the Final Reply
• Create Conversation: Streaming a Reply from a New Conversation

See Code Examples

Example 1: Splashwood Village Guide - Context-Aware AI NPC Dialogue

C++

#include "splashkit.h"

string get_full_reply(conversation conv)
{
    string reply = "";

    while (conversation_is_replying(conv))
    {
        reply += conversation_get_reply_piece(conv);
    }

    return reply;
}

int main()
{
    write_line("=== Splashwood Village Guide ===");
    write_line("");

    // Create one conversation so the NPC keeps the conversation context
    conversation guide = create_conversation();

    // Give the NPC its role and background
    string role_prompt =
        "You are Rowan, a friendly village guide in Splashwood Village. "
        "Stay in character and keep your answers short and helpful. "
        "Splashwood Village has a market in the village square, "
        "an old forest to the north, and an inn beside the fountain.";

    conversation_add_message(guide, role_prompt);

    // Consume the setup response before continuing
    get_full_reply(guide);

    string first_question = "Where can I buy supplies?";
    write_line("Player: " + first_question);

    conversation_add_message(guide, first_question);
    string first_reply = get_full_reply(guide);

    write_line("Rowan: " + first_reply);
    write_line("");

    // This question relies on the previous answer
    string second_question = "Where is that from here?";
    write_line("Player: " + second_question);

    conversation_add_message(guide, second_question);
    string second_reply = get_full_reply(guide);

    write_line("Rowan: " + second_reply);
    write_line("");

    string third_question = "Is there anywhere dangerous I should avoid?";
    write_line("Player: " + third_question);

    conversation_add_message(guide, third_question);
    string third_reply = get_full_reply(guide);

    write_line("Rowan: " + third_reply);

    free_conversation(guide);

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

string GetFullReply(Conversation conv)
{
    string reply = "";

    while (conv.IsReplying())
    {
        reply += conv.GetReplyPiece();
    }

    return reply;
}

WriteLine("=== Splashwood Village Guide ===");
WriteLine("");

// Create one conversation so the NPC keeps the conversation context
Conversation guide = CreateConversation();

string rolePrompt =
    "You are Rowan, a friendly village guide in Splashwood Village. " +
    "Stay in character and keep your answers short and helpful. " +
    "Splashwood Village has a market in the village square, " +
    "an old forest to the north, and an inn beside the fountain.";

guide.AddMessage(rolePrompt);

// Consume the setup response before continuing
GetFullReply(guide);

string firstQuestion = "Where can I buy supplies?";
WriteLine("Player: " + firstQuestion);

guide.AddMessage(firstQuestion);
string firstReply = GetFullReply(guide);

WriteLine("Rowan: " + firstReply);
WriteLine("");

string secondQuestion = "Where is that from here?";
WriteLine("Player: " + secondQuestion);

guide.AddMessage(secondQuestion);
string secondReply = GetFullReply(guide);

WriteLine("Rowan: " + secondReply);
WriteLine("");

string thirdQuestion = "Is there anywhere dangerous I should avoid?";
WriteLine("Player: " + thirdQuestion);

guide.AddMessage(thirdQuestion);
string thirdReply = GetFullReply(guide);

WriteLine("Rowan: " + thirdReply);

guide.Free();

Object-Oriented

using SplashKitSDK;

namespace AINPCDialogueExample
{
    public class Program
    {
        private static string GetFullReply(Conversation conv)
        {
            string reply = "";

            while (conv.IsReplying())
            {
                reply += conv.GetReplyPiece();
            }

            return reply;
        }

        public static void Main()
        {
            SplashKit.WriteLine("=== Splashwood Village Guide ===");
            SplashKit.WriteLine("");

            // Create one conversation so the NPC keeps the conversation context
            Conversation guide = SplashKit.CreateConversation();

            string rolePrompt =
                "You are Rowan, a friendly village guide in Splashwood Village. " +
                "Stay in character and keep your answers short and helpful. " +
                "Splashwood Village has a market in the village square, " +
                "an old forest to the north, and an inn beside the fountain.";

            guide.AddMessage(rolePrompt);

            // Consume the setup response before continuing
            GetFullReply(guide);

            string firstQuestion = "Where can I buy supplies?";
            SplashKit.WriteLine("Player: " + firstQuestion);

            guide.AddMessage(firstQuestion);
            string firstReply = GetFullReply(guide);

            SplashKit.WriteLine("Rowan: " + firstReply);
            SplashKit.WriteLine("");

            string secondQuestion = "Where is that from here?";
            SplashKit.WriteLine("Player: " + secondQuestion);

            guide.AddMessage(secondQuestion);
            string secondReply = GetFullReply(guide);

            SplashKit.WriteLine("Rowan: " + secondReply);
            SplashKit.WriteLine("");

            string thirdQuestion = "Is there anywhere dangerous I should avoid?";
            SplashKit.WriteLine("Player: " + thirdQuestion);

            guide.AddMessage(thirdQuestion);
            string thirdReply = GetFullReply(guide);

            SplashKit.WriteLine("Rowan: " + thirdReply);

            guide.Free();
        }
    }
}

Python

from splashkit import *


def ask_npc(conv, message):
    conversation_add_message(conv, message)

    # Wait until the model begins generating its response
    while not conversation_is_replying(conv):
        delay(10)

    return conversation_get_reply(conv)


write_line("=== Splashwood Village Guide ===")
write_line("")

guide = create_conversation()

# Establish Rowan's role
role_prompt = (
    "You are Rowan, a friendly village guide in Splashwood Village. "
    "Stay in character and keep your answers short and helpful. "
    "Splashwood Village has a market in the village square, "
    "an old forest to the north, and an inn beside the fountain."
)

ask_npc(guide, role_prompt)

first_question = "Where can I buy supplies?"
write_line("Player: " + first_question)
first_reply = ask_npc(guide, first_question)
write_line("Rowan: " + first_reply)
write_line("")

second_question = "Where is that from here?"
write_line("Player: " + second_question)
second_reply = ask_npc(guide, second_question)
write_line("Rowan: " + second_reply)
write_line("")

third_question = "Is there anywhere dangerous I should avoid?"
write_line("Player: " + third_question)
third_reply = ask_npc(guide, third_question)
write_line("Rowan: " + third_reply)

free_conversation(guide)

Output:

---

Conversation Get Reply  {</>}

Note

This function is overloaded. The following versions exist:

• Conversation Get Reply (conv: conversation)  {</>}
• Conversation Get Reply (conv: conversation, with_thoughts: bool)

Conversation Get Reply  {</>}

Returns a reply from a Conversation, without any related thoughts.

Parameters:

Name	Type	Description
conv	Conversation	The Conversation to recieve the reply from

Return Type: String

Returns: The response from the model

Signatures:

C++

string conversation_get_reply(conversation conv)

C#

public string Conversation.GetReply();
public static string SplashKit.ConversationGetReply(Conversation conv);

Python

def conversation_get_reply(conv):

Pascal

function ConversationGetReply(conv: Conversation): String

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Conversation Add Message: Splashwood Village Guide - Context-Aware AI NPC Dialogue
• Create Conversation: Comparing Replies from Two AI Models

---

Conversation Get Reply

Returns a reply from a Conversation, with the ability to indicate if thoughts should be included.

Parameters:

Name	Type	Description
conv	Conversation	The Conversation to recieve the reply from
with_thoughts	Boolean	A boolean to indicate if thoughts should be included in the reply

Return Type: String

Returns: The response from the model

Signatures:

C++

string conversation_get_reply(conversation conv, bool with_thoughts)

C#

public string Conversation.GetReply(bool withThoughts);
public static string SplashKit.ConversationGetReply(Conversation conv, bool withThoughts);

Python

def conversation_get_reply_with_thoughts(conv, with_thoughts):

Pascal

function ConversationGetReply(conv: Conversation; withThoughts: Boolean): String

---

Conversation Get Reply Piece  {</>}

Returns a single piece of a reply (generally one word at a time) from the Conversation You can use a loop while checking Conversation Is Replying to retrieve the reply as it generates

Parameters:

Name	Type	Description
c	Conversation	The Conversation object to recieve the reply from

Return Type: String

Returns: Returns a small piece of the reply (generally 1 word or less)

Signatures:

C++

string conversation_get_reply_piece(conversation c)

C#

public string Conversation.GetReplyPiece();
public static string SplashKit.ConversationGetReplyPiece(Conversation c);

Python

def conversation_get_reply_piece(c):

Pascal

function ConversationGetReplyPiece(c: Conversation): String

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Conversation Is Replying: Watching an AI Reply in Progress
• Conversation Is Thinking: Separating AI Thoughts from the Final Reply
• Create Conversation: Streaming a Reply from a New Conversation

See Code Examples

Example 1: Streaming AI Response

C++

#include "splashkit.h"

int main()
{
    // Create a conversation using the default language model
    conversation chat = create_conversation();

    write_line("Sending message: \"Explain what AI is in one sentence.\"");
    write_line("");

    // Add a user message — the model begins replying immediately
    conversation_add_message(chat, "Explain what AI is in one sentence.");

    // Show a thinking indicator while the model is processing
    if (conversation_is_thinking(chat))
    {
        write("Thinking");
    }

    while (conversation_is_thinking(chat))
    {
        write(".");
        delay(200);
    }

    // Move to a new line after thinking dots
    write_line("");

    write("AI: ");

    // Stream the reply one piece at a time as it generates
    while (conversation_is_replying(chat))
    {
        // Retrieve the next small piece of the reply (generally one word)
        string piece = conversation_get_reply_piece(chat);
        write(piece);
    }

    write_line("");
    write_line("");
    write_line("Response complete.");

    // Release conversation resources
    free_conversation(chat);

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Create a conversation using the default language model
SplashKitSDK.Conversation chat = CreateConversation();

WriteLine("Sending message: \"Explain what AI is in one sentence.\"");
WriteLine("");

// Add a user message — the model begins replying immediately
ConversationAddMessage(chat, "Explain what AI is in one sentence.");

// Show a thinking indicator while the model is processing
if (ConversationIsThinking(chat))
{
    Write("Thinking");
}

while (ConversationIsThinking(chat))
{
    Write(".");
    Delay(200);
}

// Move to a new line after thinking dots
WriteLine("");

Write("AI: ");

// Stream the reply one piece at a time as it generates
while (ConversationIsReplying(chat))
{
    // Retrieve the next small piece of the reply (generally one word)
    string piece = ConversationGetReplyPiece(chat);
    Write(piece);
}

WriteLine("");
WriteLine("");
WriteLine("Response complete.");

// Release conversation resources
FreeConversation(chat);

Object-Oriented

using SplashKitSDK;

namespace ConversationGetReplyPieceExample
{
    public class Program
    {
        public static void Main()
        {
            // Create a conversation using the default language model
            Conversation chat = new Conversation();

            SplashKit.WriteLine("Sending message: \"Explain what AI is in one sentence.\"");
            SplashKit.WriteLine("");

            // Add a user message — the model begins replying immediately
            chat.AddMessage("Explain what AI is in one sentence.");

            // Show a thinking indicator while the model is processing
            if (chat.IsThinking())
            {
                SplashKit.Write("Thinking");
            }

            while (chat.IsThinking())
            {
                SplashKit.Write(".");
                SplashKit.Delay(200);
            }

            // Move to a new line after thinking dots
            SplashKit.WriteLine("");

            SplashKit.Write("AI: ");

            // Stream the reply one piece at a time as it generates
            while (chat.IsReplying())
            {
                // Retrieve the next small piece of the reply (generally one word)
                string piece = chat.GetReplyPiece();
                SplashKit.Write(piece);
            }

            SplashKit.WriteLine("");
            SplashKit.WriteLine("");
            SplashKit.WriteLine("Response complete.");

            // Release conversation resources
            chat.Free();
        }
    }
}

Python

from splashkit import *

# Create a conversation using the default language model
chat = create_conversation()

write_line("Sending message: \"Explain what AI is in one sentence.\"")
write_line("")

# Add a user message — the model begins replying immediately
conversation_add_message(chat, "Explain what AI is in one sentence.")

# Show a thinking indicator while the model is processing
if conversation_is_thinking(chat):
    write("Thinking")

while conversation_is_thinking(chat):
    write(".")
    delay(200)

# Move to a new line after thinking dots
write_line("")

write("AI: ")

# Stream the reply one piece at a time as it generates
while conversation_is_replying(chat):
    # Retrieve the next small piece of the reply (generally one word)
    piece = conversation_get_reply_piece(chat)
    write(piece)

write_line("")
write_line("")
write_line("Response complete.")

# Release conversation resources
free_conversation(chat)

Output:

---

Conversation Is Replying  {</>}

Checks if a language model is currently generating a reply within a Conversation. If so, you can continue to receive the message with conversation_get_reply_piece(conversation c)

Parameters:

Name	Type	Description
c	Conversation	The Conversation object to check

Return Type: Boolean

Returns: Returns whether the language model is still generating a reply

Signatures:

C++

bool conversation_is_replying(conversation c)

C#

public bool Conversation.IsReplying();
public static bool SplashKit.ConversationIsReplying(Conversation c);

Python

def conversation_is_replying(c):

Pascal

function ConversationIsReplying(c: Conversation): Boolean

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Conversation Add Message: Splashwood Village Guide - Context-Aware AI NPC Dialogue
• Conversation Get Reply Piece: Streaming AI Response
• Conversation Is Thinking: Separating AI Thoughts from the Final Reply
• Create Conversation: Streaming a Reply from a New Conversation

See Code Examples

Example 1: Watching an AI Reply in Progress

C++

#include "splashkit.h"

using namespace std;

int main()
{
    conversation chat = create_conversation();

    string question = "Explain what a computer network is in one short paragraph.";

    write_line("Question:");
    write_line(question);
    write_line("");
    write_line("Status: AI is replying...");
    write_line("");
    write_line("AI reply:");

    conversation_add_message(chat, question);

    while (conversation_is_replying(chat))
    {
        write(conversation_get_reply_piece(chat));
    }

    write_line("");
    write_line("");
    write_line("Status: Reply complete.");

    free_conversation(chat);

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

Conversation chat = CreateConversation();

string question = "Explain what a computer network is in one short paragraph.";

WriteLine("Question:");
WriteLine(question);
WriteLine("");
WriteLine("Status: AI is replying...");
WriteLine("");
WriteLine("AI reply:");

chat.AddMessage(question);

while (chat.IsReplying())
{
    Write(chat.GetReplyPiece());
}

WriteLine("");
WriteLine("");
WriteLine("Status: Reply complete.");

chat.Free();

Object-Oriented

using SplashKitSDK;

namespace ConversationIsReplyingExample
{
    public class Program
    {
        public static void Main()
        {
            Conversation chat = SplashKit.CreateConversation();

            string question = "Explain what a computer network is in one short paragraph.";

            SplashKit.WriteLine("Question:");
            SplashKit.WriteLine(question);
            SplashKit.WriteLine("");
            SplashKit.WriteLine("Status: AI is replying...");
            SplashKit.WriteLine("");
            SplashKit.WriteLine("AI reply:");

            chat.AddMessage(question);

            while (chat.IsReplying())
            {
                SplashKit.Write(chat.GetReplyPiece());
            }

            SplashKit.WriteLine("");
            SplashKit.WriteLine("");
            SplashKit.WriteLine("Status: Reply complete.");

            chat.Free();
        }
    }
}

Python

from splashkit import *


chat = create_conversation()

question = "Explain what a computer network is in one short paragraph."

write_line("Question:")
write_line(question)
write_line("")
write_line("Status: AI is replying...")
write_line("")
write_line("AI reply:")

conversation_add_message(chat, question)

while conversation_is_replying(chat):
    write(conversation_get_reply_piece(chat))

write_line("")
write_line("")
write_line("Status: Reply complete.")

free_conversation(chat)

Output:

---

Conversation Is Thinking  {</>}

Checks if a language model is currently “thinking” while generating a reply within a Conversation. You can use this to filter out the “thoughts” and display them differently (or hide them entirely)

Parameters:

Name	Type	Description
c	Conversation	The Conversation object to check

Return Type: Boolean

Returns: Returns whether the language model is currently thinking while generating a reply

Signatures:

C++

bool conversation_is_thinking(conversation c)

C#

public bool Conversation.IsThinking();
public static bool SplashKit.ConversationIsThinking(Conversation c);

Python

def conversation_is_thinking(c):

Pascal

function ConversationIsThinking(c: Conversation): Boolean

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Conversation Get Reply Piece: Streaming AI Response

See Code Examples

Example 1: Separating AI Thoughts from the Final Reply

C++

#include "splashkit.h"

int main()
{
    conversation chat = create_conversation(QWEN3_0_6B_THINKING);

    string question = "What is 2 plus 2? Give only the answer.";

    write_line("Question: " + question);
    write_line("");

    // Send the question to the language model
    conversation_add_message(chat, question);

    bool thinking_started = false;
    bool thinking_finished = false;
    bool reply_heading_shown = false;

    while (conversation_is_replying(chat))
    {
        bool is_thinking = conversation_is_thinking(chat);

        // Display messages when the thinking state changes
        if (is_thinking && !thinking_started)
        {
            write_line("The model is thinking...");
            thinking_started = true;
        }

        if (!is_thinking && thinking_started && !thinking_finished)
        {
            write_line("Thinking done.");
            thinking_finished = true;
        }

        string reply_piece = conversation_get_reply_piece(chat);

        if (!is_thinking)
        {
            if (!reply_heading_shown)
            {
                write_line("");
                write_line("Final reply:");
                reply_heading_shown = true;
            }

            write(reply_piece);
        }
    }

    write_line("");
    write_line("");
    write_line("Reply complete.");

    free_conversation(chat);

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

Conversation chat = CreateConversation(
    LanguageModel.Qwen306BThinking
);

string question = "What is 2 plus 2? Give only the answer.";

WriteLine("Question: " + question);
WriteLine("");

// Send the question to the language model
ConversationAddMessage(chat, question);

bool thinkingStarted = false;
bool thinkingFinished = false;
bool replyHeadingShown = false;

while (ConversationIsReplying(chat))
{
    bool isThinking = ConversationIsThinking(chat);

    // Display messages when the thinking state changes
    if (isThinking && !thinkingStarted)
    {
        WriteLine("The model is thinking...");
        thinkingStarted = true;
    }

    if (!isThinking && thinkingStarted && !thinkingFinished)
    {
        WriteLine("Thinking done.");
        thinkingFinished = true;
    }

    string replyPiece = ConversationGetReplyPiece(chat);

    if (!isThinking)
    {
        if (!replyHeadingShown)
        {
            WriteLine("");
            WriteLine("Final reply:");
            replyHeadingShown = true;
        }

        Write(replyPiece);
    }
}

WriteLine("");
WriteLine("");
WriteLine("Reply complete.");

FreeConversation(chat);

Object-Oriented

using SplashKitSDK;

namespace ConversationIsThinkingExample
{
    public class Program
    {
        public static void Main()
        {
            Conversation chat = new Conversation(
                LanguageModel.Qwen306BThinking
            );

            string question = "What is 2 plus 2? Give only the answer.";

            SplashKit.WriteLine("Question: " + question);
            SplashKit.WriteLine("");

            // Send the question to the language model
            chat.AddMessage(question);

            bool thinkingStarted = false;
            bool thinkingFinished = false;
            bool replyHeadingShown = false;

            while (chat.IsReplying())
            {
                bool isThinking = chat.IsThinking();

                // Display messages when the thinking state changes
                if (isThinking && !thinkingStarted)
                {
                    SplashKit.WriteLine("The model is thinking...");
                    thinkingStarted = true;
                }

                if (
                    !isThinking &&
                    thinkingStarted &&
                    !thinkingFinished
                )
                {
                    SplashKit.WriteLine("Thinking done.");
                    thinkingFinished = true;
                }

                string replyPiece = chat.GetReplyPiece();

                if (!isThinking)
                {
                    if (!replyHeadingShown)
                    {
                        SplashKit.WriteLine("");
                        SplashKit.WriteLine("Final reply:");
                        replyHeadingShown = true;
                    }

                    SplashKit.Write(replyPiece);
                }
            }

            SplashKit.WriteLine("");
            SplashKit.WriteLine("");
            SplashKit.WriteLine("Reply complete.");

            chat.Free();
        }
    }
}

Python

from splashkit import *


chat = create_conversation_with_model(
    LanguageModel.qwen3_0_6b_thinking
)

question = "What is 2 plus 2? Give a short answer."

write_line("Question: " + question)
write_line("")

# Send the question to the language model
conversation_add_message(chat, question)

thinking_started = False
thinking_finished = False
reply_heading_shown = False

while conversation_is_replying(chat):
    is_thinking = conversation_is_thinking(chat)

    # Display messages when the thinking state changes
    if is_thinking and not thinking_started:
        write_line("The model is thinking...")
        thinking_started = True

    if not is_thinking and thinking_started and not thinking_finished:
        write_line("Thinking done.")
        thinking_finished = True

    reply_piece = conversation_get_reply_piece(chat)

    if not is_thinking:
        if not reply_heading_shown:
            write_line("")
            write_line("Final reply:")
            reply_heading_shown = True

        write(reply_piece)

write_line("")
write_line("")
write_line("Reply complete.")

free_conversation(chat)

Output:

---

Create Conversation  {</>}

Note

This function is overloaded. The following versions exist:

• Create Conversation ()  {</>}
• Create Conversation (model: language_model)  {</>}

Create Conversation  {</>}

Creates a new Conversation object, that uses the default language model. The Conversation object can have messages added to it, and responses streamed back from it via the other Conversation functions and procedures

Return Type: Conversation

Returns: Returns a new Conversation object.

Signatures:

C++

conversation create_conversation()

C#

public static Conversation SplashKit.CreateConversation();
public Conversation();

Python

def create_conversation():

Pascal

function CreateConversation(): Conversation

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Conversation Add Message: Splashwood Village Guide - Context-Aware AI NPC Dialogue
• Conversation Get Reply Piece: Streaming AI Response
• Conversation Is Replying: Watching an AI Reply in Progress
• Free All Conversations: Cleaning Up Multiple AI Conversations

See Code Examples

Example 1: Streaming a Reply from a New Conversation

C++

#include "splashkit.h"

int main()
{
    // Create a new conversation using the default language model
    conversation chat = create_conversation();

    string prompt = "What is SplashKit?";
    write_line("Prompt: " + prompt);

    // Add the prompt to the conversation
    conversation_add_message(chat, prompt);

    write_line("Reply:");

    // Retrieve and display the reply one piece at a time
    while (conversation_is_replying(chat))
    {
        write(conversation_get_reply_piece(chat));
    }

    write_line("");
    write_line("Reply complete!");

    // Release the conversation resources
    free_conversation(chat);

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Create a new conversation using the default language model
Conversation chat = CreateConversation();

string prompt = "What is SplashKit?";
WriteLine("Prompt: " + prompt);

// Add the prompt to the conversation
chat.AddMessage(prompt);

WriteLine("Reply:");

// Retrieve and display the reply one piece at a time
while (chat.IsReplying())
{
    Write(chat.GetReplyPiece());
}

WriteLine("");
WriteLine("Reply complete!");

// Release the conversation resources
chat.Free();

Object-Oriented

using SplashKitSDK;

namespace CreateConversationExample
{
    public class Program
    {
        public static void Main()
        {
            // Create a new conversation using the default language model
            Conversation chat = new Conversation();

            string prompt = "What is SplashKit?";
            SplashKit.WriteLine("Prompt: " + prompt);

            // Add the prompt to the conversation
            chat.AddMessage(prompt);

            SplashKit.WriteLine("Reply:");

            // Retrieve and display the reply one piece at a time
            while (chat.IsReplying())
            {
                SplashKit.Write(chat.GetReplyPiece());
            }

            SplashKit.WriteLine("");
            SplashKit.WriteLine("Reply complete!");

            // Release the conversation resources
            chat.Free();
        }
    }
}

Python

from splashkit import *

# Create a new conversation using the default language model
chat = create_conversation()

prompt = "What is SplashKit?"
write_line(f"Prompt: {prompt}")

# Add the prompt to the conversation
conversation_add_message(chat, prompt)

write_line("Reply:")

# Retrieve and display the reply one piece at a time
while conversation_is_replying(chat):
    write(conversation_get_reply_piece(chat))

write_line("")
write_line("Reply complete!")

# Release the conversation resources
free_conversation(chat)

Output:

---

Create Conversation  {</>}

Creates a new Conversation object, that uses a chosen language model. The Conversation object can have messages added to it, and responses streamed back from it via the other Conversation functions and procedures

Parameters:

Name	Type	Description
model	Language Model	The language model to use

Return Type: Conversation

Returns: Returns a new Conversation object.

Signatures:

C++

conversation create_conversation(language_model model)

C#

public static Conversation SplashKit.CreateConversation(LanguageModel model);
public Conversation(LanguageModel model);

Python

def create_conversation_with_model(model):

Pascal

function CreateConversation(model: LanguageModel): Conversation

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Conversation Is Thinking: Separating AI Thoughts from the Final Reply

See Code Examples

Example 1: Comparing Replies from Two AI Models

C++

#include "splashkit.h"

int main()
{
    string prompt = "What is AI?";

    write_line("Prompt: " + prompt);
    write_line("");

    // Create a conversation using the Qwen3 model, and send the prompt to it
    write_line("Asking Qwen3 1.7B Instruct...");
    conversation qwen_chat = create_conversation(QWEN3_1_7B_INSTRUCT);
    conversation_add_message(qwen_chat, prompt);
    string qwen_reply = conversation_get_reply(qwen_chat);
    write_line("Qwen3 reply: " + qwen_reply);
    write_line("");

    // Create a conversation using the Gemma3 model, and send the same prompt to it
    write_line("Asking Gemma3 1B Instruct...");
    conversation gemma_chat = create_conversation(GEMMA3_1B_INSTRUCT);
    conversation_add_message(gemma_chat, prompt);
    string gemma_reply = conversation_get_reply(gemma_chat);
    write_line("Gemma3 reply: " + gemma_reply);

    // Release the resources used by both conversations
    free_conversation(qwen_chat);
    free_conversation(gemma_chat);

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

string prompt = "What is AI?";

WriteLine("Prompt: " + prompt);
WriteLine("");

// Create a conversation using the Qwen3 model, and send the prompt to it
WriteLine("Asking Qwen3 1.7B Instruct...");
Conversation qwenChat = new Conversation(LanguageModel.Qwen317BInstruct);
qwenChat.AddMessage(prompt);
string qwenReply = qwenChat.GetReply();
WriteLine("Qwen3 reply: " + qwenReply);
WriteLine("");

// Create a conversation using the Gemma3 model, and send the same prompt to it
WriteLine("Asking Gemma3 1B Instruct...");
Conversation gemmaChat = new Conversation(LanguageModel.Gemma31BInstruct);
gemmaChat.AddMessage(prompt);
string gemmaReply = gemmaChat.GetReply();
WriteLine("Gemma3 reply: " + gemmaReply);

// Release the resources used by both conversations
qwenChat.Free();
gemmaChat.Free();

Object-Oriented

using SplashKitSDK;

namespace AIModelComparisonExample
{
    public class Program
    {
        public static void Main()
        {
            SplashKit.WriteLine("Prompt: What is AI?");
            SplashKit.WriteLine("");

            // Create a conversation using the Qwen3 model, and send the prompt to it
            SplashKit.WriteLine("Asking Qwen3 1.7B Instruct...");
            Conversation qwenChat = new Conversation(LanguageModel.Qwen317BInstruct);
            qwenChat.AddMessage("What is AI?");
            string qwenReply = qwenChat.GetReply();
            SplashKit.WriteLine("Qwen3 reply: " + qwenReply);
            SplashKit.WriteLine("");

            // Create a conversation using the Gemma3 model, and send the same prompt to it
            SplashKit.WriteLine("Asking Gemma3 1B Instruct...");
            Conversation gemmaChat = new Conversation(LanguageModel.Gemma31BInstruct);
            gemmaChat.AddMessage("What is AI?");
            string gemmaReply = gemmaChat.GetReply();
            SplashKit.WriteLine("Gemma3 reply: " + gemmaReply);

            // Release the resources used by both conversations
            qwenChat.Free();
            gemmaChat.Free();
        }
    }
}

Python

from splashkit import *

prompt = "What is AI?"

write_line(f"Prompt: {prompt}")
write_line("")

# Create a conversation using the Qwen3 model, and send the prompt to it
write_line("Asking Qwen3 1.7B Instruct...")
qwen_chat = create_conversation_with_model(QWEN3_1_7B_INSTRUCT)
conversation_add_message(qwen_chat, prompt)
qwen_reply = conversation_get_reply(qwen_chat)
write_line(f"Qwen3 reply: {qwen_reply}")
write_line("")

# Create a conversation using the Gemma3 model, and send the same prompt to it
write_line("Asking Gemma3 1B Instruct...")
gemma_chat = create_conversation_with_model(GEMMA3_1B_INSTRUCT)
conversation_add_message(gemma_chat, prompt)
gemma_reply = conversation_get_reply(gemma_chat)
write_line(f"Gemma3 reply: {gemma_reply}")

# Release the resources used by both conversations
free_conversation(qwen_chat)
free_conversation(gemma_chat)

Output:

---

Free All Conversations  {</>}

Releases all of the Conversation objects which have been loaded.

Signatures:

C++

void free_all_conversations()

C#

public static void GenerativeAi.FreeAll();
public static void SplashKit.FreeAllConversations();

Python

def free_all_conversations():

Pascal

procedure FreeAllConversations()

Usage:  {</>}

See Code Examples

Example 1: Cleaning Up Multiple AI Conversations

C++

#include "splashkit.h"

int main()
{
    conversation study_conversation = create_conversation();
    conversation travel_conversation = create_conversation();
    conversation coding_conversation = create_conversation();

    (void)study_conversation;
    (void)travel_conversation;
    (void)coding_conversation;

    write_line("Three AI conversations have been created:");
    write_line("- Study assistant");
    write_line("- Travel assistant");
    write_line("- Coding assistant");
    write_line("");

    write_line("Freeing all loaded conversations...");

    free_all_conversations();

    write_line("All conversation resources have been released.");

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

Conversation studyConversation = CreateConversation();
Conversation travelConversation = CreateConversation();
Conversation codingConversation = CreateConversation();

WriteLine("Three AI conversations have been created:");
WriteLine("- Study assistant");
WriteLine("- Travel assistant");
WriteLine("- Coding assistant");
WriteLine("");

WriteLine("Freeing all loaded conversations...");

GenerativeAi.FreeAll();

WriteLine("All conversation resources have been released.");

Object-Oriented

using SplashKitSDK;

namespace FreeAllConversationsExample
{
    public class Program
    {
        public static void Main()
        {
            Conversation studyConversation = SplashKit.CreateConversation();
            Conversation travelConversation = SplashKit.CreateConversation();
            Conversation codingConversation = SplashKit.CreateConversation();

            SplashKit.WriteLine("Three AI conversations have been created:");
            SplashKit.WriteLine("- Study assistant");
            SplashKit.WriteLine("- Travel assistant");
            SplashKit.WriteLine("- Coding assistant");
            SplashKit.WriteLine("");

            SplashKit.WriteLine("Freeing all loaded conversations...");

            GenerativeAi.FreeAll();

            SplashKit.WriteLine("All conversation resources have been released.");
        }
    }
}

Python

from splashkit import *

study_conversation = create_conversation()
travel_conversation = create_conversation()
coding_conversation = create_conversation()

print("Three AI conversations have been created:")
print("- Study assistant")
print("- Travel assistant")
print("- Coding assistant")
print()

print("Freeing all loaded conversations...")

free_all_conversations()

print("All conversation resources have been released.")

Output:

---

Free Conversation  {</>}

Frees the resources associated with the Conversation object.

Parameters:

Name	Type	Description
c	Conversation	The Conversation object whose resources should be released.

Signatures:

C++

void free_conversation(conversation c)

C#

public void Conversation.Free();
public static void SplashKit.FreeConversation(Conversation c);

Python

def free_conversation(c):

Pascal

procedure FreeConversation(c: Conversation)

Usage:  {</>}

See Implementations

API Documentation Code Examples:

• Conversation Add Message: Splashwood Village Guide - Context-Aware AI NPC Dialogue
• Conversation Get Reply Piece: Streaming AI Response
• Conversation Is Replying: Watching an AI Reply in Progress
• Conversation Is Thinking: Separating AI Thoughts from the Final Reply

See Code Examples

Example 1: Freeing a Single AI Conversation Resource

C++

#include "splashkit.h"

int main()
{
    // Create a conversation instance
    conversation conv = create_conversation();
    write_line("Conversation created.");

    // Free the conversation to release its resources
    free_conversation(conv);
    write_line("Conversation freed successfully.");

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

// Create a conversation instance
Conversation conv = CreateConversation();
WriteLine("Conversation created.");

// Free the conversation to release its resources
FreeConversation(conv);
WriteLine("Conversation freed successfully.");

Object-Oriented

using SplashKitSDK;

namespace FreeConversationExample
{
    public class Program
    {
        public static void Main()
        {
            // Create a conversation instance
            Conversation conv = SplashKit.CreateConversation();
            SplashKit.WriteLine("Conversation created.");

            // Free the conversation to release its resources
            SplashKit.FreeConversation(conv);
            SplashKit.WriteLine("Conversation freed successfully.");
        }
    }
}

Python

from splashkit import *

# Create a conversation instance
conv = create_conversation()
write_line("Conversation created.")

# Free the conversation to release its resources
free_conversation(conv)
write_line("Conversation freed successfully.")

Output:

---

Generate Reply

Note

This function is overloaded. The following versions exist:

• Generate Reply (model: language_model, prompt: string)
• Generate Reply (prompt: string)

Generate Reply

Generates a reply to a textual prompt by a language model The language model will respond to the textual prompt in a chat style format. It will follow instructions and answer questions. Instruct or Thinking models are recommended. Base models likely won’t output sensible results.

Parameters:

Name	Type	Description
model	Language Model	The language model to use
prompt	String	The prompt for the language model to reply to.

Return Type: String

Returns: The generated reply.

Signatures:

C++

string generate_reply(language_model model, string prompt)

C#

public static string SplashKit.GenerateReply(LanguageModel model, string prompt);

Python

def generate_reply_with_model(model, prompt):

Pascal

function GenerateReply(model: LanguageModel; prompt: String): String

---

Generate Reply

Generates a reply to a textual prompt by a language model The language model will respond to the textual prompt in a chat style format. It will follow instructions and answer questions. Instruct or Thinking models are recommended. Base models likely won’t output sensible results.

Parameters:

Name	Type	Description
prompt	String	The prompt for the language model to reply to.

Return Type: String

Returns: The generated reply.

Signatures:

C++

string generate_reply(string prompt)

C#

public static string SplashKit.GenerateReply(string prompt);

Python

def generate_reply(prompt):

Pascal

function GenerateReply(prompt: String): String

---

Generate Text  {</>}

Note

This function is overloaded. The following versions exist:

• Generate Text (model: language_model, text: string)
• Generate Text (model: language_model, text: string, max_tokens: int)
• Generate Text (text: string)  {</>}
• Generate Text (text: string, max_tokens: int)  {</>}

Generate Text

Generates text that continues from a prompt, with a maximum of 125 tokens. The language model will continue predicting text based on patterns in the prompt - it will not directly follow instructions or answer questions. Base models are recommended; Instruct and Thinking models may work.

Parameters:

Name	Type	Description
model	Language Model	The language model to use
text	String	The input text for the language model to continue.

Return Type: String

Returns: The generated reply.

Signatures:

C++

string generate_text(language_model model, string text)

C#

public static string SplashKit.GenerateText(LanguageModel model, string text);

Python

def generate_text_with_model(model, text):

Pascal

function GenerateText(model: LanguageModel; text: String): String

---

Generate Text

Generates text that continues from a prompt, with a maximum of 125 tokens. The language model will continue predicting text based on patterns in the prompt - it will not directly follow instructions or answer questions. Base models are recommended; Instruct and Thinking models may work.

Parameters:

Name	Type	Description
model	Language Model	The language model to use
text	String	The input text for the language model to continue.
max_tokens	Integer	The maximum tokens used in response - determining the length of the output and the time taken. Keep this small for reasonable execution times.

Return Type: String

Returns: The generated reply.

Signatures:

C++

string generate_text(language_model model, string text, int max_tokens)

C#

public static string SplashKit.GenerateText(LanguageModel model, string text, int maxTokens);

Python

def generate_text_with_model_and_tokens(model, text, max_tokens):

Pascal

function GenerateText(model: LanguageModel; text: String; maxTokens: Integer): String

---

Generate Text  {</>}

Generates text that continues from a prompt - with default of 125 tokens. The language model will continue predicting text based on patterns in the prompt - it will not directly follow instructions or answer questions. Base models are recommended; Instruct and Thinking models may work.

Parameters:

Name	Type	Description
text	String	The input text for the language model to continue.

Return Type: String

Returns: The generated reply.

Signatures:

C++

string generate_text(string text)

C#

public static string SplashKit.GenerateText(string text);

Python

def generate_text(text):

Pascal

function GenerateText(text: String): String

Usage:  {</>}

See Code Examples

Example 1: Generating Text Response from AI

C++

#include "splashkit.h"

int main()
{
    // Define a prompt to send to the AI
    // Note: Requires a local AI model to be set up via SplashKit
    string prompt = "What is the capital of France?";
    write_line("Prompt: " + prompt);

    // Generate a text response from the AI
    string response = generate_text(prompt);
    write_line("Response: " + response);

    return 0;
}

C#

Top-level Statements

using static SplashKitSDK.SplashKit;

// Define a prompt to send to the AI
// Note: Requires a local AI model to be set up via SplashKit
string prompt = "What is the capital of France?";
WriteLine("Prompt: " + prompt);

// Generate a text response from the AI
string response = GenerateText(prompt);
WriteLine("Response: " + response);

Object-Oriented

using SplashKitSDK;

namespace GenerateTextExample
{
    public class Program
    {
        public static void Main()
        {
            // Define a prompt to send to the AI
            // Note: Requires a local AI model to be set up via SplashKit
            string prompt = "What is the capital of France?";
            SplashKit.WriteLine("Prompt: " + prompt);

            // Generate a text response from the AI
            string response = SplashKit.GenerateText(prompt);
            SplashKit.WriteLine("Response: " + response);
        }
    }
}

Python

from splashkit import *

# Define a prompt to send to the AI
# Note: Requires a local AI model to be set up via SplashKit
prompt = "What is the capital of France?"
write_line("Prompt: " + prompt)

# Generate a text response from the AI
response = generate_text(prompt)
write_line("Response: " + response)

Output:

---

Generate Text  {</>}

Generates text that continues from a prompt. The language model will continue predicting text based on patterns in the prompt - it will not directly follow instructions or answer questions. Base models are recommended; Instruct and Thinking models may work.

Parameters:

Name	Type	Description
text	String	The input text for the language model to continue.
max_tokens	Integer	The maximum tokens used in response - determining the length of the output and the time taken. Keep this small for reasonable execution times.

Return Type: String

Returns: The generated reply.

Signatures:

C++

string generate_text(string text, int max_tokens)

C#

public static string SplashKit.GenerateText(string text, int maxTokens);

Python

def generate_text_with_tokens(text, max_tokens):

Pascal

function GenerateText(text: String; maxTokens: Integer): String

Usage:  {</>}

See Code Examples

Example 1: Generating a Story Continuation with a Token Limit

C++

#include "splashkit.h"

int main()
{
    string prompt = "Once upon a time, there was a robot who";

    write_line("Prompt: " + prompt);

    // Generate a continuation of the story, limited to 50 tokens
    string story = generate_text(prompt, 50);

    write_line("Generated story: " + story);

    return 0;
}

C#

Top-level Statements

using SplashKitSDK;
using static SplashKitSDK.SplashKit;

string prompt = "Once upon a time, there was a robot who";

WriteLine("Prompt: " + prompt);

// Generate a continuation of the story, limited to 50 tokens
string story = GenerateText(prompt, 50);

WriteLine("Generated story: " + story);

Object-Oriented

using SplashKitSDK;

namespace AIStoryGeneratorExample
{
    public class Program
    {
        public static void Main()
        {
            string prompt = "Once upon a time, there was a robot who";

            SplashKit.WriteLine("Prompt: " + prompt);

            // Generate a continuation of the story, limited to 50 tokens
            string story = SplashKit.GenerateText(prompt, 50);

            SplashKit.WriteLine("Generated story: " + story);
        }
    }
}

Python

from splashkit import *

prompt = "Once upon a time, there was a robot who"

write_line(f"Prompt: {prompt}")

# Generate a continuation of the story, limited to 50 tokens
story = generate_text_with_tokens(prompt, 50)

write_line(f"Generated story: {story}")

Output:

---

Types

Conversation

The Conversation type is used to refer to conversations between the user and a language model. You can use it to send messages to the language model, and stream responses back.

All Conversation objects are:

• created with create_conversation(), create_conversation(language_model model)

• and must be released using free_conversation() (to release a specific Conversation object) or free_all_conversation() (to release all created Conversation objects).

---

Language Model

Language Models: Choose between different language models to trade off speed and intelligence Each model is scaled to fit within 1~2GB and will be automatically downloaded when needed - feel free to try them out!

C++

Constant	Description
QWEN3_0_6B_BASE	Qwen3 0.6B Base model - small, extremely fast and good for text completion. Very limited world knowledge.
QWEN3_0_6B_INSTRUCT	Qwen3 0.6B Instruct model (default) - small, extremely fast and can follow simple instructions. Very limited world knowledge.
QWEN3_0_6B_THINKING	Qwen3 0.6B Thinking model - small, extremely fast and can follow more specific instructions, but has a short delay before starting to reply. Very limited world knowledge.
QWEN3_1_7B_BASE	Qwen3 1.7B Base model - decently fast and good for text completion. Limited world knowledge.
QWEN3_1_7B_INSTRUCT	Qwen3 1.7B Instruct model - decently fast and can follow instructions. Limited world knowledge.
QWEN3_1_7B_THINKING	Qwen3 1.7B Thinking model - decently fast and can follow more difficult instructions, but has a delay before starting to reply. Limited world knowledge.
QWEN3_4B_BASE	Qwen3 4B Base model - slower but excellent for text completion/pattern based completion
QWEN3_4B_INSTRUCT	Qwen3 4B Instruct model - slower but can follow complex instructions
QWEN3_4B_THINKING	Qwen3 4B Thinking model - slower but can follow complex and specific instructions, but has a potentially long delay before starting to reply
GEMMA3_270M_BASE	Gemma3 270M Base model - tiny, extremely fast, and good for text completion. Very limited world knowledge.
GEMMA3_270M_INSTRUCT	Gemma3 270M Instruct model - tiny, extremely fast, and good for very simple instructions. Very limited world knowledge.
GEMMA3_1B_BASE	Gemma3 1B Base model - fast and good for text completion. Has decent world knowledge and multilingual abilities.
GEMMA3_1B_INSTRUCT	Gemma3 1B Instruct model - fast and can follow instructions. Has decent world knowledge and multilingual abilities.
GEMMA3_4B_BASE	Gemma3 4B Base model - slower but good for text completion/pattern based completion. Has decent world knowledge and multilingual abilities.
GEMMA3_4B_INSTRUCT	Gemma3 4B Instruct model - slower but can follow complex instructions. Has decent world knowledge and multilingual abilities.

C#

Constant	Description
LanguageModel.Qwen306BBase	Qwen3 0.6B Base model - small, extremely fast and good for text completion. Very limited world knowledge.
LanguageModel.Qwen306BInstruct	Qwen3 0.6B Instruct model (default) - small, extremely fast and can follow simple instructions. Very limited world knowledge.
LanguageModel.Qwen306BThinking	Qwen3 0.6B Thinking model - small, extremely fast and can follow more specific instructions, but has a short delay before starting to reply. Very limited world knowledge.
LanguageModel.Qwen317BBase	Qwen3 1.7B Base model - decently fast and good for text completion. Limited world knowledge.
LanguageModel.Qwen317BInstruct	Qwen3 1.7B Instruct model - decently fast and can follow instructions. Limited world knowledge.
LanguageModel.Qwen317BThinking	Qwen3 1.7B Thinking model - decently fast and can follow more difficult instructions, but has a delay before starting to reply. Limited world knowledge.
LanguageModel.Qwen34BBase	Qwen3 4B Base model - slower but excellent for text completion/pattern based completion
LanguageModel.Qwen34BInstruct	Qwen3 4B Instruct model - slower but can follow complex instructions
LanguageModel.Qwen34BThinking	Qwen3 4B Thinking model - slower but can follow complex and specific instructions, but has a potentially long delay before starting to reply
LanguageModel.Gemma3270mBase	Gemma3 270M Base model - tiny, extremely fast, and good for text completion. Very limited world knowledge.
LanguageModel.Gemma3270mInstruct	Gemma3 270M Instruct model - tiny, extremely fast, and good for very simple instructions. Very limited world knowledge.
LanguageModel.Gemma31BBase	Gemma3 1B Base model - fast and good for text completion. Has decent world knowledge and multilingual abilities.
LanguageModel.Gemma31BInstruct	Gemma3 1B Instruct model - fast and can follow instructions. Has decent world knowledge and multilingual abilities.
LanguageModel.Gemma34BBase	Gemma3 4B Base model - slower but good for text completion/pattern based completion. Has decent world knowledge and multilingual abilities.
LanguageModel.Gemma34BInstruct	Gemma3 4B Instruct model - slower but can follow complex instructions. Has decent world knowledge and multilingual abilities.

Python

Constant	Description
LanguageModel.qwen3_0_6b_base	Qwen3 0.6B Base model - small, extremely fast and good for text completion. Very limited world knowledge.
LanguageModel.qwen3_0_6b_instruct	Qwen3 0.6B Instruct model (default) - small, extremely fast and can follow simple instructions. Very limited world knowledge.
LanguageModel.qwen3_0_6b_thinking	Qwen3 0.6B Thinking model - small, extremely fast and can follow more specific instructions, but has a short delay before starting to reply. Very limited world knowledge.
LanguageModel.qwen3_1_7b_base	Qwen3 1.7B Base model - decently fast and good for text completion. Limited world knowledge.
LanguageModel.qwen3_1_7b_instruct	Qwen3 1.7B Instruct model - decently fast and can follow instructions. Limited world knowledge.
LanguageModel.qwen3_1_7b_thinking	Qwen3 1.7B Thinking model - decently fast and can follow more difficult instructions, but has a delay before starting to reply. Limited world knowledge.
LanguageModel.qwen3_4b_base	Qwen3 4B Base model - slower but excellent for text completion/pattern based completion
LanguageModel.qwen3_4b_instruct	Qwen3 4B Instruct model - slower but can follow complex instructions
LanguageModel.qwen3_4b_thinking	Qwen3 4B Thinking model - slower but can follow complex and specific instructions, but has a potentially long delay before starting to reply
LanguageModel.gemma3_270m_base	Gemma3 270M Base model - tiny, extremely fast, and good for text completion. Very limited world knowledge.
LanguageModel.gemma3_270m_instruct	Gemma3 270M Instruct model - tiny, extremely fast, and good for very simple instructions. Very limited world knowledge.
LanguageModel.gemma3_1b_base	Gemma3 1B Base model - fast and good for text completion. Has decent world knowledge and multilingual abilities.
LanguageModel.gemma3_1b_instruct	Gemma3 1B Instruct model - fast and can follow instructions. Has decent world knowledge and multilingual abilities.
LanguageModel.gemma3_4b_base	Gemma3 4B Base model - slower but good for text completion/pattern based completion. Has decent world knowledge and multilingual abilities.
LanguageModel.gemma3_4b_instruct	Gemma3 4B Instruct model - slower but can follow complex instructions. Has decent world knowledge and multilingual abilities.

Pascal

Constant	Description
LanguageModel.Qwen306BBase	Qwen3 0.6B Base model - small, extremely fast and good for text completion. Very limited world knowledge.
LanguageModel.Qwen306BInstruct	Qwen3 0.6B Instruct model (default) - small, extremely fast and can follow simple instructions. Very limited world knowledge.
LanguageModel.Qwen306BThinking	Qwen3 0.6B Thinking model - small, extremely fast and can follow more specific instructions, but has a short delay before starting to reply. Very limited world knowledge.
LanguageModel.Qwen317BBase	Qwen3 1.7B Base model - decently fast and good for text completion. Limited world knowledge.
LanguageModel.Qwen317BInstruct	Qwen3 1.7B Instruct model - decently fast and can follow instructions. Limited world knowledge.
LanguageModel.Qwen317BThinking	Qwen3 1.7B Thinking model - decently fast and can follow more difficult instructions, but has a delay before starting to reply. Limited world knowledge.
LanguageModel.Qwen34BBase	Qwen3 4B Base model - slower but excellent for text completion/pattern based completion
LanguageModel.Qwen34BInstruct	Qwen3 4B Instruct model - slower but can follow complex instructions
LanguageModel.Qwen34BThinking	Qwen3 4B Thinking model - slower but can follow complex and specific instructions, but has a potentially long delay before starting to reply
LanguageModel.Gemma3270mBase	Gemma3 270M Base model - tiny, extremely fast, and good for text completion. Very limited world knowledge.
LanguageModel.Gemma3270mInstruct	Gemma3 270M Instruct model - tiny, extremely fast, and good for very simple instructions. Very limited world knowledge.
LanguageModel.Gemma31BBase	Gemma3 1B Base model - fast and good for text completion. Has decent world knowledge and multilingual abilities.
LanguageModel.Gemma31BInstruct	Gemma3 1B Instruct model - fast and can follow instructions. Has decent world knowledge and multilingual abilities.
LanguageModel.Gemma34BBase	Gemma3 4B Base model - slower but good for text completion/pattern based completion. Has decent world knowledge and multilingual abilities.
LanguageModel.Gemma34BInstruct	Gemma3 4B Instruct model - slower but can follow complex instructions. Has decent world knowledge and multilingual abilities.

---