depiction of the terran computational calendar depiction of the terran computational calendar


Synchronized with the northern winter solstice, the terran computational calendar began roughly* 10 days before the UNIX Epoch. Each year is composed of 13 identical 28-day months, followed by a 'minimonth' that houses leap days (one most years and two every 4th but not 128th year) and leap seconds (issued by the IERS during that year). Each date is an unambiguous instant in time that exploits zero-based numbering and a handful of delimiters to represent the number of years and constant length months, days, hours, minutes, and seconds that have elapsed since 0TC (the calendar's starting point). An optional 'year base' may be applied to ignore erratic leap duration. Arithmetic date adjusting 'datemods' can be applied to define things like weeks, quarters, and regional times.

Terran Computational Epoch

The epoch is roughly synchronized with the northern winter solstice, and the exact instant of this calendar's epoch is officially defined as 221788790 SI seconds (measured at the geoid) before 1977-01-01 00:00:00 TAI. Though for most practical purposes, it may be reasonable to use 1969-12-22 00:00:00 UTC or -864000 seconds of (10 days before) the UNIX Epoch as the terran computational epoch.


  • A cycle's darkest point is often treated as the beginning of a cycle, therefore, the terran computational calendar chose to synchronize itself with the shortest day of the year in the northern hemisphere.
  • The UNIX Epoch is often thought of as the beginning of modern computerized timekeeping, so (roughly*) 10 days before the UNIX Epoch was chosen.
  • UTC and TAI have both been redefined since their inceptions (the last redefinition was at the beginning of 1977), and because of this UNIX time is loosely defined. So instead of defining in terms of UNIX Time, the terran computational epoch is defined in terms of this last redefinition whereby corrections were applied to TAI atomic clocks to account for gravitational time dilation by redefining the output to represent atomic time measurements made at mean sea level (the geoid). Therefore, officially, the terran computational epoch occurred at 221788790 ((365*5 + 366*2 + 10)*86400 - 10) SI seconds measured at the geoid before 1977-01-01 00:00:00 TAI.

Basic Time Measurement


Date Field Range:

Any integer value. A '-' delimiter preceding this value denotes a negative value. All other preceding delimiters or an omitted delimiter denotes a positive value.


13 full terran computational months plus a given year's minimonth (which corresponds to that year's leap duration).

Months & Minimonth

Combined Date Field Range:



Date Field Range:



28 days


Date Field Range:



Equal to a given year's leap duration which includes the duration of all leap seconds, …, leap days, … in a given year. Falling at the end of the standard 13 full month calendar system, the purpose of a minimonth is to roughly sync up the year and day with their respective beginnings (their darkest points).


Date Field Range:



24 hours


Date Field Range:



60 minutes


Date Field Range:



60 seconds


Date Field Range:



An SI second measured at mean sea level (the geoid), assuming that an SI second is equal to the duration of 9192631770 periods of the radiation corresponding to the transition between two hyperfine levels of the ground state of the caesium 133 atom. The duration of terran computational seconds correlate exactly to the duration of single TAI seconds after the beginning of 1977 TAI.

Fractions of a Second

Date Field Range:

Any decimal value


Any positive duration less than a single Seconds.

Dynamic Time Measurement

Year Base

A year base is optional and is appended to the right hand side of the 'TC' in a given date's designator and together they effectively create their own distinct designator. Letting n represent any positive integer, TCn defines a distinct designator with a given year base, n, which signifies that only erratic leap duration before nTC will be accounted for and any erratic leap duration after nTC will be ignored. The terran computational calendar does not account for erratic leap duration before 0TC, therefore, TC0 is a designator with a year base of 0 signifying that ALL erratic leap duration should be ignored. Negative year bases are not allowed and any attempt to do so would result in a negative datemod instead. If no year base is provided, all erratic leap duration will be accounted for.

Proactive Dating

'Year basing' is specifically useful when writing a date in the future where erratic leap duration is unknown.
Therefore, if we want to write a date 10 years after the current date of 44TC and the last known leap second occurred at the end of year 42TC, we could use 43 or 44 as the year base to write this date as 54TC43 or 54TC44 (but not 54TC42 because it will not account for the last leap second that occurred at the end of year 42TC).


The optional 'datemod' (which stands for 'date modification') field takes the place of traditional timezones and offsets by adding or subtracting to/from the date instant.
If the preceding delimiter of a datemod is '-', the datemod value is negative and will be subtracted from the current date. Conversely, any other preceding delimiter constitutes a positive the datemod value that will be added to the current date. If the datemod is equivalent of 0, it is unnecessary (and discouraged, depending on your purpose) to include a datemod since any designator automatically assumes a +0 datemod.

