
alphadec
AlphaDec, a timezone-agonistic time format for humans, machines, and AI
Stars: 76

Alphadec is a timezone-agnostic, human-readable time format designed for global timestamp synchronization. It encodes any UTC timestamp into a structured string that is lexically sortable, time-series friendly, human-readable, and compact. Alphadec serves as a powerful primitive for AI models to understand the passage of time and offers emergent properties like rhythmic timestamps, chronological ID fragments, and version labels. It is AI-friendly, database-friendly, and collision-free with ISO time formats. Alphadec's canonical format consists of parts representing the UTC year, periods, arcs, bars, beats, and milliseconds offset, allowing for efficient time-range queries and index stability.
README:
A timezone-agnostic, readable time format for humans, machines, and AI.
AlphaDec is a shared global timestamp. If an event is scheduled for N0A0
, every participant worldwide knows what that means — without converting timezones or formats.
Example:
-
AlphaDec:
2025_L0V3
- UTC: June 5th, 2025, 1:45PM (Approximately)
-
AlphaDec (canonical format):
2025_L0V3_000000
- UTC: 2025-06-05T13:45:20.236Z
Current time snapshot (automatically updated; may be around 1 hour behind):
GMT: Friday, Sep 5, 2025, 3:12 PM
AlphaDec | AlphaDec Arc | Arc Remaining Time |
---|---|---|
2025_R6K3 |
R6 | 20.3 hrs |
Mexico City | NYC | Abu Dhabi |
Fri 9:12 AM | Fri 11:12 AM | Fri 7:12 PM |
Delhi | Tokyo | Sydney |
Fri 8:42 PM | Sat 12:12 AM | Sat 1:12 AM |
AlphaDec in action inside an AI chat.
Every ~7.8-minute beat (t
) triggers a new memory summary.
Instead of timestamps, the model sees structured time tokens likeN1U0
.
It doesn’t just label time — it thinks with it.
AlphaDec encodes any UTC timestamp into a readable string that sorts chronologically. This simple concept unlocks a host of powerful emergent properties.
- Lexically Sortable: Natively time-sortable in any system that can sort strings alphabetically. Perfect for database primary keys.
-
Time-Series Friendly: Truncate the string for efficient time-range queries.
2024_M
finds everything in that ~14-day period. - Human-Readable & Compact: Understand a timestamp's approximate place in the year at a glance.
- LLM & AI-Native: Its structured, tokenizable, continuous rhythm makes it a powerful primitive for giving AI a sense for how time is passing.
- Collision-free with ISO time: AlphaDec avoids datetime-like formats, so you never confuse an AlphaDec timestamp for a local time (a past Alphadec is the same 'time ago' for everyone).
The canonical AlphaDec string is composed of several parts:
YYYY_PeriodArcBarBeat_MSOffset
- YYYY: The UTC year.
-
Period: The year is divided into 26 periods, represented by letters
A
throughZ
. Each period is roughly 14 days long. -
Arc: Each period is divided into 10 arcs, numbered
0
through9
. Each arc is roughly 33.7 hours long. -
Bar: Each arc is divided into 26 bars,
A
throughZ
. Each bar is roughly 77.8 minutes long. -
Beat: Each bar is divided into 10 beats,
0
through9
. Each beat is roughly 7.8 minutes long. -
MsOffset: The number of milliseconds that have elapsed within the current beat.
- In common years (365 days), the maximum integer ms offset is 466507. In leap years (366 days), the maximum integer ms offset is 467785.
This project is language-agnostic. Below are examples of how to generate an AlphaDec string.
JavaScript Implementation
const clock = {
alphadec: {
_SCALER: 1_000_000,
_toBase26(n) {
if (n < 0 || n > 25) throw new Error("Invalid index for Base26.");
return String.fromCharCode(65 + n);
},
encode(d) {
const y = d.getUTCFullYear();
const SCALER = this._SCALER;
const msSinceYearStart_float = d.getTime() - Date.UTC(y, 0, 1, 0, 0, 0, 0);
const totalScaledMsSinceYearStart = Math.floor(msSinceYearStart_float * SCALER);
const isLeap = ((y % 4 === 0 && y % 100 !== 0) || y % 400 === 0);
const daysInYear = isLeap ? 366 : 365;
const yearTotalMs_float = daysInYear * 86_400_000;
const yearTotalScaledMs = Math.floor(yearTotalMs_float * SCALER);
const periodSizeScaled = Math.floor(yearTotalScaledMs / 26);
const arcSizeScaled = Math.floor(periodSizeScaled / 10);
const barSizeScaled = Math.floor(arcSizeScaled / 26);
const beatSizeScaled = Math.floor(barSizeScaled / 10);
let remainingScaledMs = totalScaledMsSinceYearStart;
const p_idx = Math.floor(remainingScaledMs / periodSizeScaled);
remainingScaledMs -= p_idx * periodSizeScaled;
const a_val = Math.floor(remainingScaledMs / arcSizeScaled);
remainingScaledMs -= a_val * arcSizeScaled;
const b_idx = Math.floor(remainingScaledMs / barSizeScaled);
remainingScaledMs -= b_idx * barSizeScaled;
const t_val = Math.floor(remainingScaledMs / beatSizeScaled);
remainingScaledMs -= t_val * beatSizeScaled;
const msOffsetInBeat = Math.floor(remainingScaledMs / SCALER);
const periodLetter = this._toBase26(p_idx);
const barLetter = this._toBase26(b_idx);
const canonicalMsPart = msOffsetInBeat.toString().padStart(6, "0");
const canonical = `${y}_${periodLetter}${a_val}${barLetter}${t_val}_${canonicalMsPart}`;
return { canonical };
}
}
};
PHP Implementation
<?php
/**
* Generates a lexically sortable AlphaDec timestamp from a DateTime object.
*
* @param DateTime|null $datetime The datetime to encode. Defaults to UTC now.
* @return string The canonical AlphaDec string (e.g., "2024_M5C3_123456").
* @throws Exception If the provided datetime is invalid.
*
* NOTE: This function requires a 64-bit PHP environment due to large integer calculations.
*/
function generate_alphadec(DateTime $datetime = null): string {
// If no datetime is provided, use the current time in UTC.
if ($datetime === null) {
$datetime = new DateTime("now", new DateTimeZone("UTC"));
}
$y = (int)$datetime->format("Y");
// SCALER is used to perform calculations with integer math to avoid float precision issues.
$SCALER = 1000000;
// Calculate the total milliseconds that have passed since the beginning of the year.
$startOfYear = new DateTime("$y-01-01T00:00:00Z");
$msSinceYearStart = ($datetime->format('U.v') - $startOfYear->format('U.v')) * 1000;
// Scale up for integer-based math.
$totalScaledMsSinceYearStart = (int)floor($msSinceYearStart * $SCALER);
// Determine the total number of milliseconds in the current year.
$isLeap = (bool)$datetime->format('L');
$daysInYear = $isLeap ? 366 : 365;
$yearTotalMs = $daysInYear * 86400000;
$yearTotalScaledMs = (int)floor($yearTotalMs * $SCALER);
// Calculate the size of each AlphaDec time unit in scaled milliseconds.
$periodSizeScaled = (int)floor($yearTotalScaledMs / 26); // ~14 days
$arcSizeScaled = (int)floor($periodSizeScaled / 10); // ~33.7 hours
$barSizeScaled = (int)floor($arcSizeScaled / 26); // ~77.8 minutes
$beatSizeScaled = (int)floor($barSizeScaled / 10); // ~7.8 minutes
// Use division and remainder to find the index of each time unit.
$remaining = $totalScaledMsSinceYearStart;
$p_idx = (int)floor($remaining / $periodSizeScaled); $remaining -= $p_idx * $periodSizeScaled;
$a_val = (int)floor($remaining / $arcSizeScaled); $remaining -= $a_val * $arcSizeScaled;
$b_idx = (int)floor($remaining / $barSizeScaled); $remaining -= $b_idx * $barSizeScaled;
$t_val = (int)floor($remaining / $beatSizeScaled); $remaining -= $t_val * $beatSizeScaled;
// The final remainder is the millisecond offset within the current "beat".
$msOffsetInBeat = (int)floor($remaining / $SCALER);
// Convert numeric indices to their character representation (A-Z).
$periodLetter = chr(65 + $p_idx);
$barLetter = chr(65 + $b_idx);
// Format the final milliseconds part to be 6 digits, zero-padded.
$canonicalMsPart = str_pad((string)$msOffsetInBeat, 6, "0", STR_PAD_LEFT);
// Assemble the final canonical string.
return "{$y}_{$periodLetter}{$a_val}{$barLetter}{$t_val}_{$canonicalMsPart}";
}
?>
While AlphaDec was designed as a verbally chunked and compressed form of UTC, the mathematical structure leads to many emergent properties. For example:
- AlphaDec timestamps are quite rhythmic: M2L3 ticks over to M2L4, etc.
- Period F, Period M, Period S, and Period Z always bracket equinoxes and solstices, even in leap years when AlphaDec units stretch to accomodate the longer UTC year.
- AlphaDec can be used as readable, chronological ID fragments such as prefixes and suffixes.
- Version labels: Unlike "v1, v10, v2" which breaks alphabetical order, AlphaDec versions (or version prefixes) like
2025_A1B2
sort chronologically by default.
- Unit intervals explicitly change one of four characters rather than requiring calculating numeric deltas to realize that time has passed
AlphaDec encodes time hierarchically. Each additional character narrows the scope — from periods to beats to milliseconds — forming a natural prefix tree.
This structure enables:
- Time-based partitioning (e.g., logs by 2025_M)
- Fast range queries with simple string matching
- Index stability (no random insert churn like UUIDs)
- Optional semantic suffixes without breaking order
Because Alphadec stamps are strings, you can use them in more contexts than a standard timestamp—and unlike 2025-08-11
, the unit sizes on 2025_P8G2
don't jump from 1 day to a full month.
AlphaDec does not prescribe a rigid ID format. Instead, its time-based, sortable nature makes it an excellent component for building meaningful identifiers through composition.
You can use the full canonical string or truncate it to the desired precision. Combine it with prefixes or suffixes like dictionary words, counters, or random characters to suit your specific needs.
This flexibility allows you to create IDs that are both chronologically sortable and contextually rich, without sacrificing readability.
Examples:
-
2025_G0R5_todo.txt
(A truncated AlphaDec timestamp followed by a semantic tag) -
2025_R173_154329_01.png
(An AlphaDec timestamp followed by a counter) -
sales_Y3.sql
(A category prefix followed by a truncated AlphaDec timestamp)
Consider these filenames prefixed with ISO dates:
- 2025-08-07-screenshot.png
- 2025-10-22-crashlog.txt
And now with Alphadec:
- 2025_P5I6-screenshot.png
- 2025_V0A0-crashlog.txt
Both prefixes sort chronologically, but Alphadec achieves far higher resolution with fewer characters: setting aside underscores and hyphens, 8 chars in Alphadec mark an ~8 minute period of time compared to 24 hours in ISO.
More significantly: the Alphadec prefixes are easier to skim past as a label, and less aesthetically harsh-looking. Admittedly this is a subjective point, but it's worthy of consideration.
Time is usually 'metadata': a file property, a database column. Alphadec, by virtue of being a string that can be used in filenames and AI conversations, turns time into document syntax, like a bullet point.
Furthermore, Alphadec includes strong semantics because of the way it combines unit position and compression: it's like a Zip Code for time.
These properties lead to time becoming a more prominent citizen of informational workflows.
A UUID is a collection of random characters like f81d4fae-7dec-11d0-a765-00a0c91e6bf6
.
Now consider: what is the point of all this paranoid entropy? Is there any chance that a 7-Eleven receipt and NASA spectrograph will end up in the same S3 bucket?
And even if so:
- How would you tell your objects apart? You'd still need a separate index to organize your jumble of UUIDs.
- Why would Snowflake IDs not suffice? Very few organizations are generating more varied objects at higher velocity than Twitter.
To be fair, if you were a software component identifying yourself to Windows 3.1 in 1992, a 'GUID' made sense. But UUIDs were never meant to be database keys (where they cause index problems) or URLs (where they're ugly).
Now here is a cosmic truth: Time is entropy. Why ignore literal entropy to create a bag of your own?
Alphadec, like Snowflake, KSUIDs, and ULIDs, embrace time as an inherent disambiguiator. However, an Alphadec prefix like 2025_P5U5_326662 is more easily interpretable than the others.
Consumer laptops using Node.js can encode nearly 1 million UTC dates into Alphadec per second, i.e. roughly one timestamp per microsecond. This represents the lower bound of expected performance.
AlphaDec units stretch in leap years to accommodate the extra 24 hours. Since the year is always divided into exactly 26 periods regardless of length, each time unit becomes slightly longer in leap years than in common years.
This creates temporal drift between leap and common years that accumulates throughout the year, reaching maximum separation at the midpoint at Beat N0A0 — exactly 12 hours difference.
For example, July 4th midnight demonstrates how the same calendar moment maps to different AlphaDec coordinates:
-
2025 (common):
N1B7
- July 4, 2025 00:00 UTC -
2024 (leap):
N1K9
- July 4, 2024 00:00 UTC
Notice the first two characters remain the same (N1
) as both dates fall within the same period and arc, but the bar-beat coordinates diverge significantly (K9
vs B7
), reflecting the accumulated temporal drift.
Pure Function Design: We accept this temporal drift as a deliberate trade-off to maintain AlphaDec as a pure mathematical function of UTC year duration and milliseconds elapsed since year start, ensuring the encoding remains deterministic.
Gregorian Boundary: AlphaDec acts like a temporal compass bounded by Gregorian years. The drift simply reflects the underlying astronomical reality that July 4th occurs at different orbital positions in 365-day versus 366-day years.
- Not aligned with ISO Date/Time: Alphadec units are rational fractions of the year, and are thus almost never aligned with ISO dates. Do not use Alphadec to fill out tax forms.
- Quantization Loss: Conversion (UTC → Alphadec or Alphadec → UTC) may drift by a few milliseconds. This is for two reasons: Alphadec units are almost never aligned with ISO seconds; additionally, when encoding and decoding, we never round 'up' fractional values and instead truncate to the nearest completed unit of time. (Note that in practice, an accumulated round-trip loss of ~3 ms is usually irrelevant; a default MySQL datetime has second-level precision, i.e. 1000x more coarse than a millisecond.)
- Cross-Year Math: Arithmetic operations spanning multiple years are not supported or intended due to the units stretching on leap years.
- Distributed Local Events: AlphaDec is not particularly applicable to global events that synchronize with local time of day. For example, iftar during Ramadan, Christmas midnight mass, or New Year's Eve celebrations are inherently tied to local time. AlphaDec is for marking singular moments, not distributed observances.
AlphaDec is not a replacement for ISO 8601, created_at
, or your existing datetime columns.
It’s a representation — a compact, structured, and readable fingerprint of UTC time.
You still store full datetimes in your database.
You still use ISO for APIs, logs, schemas, and interop.
But when you want to name a file, index a memory, prefix a row, or group logs, you can reach for:
AlphaDec: 2025_L0V3_001827
Instead of:
ISO 8601: 2025-06-14T23:37:42.814Z
One is for machines.
One is for humans, filenames, indexes, AI models.
AlphaDec sits beside your datetime — not in place of it.
Here’s how AlphaDec compares to other systems:
- Divides the day into 1000 “.beats” (
@000
to@999
), anchored to UTC+1. - Intended to be universal, but doesn't encode the date —
@000
repeats every day. -
@000
in Tokyo might be a different date than in NYC.
✅ Global
❌ Ambiguous
❌ Not hierarchical
❌ Not useful for indexing or filenames
- Used in ham radio to encode spatial positions in a compact grid (e.g.,
FN31pr
). - Each character increases precision, and prefixes group cleanly.
✅ Hierarchical
✅ Prefix-sortable
✅ Spatially meaningful
AlphaDec is like Maidenhead — but for time.
You can zoom in or out: Year → Period → Arc → Beat → Offset.
- Canonical format for timestamps (
2025-07-21T13:42:11Z
) - Great for storage, transport, and validation.
✅ Precise
✅ Interoperable
❌ Verbose
❌ Not sort-friendly as a string (unless zero-padded)
❌ Not great for filenames or embeddings
These are modern, sortable database IDs designed to replace UUIDs. They combine a high-precision timestamp with machine IDs (Snowflake) or randomness (ULID).
They are excellent for generating unique, chronological primary keys at scale.
- ✅ Sortable
- ✅ High-performance
- ✅ Collision-resistant
- ❌ Not Glanceable: The timestamp portion is a monolithic integer, not broken down into meaningful components. You can't tell if a ULID is from mid-year.
- ❌ Not Hierarchical: They don't have a "time tree" structure. You can't query for a ~14-day "Period" using a simple string prefix. AlphaDec focuses on human/AI legibility and hierarchical querying, whereas ULID/Snowflake focus on machine-level key generation.
Alphadec originated as a way to synchronize events across timezones. Splitting the year into A-Z creates periods with gradations, and further heirarchical division is quite effective in creating smaller 'addresses' in time.
Numeric characters were interwoven to enable verbal chunking and to avoid spelling words.
Any other characteristics of Alphadec were not designed; they emerged from this arithmetic and associated semantics.
Alphadec is well-applicable to time because of the nature of an 'Year':
- Cyclical: The ends of the scale overlap. When 2024 is 100% done we're back to 0% done in 2025
- Relational: Multiple reference points are discussed at the same time, e.g. 'the movie is coming out three periods from now'
Interestingly, the Maidenhead Locator System is quite similar to Alphadec and has both properties: geocodes are cyclical and relational.
Compass bearings have the same properties—and indeed, Alphadec functions as an approximate compass for Earth's orbit around the sun.
- If you visualize Alphadec as a radial clock, A0A0 sits at 0 degrees in the circle, and N0A0 is at 180 degrees. Period A contains the moment when Earth is closest to the Sun (perihelion), while Period N marks the time when Earth is furthest (aphelion).
We can contrast these properties by using altitude as a foil. Why would altitude not benefit from an Alphadec-like quantization? Because altitude is linear: there is a fixed zero and no "wrap-around." Additionally, altitude is absolute: when you are climbing from 5,000 ft to 10,000 ft, the starting point becomes irrelevant.
A color wheel is another helpful contrast: although it is cyclical, points on the wheel are usually discussed independently. Referring to colors in a navigational or hierarchical manner is uncommon.
An ISO time like 4:30pm represents progress in sunrise and sunset. This is useful if you are laboring in a field: when sunlight fades, you are done for the day. However, in most contemporary contexts, the clock is a marker of events decoupled from the sun. "We have three hours to get ready and reach the wedding venue." Alphadec is literally a measure of such 'time elapsed' and 'time remaining'.
The scale of Alphadec units (a ~34 hr arc and ~1hr20 min bar) can be used by a person to plan their day.
The Period unit exhibits alignment with the Earth's orbit.
Period | Event | Description |
---|---|---|
A | Perihelion | Earth's closest approach to the Sun (Early January) |
F | March Equinox | Spring in the Northern Hemisphere and autumn in the Southern Hemisphere |
M | June Solstice | Summer in the Northern Hemisphere, winter in the Southern Hemisphere |
N | Aphelion | Earth's farthest distance from the Sun (Early July) |
S | September Equinox | Autumn in the Northern Hemisphere and spring in the Southern Hemisphere |
Z | December Solstice | Winter in the Northern Hemisphere, summer in the Southern Hemisphere |
These 16 AlphaDec coordinates represent exact fractional positions in the year where the encoding aligns perfectly with millisecond boundaries (offset _000000
).
The alignments are a result of the mathematical relationship between the total number of seconds in a common year (31,536,000) and the total number of AlphaDec beats (67,600). The Greatest Common Divisor (GCD) of these two numbers is 400.
Any fraction 1/D, where D is a divisor of 400, will create a set of alignment points. This includes fractions like 1/100 (1% intervals), 1/20 (5% intervals), and even 1/400 (0.25% intervals), which yields a total of 400 perfect alignment points throughout the year. These 16 points are a subset.
% of Year | AlphaDec | 2025 UTC (Common) | 2024 UTC (Leap) |
---|---|---|---|
0% | A0A0_000000 |
Jan 1, 00:00 | Jan 1, 00:00 |
6.25% | B6G5_000000 |
Jan 23, 19:30 | Jan 23, 21:00 |
12.5% | D2N0_000000 |
Feb 15, 15:00 | Feb 15, 18:00 |
18.75% | E8T5_000000 |
Mar 10, 10:30 | Mar 9, 15:00 |
25% | G5A0_000000 |
Apr 2, 06:00 | Apr 1, 12:00 |
31.25% | I1G5_000000 |
Apr 25, 01:30 | Apr 24, 09:00 |
37.5% | J7N0_000000 |
May 17, 21:00 | May 17, 06:00 |
43.75% | L3T5_000000 |
Jun 9, 16:30 | Jun 9, 03:00 |
50% | N0A0_000000 |
Jul 2, 12:00 | Jul 2, 00:00 |
56.25% | O6G5_000000 |
Jul 25, 07:30 | Jul 24, 21:00 |
62.5% | Q2N0_000000 |
Aug 17, 03:00 | Aug 16, 18:00 |
68.75% | R8T5_000000 |
Sep 8, 22:30 | Sep 8, 15:00 |
75% | T5A0_000000 |
Oct 1, 18:00 | Oct 1, 12:00 |
81.25% | V1G5_000000 |
Oct 24, 13:30 | Oct 24, 09:00 |
87.5% | W7N0_000000 |
Nov 16, 09:00 | Nov 16, 06:00 |
93.75% | Y3T5_000000 |
Dec 9, 04:30 | Dec 9, 03:00 |
Note: While these points encode with perfect _000000
offsets, they still decode with the standard -1ms precision loss due to systematic flooring in the decoder. These represent the rare moments where AlphaDec's rational fractions of the year align exactly with integer millisecond values.
AlphaDec | 2024 ISO (Leap Yr) | 2025 ISO | Drift |
---|---|---|---|
A0A0 |
2024-01-01T00:00:00.000Z |
2025-01-01T00:00:00.000Z |
0 min |
B0A0 |
2024-01-15T01:50:46.153Z |
2025-01-15T00:55:23.076Z |
+55 min |
C0A0 |
2024-01-29T03:41:32.307Z |
2025-01-29T01:50:46.153Z |
+1h 51m |
D0A0 |
2024-02-12T05:32:18.461Z |
2025-02-12T02:46:09.230Z |
+2h 46m |
E0A0 |
2024-02-26T07:23:04.615Z |
2025-02-26T03:41:32.307Z |
+3h 42m |
F0A0 |
2024-03-11T09:13:50.769Z |
2025-03-12T04:36:55.384Z |
+4h 37m |
G0A0 |
2024-03-25T11:04:36.923Z |
2025-03-26T05:32:18.461Z |
+5h 32m |
H0A0 |
2024-04-08T12:55:23.076Z |
2025-04-09T06:27:41.538Z |
+6h 28m |
I0A0 |
2024-04-22T14:46:09.230Z |
2025-04-23T07:23:04.615Z |
+7h 23m |
J0A0 |
2024-05-06T16:36:55.384Z |
2025-05-07T08:18:27.692Z |
+8h 18m |
K0A0 |
2024-05-20T18:27:41.538Z |
2025-05-21T09:13:50.769Z |
+9h 14m |
L0A0 |
2024-06-03T20:18:27.692Z |
2025-06-04T10:09:13.846Z |
+10h 9m |
M0A0 |
2024-06-17T22:09:13.846Z |
2025-06-18T11:04:36.923Z |
+11h 5m |
N0A0 |
2024-07-01T23:59:59.999Z |
2025-07-02T12:00:00.000Z |
+12h 0m ⭐ |
O0A0 |
2024-07-16T01:50:46.153Z |
2025-07-16T12:55:23.076Z |
+11h 5m |
P0A0 |
2024-07-30T03:41:32.307Z |
2025-07-30T13:50:46.153Z |
+10h 9m |
Q0A0 |
2024-08-13T05:32:18.461Z |
2025-08-13T14:46:09.230Z |
+9h 14m |
R0A0 |
2024-08-27T07:23:04.615Z |
2025-08-27T15:41:32.307Z |
+8h 18m |
S0A0 |
2024-09-10T09:13:50.769Z |
2025-09-10T16:36:55.384Z |
+7h 23m |
T0A0 |
2024-09-24T11:04:36.923Z |
2025-09-24T17:32:18.461Z |
+6h 28m |
U0A0 |
2024-10-08T12:55:23.076Z |
2025-10-08T18:27:41.538Z |
+5h 32m |
V0A0 |
2024-10-22T14:46:09.230Z |
2025-10-22T19:23:04.615Z |
+4h 37m |
W0A0 |
2024-11-05T16:36:55.384Z |
2025-11-05T20:18:27.692Z |
+3h 42m |
X0A0 |
2024-11-19T18:27:41.538Z |
2025-11-19T21:13:50.769Z |
+2h 46m |
Y0A0 |
2024-12-03T20:18:27.692Z |
2025-12-03T22:09:13.846Z |
+1h 51m |
Z0A0 |
2024-12-17T22:09:13.846Z |
2025-12-17T23:04:36.923Z |
+55 min |
Designed by Firas Durri • https://twitter.com/firasd • https://www.linkedin.com/in/firasd
For Tasks:
Click tags to check more tools for each tasksFor Jobs:
Alternative AI tools for alphadec
Similar Open Source Tools

alphadec
Alphadec is a timezone-agnostic, human-readable time format designed for global timestamp synchronization. It encodes any UTC timestamp into a structured string that is lexically sortable, time-series friendly, human-readable, and compact. Alphadec serves as a powerful primitive for AI models to understand the passage of time and offers emergent properties like rhythmic timestamps, chronological ID fragments, and version labels. It is AI-friendly, database-friendly, and collision-free with ISO time formats. Alphadec's canonical format consists of parts representing the UTC year, periods, arcs, bars, beats, and milliseconds offset, allowing for efficient time-range queries and index stability.

Cherry_LLM
Cherry Data Selection project introduces a self-guided methodology for LLMs to autonomously discern and select cherry samples from open-source datasets, minimizing manual curation and cost for instruction tuning. The project focuses on selecting impactful training samples ('cherry data') to enhance LLM instruction tuning by estimating instruction-following difficulty. The method involves phases like 'Learning from Brief Experience', 'Evaluating Based on Experience', and 'Retraining from Self-Guided Experience' to improve LLM performance.

LLM4Decompile
LLM4Decompile is an open-source large language model dedicated to decompilation of Linux x86_64 binaries, supporting GCC's O0 to O3 optimization levels. It focuses on assessing re-executability of decompiled code through HumanEval-Decompile benchmark. The tool includes models with sizes ranging from 1.3 billion to 33 billion parameters, available on Hugging Face. Users can preprocess C code into binary and assembly instructions, then decompile assembly instructions into C using LLM4Decompile. Ongoing efforts aim to expand capabilities to support more architectures and configurations, integrate with decompilation tools like Ghidra and Rizin, and enhance performance with larger training datasets.

TPI-LLM
TPI-LLM (Tensor Parallelism Inference for Large Language Models) is a system designed to bring LLM functions to low-resource edge devices, addressing privacy concerns by enabling LLM inference on edge devices with limited resources. It leverages multiple edge devices for inference through tensor parallelism and a sliding window memory scheduler to minimize memory usage. TPI-LLM demonstrates significant improvements in TTFT and token latency compared to other models, and plans to support infinitely large models with low token latency in the future.

evalchemy
Evalchemy is a unified and easy-to-use toolkit for evaluating language models, focusing on post-trained models. It integrates multiple existing benchmarks such as RepoBench, AlpacaEval, and ZeroEval. Key features include unified installation, parallel evaluation, simplified usage, and results management. Users can run various benchmarks with a consistent command-line interface and track results locally or integrate with a database for systematic tracking and leaderboard submission.

factorio-learning-environment
Factorio Learning Environment is an open source framework designed for developing and evaluating LLM agents in the game of Factorio. It provides two settings: Lab-play with structured tasks and Open-play for building large factories. Results show limitations in spatial reasoning and automation strategies. Agents interact with the environment through code synthesis, observation, action, and feedback. Tools are provided for game actions and state representation. Agents operate in episodes with observation, planning, and action execution. Tasks specify agent goals and are implemented in JSON files. The project structure includes directories for agents, environment, cluster, data, docs, eval, and more. A database is used for checkpointing agent steps. Benchmarks show performance metrics for different configurations.

spandrel
Spandrel is a library for loading and running pre-trained PyTorch models. It automatically detects the model architecture and hyperparameters from model files, and provides a unified interface for running models.

1filellm
1filellm is a command-line data aggregation tool designed for LLM ingestion. It aggregates and preprocesses data from various sources into a single text file, facilitating the creation of information-dense prompts for large language models. The tool supports automatic source type detection, handling of multiple file formats, web crawling functionality, integration with Sci-Hub for research paper downloads, text preprocessing, and token count reporting. Users can input local files, directories, GitHub repositories, pull requests, issues, ArXiv papers, YouTube transcripts, web pages, Sci-Hub papers via DOI or PMID. The tool provides uncompressed and compressed text outputs, with the uncompressed text automatically copied to the clipboard for easy pasting into LLMs.

onefilellm
OneFileLLM is a command-line tool that streamlines the creation of information-dense prompts for large language models (LLMs). It aggregates and preprocesses data from various sources, compiling them into a single text file for quick use. The tool supports automatic source type detection, handling of multiple file formats, web crawling functionality, integration with Sci-Hub for research paper downloads, text preprocessing, token count reporting, and XML encapsulation of output for improved LLM performance. Users can easily access private GitHub repositories by generating a personal access token. The tool's output is encapsulated in XML tags to enhance LLM understanding and processing.

llm-structured-output-benchmarks
Benchmark various LLM Structured Output frameworks like Instructor, Mirascope, Langchain, LlamaIndex, Fructose, Marvin, Outlines, LMFormatEnforcer, etc on tasks like multi-label classification, named entity recognition, synthetic data generation. The tool provides benchmark results, methodology, instructions to run the benchmark, add new data, and add a new framework. It also includes a roadmap for framework-related tasks, contribution guidelines, citation information, and feedback request.

SageAttention
SageAttention is an official implementation of an accurate 8-bit attention mechanism for plug-and-play inference acceleration. It is optimized for RTX4090 and RTX3090 GPUs, providing performance improvements for specific GPU architectures. The tool offers a technique called 'smooth_k' to ensure accuracy in processing FP16/BF16 data. Users can easily replace 'scaled_dot_product_attention' with SageAttention for faster video processing.

Consistency_LLM
Consistency Large Language Models (CLLMs) is a family of efficient parallel decoders that reduce inference latency by efficiently decoding multiple tokens in parallel. The models are trained to perform efficient Jacobi decoding, mapping any randomly initialized token sequence to the same result as auto-regressive decoding in as few steps as possible. CLLMs have shown significant improvements in generation speed on various tasks, achieving up to 3.4 times faster generation. The tool provides a seamless integration with other techniques for efficient Large Language Model (LLM) inference, without the need for draft models or architectural modifications.

BetaML.jl
The Beta Machine Learning Toolkit is a package containing various algorithms and utilities for implementing machine learning workflows in multiple languages, including Julia, Python, and R. It offers a range of supervised and unsupervised models, data transformers, and assessment tools. The models are implemented entirely in Julia and are not wrappers for third-party models. Users can easily contribute new models or request implementations. The focus is on user-friendliness rather than computational efficiency, making it suitable for educational and research purposes.

AutoGPTQ
AutoGPTQ is an easy-to-use LLM quantization package with user-friendly APIs, based on GPTQ algorithm (weight-only quantization). It provides a simple and efficient way to quantize large language models (LLMs) to reduce their size and computational cost while maintaining their performance. AutoGPTQ supports a wide range of LLM models, including GPT-2, GPT-J, OPT, and BLOOM. It also supports various evaluation tasks, such as language modeling, sequence classification, and text summarization. With AutoGPTQ, users can easily quantize their LLM models and deploy them on resource-constrained devices, such as mobile phones and embedded systems.

HuatuoGPT-o1
HuatuoGPT-o1 is a medical language model designed for advanced medical reasoning. It can identify mistakes, explore alternative strategies, and refine answers. The model leverages verifiable medical problems and a specialized medical verifier to guide complex reasoning trajectories and enhance reasoning through reinforcement learning. The repository provides access to models, data, and code for HuatuoGPT-o1, allowing users to deploy the model for medical reasoning tasks.

zo2
ZO2 (Zeroth-Order Offloading) is an innovative framework designed to enhance the fine-tuning of large language models (LLMs) using zeroth-order (ZO) optimization techniques and advanced offloading technologies. It is tailored for setups with limited GPU memory, enabling the fine-tuning of models with over 175 billion parameters on single GPUs with as little as 18GB of memory. ZO2 optimizes CPU offloading, incorporates dynamic scheduling, and has the capability to handle very large models efficiently without extra time costs or accuracy losses.
For similar tasks

alphadec
Alphadec is a timezone-agnostic, human-readable time format designed for global timestamp synchronization. It encodes any UTC timestamp into a structured string that is lexically sortable, time-series friendly, human-readable, and compact. Alphadec serves as a powerful primitive for AI models to understand the passage of time and offers emergent properties like rhythmic timestamps, chronological ID fragments, and version labels. It is AI-friendly, database-friendly, and collision-free with ISO time formats. Alphadec's canonical format consists of parts representing the UTC year, periods, arcs, bars, beats, and milliseconds offset, allowing for efficient time-range queries and index stability.

PlanExe
PlanExe is a planning AI tool that helps users generate detailed plans based on vague descriptions. It offers a Gradio-based web interface for easy input and output. Users can choose between running models in the cloud or locally on a high-end computer. The tool aims to provide a straightforward path to planning various tasks efficiently.
For similar jobs

promptflow
**Prompt flow** is a suite of development tools designed to streamline the end-to-end development cycle of LLM-based AI applications, from ideation, prototyping, testing, evaluation to production deployment and monitoring. It makes prompt engineering much easier and enables you to build LLM apps with production quality.

deepeval
DeepEval is a simple-to-use, open-source LLM evaluation framework specialized for unit testing LLM outputs. It incorporates various metrics such as G-Eval, hallucination, answer relevancy, RAGAS, etc., and runs locally on your machine for evaluation. It provides a wide range of ready-to-use evaluation metrics, allows for creating custom metrics, integrates with any CI/CD environment, and enables benchmarking LLMs on popular benchmarks. DeepEval is designed for evaluating RAG and fine-tuning applications, helping users optimize hyperparameters, prevent prompt drifting, and transition from OpenAI to hosting their own Llama2 with confidence.

MegaDetector
MegaDetector is an AI model that identifies animals, people, and vehicles in camera trap images (which also makes it useful for eliminating blank images). This model is trained on several million images from a variety of ecosystems. MegaDetector is just one of many tools that aims to make conservation biologists more efficient with AI. If you want to learn about other ways to use AI to accelerate camera trap workflows, check out our of the field, affectionately titled "Everything I know about machine learning and camera traps".

leapfrogai
LeapfrogAI is a self-hosted AI platform designed to be deployed in air-gapped resource-constrained environments. It brings sophisticated AI solutions to these environments by hosting all the necessary components of an AI stack, including vector databases, model backends, API, and UI. LeapfrogAI's API closely matches that of OpenAI, allowing tools built for OpenAI/ChatGPT to function seamlessly with a LeapfrogAI backend. It provides several backends for various use cases, including llama-cpp-python, whisper, text-embeddings, and vllm. LeapfrogAI leverages Chainguard's apko to harden base python images, ensuring the latest supported Python versions are used by the other components of the stack. The LeapfrogAI SDK provides a standard set of protobuffs and python utilities for implementing backends and gRPC. LeapfrogAI offers UI options for common use-cases like chat, summarization, and transcription. It can be deployed and run locally via UDS and Kubernetes, built out using Zarf packages. LeapfrogAI is supported by a community of users and contributors, including Defense Unicorns, Beast Code, Chainguard, Exovera, Hypergiant, Pulze, SOSi, United States Navy, United States Air Force, and United States Space Force.

llava-docker
This Docker image for LLaVA (Large Language and Vision Assistant) provides a convenient way to run LLaVA locally or on RunPod. LLaVA is a powerful AI tool that combines natural language processing and computer vision capabilities. With this Docker image, you can easily access LLaVA's functionalities for various tasks, including image captioning, visual question answering, text summarization, and more. The image comes pre-installed with LLaVA v1.2.0, Torch 2.1.2, xformers 0.0.23.post1, and other necessary dependencies. You can customize the model used by setting the MODEL environment variable. The image also includes a Jupyter Lab environment for interactive development and exploration. Overall, this Docker image offers a comprehensive and user-friendly platform for leveraging LLaVA's capabilities.

carrot
The 'carrot' repository on GitHub provides a list of free and user-friendly ChatGPT mirror sites for easy access. The repository includes sponsored sites offering various GPT models and services. Users can find and share sites, report errors, and access stable and recommended sites for ChatGPT usage. The repository also includes a detailed list of ChatGPT sites, their features, and accessibility options, making it a valuable resource for ChatGPT users seeking free and unlimited GPT services.

TrustLLM
TrustLLM is a comprehensive study of trustworthiness in LLMs, including principles for different dimensions of trustworthiness, established benchmark, evaluation, and analysis of trustworthiness for mainstream LLMs, and discussion of open challenges and future directions. Specifically, we first propose a set of principles for trustworthy LLMs that span eight different dimensions. Based on these principles, we further establish a benchmark across six dimensions including truthfulness, safety, fairness, robustness, privacy, and machine ethics. We then present a study evaluating 16 mainstream LLMs in TrustLLM, consisting of over 30 datasets. The document explains how to use the trustllm python package to help you assess the performance of your LLM in trustworthiness more quickly. For more details about TrustLLM, please refer to project website.

AI-YinMei
AI-YinMei is an AI virtual anchor Vtuber development tool (N card version). It supports fastgpt knowledge base chat dialogue, a complete set of solutions for LLM large language models: [fastgpt] + [one-api] + [Xinference], supports docking bilibili live broadcast barrage reply and entering live broadcast welcome speech, supports Microsoft edge-tts speech synthesis, supports Bert-VITS2 speech synthesis, supports GPT-SoVITS speech synthesis, supports expression control Vtuber Studio, supports painting stable-diffusion-webui output OBS live broadcast room, supports painting picture pornography public-NSFW-y-distinguish, supports search and image search service duckduckgo (requires magic Internet access), supports image search service Baidu image search (no magic Internet access), supports AI reply chat box [html plug-in], supports AI singing Auto-Convert-Music, supports playlist [html plug-in], supports dancing function, supports expression video playback, supports head touching action, supports gift smashing action, supports singing automatic start dancing function, chat and singing automatic cycle swing action, supports multi scene switching, background music switching, day and night automatic switching scene, supports open singing and painting, let AI automatically judge the content.