Amiga game development gets a modern boost with BASSM 0.9.0

There is a moment every retro developer knows well. The idea is fresh, the enthusiasm is high, and the imagined game already feels alive: a sprite moving across a tiled background, a status panel at the top of the screen, maybe a chunky title font and a burst of Paula sound. Then the practical work begins. Assemblers, linkers, asset converters, emulator setup, memory limits, disk images and all the other small hurdles of classic development start to pile up. That is the space BASSM 0.9.0 steps into. BASSM is a new Windows-based development environment for creating Amiga software using a BASIC-style language inspired by Blitz2D. It is designed to give developers a more immediate way into Amiga programming while still producing native Motorola 68000 output. The code written in the IDE is translated into 68000 assembly and then built with vasm and vlink into an AmigaOS executable. The result is a tool that feels deliberately modern on the surface, but still deeply aware of the machine it targets. It does not try to hide the Amiga’s personality. Instead, it gives developers a cleaner way to work with it.

A friendlier front end for a demanding machine

The appeal of BASSM is not simply that it offers BASIC for the Amiga. The more interesting part is the workflow. The IDE brings together the editor, compiler, assembler, linker, emulator and asset tools into one environment. Graphics, tile maps, sounds and fonts can be prepared inside the same application, rather than being scattered across a chain of separate utilities. That matters because Amiga development has always been about more than writing code. A good game depends on how graphics are stored, how palettes are managed, how memory is used, how screens are arranged and how efficiently data reaches the hardware. BASSM appears to understand that. Its support for interleaved bitplanes, tile maps, palettes, collision data, slopes, animation and fonts suggests a tool built with actual Amiga production habits in mind.

The basic loop is pleasingly direct. Write code, press Run, and the project is compiled and launched through the integrated vAmiga emulator using a free AROS ROM for testing. For newcomers, that removes a large amount of setup friction. For experienced developers, it offers a faster way to prototype ideas before moving deeper into optimisation.

The most important feature may be the least glamorous

One of BASSM’s strongest ideas is its real-time resource monitor. As the developer works, the IDE estimates CPU cycle use and chip RAM consumption per frame, comparing the project against the limits of a standard Amiga 500 with 512 KB of chip RAM. That may not sound flashy, but it could be one of the tool’s defining features. Classic hardware is unforgiving. A game can look modest on paper and still run into trouble once sprites, maps, buffers, sounds and display data start competing for limited memory and processing time. Usually, those problems become obvious late in development, when they are already expensive to fix.

BASSM tries to bring that pressure into view earlier. It gives the developer a sense of whether the project is still living within the machine’s real limits. That is not just convenient. It is educational. It teaches the rhythm of the Amiga as you work.

Built around the things Amiga games actually need

BASSM’s integrated asset tools are another major part of its appeal. The environment includes editors for graphics, tilesets, tile maps, slopes, animations, collisions, sounds and fonts. These resources are then compiled directly into the final executable. That approach keeps the current workflow simple. Everything the game needs is built into the program, which makes testing and disk creation straightforward. It also suits smaller arcade-style projects, demos, prototypes and early experiments where the priority is getting something playable on screen quickly.

The viewport system is especially interesting. BASSM can split the screen vertically into separate areas, each with its own palette and copper list. That is a very Amiga-like feature. It allows a game to have a playfield, a panel, a title area or other screen sections with different visual settings. Used well, it can create exactly the kind of colourful, hardware-aware presentation that made the Amiga feel special in the first place.

From idea to bootable disk

BASSM also includes ADF export, allowing a developer to create a bootable Amiga disk image directly from the IDE. That gives the workflow a satisfying final step. The project is not merely compiled as a loose executable. It can become a disk image that boots on real hardware or in an emulator. For a modern developer, that is practical. For an Amiga enthusiast, it is also emotional. There is still something special about software that boots like it belongs to the machine.

Promising, but still early

BASSM 0.9.0 is an Early Access release, and that matters. It is already useful, but it is not yet a complete answer to every Amiga development problem. At the moment, assets cannot be loaded from floppy or hard drive at runtime. Graphics, maps, sounds and other resources are compiled into the executable. That keeps the workflow clean, but it limits the scale of what developers can comfortably build. Hardware scrolling is also not yet implemented. Tile maps are currently redrawn every VBlank, which may be acceptable for some projects, but it is not the final solution for smooth and efficient Amiga scrolling. For many game makers, proper hardware scrolling will be one of the features that determines how far BASSM can go beyond small projects and prototypes.

The roadmap is encouraging. Planned additions include runtime asset loading, hardware scrolling through an optimised ring buffer, ProTracker MOD playback through Paula and variable-size font support. Those features would push BASSM much closer to being a serious all-in-one environment for classic Amiga game development.

A new on-ramp for an old machine

The Amiga scene has no shortage of knowledge, passion or technical skill. What it often lacks is a gentle starting point. BASSM could become exactly that. It gives newcomers a way to begin without immediately facing the full complexity of 68000 assembly and traditional Amiga toolchains. It also gives experienced developers a fast environment for sketching out ideas, testing mechanics and building compact projects. The included examples and project cloning from the welcome screen help reinforce that sense of accessibility. What makes BASSM interesting is that it does not feel like a toy version of Amiga development. It still talks in the language of chip RAM, CPU cycles, bitplanes, copper lists, viewports and bootable disks. It simply presents those ideas through a friendlier, more integrated interface.

Verdict

BASSM 0.9.0 feels like the start of something genuinely useful. It is not finished, and its current limitations are important, especially around runtime asset loading and hardware scrolling. But even now, it has a clear identity. It is a modern development environment that respects the old machine instead of smoothing away everything that makes it interesting. It lowers the barrier to entry while still keeping the Amiga’s constraints visible. That balance is difficult to get right, and BASSM appears to be aiming in the right direction. If the planned features arrive and the tool continues to mature, BASSM could become one of the most approachable ways to create real Amiga software today. Not just a nostalgic experiment, but a practical bridge between modern development habits and one of the most characterful home computers ever made.

Spread the love