Text Generation
Transformers
Safetensors
English
gabgpt
gift-of-gab
small-language-model
trained-from-scratch
byte-level
game-boy-advance
browser
conversational
custom_code
Instructions to use gszauer/ChatGBA with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Transformers
How to use gszauer/ChatGBA with Transformers:
# Use a pipeline as a high-level helper from transformers import pipeline pipe = pipeline("text-generation", model="gszauer/ChatGBA", trust_remote_code=True) messages = [ {"role": "user", "content": "Who are you?"}, ] pipe(messages)# pip install -U transformers accelerate # Load model directly from transformers import AutoModelForCausalLM model = AutoModelForCausalLM.from_pretrained("gszauer/ChatGBA", trust_remote_code=True, device_map="auto") - Notebooks
- Google Colab
- Kaggle
- Local Apps Settings
- vLLM
How to use gszauer/ChatGBA with vLLM:
Install from pip and serve model
# Install vLLM from pip: pip install vllm # Start the vLLM server: vllm serve "gszauer/ChatGBA" # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:8000/v1/chat/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "gszauer/ChatGBA", "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }'Use Docker
docker model run hf.co/gszauer/ChatGBA
- SGLang
How to use gszauer/ChatGBA with SGLang:
Install from pip and serve model
# Install SGLang from pip: pip install sglang # Start the SGLang server: python3 -m sglang.launch_server \ --model-path "gszauer/ChatGBA" \ --host 0.0.0.0 \ --port 30000 # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:30000/v1/chat/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "gszauer/ChatGBA", "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }'Use Docker images
docker run --gpus all \ --shm-size 32g \ -p 30000:30000 \ -v ~/.cache/huggingface:/root/.cache/huggingface \ --env "HF_TOKEN=<secret>" \ --ipc=host \ lmsysorg/sglang:latest \ python3 -m sglang.launch_server \ --model-path "gszauer/ChatGBA" \ --host 0.0.0.0 \ --port 30000 # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:30000/v1/chat/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "gszauer/ChatGBA", "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }' - Docker Model Runner
How to use gszauer/ChatGBA with Docker Model Runner:
docker model run hf.co/gszauer/ChatGBA
File size: 20,564 Bytes
546acd4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 | // ChatGBA on the Game Boy Advance: chat with an on-screen keyboard.
//
// The screen: the conversation at the top, then the message being typed, then
// the keyboard. While the model reads and replies, the keyboard gives way to
// the conversation and a status line. Controls:
// D-pad move on the keyboard A type the key
// B delete (hold: stop a reply) START send
// R shift, then caps lock, then off
// L a sample question SELECT new conversation
//
// The headless runner (runner.c) can also ask questions: it writes them into
// the mailbox at the start of internal RAM, 0x03000000, and reads the reply
// back from it as the bytes appear.
#include <stdint.h>
#include "chat.h"
#include "engine.h"
#include "font.h"
#define REG_DISPCNT (*(volatile uint16_t*)0x04000000)
#define REG_VCOUNT (*(volatile uint16_t*)0x04000006)
#define REG_KEYINPUT (*(volatile uint16_t*)0x04000130)
#define REG_WAITCNT (*(volatile uint16_t*)0x04000204)
#define REG_TM2CNT_L (*(volatile uint16_t*)0x04000108)
#define REG_TM2CNT_H (*(volatile uint16_t*)0x0400010A)
#define REG_TM3CNT_L (*(volatile uint16_t*)0x0400010C)
#define REG_TM3CNT_H (*(volatile uint16_t*)0x0400010E)
#define VRAM ((volatile uint16_t*)0x06000000)
#define EWRAM __attribute__((section(".bss.ewram"))) // the 256 KB external RAM, past the KV cache
#define KEY_A 0x0001
#define KEY_B 0x0002
#define KEY_SELECT 0x0004
#define KEY_START 0x0008
#define KEY_RIGHT 0x0010
#define KEY_LEFT 0x0020
#define KEY_UP 0x0040
#define KEY_DOWN 0x0080
#define KEY_R 0x0100
#define KEY_L 0x0200
#define KEY_REPEATS (KEY_RIGHT | KEY_LEFT | KEY_UP | KEY_DOWN | KEY_B) // held down, these repeat
#define SCREEN_W 240
#define SCREEN_H 160
#define COLUMNS (SCREEN_W / FONT_WIDTH) // 40
#define RGB(r, g, b) ((r) | (g) << 5 | (b) << 10)
#define BACKGROUND RGB(2, 3, 6)
#define TITLE RGB(31, 24, 8)
#define USER RGB(14, 26, 31)
#define MODEL RGB(28, 28, 28)
#define DIM RGB(14, 14, 16)
#define RULE RGB(6, 7, 11)
#define KEY_FACE RGB(6, 7, 12)
extern const uint8_t model_blob[];
// The runner's mailbox. Its layout is part of the runner's protocol: runner.c
// reads and writes these offsets.
#define MAILBOX_MAGIC 0x42475241 // "ARGB": ready
typedef struct {
uint32_t magic; // 0
volatile uint32_t request; // 4: the runner adds one per command
volatile uint32_t done; // 8: set to request when the command is finished
uint32_t command; // 12: 1 reply to message, 2 forget the conversation
uint32_t length; // 16: message bytes
int32_t temperature; // 20: Q16
uint32_t seed; // 24
uint32_t max_reply; // 28
uint8_t message[512]; // 32
volatile uint32_t out_length; // 544: reply bytes so far
uint8_t out[1024]; // 548
volatile uint32_t prompt_done; // 1572: bytes processed before replying
volatile uint32_t prompt_total; // 1576
int32_t status; // 1580: engine_init's result
uint32_t prompt_ticks; // 1584: time to process them, in 1/16384 s
uint32_t reply_ticks; // 1588: time to generate the reply
int32_t reply_length; // 1592: chat_reply's result
uint32_t profile[PROFILE_PARTS]; // 1596: cycles per part, with PROFILE
} Mailbox;
Mailbox mailbox __attribute__((section(".shared")));
static const char* const questions[] = {
"What is a rainbow?",
"Why do we need to sleep?",
"Can you tell me a short story about a cat?",
"What do plants need to grow?",
"How does a bicycle stay up?",
};
// --- Drawing -------------------------------------------------------------------
static void fill(int x, int y, int w, int h, uint16_t color) {
for (int j = y; j < y + h; ++j) {
for (int i = x; i < x + w; ++i) VRAM[j * SCREEN_W + i] = color;
}
}
static void draw_char(int x, int y, int c, uint16_t ink, uint16_t paper) {
const uint8_t* glyph = font[(c < 32 || c > 126 ? '?' : c) - 32];
volatile uint16_t* at = VRAM + y * SCREEN_W + x;
for (int j = 0; j < FONT_HEIGHT; ++j) {
for (int i = 0; i < FONT_WIDTH; ++i) at[j * SCREEN_W + i] = (glyph[j] >> i & 1) ? ink : paper;
}
}
static void draw_text(int x, int y, const char* text, uint16_t ink, uint16_t paper) {
for (; *text; ++text, x += FONT_WIDTH) draw_char(x, y, (uint8_t)*text, ink, paper);
}
// Building short strings: each returns the new end, always terminated.
static char* add(char* at, const char* text) {
while (*text) *at++ = *text++;
*at = 0;
return at;
}
static char* add_number(char* at, uint32_t n) {
char digits[12];
int i = 0;
do digits[i++] = (char)('0' + n % 10); while (n /= 10);
while (i) *at++ = digits[--i];
*at = 0;
return at;
}
// A duration in 1/16384 s: "52.3s" or "4m24s".
static char* add_time(char* at, uint32_t ticks) {
uint32_t tenths = (ticks * 10ull + 8192) / 16384;
if (tenths < 600) {
at = add_number(at, tenths / 10);
*at++ = '.';
at = add_number(at, tenths % 10);
} else {
uint32_t s = tenths / 10;
at = add_number(at, s / 60);
*at++ = 'm';
if (s % 60 < 10) *at++ = '0';
at = add_number(at, s % 60);
}
return add(at, "s");
}
// --- The conversation: wrapped lines, the last few on screen ------------------
#define LOG_LINES 128
typedef struct {
char text[COLUMNS];
uint8_t length;
uint16_t color;
} Line;
static Line lines[LOG_LINES] EWRAM; // a ring: line i is lines[i % LOG_LINES]
static int line_count; // lines so far; the last is the one being written
static int dirty_from; // the first line changed since it was drawn
static int log_rows; // rows of text the conversation has on screen
static int shown_top = -1; // the line at the top of the screen when last drawn
static Line* line(int i) { return &lines[i % LOG_LINES]; }
static void mark(int i) {
if (i < dirty_from) dirty_from = i;
}
static Line* new_line(uint16_t color) {
Line* l = line(line_count);
l->length = 0;
l->color = color;
mark(line_count++);
return l;
}
// Start writing in color, on a fresh line unless the current one is empty.
static void start(uint16_t color) {
Line* l = line(line_count - 1);
if (l->length) l = new_line(color);
l->color = color;
mark(line_count - 1);
}
// One byte of UTF-8 text: ASCII as is, one '?' per other character. A word that
// would run past the edge moves to the next line.
static void log_byte(int byte) {
if (byte == '\n') {
new_line(line(line_count - 1)->color);
return;
}
if (byte == '\t') byte = ' ';
if ((byte >= 0x80 && byte < 0xC0) || byte < 32 || byte == 127) return; // continuations, controls
if (byte >= 0xC0) byte = '?';
Line* l = line(line_count - 1);
if (l->length == COLUMNS) {
if (byte == ' ') {
new_line(l->color);
return;
}
int space = COLUMNS - 1;
while (space > 0 && l->text[space] != ' ') --space;
Line* next = new_line(l->color);
if (space > 0) {
for (int i = space + 1; i < COLUMNS; ++i) next->text[next->length++] = l->text[i];
l->length = (uint8_t)space;
mark(line_count - 2);
}
l = next;
}
l->text[l->length++] = (char)byte;
mark(line_count - 1);
}
static void log_text(const char* text, uint16_t color) {
start(color);
while (*text) log_byte((uint8_t)*text++);
}
// Draw the lines that changed, or all of them if the conversation scrolled.
static void draw_log(void) {
int top = line_count > log_rows ? line_count - log_rows : 0;
int from = top != shown_top ? top : (dirty_from > top ? dirty_from : top);
for (int i = from; i < top + log_rows; ++i) {
int y = (i - top) * FONT_HEIGHT;
if (i >= line_count) {
fill(0, y, SCREEN_W, FONT_HEIGHT, BACKGROUND);
continue;
}
Line* l = line(i);
for (int c = 0; c < COLUMNS; ++c) draw_char(c * FONT_WIDTH, y, c < l->length ? l->text[c] : ' ', l->color, BACKGROUND);
}
shown_top = top;
dirty_from = line_count;
}
// --- The keyboard --------------------------------------------------------------
// Below the conversation's 8 rows: a rule, 2 rows for the message being typed,
// then 4 rows of 12 keys and a row of wide keys.
#define TYPING_ROWS 8
#define INPUT_Y 82
#define KEYS_Y 104
#define KEY_W 20
#define KEY_H 11
#define INPUT_MAX 200
static const char keys_lower[4][13] = {"1234567890-'", "qwertyuiop?!", "asdfghjkl.,:", "zxcvbnm;()\"/"};
static const char keys_upper[4][13] = {"@#$%&*+=_<>~", "QWERTYUIOP?!", "ASDFGHJKL.,:", "ZXCVBNM;()\"/"};
// The bottom row: first column of each wide key, and one past the last.
static const int wide_starts[5] = {0, 2, 8, 10, 12};
enum { WIDE_SHIFT, WIDE_SPACE, WIDE_DELETE, WIDE_SEND };
static char input[INPUT_MAX + 1] EWRAM;
static int input_length;
static int shift; // 0 off, 1 the next key, 2 caps lock
static int cursor_x, cursor_y;
static int wide_key(int x) {
int k = 0;
while (x >= wide_starts[k + 1]) ++k;
return k;
}
static void draw_key(int x, int y, int w, const char* label, int selected, uint16_t ink) {
int px = x * KEY_W, py = KEYS_Y + y * KEY_H;
uint16_t face = selected ? TITLE : KEY_FACE;
fill(px + 1, py, w * KEY_W - 2, KEY_H - 1, face);
int length = 0;
while (label[length]) ++length;
draw_text(px + (w * KEY_W - length * FONT_WIDTH) / 2, py, label, selected ? BACKGROUND : ink, face);
}
static void draw_one_key(int x, int y) {
if (y < 4) {
char label[2] = {(shift ? keys_upper : keys_lower)[y][x], 0};
draw_key(x, y, 1, label, cursor_y == y && cursor_x == x, MODEL);
return;
}
static const char* const wide_labels[4] = {"shift", "space", "del", "send"};
int k = wide_key(x);
const char* label = k == WIDE_SHIFT && shift == 2 ? "CAPS" : wide_labels[k];
uint16_t ink = k == WIDE_SHIFT && shift ? USER : k == WIDE_SEND ? TITLE : DIM;
draw_key(wide_starts[k], 4, wide_starts[k + 1] - wide_starts[k], label, cursor_y == 4 && k == wide_key(cursor_x), ink);
}
// Drawing is slow enough to miss a quick key press, so after the first time
// only the keys that changed are drawn again: where the cursor was and is, or
// every key when shift changes.
static int drawn_x = -1, drawn_y, drawn_shift;
static void draw_keyboard(void) {
if (drawn_x < 0 || shift != drawn_shift) {
for (int y = 0; y < 4; ++y) {
for (int x = 0; x < 12; ++x) draw_one_key(x, y);
}
for (int k = 0; k < 4; ++k) draw_one_key(wide_starts[k], 4);
} else if (drawn_x != cursor_x || drawn_y != cursor_y) {
draw_one_key(drawn_x, drawn_y);
draw_one_key(cursor_x, cursor_y);
}
drawn_x = cursor_x;
drawn_y = cursor_y;
drawn_shift = shift;
}
// "> " and the message, its last 2 lines' worth if it is longer, and a cursor.
// Only the characters that changed are drawn again.
static uint16_t drawn_input[2 * COLUMNS]; // character | ink << 8; 0 when unknown
static void draw_input(void) {
int total = 2 + input_length + 1;
int skip = total > 2 * COLUMNS ? total - 2 * COLUMNS : 0;
for (int i = 0; i < 2 * COLUMNS; ++i) {
int at = skip + i;
int c = at >= total ? ' ' : at < 2 ? "> "[at] : at - 2 < input_length ? input[at - 2] : '_';
int ink = at == total - 1 ? 1 : at < 2 ? 2 : 3;
uint16_t key = (uint16_t)(c | ink << 8);
if (drawn_input[i] == key) continue;
drawn_input[i] = key;
draw_char(i % COLUMNS * FONT_WIDTH, INPUT_Y + i / COLUMNS * FONT_HEIGHT, c,
ink == 1 ? TITLE : ink == 2 ? DIM : USER, BACKGROUND);
}
}
// Back to typing: the conversation's last 8 rows, the message, the keyboard.
static void typing_screen(void) {
log_rows = TYPING_ROWS;
shown_top = -1;
draw_log();
fill(0, TYPING_ROWS * FONT_HEIGHT, SCREEN_W, SCREEN_H - TYPING_ROWS * FONT_HEIGHT, BACKGROUND);
fill(0, TYPING_ROWS * FONT_HEIGHT + 1, SCREEN_W, 1, RULE);
for (int i = 0; i < 2 * COLUMNS; ++i) drawn_input[i] = 0;
drawn_x = -1;
draw_input();
draw_keyboard();
}
// --- Time ----------------------------------------------------------------------
// Timers 2 and 3 chained: one tick per 1024 cycles, 16,384 per second.
static uint32_t ticks(void) {
uint32_t high, low;
do {
high = REG_TM3CNT_L;
low = REG_TM2CNT_L;
} while (high != REG_TM3CNT_L);
return high << 16 | low;
}
// Timers 0 and 1 chained: every cycle, for profiling.
static uint32_t cycles(void) {
uint32_t high, low;
do {
high = *(volatile uint16_t*)0x04000104;
low = *(volatile uint16_t*)0x04000100;
} while (high != *(volatile uint16_t*)0x04000104);
return high << 16 | low;
}
static void wait_for_vblank(void) {
while (REG_VCOUNT >= SCREEN_H) {}
while (REG_VCOUNT < SCREEN_H) {}
}
// --- Chat ----------------------------------------------------------------------
// While the model works, the bottom row says what it is doing.
#define STATUS_Y (SCREEN_H - FONT_HEIGHT)
static void status(const char* text) {
char row[COLUMNS + 1];
int i = 0;
for (; text[i] && i < COLUMNS; ++i) row[i] = text[i];
for (; i < COLUMNS; ++i) row[i] = ' ';
row[COLUMNS] = 0;
draw_text(0, STATUS_Y, row, DIM, BACKGROUND);
}
static uint32_t reply_start;
static int stopped;
static void on_prompt(int done, int total) {
mailbox.prompt_done = done;
mailbox.prompt_total = total;
if (done == total) {
reply_start = ticks();
status("writing... hold B to stop");
} else {
char text[COLUMNS + 1];
char* at = add(text, "reading ");
at = add_number(at, done);
at = add(at, " of ");
at = add_number(at, total);
add(at, " bytes...");
status(text);
}
}
static void on_byte(int byte) {
if (mailbox.out_length < sizeof mailbox.out) mailbox.out[mailbox.out_length] = (uint8_t)byte;
mailbox.out_length = mailbox.out_length + 1;
if (byte == ' ' && line(line_count - 1)->length == 0) return; // replies start with a space
log_byte(byte);
draw_log();
}
static int stop(void) {
if (!(~REG_KEYINPUT & KEY_B)) return 0;
stopped = 1;
return 1;
}
static void ask(const uint8_t* message, int length, int32_t temperature, uint32_t seed, int max_reply) {
static uint8_t reply[1024] EWRAM;
mailbox.out_length = 0; // first: drawing takes frames, and the runner is watching
mailbox.prompt_done = mailbox.prompt_total = 0;
start(USER);
log_text("you> ", USER);
for (int i = 0; i < length; ++i) log_byte(message[i]);
start(MODEL);
// The whole screen for the conversation, the bottom row for the status.
log_rows = SCREEN_H / FONT_HEIGHT - 1;
shown_top = -1;
draw_log();
status("reading...");
ChatSettings settings = {
.temperature = temperature, .top_k = 40, .max_reply = max_reply,
.rng = seed ? seed : 1, .on_byte = on_byte, .on_prompt = on_prompt, .stop = stop,
};
stopped = 0;
uint32_t begin = ticks();
reply_start = begin;
for (int i = 0; i < PROFILE_PARTS; ++i) profile[i] = 0;
int n = chat_reply(message, length, &settings, reply, sizeof reply);
uint32_t end = ticks();
for (int i = 0; i < PROFILE_PARTS; ++i) mailbox.profile[i] = profile[i];
mailbox.reply_length = n;
mailbox.prompt_ticks = reply_start - begin;
mailbox.reply_ticks = end - reply_start;
char text[64];
char* at = add(text, "[read ");
at = add_number(at, mailbox.prompt_total);
at = add(at, "B in ");
at = add_time(at, mailbox.prompt_ticks);
at = add(at, ", wrote ");
at = add_number(at, n);
at = add(at, "B in ");
at = add_time(at, mailbox.reply_ticks);
add(at, stopped ? ", stopped]" : "]");
log_text(text, DIM);
start(MODEL);
}
static void new_conversation(void) {
chat_reset();
log_text("-- new conversation --", DIM);
start(MODEL);
}
// --- Typing --------------------------------------------------------------------
static void type(int c) {
if (input_length < INPUT_MAX) input[input_length++] = (char)c;
if (shift == 1) shift = 0;
}
static void delete_one(void) {
if (input_length) --input_length;
if (!input_length && !shift) shift = 1; // a new message starts with a capital
}
static void send(void) {
if (!input_length) return;
ask((const uint8_t*)input, input_length, (int32_t)(0.7 * 65536), ticks() | 1, 300);
input_length = 0;
shift = 1;
}
static void move(int keys) {
if (cursor_y == 4) { // the wide keys: one step per key
int k = wide_key(cursor_x);
if (keys & KEY_LEFT) cursor_x = wide_starts[(k + 3) % 4];
if (keys & KEY_RIGHT) cursor_x = wide_starts[(k + 1) % 4];
} else {
if (keys & KEY_LEFT) cursor_x = (cursor_x + 11) % 12;
if (keys & KEY_RIGHT) cursor_x = (cursor_x + 1) % 12;
}
if (keys & KEY_UP) cursor_y = (cursor_y + 4) % 5;
if (keys & KEY_DOWN) cursor_y = (cursor_y + 1) % 5;
}
static void press(void) {
if (cursor_y < 4) {
type((shift ? keys_upper : keys_lower)[cursor_y][cursor_x]);
return;
}
switch (wide_key(cursor_x)) {
case WIDE_SHIFT: shift = (shift + 1) % 3; break;
case WIDE_SPACE: type(' '); break;
case WIDE_DELETE: delete_one(); break;
case WIDE_SEND: send(); break;
}
}
int main(void) {
REG_WAITCNT = 0x4317; // faster ROM wait states (3/1) and the prefetch buffer
REG_DISPCNT = 0x0403; // mode 3: a 240 x 160 bitmap, 15-bit color
REG_TM2CNT_H = 0;
REG_TM3CNT_H = 0;
REG_TM2CNT_L = 0;
REG_TM3CNT_L = 0;
REG_TM3CNT_H = 0x0084; // counts timer 2's overflows
REG_TM2CNT_H = 0x0083; // one tick per 1024 cycles
*(volatile uint16_t*)0x04000106 = 0x0084; // timer 1 counts timer 0's overflows
*(volatile uint16_t*)0x04000102 = 0x0080; // timer 0: every cycle
profile_clock = cycles;
line_count = 0;
dirty_from = 0;
new_line(TITLE);
log_text("ChatGBA: 4M parameters 512 context", TITLE);
int status_code = engine_init(model_blob);
mailbox.status = status_code;
if (status_code) {
log_text("the weights do not match the engine", TITLE);
typing_screen();
for (;;) {}
}
log_text("A type B delete START send", DIM);
log_text("R shift L sample question", DIM);
log_text("SELECT new conversation", DIM);
start(MODEL);
input_length = 0;
shift = 1;
cursor_x = cursor_y = 0;
typing_screen();
mailbox.magic = MAILBOX_MAGIC;
unsigned next_question = 0;
uint16_t last_keys = 0;
int held = 0;
for (;;) {
wait_for_vblank();
if (mailbox.request != mailbox.done) {
if (mailbox.command == 2) new_conversation();
else ask(mailbox.message, (int)mailbox.length, mailbox.temperature, mailbox.seed, (int)mailbox.max_reply);
mailbox.done = mailbox.request;
typing_screen();
continue;
}
uint16_t keys = (uint16_t)~REG_KEYINPUT & 0x3FF; // pressed keys read as 0
uint16_t pressed = keys & ~last_keys;
// Held keys repeat after 18 frames, then every 4.
if ((keys & KEY_REPEATS) && (keys & KEY_REPEATS) == (last_keys & KEY_REPEATS)) {
if (++held >= 18 && (held - 18) % 4 == 0) pressed |= keys & KEY_REPEATS;
} else {
held = 0;
}
last_keys = keys;
if (!pressed) continue;
if (pressed & (KEY_LEFT | KEY_RIGHT | KEY_UP | KEY_DOWN)) move(pressed);
if (pressed & KEY_A) press();
if (pressed & KEY_B) delete_one();
if (pressed & KEY_R) shift = (shift + 1) % 3;
if (pressed & KEY_L) {
const char* q = questions[next_question++ % (sizeof questions / sizeof questions[0])];
for (input_length = 0; q[input_length]; ++input_length) input[input_length] = q[input_length];
shift = 0;
}
if (pressed & KEY_SELECT) new_conversation();
if (pressed & KEY_START) send();
if (log_rows != TYPING_ROWS) { // a reply just finished
typing_screen();
} else {
draw_log();
draw_input();
draw_keyboard();
}
}
}
|