2027 · MerTek technology
Core system / System overview
Supplier files stop at one import boundary
Nautilus is MTK's asset import boundary. It decodes supplier files such as GLB, FBX, PNG and JPEG once, into MerTek-owned mesh, texture, rig, animation, point and image profiles. Renderers and programs read only those profiles, by name and within a byte budget.
Worked example
A utility's training team builds a pump-room trainer for new operators. The pump vendor sends GLB models, the site team sends photos, and a contractor sends a laser scan of the room. The trainer runs on workstations, headsets and a watch, and the watch build must stay under 8 MB of mesh data.
Every source file sits under the application's _assets/ folder, and its path names it: _assets/models/pump.glb becomes the asset models.pump. One command writes a starting recipe for each folder from the import format table. It reads no file contents and leaves any folder whose files mix kinds.
$ tricli --stub-imports pumpTrainer
left _assets/: mixed font image mesh
wrote _assets/fonts/_import.draft: font .ttf
wrote _assets/models/_import.draft: mesh .glb
wrote _assets/photos/_import.draft: image .jpg .png
wrote _assets/rigs/_import.draft: mesh .glbA person reviews each recipe before committing it. The pump mesh asks for four smaller levels, and the photos state their color space and a 2,048-pixel cap. The valve-handle model carries a skeleton and clips, so its recipe changes from mesh to rigClip. A recipe states intent and never names a platform.
# _assets/models/_import.draft
text[] formats = ["glb"]
text group = "file"
chest intent = {
u8 levels = 4
}
text profile = "mesh"
# _assets/photos/_import.draft
text[] formats = ["jpg", "png"]
text group = "file"
chest intent = {
text colorSpace = "srgb"
u8 levels = 6
u32 maxDimension = 2048
}
text profile = "image"The build's assets stage imports each source once. Nautilus decodes the GLB through MerCodec and writes the mesh profile and its levels to the build store. It records the source, recipe and importer digests. On the next build an unchanged source is trusted and never opened. The program reads the result by name.
# The pinned reference every keyed read takes.
chest pumpReference() {
chest family = t.assets.family("models.pump")
text state = family.state
u64 levels = family.levels
t.log.info("models.pump: " + state + ", " + text(levels) + " levels")
u64 asset = family.asset
sha256 identity = family.identity
return {u64 asset = asset, sha256 identity = identity}
}The program checks each profile before it builds a scene. A mesh level reports its topology, frame and unit, and a scan reports its point count. Handing an image document to the mesh reader refuses, and the refusal names the profile the reader expected.
bool pumpMeshFits(chest mesh) {
text topology = mesh.topology
text frame = mesh.frame
text unitName = mesh.unitName
u64 vertexCount = mesh.vertexCount
return topology == "triangles" && frame == "rightHandYUp" &&
unitName == "m" && vertexCount <= 250000
}
bool scanFits(chest cloud) {
text frame = cloud.frame
text unitName = cloud.unitName
u64 points = cloud.pointCount
return frame == "rightHandYUp" && unitName == "m" && points > 0
}
text checkAssets() {
assert (pumpMeshFits(t.media.meshLod(finest("models.pump", 8000000))), "pump mesh")
assert (scanFits(t.media.attributedPoint(finest("scans.pumpRoom", 64000000))), "room scan")
return "assets ready"
}Each device asks for the same asset with a byte budget, and Nautilus returns the finest published level that fits. On the watch, the program first narrows mesh picks to 8 MB for its own runtime. The same pick call then lands on a smaller level of the pump.
# The watch build narrows mesh picks to 8 MB for this runtime.
void capForWatch() {
t.assets.limit({chest byProfile = {chest mesh = {u64 pickBytes = 8388608}}})
}
chest pumpForThisDevice() {
chest picked = t.assets.pick("models.pump",
{text kind = "decodedBytes", u64 maxBytes = 268435456})
u64 lod = picked.lod
u64 bytes = picked.decodedBytes
t.log.info("models.pump level " + text(lod) + ", " + text(bytes) + " bytes")
return picked
}No code in the trainer parsed a GLB or a JPEG. The workstation read the full pump, and the watch read a smaller level under its 8 MB cap from the same call. When a photo landed in the mesh folder by mistake, the next build refused it by name instead of shipping a broken asset.
System diagram
Only the import edge reads the supplier format. Everything after it uses MerTek-owned profiles and names.
Inside the system
Follow the data, decisions, and access boundaries. Each diagram explains a concept used by applications.
Each foreign format decodes once into a profile MTK owns: mesh, texture, image, rig and clip, points, audio, video or font.
GLB, glTF, FBX, image and point sources each map their own vocabulary into the same profiles.
The build imports once. A scene names the stored profile by id and digest, and the renderer picks a level within its budget.
A supplier's field names end at import. Everything after it reads MTK's profile fields.
Key parts
These are the main boundaries, inputs, outputs, and failure rules. The examples show a specific use of each part.
Supplier bytes are decoded once, at the build's assets stage, through MerCodec. What leaves the boundary is a Chest document in a Nautilus profile, published to the build store. No renderer or program opens a GLB, FBX, PNG or JPEG.
The pump arrives as GLB and leaves as a mesh family with four smaller levels, each with its own content digest.
A profile is a named, versioned document shape: image, texture, audio, mesh, attributed point, rig and clip, video and font. Each fixes its fields, its coordinate frame and its units. A reader for one profile refuses a document of another.
Every mesh the trainer reads reports triangles, rightHandYUp and m, so no consumer guesses a supplier's axis or unit convention.
A program or renderer names an asset and a byte budget. Nautilus returns the finest published level that fits, or the root floor. The runtime's own cap narrows every pick it makes.
With mesh picks capped at 8 MB, the watch gets a coarser pump from the same call the workstation makes.
Code
Each example is short and complete enough to read on its own. Hover a dotted word for its definition.
The face record comes from t.gfx.faces.roster(), where an imported font appears under its asset name. The scene names it by store, asset id and root content address, never by file name, and Thalassa refuses a mismatched digest at commit.
chest labelFont(chest face) {
u64 authority = face.authority
u64 asset = face.asset
sha256 root = face.expectedRootDigest
sha256 identity = face.identity
return t.gfx.uiFont({
id = 4,
profiles = [{ u64 authority = authority, u64 asset = asset,
sha256 expectedRootDigest = root, sha256 identity = identity,
u32 faceOrdinal = 0, u64 byteBudget = 262144 }],
script = [76,97,116,110],
language = [100,102,108,116],
material = 5,
rasterProfile = "sdf",
spread = 4,
pxPerEm = 32
})
}A pinned reference reads the family's menu without fetching any level. Each row carries the sizes a budget pick reads and, for images, the pixel extent.
bool photoFits(chest levels) {
text profile = levels.profile
chest[] menu = levels.menu
chest finestLevel = menu[0]
u64 width = finestLevel.width
u64 bytes = finestLevel.decodedBytes
return profile == "image" && width >= 1024 && bytes <= 16777216
}
text checkPhoto() {
assert (photoFits(t.media.asset(pinned("photos.pumpRoom"))), "room photo")
return "photo ready"
}t.media.view picks the coarsest image level whose larger side still covers the screen's need. A 396 by 484 watch face needs 484 pixels, so it never downloads the 2,048-pixel level.
u64 photoLevelForWatch(chest photo) {
i32 need = t.media.targetNeed(396.0, 484.0, 1.0) # 484
chest viewed = t.media.view(photo, need)
u64 pick = viewed.pick
return pick
}A program that recorded a level's identity earlier can confirm the served bytes still match it. The comparison runs in constant time, and an all-zero digest refuses instead of comparing.
bool levelUnchanged(chest pump, u64 lod, sha256 recorded) {
bool same = t.media.verifyTile(pump, lod, recorded)
if (!same) {
t.log.warn("models.pump level " + text(lod) + " changed since review")
}
return same
}The texture reader returns the level's storage exactly as imported. A block-compressed level stays block-compressed, and format names it.
bool labelTextureFits(chest texture) {
text format = texture.format
text colorspace = texture.colorspace
text dimension = texture.dimension
u64 width = texture.width
return format == "rgba8Unorm" && colorspace == "srgb" &&
dimension == "2d" && width <= 2048
}Uses
Review questions
Which formats each supplier delivers, and which profile each becomes
Which level each device class should receive, by bytes or by pixels
Who reviews and commits each import recipe