# One man's look at software version numbering and naming

This article by Dan Polansky intends to look at software version numbering and naming, to complement the linked Wikipedia article. It intends to contain descriptions/observations, with view to application: designing and choosing a scheme.
Conflicting requirements on version numbering and naming clash and result in considerable chaos, lack of unity. Example of conflicting requirements:
* Software versions of the same product should use a single numbering and naming scheme.
* Software version identifications of the same product should have some charm, avoiding boredom.
* When the software version identification consists of multiple separated parts, there should be some meaning to these parts, e.g. major version and minor version.

## Microsoft Windows

One case illustrating the lack of unity/consistency is Microsoft Windows. Let us consider some of the versions (mostly from memory, to be double checked):
* Windows 1.01
* Windows 3.0
* Windows 3.1
* Windows 3.11
* Windows NT 3.1
* Windows NT 3.5
* Windows NT 4.0
* Windows 95 (Windows 9x branch)
* Windows 98 (Windows 9x branch)
* Windows 2000 (NT branch)
* Windows Me (Windows 9x branch)
* Windows 2003 (NT branch)
* Windows XP (NT branch)
* Windows Vista (NT branch)
* Windows 7 (NT branch)
* Windows 8 (NT branch)
* Windows 10 (NT branch)
* Windows 11 (NT branch)
We see multiple numbering/naming schemes:
* Use of a two-part number (1.0, 3.0, 3.1)
* Use of a single-part numnber (7, 8, 10, 11)
* Use of a year (95, 98, 2000, 2003)
* Use of an acronym (NT, XP)
* Use of a single-word name
Some oddities or things worth mentioning:
* There is the same scheme of using a year referring to different platforms, the non-NT platform (95, 98) and the NT platform (2000, 2003). From the version number, one could think that Windows 2000 is an iteration of Windows 98, but that is not so.
* 7 stands out apart from Vista although it can be seen as a relatively minor iteration of Vista; the big break was between XP and Vista.
* 3.11 seems to be a strange follow-up on 3.1 until one realizes that 3.1 is something like 3.10 (zero appended, but without additional dot).
Further reading:
* List of Microsoft Windows versions, wikipedia.org

## Microsoft Office

In Microsoft Office version labeling we see some of the patterns seen in Windows.
Further reading:
* History of Microsoft Office, wikipedia.org

## Mac OS X

Mac OS X (meanwhile rebranded to macOS) has numbered versioning accompanied by names. I seem to recall the version numbers are deemphasized in the marketing materials, but this needs verification.
In Max OS X itself, "X" stood for 10, hinting at being an iteration of Mac OS 9. But it was no such iteration. On the other hand, the form "X" can be interpreted as suggestive of a break from previous Mac OS versions.
Further reading:
* macOS#Release history, wikipedia.org
* MacOS version history#Releases, wikipedia.org
* Classic Mac OS, wikipedia.org

## Ubuntu

Ubuntu (a GNU/Linux distribution) accompanies version numbers with codenames, perhaps as mnemonic.
Examples:
* Ubuntu 24.04 LTS: Noble Numbat
* Ubuntu 24.10: Oracular Oriole
* Ubuntu 25.04: Plucky Puffin
Further reading:
* Releases, wiki.ubuntu.com
* Ubuntu, betawiki.net

## Emacs and XEmacs

The case of Emacs and XEmacs illustrates naming/branding of forks. If Emacs was a brand name of a commercial corporation, one could imagine the corporation suing the fork supplier for using the brand name Emacs in the name XEmacs, competing for the same market. By contrast, OpenOffice and LibreOffice stand fartehr apart in their names. (XEmacs was previously called Lucid Emacs).
One could think that forking does not have that much to do with versioning. However, I find it sufficiently reasonable/compelling to view versions of the fork as versions of the ancestral code that both the fork and the main continuation share.
Further reading:
* GNU Emacs Release History, gnu.org

## Java

