With 512 KB of RAM and a single floppy disk, Wolf500 brings Wolfenstein 3D’s corridors to the Amiga 500. The conversion reopens a decades-long debate and invites a fresh look at the machine’s limits in light of what software can achieve today.
For years, those corridors were part of the distance between the PC and the Amiga. Textured walls, doors to open, guards advancing as the player backed away. Wolfenstein 3D had made a new kind of first-person action instantly recognisable. Seeing that experience adapted to the Amiga 500 in its original configuration brings back a question long suspended between technical difficulties, memories and received wisdom. How much of what we considered impossible was actually down to the machine?
Wolf500 and the minimum configuration
Serpentchain’s Wolf500, released on 12 November 2026, requires an OCS Amiga 500, 512 KB of RAM and Kickstart 1.3. It adapts the shareware episode Escape from Wolfenstein, supports PAL and NTSC, and runs from an 880 KB floppy. One megabyte is optional.
From the Commodore 64 to the Amiga question
Following this release brought me back to an idea that emerged during my work on 3Dvibe64, the project covered on Retromind. With AI assistance, I explored a polygonal engine for the Commodore 64 architecture, extending it to Gouraud shading and textures. Its more demanding modes find the processing power they need primarily in accelerated machines, including the C64 Ultimate. The VIC-II still defines the graphics constraints, while the CPU has far more computing capacity than the original machine.
Along the way, I also explored raycasting through a textured prototype and a subsequent 2.5D pipeline. Here, the objective changes. Instead of freely transforming meshes in space, the engine builds a perspective view from a map and a precise set of geometric rules. Wolfenstein 3D belongs to the same family of approaches. The implementations remain different, as do their visual detail and the amount of work needed to produce each image.
These experiments prompted my question about the Amiga. If a stock C=64 can produce a first-person environment through raycasting, and the community can achieve playable results with a processor running at roughly one megahertz, a 68000 at around seven megahertz should offer some interesting possibilities. The architectural step forward, the available memory and the dedicated hardware suggested room for a good game with textured walls. Wolfenstein seemed a particularly credible target, with a much more tightly defined set of demands than those introduced by Doom.
Frame rates and renderer versions
Experiences such as Grey show how much raycasting can achieve even on an original C=64. Jammer64 reported a nominal speed of sixteen frames per second, with performance naturally depending on the scene, visual detail and game features. For my thinking about the Amiga, the key point was that a machine running at around one megahertz could already make a first-person environment explorable.
My raycasting experiments in 3Dvibe64 also helped me explore that balance, trying different ways of building and drawing environments. Changing the detail of the walls or the way the view is organised can have a substantial effect on speed. More than any individual figure, I wanted to understand which solutions could make a space convincing and enjoyable to move through.

