To translate UUIDs, GUIDs and ULIDs accurately, a translator must separate software-object identity from the ordinary language used to describe records, events, files and API resources. Application logs, databases, configuration files, software interfaces and technical documentation can place object names, universally unique identifiers, GUIDs, ULIDs and timestamps in the same record. The explanatory prose may need translation; the identifiers normally must remain exact. One changed character can detach the target text from the underlying object.
This guide explains how to translate software and database content without changing UUIDs, GUIDs, UUID URNs or ULIDs. It solves one distinct search intent: what does each identifier represent, which parts may be localized, why UUID version matters, how GUID terminology relates to UUID, how UUIDv7 differs from UUIDv4, how ULID encodes time and randomness, and how multilingual systems can preserve the same object identity after translation.
The working rule is translate the human-readable label, preserve the identifier, keep the identifier format and version visible, and verify every relationship after export. RFC 9562 defines 128-bit UUIDs—also known as GUIDs in common software usage—and obsoletes RFC 4122. The canonical UUID text form uses hexadecimal digits in groups separated by hyphens; UUIDv7 incorporates a Unix-epoch millisecond timestamp and random data, while ULID is a separate 128-bit identifier format using a 26-character Crockford Base32 representation with a timestamp plus randomness. These systems are related in purpose but not interchangeable.
UUID is a 128-bit identifier
RFC 9562 defines UUIDs as 128-bit universally unique identifiers. The hexadecimal display is an encoding of those bits, not translatable text. Preserve the identifier exactly. Treat the human-readable object label as translatable, the identifier as protected, and the database or API relationship as something to verify after export. This keeps the same software object addressable across every language.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
GUID is widely used as a synonym
RFC 9562 notes that UUIDs are also known as GUIDs. Terminology differs across ecosystems, but the identifier value remains the machine key. Translate explanations, not the GUID string. The practical test is application traceability. A reviewer using only the target should be able to query the same resource or database row and understand whether the ID is UUID, GUID, ULID or another local identifier.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
RFC 9562 is the current UUID standard
RFC 9562 obsoletes RFC 4122 and defines current UUID formats including newer versions. Old documentation can still cite RFC 4122. Preserve historical references while using current terminology in new guidance. For structured files, keep identifiers in native or text fields and exclude them from locale formatting, case conversion, spell-checking and generative rewriting. Translation can change display language around a stable machine key.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Canonical UUID text form uses hexadecimal
Common UUID text uses 32 hexadecimal digits separated into 8-4-4-4-12 groups. Changing separators or digit case usually changes representation and can break strict systems. Keep the source form. A strong reviewer checks both directions: start from the target object and confirm its identifier, then start from the identifier and confirm the same resource, version, parent-child links and API route.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Hyphens are structural delimiters
The canonical text representation includes hyphens at fixed positions. Smart punctuation can replace hyphens with dashes. Protect ASCII hyphens. Treat the human-readable object label as translatable, the identifier as protected, and the database or API relationship as something to verify after export. This keeps the same software object addressable across every language.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Hex digits are not words
Letters a-f or A-F belong to hexadecimal representation. Translating or expanding them is meaningless. Preserve the token. The practical test is application traceability. A reviewer using only the target should be able to query the same resource or database row and understand whether the ID is UUID, GUID, ULID or another local identifier.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
UUID is not a decimal number
Although it represents 128 bits, the displayed UUID should not be parsed as an ordinary user-facing number. Numeric formatting can destroy the string. Store UUIDs as text or native UUID type. For structured files, keep identifiers in native or text fields and exclude them from locale formatting, case conversion, spell-checking and generative rewriting. Translation can change display language around a stable machine key.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
UUID version is encoded in the value
Version bits identify how the UUID was constructed under the standard. Changing one character can alter the version field and identity. Never edit UUID characters for language reasons. A strong reviewer checks both directions: start from the target object and confirm its identifier, then start from the identifier and confirm the same resource, version, parent-child links and API route.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Variant is another structural field
UUID layout includes variant bits governing interpretation. The variant is machine-level metadata, not translatable content. Preserve the full 128-bit value. Treat the human-readable object label as translatable, the identifier as protected, and the database or API relationship as something to verify after export. This keeps the same software object addressable across every language.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
UUIDv1 is time-based with legacy node semantics
Version 1 uses timestamp and node-related fields in the historical DCE model. It can expose temporal or node information depending on generation method. Do not infer privacy or identity claims beyond the source. The practical test is application traceability. A reviewer using only the target should be able to query the same resource or database row and understand whether the ID is UUID, GUID, ULID or another local identifier.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
UUIDv3 is name-based using MD5
Version 3 deterministically derives a UUID from namespace plus name using MD5 under the standard. Translating the input name would generate a different UUID. Preserve stored v3 identifiers. For structured files, keep identifiers in native or text fields and exclude them from locale formatting, case conversion, spell-checking and generative rewriting. Translation can change display language around a stable machine key.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
UUIDv4 is random-based
Version 4 uses random or pseudorandom bits except for required version and variant fields. It carries no user-facing linguistic content. Keep the generated value unchanged. A strong reviewer checks both directions: start from the target object and confirm its identifier, then start from the identifier and confirm the same resource, version, parent-child links and API route.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
UUIDv5 is name-based using SHA-1
Version 5 deterministically derives the identifier from namespace and name using SHA-1. A translated source name can generate another UUID. Do not regenerate IDs during localization. Treat the human-readable object label as translatable, the identifier as protected, and the database or API relationship as something to verify after export. This keeps the same software object addressable across every language.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
UUIDv6 reorders time fields
RFC 9562 defines version 6 as a reordered time-based format improving database locality over v1-style layout. It is a distinct version, not a textual reformatting of v1. Keep version identity. The practical test is application traceability. A reviewer using only the target should be able to query the same resource or database row and understand whether the ID is UUID, GUID, ULID or another local identifier.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
UUIDv7 is Unix-time ordered
Version 7 places Unix-epoch milliseconds in the most significant 48 bits and uses remaining bits for randomness or optional monotonicity mechanisms. It is useful for time-ordered systems. Preserve the exact generated identifier. For structured files, keep identifiers in native or text fields and exclude them from locale formatting, case conversion, spell-checking and generative rewriting. Translation can change display language around a stable machine key.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
UUIDv8 is application-specific
Version 8 allows custom layouts within the UUID framework while preserving version and variant constraints. Its semantics depend on the generating application. Do not infer meaning from the visible characters. A strong reviewer checks both directions: start from the target object and confirm its identifier, then start from the identifier and confirm the same resource, version, parent-child links and API route.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
UUID versions are not interchangeable
Different versions can encode or generate identity using different methods. Converting v4 to v7 by editing digits is invalid. Migration requires application-level generation and data mapping. Treat the human-readable object label as translatable, the identifier as protected, and the database or API relationship as something to verify after export. This keeps the same software object addressable across every language.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Namespace UUID is another identifier
Name-based UUIDs use namespace UUIDs such as DNS or URL namespace values. The namespace is part of deterministic generation context. Preserve it exactly. The practical test is application traceability. A reviewer using only the target should be able to query the same resource or database row and understand whether the ID is UUID, GUID, ULID or another local identifier.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Name input can be human-readable
The name used to generate a v3 or v5 UUID can be a domain, URL or other string. Translating that input changes the resulting UUID. Keep generation inputs stable when identity must remain stable. For structured files, keep identifiers in native or text fields and exclude them from locale formatting, case conversion, spell-checking and generative rewriting. Translation can change display language around a stable machine key.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
UUID URN adds another syntax layer
RFC 9562 defines the urn:uuid namespace for representing UUIDs as URNs. The urn:uuid prefix is machine syntax. Do not translate the prefix. A strong reviewer checks both directions: start from the target object and confirm its identifier, then start from the identifier and confirm the same resource, version, parent-child links and API route.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
URN representation is not the same as bare UUID field
A system can store either a bare UUID or a UUID URN depending on schema. Removing urn:uuid changes the representation expected by some APIs. Honor the field contract. Treat the human-readable object label as translatable, the identifier as protected, and the database or API relationship as something to verify after export. This keeps the same software object addressable across every language.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Braces are ecosystem-specific presentation
Some software displays GUIDs inside braces. Those braces are not part of the canonical RFC text form but may be required by a particular API or file format. Preserve the source representation. The practical test is application traceability. A reviewer using only the target should be able to query the same resource or database row and understand whether the ID is UUID, GUID, ULID or another local identifier.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Uppercase and lowercase can both appear
Hexadecimal UUIDs are commonly case-insensitive in many parsers, but systems can preserve one presentation style. Translation should not change case without a reason. Keep source formatting for auditability. For structured files, keep identifiers in native or text fields and exclude them from locale formatting, case conversion, spell-checking and generative rewriting. Translation can change display language around a stable machine key.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
GUID binary byte order can differ in some APIs
Some Microsoft-oriented binary or textual conversions historically expose mixed-endian field handling. Copying raw bytes between systems without defined conversion can change display. Treat binary conversion as engineering, not translation. A strong reviewer checks both directions: start from the target object and confirm its identifier, then start from the identifier and confirm the same resource, version, parent-child links and API route.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Database UUID type is preferable to text where available
Many databases provide a native UUID type. Translation pipelines should not convert native IDs into localized strings. Keep the data field outside language processing. Treat the human-readable object label as translatable, the identifier as protected, and the database or API relationship as something to verify after export. This keeps the same software object addressable across every language.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Primary keys often use UUIDs
Applications can use UUIDs as database primary keys. Changing the key breaks foreign-key relationships. Never localize database identity. The practical test is application traceability. A reviewer using only the target should be able to query the same resource or database row and understand whether the ID is UUID, GUID, ULID or another local identifier.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Foreign keys must remain paired
Related tables can store the same UUID to link records. A correct UUID moved to the wrong row still corrupts data. Verify relationships, not just characters. For structured files, keep identifiers in native or text fields and exclude them from locale formatting, case conversion, spell-checking and generative rewriting. Translation can change display language around a stable machine key.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
API resource IDs often use UUIDs
REST and GraphQL APIs can place UUIDs in paths, variables or payloads. Translating the path component breaks retrieval. Keep resource IDs exact. A strong reviewer checks both directions: start from the target object and confirm its identifier, then start from the identifier and confirm the same resource, version, parent-child links and API route.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
URL encoding should not rewrite UUID content
UUIDs may appear inside URLs or query parameters. Percent encoding belongs to transport syntax rather than language. Preserve underlying identifier. Treat the human-readable object label as translatable, the identifier as protected, and the database or API relationship as something to verify after export. This keeps the same software object addressable across every language.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Log correlation IDs can be UUIDs
Distributed systems often use UUID-like request or trace IDs. They connect events across services. A translation should not regenerate them. The practical test is application traceability. A reviewer using only the target should be able to query the same resource or database row and understand whether the ID is UUID, GUID, ULID or another local identifier.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Session IDs are a different security-sensitive layer
Some UUID-looking values can function as sessions or tokens. Public translation examples should redact secrets even if they resemble benign UUIDs. Follow security policy. For structured files, keep identifiers in native or text fields and exclude them from locale formatting, case conversion, spell-checking and generative rewriting. Translation can change display language around a stable machine key.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
UUID is not automatically a secret
Many UUIDs are public identifiers, while some applications misuse them as unguessable tokens. A translator should not infer confidentiality from format alone. Use field context. A strong reviewer checks both directions: start from the target object and confirm its identifier, then start from the identifier and confirm the same resource, version, parent-child links and API route.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Object IDs and UUIDs can coexist
Systems can use integer IDs, UUIDs and human-readable slugs simultaneously. Replacing one with another changes schema. Keep identifier type explicit. Treat the human-readable object label as translatable, the identifier as protected, and the database or API relationship as something to verify after export. This keeps the same software object addressable across every language.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Slug is not UUID
A localized URL slug can change by language while the underlying resource UUID remains stable. This is a useful multilingual design pattern. Keep slug and ID separate. The practical test is application traceability. A reviewer using only the target should be able to query the same resource or database row and understand whether the ID is UUID, GUID, ULID or another local identifier.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Filename can include UUID
Generated files may include UUIDs to prevent collisions. Translating the surrounding filename text should not alter the UUID segment. Protect mixed tokens. For structured files, keep identifiers in native or text fields and exclude them from locale formatting, case conversion, spell-checking and generative rewriting. Translation can change display language around a stable machine key.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Configuration files can contain UUIDs
Device IDs, profile IDs and deployment identifiers often appear in YAML, JSON or XML. Translating values breaks configuration. Localize comments and UI labels only. A strong reviewer checks both directions: start from the target object and confirm its identifier, then start from the identifier and confirm the same resource, version, parent-child links and API route.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
JSON keys can be translated only in documentation
Production JSON field names and UUID values are machine contracts. Changing them breaks consumers. Translate explanatory documentation, not payload schema. Treat the human-readable object label as translatable, the identifier as protected, and the database or API relationship as something to verify after export. This keeps the same software object addressable across every language.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
YAML anchors and IDs are separate syntax
YAML can contain identifiers as scalar values plus its own structural features. Translation should not treat all short tokens as prose. Use schema-aware tooling. The practical test is application traceability. A reviewer using only the target should be able to query the same resource or database row and understand whether the ID is UUID, GUID, ULID or another local identifier.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
XML attributes can carry UUIDs
XML documents often store UUIDs in attributes. The attribute value is identity data. Protect values and element names required by schema. For structured files, keep identifiers in native or text fields and exclude them from locale formatting, case conversion, spell-checking and generative rewriting. Translation can change display language around a stable machine key.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
ULID is a separate identifier format
ULID is a 128-bit identifier specification designed to be lexicographically sortable. It is not a UUID version. Keep ULID and UUID namespaces separate. A strong reviewer checks both directions: start from the target object and confirm its identifier, then start from the identifier and confirm the same resource, version, parent-child links and API route.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
ULID canonical string has 26 characters
The ULID spec uses 26 Crockford Base32 characters. Changing length or alphabet breaks the canonical form. Preserve the full string. Treat the human-readable object label as translatable, the identifier as protected, and the database or API relationship as something to verify after export. This keeps the same software object addressable across every language.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
ULID uses Crockford Base32
The alphabet excludes easily confused letters such as I, L, O and U. Translating characters or replacing them with look-alikes creates invalid IDs. Protect the token. The practical test is application traceability. A reviewer using only the target should be able to query the same resource or database row and understand whether the ID is UUID, GUID, ULID or another local identifier.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
ULID includes a timestamp component
The first 48 bits represent Unix time in milliseconds. It can support lexical ordering by time in canonical representation. Do not edit timestamp characters. For structured files, keep identifiers in native or text fields and exclude them from locale formatting, case conversion, spell-checking and generative rewriting. Translation can change display language around a stable machine key.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
ULID includes 80 bits of randomness
The remaining bits provide randomness for uniqueness within time constraints. Translation has no role in regenerating them. Preserve the original value. A strong reviewer checks both directions: start from the target object and confirm its identifier, then start from the identifier and confirm the same resource, version, parent-child links and API route.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
ULID sorting depends on canonical representation
Lexicographic sorting works when the canonical encoding and consistent collation are used. Locale-aware sort rules can interfere. Use ASCII/binary ordering for IDs. Treat the human-readable object label as translatable, the identifier as protected, and the database or API relationship as something to verify after export. This keeps the same software object addressable across every language.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
ULID is case-insensitive by specification
The canonical ecosystem commonly displays uppercase, while comparison can be case-insensitive under the spec. Translation should still preserve source case for consistency. Do not case-transform IDs casually. The practical test is application traceability. A reviewer using only the target should be able to query the same resource or database row and understand whether the ID is UUID, GUID, ULID or another local identifier.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
ULID is URL-safe without punctuation
Canonical ULIDs avoid hyphens and special characters. Adding separators for readability creates a noncanonical string. Keep all 26 characters contiguous. For structured files, keep identifiers in native or text fields and exclude them from locale formatting, case conversion, spell-checking and generative rewriting. Translation can change display language around a stable machine key.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
ULID monotonic generation is an implementation option
Implementations can use monotonic behavior for IDs generated in the same millisecond. The visible ID should not be rewritten after creation. Leave generation semantics to software. A strong reviewer checks both directions: start from the target object and confirm its identifier, then start from the identifier and confirm the same resource, version, parent-child links and API route.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
ULID and UUIDv7 both provide time-ordering ideas
Both can support time-oriented database behavior but use different encodings and standards. They are not text conversions of each other. Migration requires explicit application logic. Treat the human-readable object label as translatable, the identifier as protected, and the database or API relationship as something to verify after export. This keeps the same software object addressable across every language.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Timestamp leakage can matter
Time-based identifiers can reveal approximate creation time. A translation should not expose or hide that fact by altering the ID. Handle privacy at system-design level. The practical test is application traceability. A reviewer using only the target should be able to query the same resource or database row and understand whether the ID is UUID, GUID, ULID or another local identifier.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Sorting by ID is not the same as translating date order
A target locale may display dates differently, but identifier sort semantics remain technical. Locale collation should not be applied to UUID or ULID ordering. Keep machine sort separate. For structured files, keep identifiers in native or text fields and exclude them from locale formatting, case conversion, spell-checking and generative rewriting. Translation can change display language around a stable machine key.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Spreadsheets can alter long identifiers
UUIDs are usually safe as text, but tools can trim braces, lowercase values or split columns. ULIDs can also be autoformatted as text but still be damaged by cleanup rules. Define protected columns. A strong reviewer checks both directions: start from the target object and confirm its identifier, then start from the identifier and confirm the same resource, version, parent-child links and API route.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
CSV needs explicit field names
A generic id column can contain UUID, ULID, integer or external reference. Translation teams need schema context. Record identifier type. Treat the human-readable object label as translatable, the identifier as protected, and the database or API relationship as something to verify after export. This keeps the same software object addressable across every language.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
OCR can misread identifiers
Screenshots can confuse 0/O, 1/I or hex characters. A one-character error can create another syntactically plausible ID. Use copyable digital source data. The practical test is application traceability. A reviewer using only the target should be able to query the same resource or database row and understand whether the ID is UUID, GUID, ULID or another local identifier.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Smart punctuation can corrupt UUID hyphens
Desktop publishing can substitute typographic dashes. Visual similarity does not guarantee parser equality. Protect ASCII characters. For structured files, keep identifiers in native or text fields and exclude them from locale formatting, case conversion, spell-checking and generative rewriting. Translation can change display language around a stable machine key.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Right-to-left layouts need directionality testing
UUID and ULID strings can appear inside RTL interfaces. Visual ordering or selection can become confusing. Test copy/paste behavior. A strong reviewer checks both directions: start from the target object and confirm its identifier, then start from the identifier and confirm the same resource, version, parent-child links and API route.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Do not localize hexadecimal digits
Some target locales use alternate numeral glyphs. UUID textual syntax expects ASCII hexadecimal representation. Translate labels, not identifier characters. Treat the human-readable object label as translatable, the identifier as protected, and the database or API relationship as something to verify after export. This keeps the same software object addressable across every language.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Machine translation should lock identifiers
MT can insert spaces, explain acronyms or change punctuation. A fluent target can break object lookup. Mask UUID/GUID/ULID strings. The practical test is application traceability. A reviewer using only the target should be able to query the same resource or database row and understand whether the ID is UUID, GUID, ULID or another local identifier.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Translation memory can carry stale resource IDs
Templates and logs are repetitive. High matches can reuse another object’s identifier. Populate IDs from current source data. For structured files, keep identifiers in native or text fields and exclude them from locale formatting, case conversion, spell-checking and generative rewriting. Translation can change display language around a stable machine key.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Search-and-replace can damage entire datasets
Bulk hyphen or case changes can modify every UUID. One editorial command can break relationships at scale. Restrict changes to translatable fields. A strong reviewer checks both directions: start from the target object and confirm its identifier, then start from the identifier and confirm the same resource, version, parent-child links and API route.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Worked example: localized resource label
A fictional database record has a UUID primary key and a translatable product name. The target changes the name while the UUID remains stable. All foreign-key links continue to work. Treat the human-readable object label as translatable, the identifier as protected, and the database or API relationship as something to verify after export. This keeps the same software object addressable across every language.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Worked example: UUIDv7 event log
A fictional event stream uses UUIDv7 IDs that sort approximately by creation time. The target translates event messages but preserves IDs. Keep timestamp-derived ordering technical. The practical test is application traceability. A reviewer using only the target should be able to query the same resource or database row and understand whether the ID is UUID, GUID, ULID or another local identifier.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Worked example: ULID API object
A fictional API returns a ULID resource ID and localized display title. The title changes language while the 26-character ULID remains exact. Use the ID for cross-locale retrieval. For structured files, keep identifiers in native or text fields and exclude them from locale formatting, case conversion, spell-checking and generative rewriting. Translation can change display language around a stable machine key.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Error clinic
Common failures include smart-dash substitution, GUID/UUID schema confusion, UUID regeneration, ULID separator insertion, locale sorting and stale TM identifiers. These errors can survive fluent software documentation. Run dedicated software-ID QA. A strong reviewer checks both directions: start from the target object and confirm its identifier, then start from the identifier and confirm the same resource, version, parent-child links and API route.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Release checklist
Identifier type, UUID version, representation, namespace, resource relationship, sort semantics and privacy context all need verification. Checking only visible labels is insufficient. Validate token equality and database relationships. Treat the human-readable object label as translatable, the identifier as protected, and the database or API relationship as something to verify after export. This keeps the same software object addressable across every language.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Frequently asked questions
UUIDs, GUIDs and ULIDs should not be translated. Users often ask whether GUID and UUID are the same or whether ULID is UUIDv7. Explain shared purpose but different representation and standards. The practical test is application traceability. A reviewer using only the target should be able to query the same resource or database row and understand whether the ID is UUID, GUID, ULID or another local identifier.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Connection to eduKateSG architecture
This specialist owner protects software-object identity rather than broad localization or code translation. Existing technical translation owners cover software interfaces and files. Use this page for persistent software identifiers. For structured files, keep identifiers in native or text fields and exclude them from locale formatting, case conversion, spell-checking and generative rewriting. Translation can change display language around a stable machine key.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Authoritative sources
RFC 9562 is the current UUID standard and the ULID project publishes its canonical specification. Framework-specific GUID behavior can add representation details. Verify production formats against the standard and application schema. A strong reviewer checks both directions: start from the target object and confirm its identifier, then start from the identifier and confirm the same resource, version, parent-child links and API route.
Before release, ask what the field identifies and which format governs it. The target should make UUID version, GUID representation or ULID use explicit when those details affect sorting, interoperability or debugging.
Reference verification route
For current UUID semantics, use RFC 9562, which defines UUIDs/GUIDs and versions including UUIDv7 and obsoletes RFC 4122. For ULID, use the canonical ULID specification. Application frameworks may add display or byte-order conventions, so production translation should preserve the identifier exactly and follow the system’s schema rather than reformatting it for language.