Using Assembly Language for Creating Games

Aleksandra Leki\'c; David Vukoje; Haris Turkmanovi\'c; Milan Prokin

arxiv: 2604.21532 · v1 · submitted 2026-04-23 · 📡 eess.SY · cs.SY

Using Assembly Language for Creating Games

Haris Turkmanovi\'c , David Vukoje , Aleksandra Leki\'c , Milan Prokin This is my paper

Pith reviewed 2026-05-09 20:48 UTC · model grok-4.3

classification 📡 eess.SY cs.SY

keywords assembly languagex86 assemblygame developmentArkanoidWindows consolelow-level programmingVisual Studio

0 comments

The pith

An x86 assembly implementation of Arkanoid in the Windows console demonstrates practical approaches to low-level game programming.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper aims to show that assembly language remains capable of building complete interactive programs by coding an Arkanoid game in x86 assembly. The authors use Visual Studio 2015 to develop and debug the code, which then runs as a playable version inside the standard Windows console. A reader would care because the example ties low-level instructions directly to familiar game elements like ball physics, paddle movement, and brick collisions. This concrete project is meant to illustrate algorithms that make assembly useful rather than purely theoretical.

Core claim

The authors built a working Arkanoid game entirely in x86 assembly language that executes in the Windows OS console, presenting several algorithms for game mechanics and output, with the explicit purpose of demonstrating interesting and useful ways to write programs in assembly.

What carries the argument

The x86 assembly source code for the Arkanoid clone, which handles game loop timing, collision detection, user input via console, and text-based rendering, all compiled and tested inside Visual Studio 2015.

If this is right

Assembly code can manage real-time loops, input polling, and simple physics calculations inside a standard operating-system console.
Visual Studio 2015 supplies debugging and testing features sufficient for developing and verifying assembly-based games.
Console output can serve as a minimal rendering layer for demonstrating full game logic without external graphics libraries.
The same low-level techniques could apply to other small interactive programs that need direct hardware or OS access.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

Similar projects could be used to teach assembly by replacing the console renderer with other simple output targets such as serial ports or LED matrices.
The approach highlights a possible niche for assembly in size-constrained or legacy-system game ports where higher-level languages add unwanted overhead.
Readers might compare the code size and execution speed against an equivalent C or C++ version to quantify the claimed low-level advantages.

Load-bearing premise

Successfully creating and running one console Arkanoid game in x86 assembly is enough to establish that the language offers interesting and useful approaches for writing programs.

What would settle it

Inspection of the source code or execution of the binary showing that the game either fails to run, lacks functional collision or input handling, or contains no algorithms beyond the most basic console I/O loops.

Figures

Figures reproduced from arXiv: 2604.21532 by Aleksandra Leki\'c, David Vukoje, Haris Turkmanovi\'c, Milan Prokin.

**Figure 3.** Figure 3: Illustration of Arkanoid Structure [PITH_FULL_IMAGE:figures/full_fig_p002_3.png] view at source ↗

**Figure 6.** Figure 6: Concept of BigString idea. Basic building elements for “Char bitmap” are two CHAR_INFO structure elements, which represent full and empty rectangle in the console. Full rectangle forms shape of “Big chars” (symbols). Empty rectangle forms “Big chars” background. Combining the empty and the full rectangle we can create random shapes. This is very useful for creating different sized arbitrary forms and allow… view at source ↗

read the original abstract

The aim of this paper is to demonstrate some interesting and useful approaches for writing a program in the assembly language. In order to demonstrate the possibilities of the assembly language, a project called "Arkanoid" was created. This project is written in assembly language and it presents few interesting algorithms. Assembly language, which is used for designing the game is x86 Assembly language, which produces object code for the x86 class of processors. As a working environment is chosen Visual Studio 2015, because it gives the useful tools for debugging and testing of the created software (game). Execution of the program results in a "Arkanoid" game, placed in Windows OS Console.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Desk Editor's Note private letter to a colleague

This is a student project report on building a console Arkanoid clone in x86 assembly, with no new techniques or results.

read the letter

This paper reports on a student project that implements the Arkanoid game in x86 assembly language targeting the Windows console through Visual Studio 2015. The central point is that the authors wrote and ran the program, which they say demonstrates some approaches to assembly programming. That is the whole contribution. Assembly-level game code has existed since the 1980s, so nothing here is new in method or insight. The work does show that a basic paddle-and-ball game can be put together at that level using standard tools, and the choice of Visual Studio for debugging is reasonable for a Windows target. A reader who wants a concrete, if simple, example of low-level console output and game loop structure might find it mildly useful as a starting point for learning. The soft spots are straightforward. The text gives no code, no algorithm descriptions, no timing details, and no explanation of how collision, scoring, or brick handling were actually coded in assembly. The claim of “few interesting algorithms” is left unsupported. Without those specifics, the paper functions only as an assertion that the game runs rather than as something others can study or reproduce from the manuscript alone. This kind of write-up is for undergraduates or hobbyists who are first learning assembly through a game project. It has no place in a research journal. I would not bring it to a reading group, would not cite it, and would not send it for peer review.

Referee Report

2 major / 1 minor

Summary. The manuscript claims to demonstrate interesting and useful approaches for writing programs in x86 assembly language by creating a console-based Arkanoid game implemented in assembly using Visual Studio 2015, with execution producing the game in the Windows OS console.

Significance. A verified, detailed implementation could serve as a basic educational example of low-level assembly techniques applied to simple game logic. However, the manuscript contains no code, algorithms, or verification, so no positive significance can be assigned.

major comments (2)

[Abstract] Abstract: the claim that the project 'presents few interesting algorithms' is unsupported because the manuscript provides no description, pseudocode, or analysis of any algorithms.
[Abstract] Abstract: the central claim that 'Execution of the program results in a Arkanoid game' cannot be evaluated, as the text supplies neither source code, build instructions, nor any test output or verification steps.

minor comments (1)

[Abstract] Abstract: grammatical and phrasing issues include 'a Arkanoid' (should be 'an Arkanoid'), 'few interesting algorithms' (should be 'a few interesting algorithms'), and the unclear phrase 'placed in Windows OS Console'.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the detailed and constructive report. The comments correctly identify that the current manuscript version is too brief and lacks the supporting material needed to substantiate its claims. We agree that major revisions are required and will address each point by expanding the paper with the necessary technical content.

read point-by-point responses

Referee: [Abstract] Abstract: the claim that the project 'presents few interesting algorithms' is unsupported because the manuscript provides no description, pseudocode, or analysis of any algorithms.

Authors: We agree that the abstract's reference to 'few interesting algorithms' is unsupported in the present text. The manuscript will be revised to include explicit descriptions of the algorithms used (e.g., ball trajectory and collision handling, brick destruction logic, and paddle-boundary checks), accompanied by pseudocode and brief analysis of their implementation in x86 assembly. revision: yes
Referee: [Abstract] Abstract: the central claim that 'Execution of the program results in a Arkanoid game' cannot be evaluated, as the text supplies neither source code, build instructions, nor any test output or verification steps.

Authors: The referee is correct that the claim cannot be verified without the code and supporting material. In the revised manuscript we will append the full x86 assembly source code, precise build and run instructions for Visual Studio 2015 under Windows, and console screenshots or sample output demonstrating the running Arkanoid game. revision: yes

Circularity Check

0 steps flagged

No circularity: straightforward implementation demonstration

full rationale

The paper is a programming demonstration that reports the creation and execution of a console-based Arkanoid game in x86 assembly under Visual Studio 2015. No equations, derivations, predictions, fitted parameters, ansatzes, or uniqueness theorems appear anywhere in the text. The central claim reduces only to the direct statement that the assembled program runs and produces the described game behavior, which is a self-contained reproducibility assertion with no reduction to prior inputs by construction. No self-citations are load-bearing, and the work contains no theoretical chain that could be circular.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

This is a software demonstration paper. No mathematical derivations, fitted parameters, background axioms, or new postulated entities are present or required.

pith-pipeline@v0.9.0 · 5415 in / 1085 out tokens · 34338 ms · 2026-05-09T20:48:12.319058+00:00 · methodology

discussion (0)

Reference graph

Works this paper leans on

8 extracted references · 8 canonical work pages

[1]

K. R. Irvine and L. B. Das, Assembly language for x86 processors : Prentice Hall, 2011

work page 2011
[2]

Prokin, Računarska elektronika

M. Prokin, Računarska elektronika . Belgrade: Akademska misao, 2006

work page 2006
[3]

K. R. Irvine, Assembly language for Intel -based computers: Citeseer, 2003

work page 2003
[4]

D. D. Gajski, S. Abdi, A. Gerstlauer, and G. Schirner, Embedded system design: modeling, synthesis and verification : Springer Science & Business Media, 2009

work page 2009
[5]

Wolf, High-performance embedded computing: applications in cyber-physical systems and mobile computing: Newnes, 2014

M. Wolf, High-performance embedded computing: applications in cyber-physical systems and mobile computing: Newnes, 2014

work page 2014
[6]

Zurawski, Embedded systems handbook: CRC press, 2005

R. Zurawski, Embedded systems handbook: CRC press, 2005

work page 2005
[7]

S. M. Kuo, B. H. Lee, an d W. Tian, Real-time digital signal processing: fundamentals, implementations and applications : John Wiley & Sons, 2013

work page 2013
[8]

Stroustrup, The C++ programming language : Pearson Education India, 2000

B. Stroustrup, The C++ programming language : Pearson Education India, 2000

work page 2000

[1] [1]

K. R. Irvine and L. B. Das, Assembly language for x86 processors : Prentice Hall, 2011

work page 2011

[2] [2]

Prokin, Računarska elektronika

M. Prokin, Računarska elektronika . Belgrade: Akademska misao, 2006

work page 2006

[3] [3]

K. R. Irvine, Assembly language for Intel -based computers: Citeseer, 2003

work page 2003

[4] [4]

D. D. Gajski, S. Abdi, A. Gerstlauer, and G. Schirner, Embedded system design: modeling, synthesis and verification : Springer Science & Business Media, 2009

work page 2009

[5] [5]

Wolf, High-performance embedded computing: applications in cyber-physical systems and mobile computing: Newnes, 2014

M. Wolf, High-performance embedded computing: applications in cyber-physical systems and mobile computing: Newnes, 2014

work page 2014

[6] [6]

Zurawski, Embedded systems handbook: CRC press, 2005

R. Zurawski, Embedded systems handbook: CRC press, 2005

work page 2005

[7] [7]

S. M. Kuo, B. H. Lee, an d W. Tian, Real-time digital signal processing: fundamentals, implementations and applications : John Wiley & Sons, 2013

work page 2013

[8] [8]

Stroustrup, The C++ programming language : Pearson Education India, 2000

B. Stroustrup, The C++ programming language : Pearson Education India, 2000

work page 2000