The wider picture even includes Kweepa’s Wolf64, a playable adaptation of Wolfenstein itself for the C=64. In his technical account, the developer describes a 38 × 40-pixel view, reduced textures adapted to the palette, specialised routines and a selection of content designed to fit the machine’s limits. It is a valuable reference precisely because it makes the trade-offs visible. The extremely low resolution reduces the rendering workload and profoundly changes the image, while preserving enough information for players to recognise their surroundings and play the game.
An empty corridor and a populated level impose different workloads. Finding the walls is joined by the work of handling enemies, collisions, animation and game logic. The time needed to draw a view also changes with the camera’s position and whatever enters the frame. The C=64 experience therefore suggested a concrete possibility worth exploring on the Amiga. Demonstrating the quality of a conversion still required a program that could bring all those functions together, with consistent choices suited to the target hardware.
Raycasting: perspective and constraints
The term “fake 3D” helps place Wolfenstein in context, provided its meaning is clear. The engine produces perspective calculated in real time. Its underlying world is a two-dimensional grid, with vertical walls and very strict constraints on heights and orientations. For each direction sampled across the view, the program traverses the map until it encounters a wall. The distance determines how tall that wall should appear on screen; the point of impact determines which part of the texture to draw. Enemy images are then scaled and placed in the scene with obstacles taken into account.
This organisation avoids much of the work required by an unrestricted polygonal scene. Knowing that a wall is vertical and that the world follows a grid allows highly specialised routines to be prepared. “Fake” therefore describes the constraints placed on the construction of the space. The perceived depth comes from actual perspective calculations, and navigation remains interactive. The term “raycasting” also deserves precision, since in other contexts it can refer to techniques applied to fully three-dimensional geometry. Here, we are discussing the specific 2.5D model used by those early textured corridors.
In 1992, Wolfenstein 3D played a decisive role in popularising this experience on the PC. Three-dimensional graphics and first-person games already had a history; the success of id Software’s title accelerated the spread of an immediately accessible formula built around continuous movement, recognisable environments and combat. To understand its appeal, consider how little the player needed to know about the engine. A door looked like a door, a distant guard grew larger as he approached, and a corner concealed whatever lay beyond it. The geometric restrictions faded into the background during the action.
The 68000 and the cost of bitplanes
This mechanism made my reasoning about the 68000 plausible, without justifying simple multiplications between clock speeds. The Amiga’s processor belongs to a 16/32-bit architecture, with a 16-bit data bus and 32-bit registers. Comparing it with the 6510 requires consideration of instructions, memory access and data organisation. Seven megahertz versus one describes two frequencies; a renderer’s speed depends on the complete program. What matters most is the cost of the operations repeated for each column and each frame, together with the work needed to transfer the image to the video system.
This is where the bitplane issue arises. In the Amiga’s standard planar modes, the bits that form a pixel’s colour index reside in separate planes. Five bitplanes allow five bits to be combined to select one of thirty-two colours. In a chunky image, the information for each pixel is stored together, for example in a single byte. Writing a column of colours sampled from a texture suits that arrangement well. On a planar display, those bits have to be distributed into the form expected by the chipset.
The distinction concerns the graphics system, so the relevant comparison is between the Amiga and VGA. MS-DOS is the operating system. Wolfenstein also used a modified VGA mode, often called Mode Y, with chain-4 addressing disabled. There are four planes here too, each containing complete pixels interleaved with those in the other planes. Each individual pixel’s colour still occupies a byte. This arrangement therefore differs from the Amiga’s bitplanes, which separate the bits that make up that colour. Describing the original PC version as using a simple linear framebuffer would lose this distinction.
Chunky-to-planar conversion adds work. One solution is to generate an intermediate image first and then rearrange its bits; other strategies prepare data and routines to work more directly towards the output format. It is also possible to reduce the number of calculated samples, limit the colours or take advantage of repetitions in the image. The cost of bitplanes is real and influences the whole project. Its extent, however, depends on how much is drawn and the path chosen to draw it. A conversion difficulty, considered in isolation, would be insufficient grounds for declaring a game absolutely impossible.
Blitter, Copper and rendering choices
The coprocessors should likewise be assessed in terms of the operations they can perform. The Blitter accelerates copying and combining blocks of memory, as well as drawing lines and carrying out certain fill operations. The Copper changes chipset registers in synchronisation with the video scan. A programmer can use these capabilities to organise the display and reduce particular parts of the workload. Selecting texels, calculating distances and scaling in perspective still require suitable algorithms. The CPU and custom chips also share memory access, so their cooperation must be designed around the available bandwidth.
The Wolf500 devlog provides concrete evidence of this attention to detail. The 0.91b update, released on 14 November, introduces additional dithering options and a thirty-one-colour mode for expanded machines, accompanied by a small speed reduction acknowledged by the developer. It also documents an optimisation to the game view’s Copper list loop. These details help explain the result as a balance between quality and rendering cost. The documentation consulted still leaves some implementation details and comprehensive numerical measurements open; a precise internal resolution or a relationship with other engines would require further confirmation.

Earlier Amiga conversions
The historical account requires the same care. Wolfenstein 3D had already received Amiga conversions. NovaCoder’s OCS/ECS version of AmiWolf required a fast 68020 and eight megabytes of Fast RAM. BSzili’s Wolf4Amiga targeted AGA Amigas with a 68020 running at fourteen megahertz, recommending additional Fast RAM. These precedents make Wolf500’s achievement clearer. It lowers the threshold to the A500’s standard 68000 and minimum memory configuration, entering a very different class of machines from accelerated Amigas.
What Carmack and Romero actually said
As for the statements attributed to id Software, the most frequently cited historical trail leads to Doom. On 4 September 1994, George Sanderson posted to Usenet an email attributed to John Carmack and dated the previous day. Carmack considered the Amiga insufficient for Doom, referring to the processing power of the 68040 and the burden of bitplane conversion. This was a reply reproduced by its recipient at the time, with the subject “amiga doom”. The primary sources examined contain no equivalent statement specifically declaring Wolfenstein 3D impossible on the Amiga 500.
There is also direct testimony from John Romero, interviewed by David Craddock in 2020. Recalling the surprise caused by Doom on the Super Nintendo, Romero compared the Amiga with hardware poorly suited to the three-dimensional games of that period. The context conveys real scepticism, shared by leading figures at id Software. It remains a retrospective recollection, expressed during a conversation about Doom ports. Turning it into a 1992 declaration against Wolfenstein on the A500 would change the substance of the testimony. That distinction matters more than the satisfaction of claiming a spectacular rebuttal.
Wolfenstein, Doom and the context of 1992
Doom did require a different comparison. Its sector-based geometry allowed walls at more varied angles, floors and ceilings at different heights, textured horizontal surfaces and variable lighting. That engine also retains a structure commonly described as 2.5D, with precise limitations, while visibility processing and drawing become more involved than in Wolfenstein’s grid. This is why I consider Wolfenstein a sensible target for the original Amiga configuration. That observation leaves open the possibilities of any present or future adaptation of Doom.
There is another distinction to make. Demonstrating today that a conversion is technically feasible leaves open the question of how a commercial production would have turned out in 1992. A team would have needed to establish an acceptable level of quality, finish the game to a deadline and cover the project’s cost. It would also have had to develop the necessary tools with the knowledge and time available then. Hardware capabilities and the conditions of a production are separate matters. Wolf500 clarifies the first question; the precise reasons behind a historical commercial decision would require specific testimony.
Contemporary development also benefits from an accumulated body of technical knowledge. Wolfenstein’s original source code is publicly accessible, the machines have been studied in detail, and modern tools make testing cycles far more convenient. All of this helps developers search for different solutions. The achievement becomes meaningful when we look at what the target computer actually executes. For Wolf500, the stated reference remains the standard A500; for the more elaborate modes in 3Dvibe64, acceleration is an explicit condition of the project. Making that clear allows both efforts to be appreciated on their own terms.
Trying Wolf500 today
As of 18 November, the Wolf500 page still reports a save corruption issue in 0.91b. Anyone trying it should use a copy of the ADF image. The project is therefore already available, with development still in progress. Assessing performance will require tests that specify the configuration, view size and scene. A smooth video can generate enthusiasm; a repeatable comparison helps establish how consistently that behaviour holds up during play.
The conclusion I draw from Wolf500 is more interesting than a simple victory in an old computer rivalry. The structure of a game, its data format and the way its images are built can profoundly change what a machine can do. My experience with the C=64 had led me to believe that a good version of Wolfenstein on the Amiga 500 was a credible prospect. This conversion finally gives that intuition concrete form, through an adaptation designed for very limited resources. Bitplanes still require work, the 68000 retains its clock speed, and memory remains limited. Now, within those limits, there are Wolfenstein’s corridors too.
Sources
- serpentchain, Wolf500. Official page, requirements, download, gallery and save status, accessed on 18 November 2026.
- serpentchain, Wolf500 version .91b update. Devlog dated 14 November 2026.
- Retromind, 3Dvibe64: Gouraud, textures and raycasting in Commodore’s 8-bit world. Project introduction and original VICE captures.
- Librologica, 3Dvibe64 repository, Mode 8 documentation and 1.20.0 qualification log. Architecture, configurations and reported measurements.
- jammer64, Grey development discussion on Lemon64. Engine description and nominal performance published by its co-author.
- Kweepa, Tech breakdown for Wolf64. Technical description of the Commodore 64 adaptation.
- George Sanderson, Id Software (Doom) responds!. Usenet post dated 4 September 1994, containing the email attributed to John Carmack from 3 September.
- David L. Craddock, Apollo 11 Situations: John Romero on Porting Doom and Wolfenstein 3D. Interview with John Romero, Shacknews, 18 March 2020.
- NovaCoder, AmiWolf OCS/ECS, README on Aminet.
- Szilard Biro, Wolf4Amiga, README on Aminet.
- id Software, original Wolfenstein 3D source code, including the ID_VL.C video module for VGA configuration.
- id Software, original Doom source code. Renderer structure and sector-based geometry.
- Motorola, M68000 Microprocessors User’s Manual, hosted by NXP.
- Commodore, Amiga Hardware Reference Manual, archived copy: Coprocessor Hardware, Playfield Hardware, Blitter Hardware.
Cover image. A Wolf500 screenshot from the developer’s gallery. Source: serpentchain, itch.io. Original game and graphics: id Software. The capture documents the visual result; performance requires separate measurement.