Datemod Values

A datemod with only an integer value and no letters indicates an integer number of seconds that the terran computational date should be modified by. The datemod field may alternatively represent the number of Minutes, Hours, Days, Weeks, Lunas (months), and/or Quarters if proceeded by a M, H, D, W, L, or Q respectively. Any combination may be used as well as long as they are in decreasing order of value, so for instance, could be written as 44TC+4W2D3H4M5 or 44TC+1L2D3H4M5. Notice that if a letter doesn't follow a number value, then it should be treated as seconds. Therefore all the following dates are equivalent: 44.6.14TC = 44TC+2Q = 44TC+26W = 44TC+182D = 44TC+4368H = 44TC+262080M = 44TC+15724800 = TC+1404172825


A terran computational timestamp begins with a "TC" designator proceeded by a delimiter and a datemod indicating the number of continuous seconds that have past since the the terran computational epoch. The UNIX Epoch can roughly* be written as TC+864000 and the the terran computational epoch can roughly* be written as -864000 in UNIX Time. The current timestamp is TC+. Since the terran computational calendar is a continuous algorithm, any year base will result in the same timestamp, so year bases are unnecessary if writing a timestamp. Please note, however that if the delimiter is not included, the timestamp will actually be parsed as a 'year base' resulting in the equivalent of the terran computational epoch or 0TC.

Leap Duration

A terran computational year's leap duration is defined as the sum of all leap units (leap seconds,…, & leap days,…) within that year. This leap duration is put into an additional minimonth at the end of the year. All leap units have the same field placement within a date and are equal in duration to their corresponding unit.

Leap Days

There is always at least 1 leap day per year. In years that are a multiple of 4 but not of 128, an additional leap day is included resulting in 2 leap days that year. Adding leap days in this fashion is extremely efficient and will keep each year synchronized with the northern winter solstice.
There will be no leap year day when the remainder of dividing the year by 128 is 0 (when the year is exactly divisible by 128 & the year is a multiple of 128). This includes the year 0 and any negative or positive multiples of 128, so, for example, there would be no leap years in the years …, -512, -384, -256, -128, 0, 128, 256, …
Assume 1 mean tropical year = 365.2421897 days
Assume an average year with 1 leap year day every 4 years = (365 + 365 + 365 + 366) / 4 = 365.25 days
Let YEARtrop = 365.2421897 days
Let YEARavg = 365.25 days
Let DIFF be the number of days per year that must be made up for each year
DIFF = YEARavg - YEARtrop
      = 0.0078103 days per year
Let NUMYEARSexact be the number of DIFFs it takes to equal a day
NUMYEARSexact = 1 day / DIFF
      = 1 day / 0.0078103 days per year
      = 128.036054953 years
128.036054953 years is extremely close to 128 years, so that's why 128 is chosen as the point to omit a leap year.

Leap Seconds

Any leap seconds issued by the IERS within the bounds of a given terran computational year will manifest themselves in that year's minimonth. The terran computational calendar does not account for erratic leap duration before 0TC, so to ignore all leap seconds, apply a year base of 0 to a date's designator (TC0). There have been 25 leap seconds since 0TC, all of which occurred in different years (2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 18, 20, 21, 22, 23, 24, 26, 27, 29, 36, 39, 42). Check out the following UTC and terran computational leap second comparison tables: The IERS issues leap seconds in order to keep the beginning of each day synchronized to the same point. The terran computational calendar recognizes the need for this synchronization over the centuries and therefore adds any leap seconds issued by the IERS during a given Year to its leap duration (minimonth). These leap seconds include all those that have been issued for UTC from 1972 UTC onward. Please note that, functionally, terran computational leap seconds do not manifest themselves in the same way or at the same time as UTC leap seconds.

UTC Leap Seconds

