I decided to try using Golang on the PSP and explored several approaches, including porting Clang, using TinyGo, and compiling Golang to JavaScript with GopherJS. Then, I came across a user named aethiopicuschan on the PSP homebrew Discord, who was attempting the same goal using WebAssembly. His example worked on PPSSPP but not on actual hardware.

Anyways, I had to put my project on hold due to upcoming exams. But, a few months later, I found an article where aethiopicuschan successfully compiled Golang to WASM and ran it on the PSP using a WASM interpreter.
His approach used a Wasm interpreter called Wasm3 to run the code, but I knew I could do better. I knew about projects like Wasm2C which convert your Wasm binaries to C.
Excited, I dove deeper into the topic and discovered an article about compiling WebAssembly to portable C code. They used a compiler called w2c2, which I guess is the sequel.

After hours of tinkering with CMake, I managed to create a working example using TinyGo and targeting WASI. I also wrapped a raylib function, InitWindow (the psp has a raylib port by the way), with the goal of porting raylib-go bindings to this WASM-to-C platform. The example successfully binds the C InitWindow function to the compiled WASM code.

As you can see, it looks like any other golang code

package main

import "time"

import rl "github.com/gen2brain/raylib-go/raylib"

func main() {

    rl.InitWindow(480, 272, "Psp test")
    for {
        time.Sleep(time.Millisecond * 16)
    }
}

but in the rl package, we are importing a C function, we give it a function signature as well. Keep it in mind.

package rl

//go:wasmimport rl InitWindow
func c_InitWindow(width int32, height int32, title string)

// InitWindow - Initialize Window and OpenGL Graphics

func InitWindow(width int32, height int32, title string) {
    c_InitWindow(width, height, title)
}

lets break this code down step by step.

#define __GLIBC_USE

#include <raylib.h>
#include <stdio.h>
#include <time.h>

#include <pspkernel.h>
PSP_MODULE_INFO("WasiExample", 0, 1, 0);
PSP_MAIN_THREAD_ATTR(THREAD_ATTR_USER);
#include "pspdebug.h"
#define printf pspDebugScreenPrintf

first we import psp libraries, and setup the boiler plate, we also import the raylib port

here we are importing the compiled module app.h
we also import the wasi "runtime" which is provided by w2c2

// // the compiled wasm -> C code
#include "app.h"
// // wasi runtime
#include "w2c2_base.h"
#include "wasi.h"

extern wasmMemory* e_memory;  // the WASM memory.
void trap(Trap trap)
{
  fprintf(stderr, "TRAP: %s\n", trapDescription(trap));
  abort();
}

wasmMemory* wasiMemory(void* instance)
{
  return app_memory((appInstance*)instance);
}
extern char** environ;

The trap function is boiler plate,
the wasiMemory function is a helper function I made for another helper function

char* getCStringFromMemory(void* memoryptr, U32 offset, U32 length)
{
  wasmMemory* memory = wasiMemory(memoryptr);
  char* str = (char*)(memory->data + offset);
  char* result = (char*)malloc(
    length + 1);  // Allocate space for the string + null terminator
  if (result == NULL) {
    fprintf(stderr, "Memory allocation failed\n");
    return NULL;
  }

  // Copy the string from WASI memory to local memory
  for (U32 i = 0; i < length; ++i) {
    result[i] = str[i];
  }
  result[length] = '\0';  // Null-terminate the string

  return result;
}

all this function does is it takes the memory pointer for a string memory pointer (in wasm we handle strings by passing a memory offset, and the string's length), and returns a C string using the offset and length

this is the C function we call from our golang code, I had to define it myself.

void rl__InitWindow(
  void* memoryptr, U32 width, U32 height, U32 offset, U32 length)
{
  char* title = getCStringFromMemory(memoryptr, offset, length);
  InitWindow(width, height, title);
  bool ready = IsWindowReady();
  if (ready) {
    // this will print to the psp screen.
    printf("Window was created");
  }
}

we are reading the args passed by the transpiled wasm, and passing them on to raylib.

this is some more boilerplate, all we're doing is running the main function of the golang code, which is exported as app_start()

int main(int argc, char* argv[])
{
  pspDebugScreenInit();
  appInstance i;
  appInstantiate(&i, NULL);
  if (!wasiInit(argc, argv, environ)) {
    fprintf(stderr, "failed to initialize WASI\n");
    return 1;
  }

  app__start(&i);
  appFreeInstance(&i);
  return 0;
}

it works!

This is a screenshot of a psp 🚨emulator🚨.
but it also works on original hardware.

Leave any questions in the comment section!