Java is interesting for having switched from 1.X numbering scheme to X numbering scheme, dropping the leading 1. Thus, e.g. Java 8 is what would have been Java 1.8. Careful verification pending.
Further reading:
* Java version history, wikipedia.org

## Perl

Perl is interesting in that what was originally called Perl 6 was eventually considered so different from Perl 5 as to deserve a new name; Raku was picked.
Further reading:
* Raku, wikipedia.org

## Firefox

Early on, Firefox used a major-minor version number scheme; for instance:
* Firefox 1.5
* Firefox 2
* Firefox 3
* Firefox 3.5
* Firefox 3.6
* Firefox 4
Then, it switched to a single-number rapid release scheme. As per Wikipedia: "In March 2011, Mozilla presented plans to switch to a faster 16-week development cycle, similar to Google Chrome." The idea would be to push/nudge all users to be at the latest version. A rationale could have been that this will avoid people using versions with known vulnerabilities. Double check needed.
Further reading:
* Firefox version history, wikipedia.org
* Firefox early version history, wikipedia.org

## GCC and EGCS

EGCS was a fork of GCC, GNU C Compiler, which later became GNU Compiler Collection. EGCS was later either merged into GCC or it became GCC by act of renaming.
As per gnu.org, "The first compiler version released after the reunification was GCC version 2.95."
Relevant release numbers showing the interplay between GCC and EGCS release numbers, as per gcc.gnu.org:
| GCC 2.95 | July 31, 1999 |
| EGCS 1.1.2 | March 15, 1999 |
| EGCS 1.1.1 | December 1, 1998 |
| EGCS 1.1 | September 3, 1998 |
| EGCS 1.0.3 | May 15, 1998 |
| EGCS 1.0.2 | March 16, 1998 |
| gcc 2.8.1 | March 2, 1998 |
| gcc 2.8.0 | January 7, 1998 |
| EGCS 1.0.1 | January 6, 1998 |
| EGCS 1.0 | December 3, 1997 |
| 2.7.2.3 | August 22, 1997 |
The meaning of 95 in 2.95 is unclear: one would expect 2.9.x.
Further reading:
* GNU Compiler Collection#EGCS Fork, wikipedia.org

## TeX

TeX's version numbering scheme is an outlier/peculiarity: the version numbers are ever longer decimal expansions of pi, and thus, 3.1, 3.14, 3.141, 3.1415, etc. This has come as far as 3.141592653. From what I recall, one idea behind this scheme was that ever expanding feature set or changes of software are not necessarily a good thing and that a software package should convert to something definite within its niche; needs verification. I find this idea of software converging/stabilizing attractive; the playful numbering scheme, not so much, or at least I would not recommend its emulation.

## HTML

HTML is not a software package but is related to it and is subject to versioning.
HTML versions include:
* HTML 3.2
* HTML 4.0
* HTML 4.01
* HTML 5.1
* HTML 5.2
Further reading:
* HTML#HTML version timeline, wikipedia.org

## C++

C++ is not a software package, but just like them, it is subject to versioning.
C++ versions include (and are based on year):
* C++98
* C++03
* C++11
* C++14
* C++17
* C++20
* C++23
Further reading:
* C++, wikipedia.org

## Alpha, Beta, Release Candidate

Some [which?] software projects use alpha, beta and release candidate labels to indicate pre-release versions.
LibreOffice uses the label release candidate.
OpenOffice uses the label beta.
Microsoft Windows 1.0 used the labels alpha and beta. Some Windows versions used the label release candidate. Microsoft used label release candidate for some versions of .NET and SQL Server.
Further reading:
* Software release life cycle, wikipedia.org
* What is the difference between alpha and beta release?, stackoverflow.com

## Semantic versioning

Semantic versioning is multi-part numbering scheme, covered in the Wikipedia article. The first idea is to use numbering scheme MAJOR_VERSION_NUMBER.MINOR_VERSION_NUMBER, e.g. Windows 3.1. Further components can be added, e.g. build number; up to four components are sometimes used. Minor versions are less breaking in some sense than major versions. There is a technically specified concept of semantic versioning linked from Wikipedia.