It seems that 3D games, especially simulations like Falcon, were not faster (fps) on the Amiga than on the Atari ST - even a bit slower due to the CPU clock.

I was wondering why this is the case, since the Agnus seems to me as an early model of a GPU, capable of drawing vector lines and even fill out polygons. Was it not capable to display the typical number of 3D objects in those games or was it simply not used, since it would require a complete different codeline for the Amiga with respect to 3D rendering ?

  • What does "faster" mean? more frames per second or something? Commented Sep 19, 2018 at 7:46
  • yes, more fps, I update the question
    – Marco
    Commented Sep 19, 2018 at 8:23
  • 2
    That is a little tough for me, since I did not the comparison by myself. I have a print magazine from 1990, which only covered simulations cross-system and there almost was for every game the statement that the 3D aspects between Amiga and Atari ST would be more or less the same
    – Marco
    Commented Sep 19, 2018 at 11:15
  • 2
    Would it be worth (someone's) while to add an answer talking about how as 3d graphics algorithms developed, they were frequently better able to be implemented on graphics systems that used a "chunky" approach vs the Amiga's (and many other older systems) "planar" approach? Commented Sep 19, 2018 at 13:47
  • 1
    As a piece of trivia, uncovered while working on an emulator, F/A-18 Interceptor is one major title that uses the blitter’s polygon filling mode.
    – Tommy
    Commented May 21 at 16:18

5 Answers 5


There are a few reasons why multi-platform 3D games turned out to be no faster on the Amiga than on other 68000-based platforms without its blitter:

The developers may have targetted the lowest common denominator system and not taken advantage of the blitter when they ported to the Amiga. Early games and poor conversions tended to be like this.

A naive implementation by somebody unfamiliar with the hardware may well fail to use the blitter's line-drawing and space-filling operations efficiently, thus losing the benefit. If one draws and fills individual polygons and then blits them to the framebuffer, that is a lot of wasteful work. AmigaOS itself didn't set a good example here.

Finally, the blitter is a pure 2D device which offers no acceleration for 3D calculations, so the main CPU needs to do those. This involves a lot of matrix multiplication, and the 68000's MULU/MULS instructions are very slow, taking about 70 cycles. (The exact number of cycles is data-dependent because the microcode uses an iterative algorithm.) At 7.09MHz that's a shade over 100,000 multiplies per second, or 2,000 per 50Hz field. Even if the blitter was infinitely-fast, this still sets an upper limit of a few hundred points on screen or compromise on frame rate.

  • 5
    "that's a shade over 100,000 multiplies per second" ;-) Commented Sep 19, 2018 at 12:56
  • 1
    I would dare imagine that most optimised titles do not use MULU/MULS, preferring a more limited numerical range and the lookup table options that permits. But that's not to argue with your main point about calculation versus drawing costs.
    – Tommy
    Commented Sep 19, 2018 at 14:02
  • 2
    Actually the biggest performance hit in 3D calculations usually comes from the perspective divide, as divide instructions are much slower than multiply instructions. Of course like Tommy said with multiplies, in practice games would avoid using an actual divide instruction.
    – user722
    Commented Sep 19, 2018 at 14:22
  • 1
    @RossRidge but both the final column and final row are invariably 0, 0, 0, 1 assuming you're doing only linear transforms. So you can just multiply by the inner 3x3 and then add the final column as a translation. I think another common optimisation is spotting that most of the time you're just doing rotation, so elements are in the range [-1, 1], giving a great opportunity for locally-limited-precision arithmetic. E.g. 8x8 matrix arithmetic into a 16.16 space. But then the divides have to occur in the objective space, which further helps your point — 8x8 multiply vs at least 16x16 divide!
    – Tommy
    Commented Sep 19, 2018 at 20:09
  • 3
    The AtariST has a slightly higher clock than the Amiga, but most of the cpu time was spent in drawing the picture. The Amiga had an edge in theory because the blitter has a fill mode so you could draw lines and use the blitter to do the fill, but the constraints made it so that it wasn't that useful in games, however it was used a lot in demos
    – Thomas
    Commented Sep 19, 2018 at 23:56

The thing the Agnus has that speeds up 3D games is the polygon fill feature. Blitting by itself is not so much a standard operation driving 3D performance. It can help 2D games and windowed GUIs a lot, however, one of the reasons the Atari ST got a (much simpler) blitter as well in later releases.

3D Games are CPU-heavy, or rather performance is driven how fast you can do vector arithmetics and trigonometric functions (which would mainly be done by table lookups in older games) - Agnus doesn't help here, even a 68881 wouldn't help much, as fixed-point integer maths done by a 68k are still faster. We're talking mainly integer operations here, and that is driven by raw CPU speed and bus contention.

  • 1
    Polygon fill doesn't really help with 3D though, because you have to draw the boundaries, fill the polygon and then later blit it into place, all stealing memory access cycles away from the CPU. It's faster to use the CPU to fill, rather than doing so many blitter operations (3 line draws, one fill, blit into target image).
    – user
    Commented Sep 20, 2018 at 8:10
  • @user Yep - That's what I was trying to convey with "bus contention". Fill, however, can be made a lot faster or slower by the layout of your video memory and allocation of bitplanes - The more linear, the better. The Amiga was a bit complicated in that respect, I seem to recall.
    – tofro
    Commented Sep 20, 2018 at 8:16
  • @user Because of the bitplane layout, you can line-draw the horizontal edges in XOR mode in just the planes for which you want to set the colour, and then polygon-fill the entire scene afterwards. Drawing and filling a polygon in an off-screen buffer then copy-blitting it to the framebuffer is wasteful of precious memory bandwidth.
    – pndc
    Commented May 20 at 15:03
  • @pndc do you have any examples of that? It seems like it wouldn't work if there were overlapping polygons.
    – user
    Commented May 21 at 10:49
  • @user It depends on what effect you're trying to achieve. If you need to plot overlapping polygons then you will either need to sort and clip them so that they are not overlapping—which is probably too expensive on a plain 68000 for anything but precomputed data—or you can do a hybrid of draw-and-fill of entire 3D models (such a spaceship) to an off-screen buffer and blit the whole thing, which should still save quite a bit of bandwidth over blitting individual filled polygons.
    – pndc
    Commented May 21 at 11:26