1972-06-30 23:59:60 UTC
1972-12-31 23:59:60 UTC
1973-12-31 23:59:60 UTC
1974-12-31 23:59:60 UTC
1975-12-31 23:59:60 UTC
1976-12-31 23:59:60 UTC
1977-12-31 23:59:60 UTC
1978-12-31 23:59:60 UTC
1979-12-31 23:59:60 UTC
1981-06-30 23:59:60 UTC
1982-06-30 23:59:60 UTC
1983-06-30 23:59:60 UTC
1985-06-30 23:59:60 UTC
1987-12-31 23:59:60 UTC
1989-12-31 23:59:60 UTC
1990-12-31 23:59:60 UTC
1992-06-30 23:59:60 UTC
1993-06-30 23:59:60 UTC
1994-06-30 23:59:60 UTC
1995-12-31 23:59:60 UTC
1997-06-30 23:59:60 UTC
1998-12-31 23:59:60 UTC
2005-12-31 23:59:60 UTC
2008-12-31 23:59:60 UTC
2012-06-30 23:59:60 UTC
2.6.24,0.0.0 TC
3.0.11,0.0.0 TC
4.0.11,0.0.0 TC
5.0.10,0.0.0 TC
6.0.10,0.0.0 TC
7.0.11,0.0.0 TC
8.0.11,0.0.0 TC
9.0.10,0.0.0 TC
10.0.10,0.0.0 TC
11.6.24,0.0.0 TC
12.6.24,0.0.0 TC
13.6.23,0.0.0 TC
15.6.24,0.0.0 TC
18.0.10,0.0.0 TC
20.0.11,0.0.0 TC
21.0.10,0.0.0 TC
22.6.24,0.0.0 TC
23.6.24,0.0.0 TC
24.6.24,0.0.0 TC
26.0.10,0.0.0 TC
27.6.24,0.0.0 TC
29.0.10,0.0.0 TC
36.0.11,0.0.0 TC
39.0.11,0.0.0 TC
42.6.24,0.0.0 TC

Terran Computational Leap Seconds

1972-12-20 23:59:59 UTC
1973-12-20 23:59:59 UTC
1974-12-21 23:59:59 UTC
1975-12-21 23:59:59 UTC
1976-12-20 23:59:59 UTC
1977-12-20 23:59:59 UTC
1978-12-21 23:59:59 UTC
1979-12-21 23:59:59 UTC
1980-12-20 23:59:59 UTC
1981-12-20 23:59:59 UTC
1982-12-21 23:59:59 UTC
1983-12-21 23:59:59 UTC
1985-12-20 23:59:59 UTC
1988-12-20 23:59:59 UTC
1990-12-21 23:59:59 UTC
1991-12-21 23:59:59 UTC
1992-12-20 23:59:59 UTC
1993-12-20 23:59:59 UTC
1994-12-21 23:59:59 UTC
1996-12-20 23:59:59 UTC
1997-12-20 23:59:59 UTC
1999-12-21 23:59:59 UTC
2006-12-21 23:59:59 UTC
2009-12-20 23:59:59 UTC
2012-12-20 23:59:59 UTC
2.13.1,0.0.0 TC
3.13.1,0.0.0 TC
4.13.2,0.0.0 TC
5.13.1,0.0.0 TC
6.13.1,0.0.0 TC
7.13.1,0.0.0 TC
8.13.2,0.0.0 TC
9.13.1,0.0.0 TC
10.13.1,0.0.0 TC
11.13.1,0.0.0 TC
12.13.2,0.0.0 TC
13.13.1,0.0.0 TC
15.13.1,0.0.0 TC
18.13.1,0.0.0 TC
20.13.2,0.0.0 TC
21.13.1,0.0.0 TC
22.13.1,0.0.0 TC
23.13.1,0.0.0 TC
24.13.2,0.0.0 TC
26.13.1,0.0.0 TC
27.13.1,0.0.0 TC
29.13.1,0.0.0 TC
36.13.2,0.0.0 TC
39.13.1,0.0.0 TC
42.13.1,0.0.0 TC

Erratic Leap Duration

Erratic leap duration refers to unknown or unstable leap duration, such as IERS issued leap seconds. No erratic leap duration occurs before 0TC, so, to ignore all erratic leap duration apply a year base of 0 to a date's designator (TC0).
If other standardized methods ever arise to account for leap drift, the resulting remaining shift in duration will be rounded up to a terran computational second, treated as erratic leap duration, and be added to a given year's minimonth. And any resulting remainder will be used to calculate the next year's erratic leap duration. A year base of 0 (TC0) ignores all erratic leap duration.

Date Notation

The following is equivalent to the terran computational epoch (0TC): terran computational calendar date notation (-1,13/0 23_59:59.0TC0+1) Each terran computational date defines an exact unambiguous instant in time and is composed of a designator plus other conditionally optional date fields concatenated together by delimiters. In order, these fields are year, month, day, hour, minute, second, fraction, designator, datemod and their ranges are roughly: ±*.[0-13].[0-27].[0-23].[0-59].[0-59].*.TC*±*, where * is any acceptable range. The current terran computational date (which could be written like this: 42.13.1,0.0.0 TC ) literally means that exactly 42 years, 13 months, 1 days, 0 hours, 0 minutes, and 0 seconds have passed since the Terran Computational Epoch. To learn about the other acceptable ways to write terran computational dates, see the section on algorithm for formatting & parsing.


