Prelude

When we first ported GameForge to Amiga, people loved the deep-dive into Amiblitz internals. So we approached Oscar64 the same way: crack it open, poke around its libraries, and figure out how to fuse it with our visual scripting dreams.

Spoiler: Oscar64 is a treasure chest.

1. First Contact: “Where does Oscar64 live?”

• The Windows bundle drops oscar64.exe plus a tidy include/, lib/, and bin/.
• No PATH entries, no registry hooks—it’s intentionally self-contained.
• We confirmed it runs fine from arbitrary folders, which means GameForge can either discover it via common paths (C:\Oscar64\, C:\Programs\Oscar64\) or let users browse to it.
• The lack of global install actually simplifies portable builds: we can ask for one directory and we’re done.

2. CLI Behavior: Friendly to Automation

• Command format is clean: oscar64 source.c -o output.prg.
• Returns non-zero on errors (bless). STDOUT for warnings, STDERR for actual failures.
• Adding -I for include directories is exactly how you’d expect.
• There’s a --vice mode that auto-launches VICE after compile, but it hardcodes default VICE paths. We’ll bypass that and launch VICE ourselves so users can pick any emulator.

3. Library Archaeology 🪙

The most fun part: digging through include/ and lib/.

3.1 Graphics & Sprites

• include/vic/sprites.h exposes friendly macros for sprite pointers, colors, multicolor mode, even double-height toggles.
• There’s a lib/vic/sprite.lib that abstracts DMA list setup. Perfect for our node-based “sprite multiplexer” settings.
• Found helpers for character mode, bitmap mode, and vic.h constants. This means our visual nodes can map directly to real register writes.

3.2 Sound & SID Glue

• include/sid/sid.h and friends wrap register pokes with inline functions (sid_voice, sid_adsr, etc.).
• There’s sample code showing how to load instrument tables. We can auto-generate these from node data.
• Oscar64’s runtime even has a music IRQ helper, so we don’t have to reinvent timer installs.

3.3 Runtime & Tooling

• lib/runtime.lib bundles keyboard scanning, joystick helpers, timer interrupts, and memory copy routines.
• Since Oscar64 is LLVM-based, it emits optimized code that still links against these libs seamlessly.
• There’s documentation for mixing C with inline assembly, so advanced users could extend whatever GameForge generates.

In short: we’re not just compiling C—we’re piggybacking on a full-featured C64 SDK.

4. Prototyping Detection & UX

• Electron preload calls oscar64 --version. If it resolves quickly, we set the compiler status to ✅.
• When running in dev mode (no Electron), we fake “found” states so we can still test UI.
• Future step: store user-edited paths so build/test buttons know where to find oscar64.exe and x64sc.exe.

5. Lessons Learned (and Excitement!)

1. Oscar64’s includes are gold. Instead of writing low-level register code, our visual nodes can emit higher-level API calls (e.g., sprite_set_pos(0, x, y)).
2. Libraries unlock presets. We can ship GameForge presets for “Scroll Map,” “Sprite Multiplexer,” “SID Instrument,” each backed by Oscar64 helper functions.
3. Compile→VICE loop is totally doable. Build times are sub-second for small projects. Once we store the path to VICE, clicking “Run” can spawn the emulator automatically.
4. Publishing findings sparks community attention. The Amiblitz post caught X’s eye; this Oscar64 library breakdown will likely have the same effect—so we’re documenting everything in public devlogs.

6. Next Steps

• Wire the visual nodes to Oscar64’s headers (sprites, SID voices, IRQ timers).
• Finalize the compile pipeline: write generated C to temp folder → call oscar64 with proper -I and libs → stream output to the UI.
• Add a settings modal so users can browse to Oscar64/VICE paths.
• Keep sharing these discoveries—our early research devlogs are already pulling in pro-level attention.

📝 TL;DR: Oscar64 isn’t just a compiler; it’s a complete C64 runtime. We’re mapping our visual scripting graph directly onto its libraries, so future GameForge users can drag nodes and get legit, optimized C code that builds cleanly. That’s the kind of geeky excitement that made the Amiga research pop, and it’s happening again right here.