Spacewar on microcontroller

The free GCC toolchain supports ARM/Cortex just fine. Pre-compiled versions can be found all over the web, or you can build your own. You could do assembler if you want, but I would suggest at least C, personally I like C++ even better because it allows very efficient libraries.

The things that 'hang around' the compiler can be a bit trickier. I wrote my own make scripts, linker scripts, startup code, and some support libraries. That requires some in-depth knowledge, but it is not that much work (at least for the first few chips). I mainly use the LPC DIP chips, LPC1114FN28 and LPC810M021FN8.

I am not a fan of the 'heavy' IDEs. I use mostly PSPpad, but the make-script can be used with any editor that can call a shell script, catch the output, and parse a (GCC) error message.

I am not a fan of debuggers, I prefer to insert print statements. I use lpc21isp for hands-off serial downloading + terminal emulation. Works OK, except that I had to patch lpc21isp it to reset the chip after downloading (instead of using the ISP GO command, which is broken on Cortex. Blame on you NXP for not fixing this!).

An article about how I use C++ can be found here.

In about two weeks I'll have my environment up-to-date for my C-on-LPC1114 course. The last-year version can be found here.

Ultimately you will have to send pixel data to the display. There is no way around that; that's just how VGA works. The monitor at the other end only understands frames, the FPGA will need to generate complete frames at the correct rate. The simplest way to do this is to have a frame buffer that holds pixel data for the entire display. This generally will require more memory than the FPGA will have internally, so that means your frame buffer will have to sit on an external memory.

However, if what you intend to display has some structure, then you may not need a complete frame buffer. For example, if you want to make a text-only display, then all you need is a character buffer that indicates what character to display at every position on the display, each position corresponding to a character-sized box of pixels. Then you can build a 'mapping' between the characters in the buffer and the pixels on the display - a font buffer. To generate a line of video, pull characters from the corresponding row in the character buffer, use that to index the font buffer, and then display the pixels that correspond to the particular row in the selected characters. This would be a very simple text drawing pipeline. It is possible to do something similar with sprites as well so you can do basic graphics without requiring a complete frame buffer. Depending on the implementation, it can be more efficient to use a hardware sprite drawing engine since moving the sprite only involves updating the position in the drawing engine instead of rewriting all of the pixels that make up the sprite.