'TC' is an acronym for 'terran computational'. Terran computational dates and written timestamps must utilize a 'TC' and optionally concatenated positive integer year base as a designator. A 'TC' designator without a year base signifies that all known erratic leap duration should be accounted for. A 'TC' designator with a given year base, n, signifies that only erratic leap duration before nTC should be accounted for.


Delimiters separate date fields from one another. The only 8 acceptable delimiters are space, plus, comma, minus, dot, slash, colon, underscore ( +,-./:_) (UTF8 hex codes 20, 2b, 2c, 2d, 2e, 2f, 3a, 5f). A delimiter directly before the designator is optional. For exact rules regarding delimiters, view the algorithm for formatting & parsing.

Algorithm for Formatting and Parsing

The following is a comprehensive list of rules for formatting and parsing terran computational dates:
  • The order of fields is: year, month, day, hour, minute, second, fraction, designator, datemod.
  • The only characters that may be used in a terran computational date are the following 26: ' +,-./1234567890:CDHLMQTW_' corresponding to UTF8 hex codes (20, 2b, 2c, 2d, 2e, 2f, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 3a, 43, 44, 48, 4c, 4d, 51, 54, 57, 5f).
  • Each delimiter must comply with the delimiter section.
  • All fields must have a delimiter on each side unless specified otherwise.
  • Each date field must comply to its corresponding range for each unit in the basic time measurement section, the designator section and the datemod section.
  • All fields may represent a positive integer value. Only the year field or the datemod field may represent negative values. If the value of either the year field or the datemod field represents a negative value, the field's preceding delimiter must be the '-' character.
  • The delimiter to the right of the datemod field is always optional and generally discouraged.
  • The delimiter to the left of the year field is required if its value is negative, but is otherwise optional.
  • If the datemod is a value of zero, it is optional. If the datemod has been omitted, the delimiters on either side are optional. If a non-zero datemod is present, the delimiter to the left is always required.
  • The delimiter to the left of the designator is always optional.
  • If the value of the field to the left of the designator is zero, it is optional.

Accommodated Time Measurement

Weeks and quarters can be expressed, in some manner, utilizing datemods and decades, centuries, & millennia are implied by years.


One week is defined as the duration of 7 days. Any integer number of weeks can be expressed by appending a W as a datemod. For example, 44TC+39W is the equivalent of 44.9.21TC, or if you want to do away with years, and use weeks for the highest unit, you could write this date as TC+2334W5D25 For reasons of simplicity and neutrality, any further definition of weeks, other than their datemod duration, is undefined because it's outside the calendar template's purpose. Any further definition of weeks or other values is up to the individual or group who may want to use and define them for their own specific purposes. Terran computaional dates are unambiguous instances in time, nothing more. There is really no requirement to associate any names or labels with the calendar at all. The only reason labels such as "years", "months", "minimonths", "datemod"... are used is just to more easily describe the duration and purpose of these date fields.


One quarter is defined as the duration of 13 weeks. Any integer number of quarters can be expressed by appending a Q as a datemod. For example, 44TC+3Q is the equivalent of 44.9.21TC, or if you want to do away with years, and use quarters for the highest unit, you could write this date as TC+179Q7W5D25

Decades, Centuries, & Millennia

Just like years, decades, centuries, and millennia also function as integers whereby decade -1 covers years -10 through -1 and decade 0 covers years 0 through 9; millennia -1 would cover years -1000 to -1 and millennia 0 would cover years 0 through 999.

Unaccommodated Time Measurement

The following cycles have complex algorithms or are somewhat erratic and therefore the terran computational calendar has not hard-wired simple ways to track their cycles into its algorithm.

Timezone Abbreviations

The terran computational calendar does not implement or support traditional timezone abbreviations, but it does allow for dynamic date modifications, or 'datemods' which easily represent regional time.
To convert a timezone abbreviation into a datemod, determine the UTC offset in hours, minutes or seconds multiply it by -1 to get the datemod. For Instance, the PST timezone has an offset of -7 hours in UTC, so the datemod would be +7H in the terran computational calendar.