Agnes doesn't help much with 3D acceleration. It has a blitter which is capable of filling polygons, but they must then be copied in to the display bitmap so it's actually slower than just filling with the CPU. Additionally the blitter requires the horizontal limits of the polygon to be rendered first, meaning an additional line draw per vertex.

The biggest performance limitation for 3D on the Amiga is memory bandwidth. In fact all 16 bit home machines of the time were the same, memory bandwidth was the biggest challenge.

The maximum fill rate can be achieved by using unrolled CPU loops that write directly in to bitmaps. There is then no copy stage, and no need to line draw vertexes.

The general strategy used by most high performance 3D on the Amiga is to calculate all vectors in one go, allowing as much data to be kept in CPU registers as possible, to avoid memory reads. The display is then rendered by the CPU alone as outlined above.

Since the Amiga had the same CPU as the Atari ST running at a similar speed, but with actually a little bit less memory bandwidth, performance was about the same. The Amiga could do some tricks to improve things, such as variable colour depth on different parts of the screen and sprites for low overhead overlays, but in practice they tended not to be that significant performance-wise.


I did 3d on both and optimizations were different on both machines; I didn't do very advanced stuff at the time, mostly rotating simple objects, etc but no game or complex scenes.

On the Amiga, you would use the blitter to draw lines and fill the bitplanes. The different bit planes were not interleaved but sequential, so the size of the blitter pass you had to do was depending on the colors used. You would draw the same lines in all the planes needed and then do a blitter fill, but filling plane 0 and plane 3 in two passes was slower than filling plane 0 and 1 in a single pass which was slower than filling only plane 1 for example.

The blitter really sped up the filling, but the bitplane layout forced color palette organization in order to make sure the largest surfaces of your objects were the fastest to fill.

On the Atari ST, it was a different story: you had to draw your picture as you were building your triangles, so you needed to sort the vertices vertically and then, as you were doing line interpolations, you were filling up the screen. The edges were tricky to work with, but large surfaces could be filled in a single pass.

In short, the ST required more CPU work, but drawing the picture could be done in a single pass. On the Amiga, the process was generally faster, but the memory layout generated a lot more memory traffic.

Despite these differences, the two came remarkably close in performance.


It's because of the particular things each system was best at, and could better accelerate. 3D games were actually one of the few cases (plus a few other number-crunching sims?) where games ran faster (not just "at the same speed") on the ST rather than the Amiga. And it's entirely because of the reason you first posit; the Atari had an ~11% faster CPU clock.

The games in question were very heavily CPU-bound, their simulation, and their drawing as well, relied almost entirely upon numeric calculation (and getting stuff in and out of RAM, which was also faster). The actual moving-data-to-the-screenbuffer part was a relatively small piece of the whole setup; I daresay that the Amiga's custom chipset still made that operation somewhat faster than the same job in the ST, at least what parts of the job it was actually capable of accelerating (it's not really much of a GPU; it's pretty much just a console style hardware-sprite-and-scroll engine, with a few fancy tricks like line-by-line auto-fill which helps a bit with rendering solid polygons if the programmer knows how to / can be bothered making use of it, or the register bit-banging provided by the Copper), but the ST was already entirely capable of shoving the calculated and rendered output to the screen pretty much as fast as it was produced (by double buffering, so the final "painting" of the screen was a single register-write), so the best it could have done was maybe shave one scan-time off the construction and display of each frame.

There's no line or box or other primitive drawing acceleration, no large-area auto fill, no bezier curves, absolutely nothing that would count as even the most rudimentary 3D acceleration, the sprites or second playfield only appear as overlays (and for the most part are irrelevant here, other than PF2 being used as a cockpit/HUD for a fairly minor speedup), hardware scrolling is pretty much useless, as are most Copper tricks, and even the (less efficient than the ST's - assuming the Atari had one fitted of course) Blitter is of limited usefulness.

If the complexity of the scene was such that it took the Amiga CPU fully 8 scans to finish computing and rendering the image, but the ST only needed 7 (entirely plausible given that a lot of 3D polygon games really struggled to do any better than maybe 6~7fps, which is a 7 to 8 "frameskip" on a PAL monitor, and worse on NTSC), then even that minor improvement to the rest of the system latency wouldn't do anything more than bring them back to level-pegging.

Pretty much any other type of contemporary game, sure, the Amiga had it comfortably in the bag. But for sims and other 3D stuff, the ST just about nosed ahead.

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .