I heard about 2 terms defining a game error: "Bug" and "Glitch".
What's the difference between them?
I heard about 2 terms defining a game error: "Bug" and "Glitch".
Highly non-technical answer:
I would say they are effectively interchangeable, though there tends to be a nuance in the way they are used:
The word bug is usually used when an intended game state is not achievable, due to an unforeseen issue in the game's code. i.e., you are unable to complete a level (or a boss doesn't spawn, etc.) due to an error in the code.
The word glitch is usually used when an unintended game state is achievable, due to an unforeseen issue in the game's code. i.e., you are able to clip through the ground (or advance to a part of a quest that normally requires more objectives to be met) due to an error in the code.
Additionally, "glitch" is used to refer to issues with graphics and sound in a way that "bug" almost never is.
This post has been locked due to the high amount of off-topic comments generated. For extended discussions, please use chat.
I don't see one answer with sources so far, although perhaps that will change after I post this.
Glitch and Bug are essentially synonymous, but some groups will draw different, subtle differences depending on context. The most common theme among these differences is that glitches are sudden, or temporary, and the most common manifestation of this theme is that bugs are mistakes in code, while glitches are the behavior that results from those mistakes.
Note that a glitch is described as "transient". Also note that the glitch is the fault itself, whereas a bug might refer more to the code that causes the fault, which is less transient than the actual fault.
Common Usage Definitions
Here are some dictionary definitions of glitch and bug, to illustrate how similar these terms are in common usage.
Note the use of 'temporary' to describe a glitch, but also note that an alternate definition is simply 'bug'.
Note the idea of a brief surge of power in one of the glitch definitions, but also note how general the first definition is, and how it is essentially the same as a 'defect'.
Those who have always known of a certain distinction between 'glitch' and 'bug' as being the "correct" one should note these dictionary definitions, and keep them in mind when speaking to someone outside of whatever sub-culture or profession makes that distinction. The person you're speaking with may regard the terms as completely synonymous.
These terms are used in gaming, as gaming involves software, and software involves bugs. Some subtle distinctions specific to this context can be made, but - as you can see from the other answers here - there's no real consensus on what those distinctions should be. So, it's the same general situation, where 'glitch' is more likely to mean the manifestation of a bug at run-time, and 'bug' is more likely to refer to the issue in the actual code.
Wikipedia's Glitch page has a section entitled Video game glitches. This section treats the terms as interchangeable:
A video game is a program, considering this, we have the following.
A bug is an error found in the development environment before the product is shipped to the customer. We're talking about code issues here mostly.
A glitch on the other hand is a way of saying defect on a video game environment. A defect is the difference between expected and actual result in the context of testing. As such a defect is the deviation of the customer requirement. This defect can lead to failures.
The relation between bug, defect and failure is a common topic on software testing studies, specially QA and also software development. Moreso, this is a common question in the area.
Now the relation stated between glitch and defect can be worked through their definitions. A glitch is a short-lived fault in a system. In this case a software system, namely a video game. A fault is defined as an abnormal condition or defect at the component, equipment, or sub-system level which may lead to a failure. Which is to to say that a fault is a general way of saying defect. So this means glitches, defects and faults are heavily related.
So this means a glitch is, most of the times, a product of a bug. Although a lot of people use bug to define problems within games, bugs should be used in a development environment as that's what the word defect is for, which, given what was stated earlier, we can associate with glitch.
The difference between bug and glitch is more of a semantic one. The most common way these are interpreted is that a glitch usually has to do with the presentation of a product, while a bug is usually seen more as interfering with gameplay.
For example, corrupted audio and textures are usually seen as glitches. another thing that's usually labeled as a glitch is collision detection going wrong.
The term bugs is usually used for problems like certain enemies not working properly, an item not doing the right thing,...
There's also a linguistical difference: the term glitch is often used for neutral or even positive incidents, while the term bug is usually used for something that is objectively negative. For example, when speed runners use an unintended way to traverse an object, they usually call it a glitch.
The term glitch also is used fairly often outside of software, mainly for electrical engineering and TV broadcasting.
Finally, some people also get the randomness of the event involved: Bugs are considered deterministic: most of them can be reliably triggered when the right circumstances are met. Glitches, on the other hand, are much harder to trigger reliably.
A bug is an undesired consequence caused by a fault in the programming, it can be repeated exactly by following all the same inputs which caused it the first time.
Corrected by editing program code.
A glitch is a more random undesired effect, usually hardware based, caused by eg. lightning strike, fluctuating power supply, a loose data connection, dust getting into magnetic readers ( this last one is very rare these days )
Remedied by better hardware maintenance, more robust power supply. Military hardware is to some extent bomb proof.
Other answers are claiming that bugs and glitches are differentiated by the response of the program, but I've never heard this distinction used in a technical context. The distinction I've always used is that a bug is caused by a program executing correctly, but in a way the programmer does not want, while a glitch is a program which executes incorrectly (as in, differently to the actual instructions in the executable) for some reason. The distinction here is that glitches are caused by the executing environment failing to properly execute the program - as an example, if a graphics card overheats and fails to correctly display graphics, that is a glitch. If the program loads the wrong image to render under some unusual set of conditions in the code, that is a bug.
Most glitches cannot be easily repeated, and more importantly tend to have different effects depending on the specific condition - because of this, in just about every use case of specific "glitches", the person is actually referring to a bug. For example, "glitched Pokemon" are caused by the program attempting to load a Pokemon from an index number that doesn't contain a Pokemon - this is the programmer's mistake. In order to invoke this bug, at no point does the program execute incorrectly; rather, the programmers did not expect players to take the exact actions that must be taken to encounter the undefined Pokemon, and because of that the program exhibits correct but undesirable behavior when those actions are taken.
Bugs are effectively different from glitches.
Glitches are ocasions where unforeseen mechanics collide and create something which wasn't intended to be provokeable.
Bugs on the other hand are issues with the coding itself, which was expected to behave differently.
What are the differences explicitly?
One example would be Open World Games. While buildings and the ground may appear solid, most of the times it's just a single layer, in order to improve performance. Let's imagine that there's an intended underground level acessible by a trapdoor, which places the character in a small room (which has the ground level above, and walls around, but 'empty' past the walls).
A bug would've been the game being programmed accidentally being able to acess the trapdoor in other points of the map, placing the character in the 'empty' zone out of the room.
A glitch would've been using features which were not considered to be tried, such as trying to ride a bike through the hole, as in when exiting you'd be on the other side of the wall. One instance of this is GTA San Andreas.
A bug would create an undesired game state due to an error in coding, while a glitch is able to exploit the current game state by abusing it's engine
A glitch is a certain type of bug.
"Bug" is a general term for any kind of programming error or unintended behavior. Some types of bugs are:
A "glitch" is a bug that is neither a crash or a hang: The program continues to execute, albeit in a possibly invalid state.
This can be recoverable (e.g. just a display error, or you move back out of the object that you were not supposed to be able to move through) or not (e.g. you fall off the bottom of the level).
It can also simply be an error in the display (e.g you don't see or see through some object or some polygon goes across the whole screen). It could be an error in some AI behavior, e.g. an enemy that is stuck at some object an is not able to move on.
A bug is an error, flaw, failure or fault in a computer program or system that causes it to produce an incorrect or unexpected result, or to behave in unintended ways. Most bugs arise from mistakes and errors made by people in either a program's source code or its design, or in frameworks and operating systems used by such programs, and a few are caused by compilers producing incorrect code. A program that contains a large number of bugs, and/or bugs that seriously interfere with its functionality, is said to be buggy or defective. Reports detailing bugs in a program are commonly known as bug reports, defect reports, fault reports, problem reports, trouble reports, change requests and so forth.
A glitch is a short-lived fault in a system. It is often used to describe a transient fault that corrects itself, and is therefore difficult to troubleshoot. The term is particularly common in the computing and electronics industries, and in circuit bending, as well as among players of video games, although it is applied to all types of systems including human organizations and nature.
A "bug" is unintended behaviour of a program/game. This can be a crash or a showstopper or anything else that is unforeseen.
A "glitch" is a bug that does not result in a crash or anything similar, but it does something the user/player can "profit" of. Examples are unintended unlocks (ingame items or program features), places one can reach where one is invulnerable, duplicating items and so on.
In electronics hardware, a bug comes from an actual bug getting caught in a component and causing a short while a glitch is an undesired condition that corrects itself.
So I would say that if your game crashes, it's a bug, if it wacks out for a second then goes on as nothing happened, then it's a glitch, and varying degrees of the two.
Essentially if the issue corrects itself it's a glitch, otherwise if it persists it's a bug. There's obviously a very large grey area here.
To keep it in more layman's terms, I going to try and treat it in more of a cause-effect relationship between the two.
A glitch is more often than not an effect caused by an unforeseen bug. A much more recent example is the "G-Slide" of Call of Duty Black Ops 3. Timed correctly, a player was able to jump and slide creating a more boosted movement throughout the map. This should be considered a glitch which other have defined as the unintentional consequence of some action or combination of actions by an actor (player/ai/physics miscalculation).
A bug is more often considered to be mentioned with regard to more serious consequences in-game. A much more recent example is Fallout 4's game save corruption. This can be near-repeatable or a one-time instance over a very specific set of circumstances. Bugs as stated above exist in code errors or misunderstandings of what the machine is being told to do. A simple "bug" is not closing a file after it has been written to (Some "corrupted" saves are just data that is mixed in a certain way such as writing the alphabet forwards to a file and not closing it then writing half the same data backwards to the file and attempting to read the file the same way as though it was a-z instead of z-nn-z).
Hope that helps. Technically, my definitions are dependent on severity.
The two terms are pretty interchangeable, but for the "political" ramifications of each. A "Glitch" is an unexpected and potentially "out of our control" kind of error in an automated system or program or application or whatever the algorithm is being called. In this scenario, the technical designers and maintainers of the system accept little or no responsibility for the problem. A "Bug" on the other hand is an identified problem in how the system was "coded" and therefore use of this term implies that the problem was and/or is still under the control of the designers/maintainers of the system. In a nutshell, the difference between bug and glitch has to do with spin doctoring and blamestorms.
I speak from my own perspective, which is how I personally learned the words. Others are welcome to show agreement or disagreement.
bug - technical terminology
As I understood a "bug", the word was taught in computer classes, and these classes taught me the history of the word. An old computer (which was very large, possibly filling most of a large room, and probably using vacuum tubes) had a failure. Investigation found the mechanical cause was from a moth.
Since then, the term "bug" was used for computer errors, and especially used by "software development" / "computer programming". So, an error in a computer program is a bug.
Since software specifies to do the same thing when all inputs are the same, many bugs are commonly easy to reproduce. Some bugs, like being little with fireballs in Super Mario Bros. 1 (NES), may be rather safe (after their effects are mastered).
Glitches always have detectable effects. For instance, if a software bug corrupts some data, I've never heard of such an error being referred to as a "glitch" until that data is used, at which point problems may occur. If a player's attack does 25% extra damage, and that is wrong, then it is a mistake and is, therefore, an actual bug. However, if the enemy would have died anyway, and the game doesn't display the amount of damage, then the end result is the same and there is no lasting impact, so it is not a glitch.
The first time I heard of "glitch" was referring to an 8-bit NES game. It probably related to something that was particularly nasty, causing the software to be unusable. (Maybe a character got moved and trapped, or the game just crashed.) Regardless, I considered it to be when something got into a state of being "broken", particularly if it then remained broken.
Another characteristic for the term "glitch" is if the effect is caused by hardware issues, such as malfunctions caused by things like dirt on a cartridge, would be a likely cause of a glitch. Software issues could also be described as a glitch if they caused an effect that seemed similar to hardware being broken. For instance, if a character teleports, which might be the effect that is expected if RAM kept track of information wrong, or if incorrect data was read from ROM, then that would also indicate a glitch.
Glitches are quite often very unsafe, although software may be able to fix some glitches by overwriting problematic data (such as when re-initializing a level after a death, or loading a "saved" game data).
Recap : examples
So when Sinistar gave a player less than zero lives, and then treated the number as 255 lives, the game was still able to run stable. There was no threat of the game becoming unusable. After the lives became 255, Sinistar behaved as expected, and the game would end if the "player" continued to lose all of the remaining lives. So this bug did not represent a "glitch". In contrast, if a bug in DOOM 2 led to an Archvile causing another creature to become invincible, the result was a glitch because the situation continued to remain broken as the enemy continued to be unattackable. The resurrection placing the enemy in an incorrect plane was a bug, but the remaining situation represented the glitch.
Recap : Summary
A bug is a design flaw, most commonly referring to an error in the instructions which we typically call "software".
Glitches refer to hardware errors, things that seem like hardware errors (like if a sprite becomes garbled), or something that has a lasting impact. A non-impacting error is not a glitch.
Fun side notes
Oddly, based on these definitions, this means that the moth in the old computer would have caused glitched behavior, and doesn't represent a "bug" based on the newer way that the word has been used.
Super Meat Boy has a character that has been named "Glitch Girl".
Bug is a software error, ending in wrong results or freezing of the system. Glitch is a created error to take over the system and run different code.
protected by Ash♦ Feb 27 at 1:01
Thank you for your interest in this question.
Because it has attracted low-quality or spam answers that had to be removed, posting an answer now requires 10 reputation on this site (the association bonus does not count).
Would you like to answer one of these unanswered questions instead?