JST, a +09:00 offset in UTC is a -9H datemod. NST, a -03:30 offset in UTC is a +210M TC datemod. Note that these datemods can also be expressed in different ways.

In UTC, there are a large number of timezones, each with their own set of rules which are even themselves possibly subject to change. Therefore, for reasons of transparency, timezones are not implemented in terran computational dates. Although not as descriptive and verbose, datemods are more well defined, easier to calculate, and they do not require complicated lengthy tables of offsets (unless you are of course converting between another calendar system which utilizes timezones). Timezones may still be useful for referencing datemods, but they are still not permitted for use in terran computational dates.

Seasons, Solstices, & Equinoxes

While the terran computational calendar accommodates quarters, the only season/solstice that the terran computational calendar tracks, within some degree of extreme ease, is the beginning of winter and the winter solstice of the northern hemisphere which falls around the beginning/end of each year. But even that is not constant, so in order to determine the exact time of an equinox, solstice, or season, please check out the follow conversion table:
Seasons generally still start within a day of the following corresponding terran computational dates: (*=any given year) *.0.0TC (n. winter solstice), *.3.5TC (n. vernal equinox), *.6.13TC (n. summer solstice), *.9.24TC (n. autumnal equinox) which in turn are within a couple days of their corresponding quarter: *.0.0TC, *.3.7TC, *.6.14TC, *.9.21TC .

Northern Winter Solstice

2010-12-21 23:38:00 UTC
2011-12-22 05:30:00 UTC
2012-12-21 11:12:00 UTC
2013-12-21 17:11:00 UTC
2014-12-21 23:03:00 UTC
2015-12-22 04:48:00 UTC
2016-12-21 10:44:00 UTC
2017-12-21 16:28:00 UTC
2018-12-21 22:23:00 UTC
2019-12-22 04:19:00 UTC
2020-12-21 10:02:00 UTC
40-13-01 23:38:00 TC
42-00-00 05:30:00 TC
43-00-00 11:12:00 TC
44-00-00 17:11:00 TC
44-13-01 23:03:00 TC
46-00-00 04:48:00 TC
47-00-00 10:44:00 TC
48-00-00 16:28:00 TC
48-13-01 22:23:00 TC
50-00-00 04:19:00 TC
51-00-00 10:02:00 TC

Northern Vernal Equinox

2010-03-20 17:32:00 UTC
2011-03-20 23:21:00 UTC
2012-03-20 05:14:00 UTC
2013-03-20 11:02:00 UTC
2014-03-20 16:57:00 UTC
2015-03-20 22:45:00 UTC
2016-03-20 04:30:00 UTC
2017-03-20 10:29:00 UTC
2018-03-20 16:15:00 UTC
2019-03-20 21:58:00 UTC
2020-03-20 03:50:00 UTC
40-03-05 17:32:00 TC
41-03-04 23:21:00 TC
42-03-05 05:14:00 TC
43-03-05 11:02:00 TC
44-03-05 16:57:00 TC
45-03-04 22:45:00 TC
46-03-05 04:30:00 TC
47-03-05 10:29:00 TC
48-03-05 16:15:00 TC
49-03-04 21:58:00 TC
50-03-05 03:50:00 TC

Northern Summer Solstice

2010-06-21 11:28:00 UTC
2011-06-21 17:16:00 UTC
2012-06-20 23:09:00 UTC
2013-06-21 05:04:00 UTC
2014-06-21 10:51:00 UTC
2015-06-21 16:38:00 UTC
2016-06-20 22:34:00 UTC
2017-06-21 04:24:00 UTC
2018-06-21 10:07:00 UTC
2019-06-21 15:54:00 UTC
2020-06-20 21:44:00 UTC
40-06-14 11:28:00 TC
41-06-13 17:16:00 TC
42-06-13 23:09:00 TC
43-06-14 05:04:00 TC
44-06-14 10:51:00 TC
45-06-13 16:38:00 TC
46-06-13 22:34:00 TC
47-06-14 04:24:00 TC
48-06-14 10:07:00 TC
49-06-13 15:54:00 TC
50-06-13 21:44:00 TC

Northern Autumnal Equinox

