ORBIS BASIC 32X / ORBIS BUILDER

ORBIS BASIC 32X is a retro-future development toolkit for creating real bootable Sega 32X / Mega 32X ROMs, native desktop builds, and retro-style game projects.

It started as a BASIC compiler. It still is one. You can write approachable BASIC code, compile it, and produce a playable .32x ROM.

But with the newer Builder Edition, the idea has grown.

Orbis Basic is no longer only BASIC as a programming language. It is also “basic” as in the essential tools for making retro games.

That means BASIC, C, real string support, automatic asset integration, desktop builds, GPU-accelerated desktop presentation, 32X ROM building, and the Orbis Pixel Pipeline all working together as one creative workflow.

From BASIC Language to Basic Game-Making Tools

The original idea remains simple:

Write code. Build a real Sega 32X ROM.

The new Builder workflow expands that idea:

Write in BASIC. Build in C. Prepare pixels. Build ROMs. Build desktop apps.

BASIC is still the fastest way to start. It gives you simple commands for graphics, sprites, audio, input, text, data, and game logic.

But Orbis Builder also gives developers a stronger C workflow. The package includes generated Orbis C examples and real string support, making C much more practical for menus, text handling, file paths, tools, UI logic, save/load helpers, generated code, and larger desktop-oriented projects.

So you can choose your level:

Write games in BASIC.
Write games in C.
Use both workflows inside the Orbis ecosystem.
Build for Sega 32X.
Build for desktop.
Prepare assets with the Pixel Pipeline.

That is the new meaning of Orbis Basic: the BASIC language, and the basic tools for building retro games.

Real Sega 32X ROMs and Native Desktop Builds

Unlike a traditional runtime, fantasy console, emulator scripting layer, or generic game engine, ORBIS BASIC 32X generates real 32X ROMs around a custom SH-2 runtime and a direct-color framebuffer graphics model.

It produces bootable .32x ROMs that can run in compatible emulators, on suitable handheld setups using PicoDrive, and in appropriate flash-cartridge or homebrew workflows.

A project made with ORBIS BASIC 32X is not only something that runs on a PC. It can become a real Sega 32X ROM that can be shared with emulator users, tested on suitable hardware, published as homebrew, or prepared for possible physical cartridge production.

The desktop target is a companion workflow. It makes testing, iteration, experiments, and presentation much faster on modern systems while keeping the Sega 32X ROM target as the soul of the project.

GPU-Accelerated Desktop Presentation

The desktop version is now a much stronger part of the workflow.

Native desktop builds use GPU-accelerated OpenGL presentation. The game still draws into an Orbis-style RGB555 framebuffer, so the retro pixel model stays intact, but the window presentation and scaling are handled through a GPU-backed path.

This makes desktop builds smoother and more comfortable while preserving the same retro-style framebuffer thinking used by the 32X target.

Desktop builds can also use larger logical screen modes with SCREEN(width,height), including common desktop resolutions such as 1280x720 and 1920x1080.

This is useful for desktop tools, menus, visual experiments, large images, high-resolution previews, mouse-driven projects, and native app versions of Orbis projects.

BASIC for Games, Demos and Visual Experiments

ORBIS BASIC 32X supports a practical BASIC-style command set for building visual and interactive projects, including:

TYPE and SUB support
CALL structure
drawing commands
image drawing
scaled drawing
sprites
scrolling commands
alpha blending
multi-level parallax
audio commands
mouse input
controller input
DATA handling
SAVE and LOAD support
automatic asset baking
desktop builds
GUI and world helpers

The project is built for creators who want to make original Sega 32X software with the immediacy of BASIC, the visual identity of retro hardware, and the freedom of a modern portable toolchain.

Orbis C with Real String Support

Orbis Builder also includes a stronger C path.

This is important because not every project needs to stay purely in .bas form. Some creators may want to use BASIC for fast prototyping and C for larger systems, desktop tools, generated examples, or more structured projects.

The included Orbis C workflow gives that path a real foundation.

Real string support as language extension makes the C side much more useful.

It enables practical text handling for menus, messages, names, file paths, UI logic, generated content, save/load helpers, and tool-like desktop projects.

This turns Orbis Builder into more than a BASIC compiler. It becomes a small retro development environment where BASIC and C both have a place.

BASIC for immediacy.
C for control.
Strings for real tools and real game structure.
ROM output for the 32X.
Desktop output for modern systems.

Automatic Asset Integration

One of the defining features of ORBIS BASIC 32X is immediate asset integration.

Images and audio can be baked into the ROM during compilation. The compiler automatically converts, integrates, and prepares assets as part of the build process, removing the need for a large external toolchain or complicated manual conversion steps.

Write BASIC code, reference your assets, compile, and the compiler prepares the ROM for you.

For larger Full Edition projects, the newer 32 MB ROM workflow allows much larger image-heavy projects. Mapper-backed image data can be stored in ROM banks and accessed by the runtime when needed.

This is useful for large backgrounds, panoramas, scrolling scenes, visual novels, image-heavy demos, animated intros, and bigger game worlds.

Dynamic Desktop Assets

Desktop builds can also use dynamic runtime assets.

DYNIMAGE(path$)
DYNAUDIO(path$)
FREEIMAGE handle
FREEAUDIO handle

These commands are desktop-only. They are designed for cases where a native desktop build should load images or audio from disk instead of embedding everything into the executable.

This is useful for large 1080p images, external music, galleries, mod folders, menu assets, animation tests, and desktop-first tools.

The classic portable commands keep their original role:

LOADIMAGE
LOADSOUND

Those remain the static compile-time asset path for shared Sega 32X and desktop projects.

Orbis Pixel Pipeline Companion Tool

Orbis Pixel Pipeline is the advanced standalone evolution of the original Orbis Scaler companion tool.

It is designed for preparing artwork, rendered images, screenshots, AI-generated images, concept art, scanned artwork, and other source graphics for retro-style game development workflows.

It can downscale images to fixed or custom resolutions, apply adjustable pixelation, limit colours with k-means, map output to external GPL palettes, process complete folders in batch mode, and upscale previews with nearest-neighbor scaling.

For ORBIS BASIC 32X projects, Orbis Pixel Pipeline can be used to prepare cleaner low-resolution image material, references, backgrounds, sprites, and pixel-art-style base images before further editing, palette work, or integration into a Sega 32X project.

This is another part of the Builder idea: Orbis is not only about code. It is also about preparing the pixels that the code will use.

Mouse Support

Recent builds include shared mouse support for Sega 32X and desktop targets.

The mouse commands make it possible to build mouse-driven programs using a Sega/Mega Mouse or compatible setup, while keeping the same source code usable in the desktop build.

MOUSEINIT("mousepointer.png", port[, protocol])
MOUSEUPDATE
MOUSEX()
MOUSEY()
MOUSEBUTTON()

On 32X, the port argument selects controller port 1 or 2. On desktop, the same commands map to the host window mouse.

This makes ORBIS BASIC 32X useful not only for games, but also for menus, editors, visual tools, GUI experiments, and desktop companion projects.

Portable and Self-Contained

The compiler and companion tools are intentionally minimal, portable, and self-contained.

The release package is designed around bundled executables and included documentation. Users can work from the release folder without needing a source-tree build system.

The goal is to keep the workflow direct:

Write source.
Run the bundled compiler.
Build ROMs or desktop apps.
Test and iterate.

Free Edition vs Full Edition

ORBIS BASIC 32X is available in Free Edition and Full Edition.

The Free Edition is intended for trying the compiler, learning the workflow, and building smaller Sega 32X projects. It can produce real bootable Sega 32X ROMs up to 512 KB.

The Full Edition is intended for larger projects, asset-heavy demos, desktop workflows, and creators who want the complete ORBIS BASIC 32X / Orbis Builder experience.

The Full Edition can produce Sega 32X ROMs up to 32 MB and includes the larger desktop build workflow for creating native desktop versions of compatible projects.

Both editions use the same core idea:

Write code, integrate assets automatically, and build real Sega 32X ROMs.

Download Options

The free download includes the Free Edition of ORBIS BASIC 32X.

The full bundle includes the Full Edition of ORBIS BASIC 32X with the complete ROM size limit and desktop build workflow.

Orbis Pixel Pipeline is available separately as an advanced companion tool for pixel-art-style asset preparation and batch image processing.

What This Page Contains

This page contains ORBIS BASIC 32X builds, Orbis Builder updates, demos, documentation, examples, and ongoing development progress.

You can use it for arcade games, platformers, puzzle games, visual novels, scrolling scenes, sprite tests, audio demos, mouse experiments, desktop tools, generated C projects, pixel-art workflows, and Sega 32X homebrew.

Simple. Powerful. Retro. Future.

Write in BASIC. Build in C. Prepare the pixels. Build the ROM. Build the app.

From BASIC to metal.

W = LOADWORLD("world.png", "world_colormap.png") 
SHOWWORLD W, XW, YW 
HIT = CALLWORLD(W, X, Y, XW, YW) 
ADDSPRITE W, SPRITEID, COLORCODE 

GUI = LOADGUI("menu.png", "menu_colormap.png") 
SHOWGUI(GUI) 
HIT = CALLGUI(GUI, X, Y) 

MOUSEINIT("mousepointer.png", port[, protocol]) 
MOUSEUPDATE 
MOUSEX() 
MOUSEY() 
MOUSEDX() 
MOUSEDY() 
MOUSEBUTTON() 

SUB DrawHud
   LOCATE 1,1
   PRINT "HUD"
END SUB  
CALL DrawHud 

IF condition THEN CALL Name 
ON expr CALL Name1, Name2, Name3 

TYPE Actor
     X AS INTEGER
     Y AS INTEGER
     SPEED AS INTEGER
END TYPE 
 
DIM Player AS Actor 
DIM Enemy(8) AS Actor
  
Player.X = 100 
Enemy(I).Y = Enemy(I).Y + Enemy(I).SPEED 

chmod +x ob32x_free.exe 
./ob32x_free.exe examples/hello.bas