2010-09-23 03:09:00 UTC
2011-09-23 09:05:00 UTC
2012-09-22 14:49:00 UTC
2013-09-22 20:44:00 UTC
2014-09-23 02:29:00 UTC
2015-09-23 08:21:00 UTC
2016-09-22 14:21:00 UTC
2017-09-22 20:02:00 UTC
2018-09-23 01:54:00 UTC
2019-09-23 07:50:00 UTC
2020-09-22 13:31:00 UTC
40-09-24 03:09:00 TC
41-09-23 09:05:00 TC
42-09-23 14:49:01 TC
43-09-23 20:44:00 TC
44-09-24 02:29:00 TC
45-09-23 08:21:00 TC
46-09-23 14:21:00 TC
47-09-23 20:02:00 TC
48-09-24 01:54:00 TC
49-09-23 07:50:00 TC
50-09-23 13:31:00 TC

Moon Cycles

The cycles of the moon, like most objects in our solar system including the earth, are somewhat erratic. And although months are a general approximation of lunar cycles, the terran computational calendar makes no attempt to track these cycles explicitly. On average, the duration of time from one new moon to the next (its synodic period) is roughly 29.53 days and the duration of time for the moon to completely orbit the earth (its orbital period) is roughly 27.32 days. The duration of a terran computational month is 28 days which is in between those two periods, but does not match either of these cycles to any great degree of accuracy.

Milankovitch Cycles

Milankovitch Cycles include the many cycles of the earth whose periods are on timescales of tens of thousands of years. Since these periods are so extensive and also so erratic, they are generally incredibly difficult to predict within any great degree of accuracy. Therefore, the terran computational calendar does not explicitly track any of these cycles.

Accuracy, Neutrality, & Permanency

Calendar Accuracy

Adding leaps days in years that are a multiple of 4 but not a multiple of 128 creates an extremely efficient time keeping method. Much more so than any other simplistic consistent algorithm.
Accuracy is affected by many factors, but compared to other methods of adding and omitting leap days, the accuracy of this calendar has overwhelmingly more accuracy, possibly by a factor of over 100. Our simple demonstrative calculations show the accuracy of the terran computational calendar to the a loss of one day per half million years (based on the 365.2421897 day mean tropical year).

In calculations for the Leap Days section, we find that we need to correct for leap years once every 128.036054953 years, but since it's convenient to have an integer amount to do this, we chose to correct the leap years once every 128 years. By doing so, we lose a little accuracy, but not much. Continuing from previous calculations:
NUMYEARSexact = 128.036054953 years
DIFF = 0.0078103 days per year
Let NUMYEARS = 128 years
Let DIFFomit be the number of days per year that must be made up by using the leap year omissions every 128 years
DIFFomit = (1 day/NUMYEARS) - (1 day/NUMYEARSexact) = (1 day/128 years) - (1 day/128.036054953 years) = 0.0078125 days per year
Let DIFFdiff be the number of days per year that must be made up per year using leap year omissions every 128 years
DIFFdiff = DIFF - DIFFdiff = 0.0078103 days per year - 0.0078125 days per year = −0.0000022 days per year
Let ACCURACY be the number of years it will take before this calendar is off by a day
ACCURACY = 1 day / DIFFdiff = 1 day / 0.0000022 days/year =
454545.45 years
This is a really really long time in calendar terms, though keep in mind that there are many factors that influence a calendar's accuracy and so it is highly unlikely that this calendar is that accurate as there are many other bottlenecks to consider.


Apart from inherent bias, the terran computational calendar intends to be a non-biased neutral calendar for anyone to use for any purpose. Besides its connections to math, computers, atomic time, and astronomy, this calendar does not intend to favor any culture, creed, time, or place. It is a simple idea intending to remain as simple as possible for its purpose, nothing more. Its public domain mark allows people to use the calendar without having worry about most legal restrictions. For reasons of simplicity and neutrality, any further definition of weeks, other than their datemod duration, is undefined because it's outside the calendar template's purpose. Any further definition of weeks or other values is up to the individual or group who may want to use and define them for their own specific purposes. Terran computaional dates are unambiguous instances in time, nothing more. There is really no requirement to associate any names or labels with the calendar at all. The only reason labels such as "years", "months", "minimonths", "datemod"... are used is just to more easily describe the duration and purpose of these date fields.

Level of Permanency

The terran computational calendar maintains a very high level of conformity and permanency:
  • Each full month, day, hour, minute, second, week, and quarter are of constant length
  • Each time measurement unit begins at 0
  • Years, decades, centuries, etc. are integer based
  • Each year begins near the northern winter solstice
  • Each quarter lasts for 3¼ months or 13 weeks
  • Calendrical drift is suspended by including leap days in years that are a multiple of 4 but not of 128
  • All written dates are unambiguous.
  • Any date tells you explicitly how many years, months, days, hours, minutes, and seconds have past since the terran computational epoch.