EDGEFAB / DOCS

EDGEfab build plan

Status: proposed, 2026-10-25; extended 2026-10-26 (Blender assets beside Unreal’s, animation as a key focus). The first build agreed with the owner on 2026-10-30 (below): F1 is a textured GLB, imported or generated by Tripo, added to the project and placed with EDGEbuilder, with collision and LODs. Written from the owner’s vision (below), on top of design draft 0.1. Nothing is built. F0 agrees this plan with the owner. Until then every other phase, name and order here is a proposal. Anything not yet checked is marked unverified.

The vision

The owner, 2026-10-25:

EDGEfab is not a mesh editor the way Blender is. It is a full-spectrum fabricator: it can load a mesh and do things with it, but its goal is the game asset. So clothing, props, characters, NPCs and everything that goes with them. It connects to MCP servers like Blender’s and Unreal’s for meshwork, and to AI services like Tripo for text to mesh; the ultimate goal is to prompt new assets. .mesh files still open REDcode’s 3D viewer when clicked, and the right-click menu adds Open in EDGEfab, where an asset is changed in one place, by prompts.

The unit of work What it includes  
A prop Mesh, materials and looks, entity, collision, LODs; placed in a scene by EDGEbuilder First
A piece of clothing A mesh per body, looks, item record, name, icon, layering  
A character or NPC Body, head, hair, clothes (its appearances), rig and animations, voice, its records (who it is, how it behaves), where it stands The big one

Blender, Unreal, Tripo and EDGEmat are tools EDGEfab orchestrates. EDGEfab itself owns the asset: what it is made of, that its files agree, and getting it into the game.

The modder says EDGEfab sends it to What comes back
“Make the jacket green and the sleeves red” EDGEmat (colors, mat_apply), on the parts named “jacket” and “sleeves” A new look on the same garment
“Make an old worn trenchcoat” Tripo (text to 3D), then EDGEfab’s Blender steps (clean, fit to V’s bodies, weights), then EDGEmat (a worn material) A new garment V can wear
“Animate the pinwheel” Blender or Unreal Engine (a looping clip on a small rig) An animated prop
“Give this NPC a deeper voice and a leather coat” EDGEwave for the voice, EDGEfab’s clothing for the coat The same NPC, changed
“Bring in this Fab prop” Unreal Engine (export, bake), then Blender, then REDbridge A placeable prop (UE5 assets)

The long-term goals: bring free and royalty-free Unreal Engine and Blender assets into the game, and prompt new assets from nothing.

The owner, 2026-10-26:

Import the same kinds of assets from Blender as from Unreal: meshes, materials, rigs, animations, the things the RED engine naturally accepts. Exotic assets unique to Blender or Unreal and not native to the RED engine are left aside for now. The Cyberpunk modding community strongly wants easy tooling for importing or generating animations, so animation is a key focus. An animation is almost always attached to something, so the something usually comes first, and the modder sees what the thing is.

What changes in the design

Draft 0.1 said “EDGEfab does not connect to Blender: the assistant connects to both servers”. The vision changes that. EDGEfab becomes the place where the modder works on an asset by prompts, so it needs its own agent that connects to the other servers as their client. Its MCP server stays, so Claude Code and REDagent can still drive everything from outside.

                         ┌──────────────────────────── EDGEfab (VS Code) ─────────────────────────────┐
 Open in EDGEfab on a ──►│  The asset: 3D view (body, clothes, animation) · parts · looks · voice ·   │
 .mesh, .ent, .app or    │  records · files that make it · checks · history · prompt bar              │
 a Character/Item record │                          │                                                 │
                         │                       the agent  (Claude Agent SDK, the modder's own key)  │
                         └──┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬────────────┘
                         EDGEmat   EDGEwave   REDcode    Tripo    Blender   Unreal    REDnode, EDGEbuilder
                        materials   voice   files, pack text→mesh (opt-in) (opt-in)  try it, place it
                            │                   │                    │        │
                            └──── REDbridge (game files) ────────────┴────────┴── EDGEfab's own background
                                                                                   scripts (blender --background,
                                                                                   UnrealEditor-Cmd)
 EDGEfab's own MCP server ◄── Claude Code, REDagent (the same tools, from outside)
Decision for F0 Recommendation Why
What EDGEfab opens A game asset, reached from any of its files: a .mesh, .ent or .app, or a TweakDB Character or Items record. EDGEfab finds the rest of the asset from there The asset is the unit, not the file
The agent inside EDGEfab Claude Agent SDK, with the modder’s own Anthropic API key, as REDagent decided Anthropic doesn’t allow claude.ai login in third-party products. The SDK connects to MCP servers over stdio and HTTP. Whether it packages cleanly inside a VS Code extension is unverified
Without a key Everything still works by hand (buttons and fields), and Claude Code can drive it through EDGEfab’s MCP server AI stays optional, as in every EDGE tool
Two layers for Blender, and the same for Unreal Fixed steps run by EDGEfab’s own scripts in the background (blender --background, UnrealEditor-Cmd -run=pythonscript). Free-form work goes through the opt-in Blender MCP or Unreal MCP servers The fixed steps are safe and give the same result every time. Free-form steps are where an AI writes code, so the modder opts in
Tripo EDGEfab’s own client for Tripo’s REST API (v3), with the modder’s own key from the EDGE tools’ shared key store (%APPDATA%\Edgemodders\keys, REDnode’s keys.mjs), the same way EDGEmat calls its image services Tripo has no official MCP server (community ones exist). The REST API covers text and image to 3D, decimation, texturing and rigging. One client is easier to guard than a third-party server
Other text-to-mesh services Later, behind the same interface (Meshy, Hunyuan3D, Rodin) One service first
Open in EDGEfab beside Open in EDGEmat Both stay: EDGEmat for editing a material by hand, EDGEfab for the whole asset, which calls EDGEmat To confirm with the owner
Where animation sits Split F7: animated props (F7a) right after F2, character animation (F7b) right after F5, ahead of F6 Animation is a key focus, and each half needs only its subject in the view: a prop (F1, F2) or a whole character (F5). See “Animation: a key focus”

Words to parts

“The sleeves” must name something EDGEfab can change. On a game asset a part is a submesh, a mask layer in a multilayered material (EDGEmat already maps layers), or, on a character, an appearance part (head, torso, legs, a garment). EDGEfab keeps a part map per asset: plain names for those parts. The map is made once by rendering each part highlighted, asking the model to name it, and letting the modder correct the names. It is stored with the project. The agent then resolves “sleeves” through the map, never by guessing. If no part matches, it asks.

Licenses travel with the asset

Every asset EDGEfab brings in records where it came from and under what terms: a Fab listing and its license, a Tripo task and the modder’s plan, a UE project of the modder’s own. The record goes into the project’s manifest and into a credits file in the packed mod. Tripo’s terms (Terms of User Agreement, last updated July 11, 2025, read 2026-11-01):

  Free users (5.2.1) Paid users (5.2.2)
Who owns the model Tripo keeps all rights, the IP included The modder has all rights: use, change, distribute, license, sell
Tripo’s use Anything A licence to use and show it as needed to run the service; not used to train its AI
In a released mod No: the rights are Tripo’s Yes

Some third-party summaries and one Tripo blog say free models are CC BY 4.0. The terms themselves don’t say that, so EDGEfab goes by the terms. A modder’s inputs are their own responsibility (section 3.1): words and images must not infringe anyone’s rights, which matters when an image of a game asset is sent (Wardrobe Designer’s Reshape, EDGEfab #3). The owner is on Pro, a paid plan. No separate terms for the API were found (platform.tripo3d.ai is a script-only page; the terms say supplemental terms would be shown at sign-up). So EDGEfab asks the modder once, in Tripo’s setup, whether their plan is paid or free. It records that in each asset’s license, and warns on a free plan that the model is Tripo’s and cannot go in a released mod. It shows the terms; it never decides for the modder.

Blender and Unreal, the same kinds of asset

EDGEfab imports the same kinds of asset from Blender as from Unreal: what the RED engine accepts natively. Blender is the easier source, since Cyberpunk modders already use it with WolvenKit’s Blender add-on and it runs headless with no project. Unreal needs its export step first (UE5 assets).

Kind From Blender From Unreal In the game
Static mesh with textures A .blend, or GLB/FBX it exported A Static Mesh, exported by EDGEfab’s script .mesh over a template, .xbm textures
Materials Principled BSDF: base color, normal, roughness, metallic Material inputs, or baked (UE5 assets, U2) The game’s material templates (through EDGEmat)
Skinned mesh on the game’s rig An armature with the game’s bone names A Skeletal Mesh moved onto the game’s rig .mesh with skinning, .rig
A small rig of its own (a prop that moves) An armature A skeleton .rig and .anims on an entity
Animation Actions Animation Sequences, retargeted in Unreal .anims, played by the entity or a workspot
Shape keys / morph targets Shape keys Morph targets .morphtarget (WolvenKit import unverified)
LODs, collision Lower-detail copies; simple shapes LODs; simple collision Mesh LODs; the entity’s physics

Left aside for now (not native to the RED engine): Blender’s geometry nodes, particles and hair systems, simulations, drivers and constraints, procedural shaders; Unreal’s Blueprints, Niagara, Control Rig, Chaos, Groom, Substrate’s layered materials and MetaHuman’s facial rig logic. EDGEfab says so plainly when a source holds them, and bakes what it can (a procedural shader into textures, a simulation into an animation, a constraint into keys) only where the result is a plain asset.

Blender sources arrive with each asset kind: .blend and FBX props in F3 (right after F1, which takes GLB only), clothing in F4, animation in F7. Unreal keeps its own phase (F8) for its export step.

Animation: a key focus

The modding community wants easy tooling for importing and generating animations, and today it means WolvenKit, Blender and many manual steps. EDGEfab makes it a key focus, built on one rule: the subject comes first. An animation is almost always attached to something, so EDGEfab opens the thing (a prop, an NPC, V’s body) and shows it in the 3D view before any animation work starts. Then:

Step What the modder does What EDGEfab does
See the subject Open in EDGEfab on the prop or NPC Shows it on its rig, with the animations it already has, playable
Bring in Drop a Blender .blend action, an FBX or GLB clip, an Unreal sequence (F8) Checks the bones against the subject’s rig, retargets what it can (in Blender’s or Unreal’s background), says what it cannot
Generate (later) “Make him lean on the wall and check his phone” A text-to-motion service behind the same interface as Tripo; candidates unverified, chosen when the phase starts
Preview Scrub and loop it on the subject Plays it in the 3D view
Use it “Play it when he stands here”, “loop it”, “add it to his idles” Writes the .anims, the entity or workspot, the records; Try it in the running game

The first build, agreed 2026-10-30

The owner’s round trip: import or generate a fully textured mesh, convert it to something the game can use, Add to Project (the open REDcode project), then place it in the game with EDGEbuilder. Small, but it touches every tool once, and every later asset reuses its path.

Step How Built on Unverified
1a. Import A textured GLB from disk    
1b. Generate Words (or an image) to Tripo, with the modder’s own key from the EDGE tools’ shared key store. Its source and terms go in the asset’s record. Ask for a face_limit (about 20,000) Tripo’s v3 REST API (openapi.tripo3d.ai; v2 shut down 2026-10-31) Checked 2026-10-31 (Tests): a GLB in about 2 minutes for 20 credits; one mesh; 1.4 million triangles without a limit, 19,021 with face_limit 20000; Color, ORM and NormalGL textures at 2048²; auto_size puts real size on the node. Terms read 2026-11-01 (above, “Licenses travel with the asset”): paid plans give the modder all rights, free plans leave them with Tripo
2. Prepare In Node, no Blender: node transforms baked in, the base put at height 0, MikkTSpace tangents (WolvenKit refuses a GLB without them), under 65,535 vertices per submesh, one primitive per mesh, LODs made by simplifying and named submesh_00_LOD_1, _LOD_2, _LOD_4, textures taken out glTF-Transform 4.5.1, mikktspace, meshoptimizer (all MIT): tried in F0 Checked 2026-11-01 (Tests): REDbridge imports the prepared drum over a game barrel with 3 LODs
3. Convert, Add to Project The mesh imported over a prop template. Materials from the model’s own textures, by EDGEmat (EDGEmat #4). An .ent with the mesh as an entMeshComponent and collision as an entPhysicalMeshComponent, static unless the modder asks for a dynamic prop; its appearance names match the mesh’s. Paths lowercase, no spaces, under the mod’s own folder (<modname>\...). The shape EDGEbuilder asked for in EDGEfab #2 REDcodeApi.importFile(file, { template }), REDbridge 0.11.0’s texture setups, EDGEmat’s API Checked 2026-11-01 without the game: the import keeps the template’s materials and its cooked collision shape, so Add to Project replaces both. Game props are solid through an entColliderComponent with a box; an entPhysicalMeshComponent takes the mesh’s cooked shape, which EDGEfab cannot make. Open, in the game: a fitted box in an entColliderComponent, or in the mesh’s physics data under an entPhysicalMeshComponent
4. Pack and install Pack the project, install it with EDGEdeck REDcodeApi.pack(), packAndTry() Hot load waits for RED Hot Tools on 2.5: start or reload the game
5. Place EDGEbuilder’s Browse shows the prop from the project’s loose files or the packed archive; the modder drops the .ent, saves the scene, and later bakes it EDGEbuilder’s B2c, built in EDGEbuilder 0.4.0 (2026-10-30, waits for its test): Browse lists the open project’s source\archive (through REDcode’s redcode service, REDcode 0.10.5) and mod archives, and drops a .mesh or .ent Its B2c test is to place EDGEfab’s first prop

What EDGEbuilder’s bake probe found (game 2.5, 2026-10-30, its tests): a baked .mesh becomes a worldMeshNode, which only draws, so V walks through it even when the mesh has meshMeshParamPhysics. A baked entity with an entPhysicalMeshComponent is solid. So the entity is what places a solid prop, until EDGEbuilder’s B4 finds a node type that gives a bare mesh collision. Streaming distance is the scene’s, so the files need nothing for it.

Decided 2026-10-30  
Inputs GLB, from disk or from Tripo. FBX and .blend come next, through Blender’s background (F3)
Collision and LODs In the first build
Materials EDGEmat’s, asked for as EDGEmat #4: a GLB’s PBR textures to .xbm and a .mi, in its API and as MCP mat_from_model. Built in EDGEmat’s main 2026-11-04 (a7b66a8, not released): core materialsFromModel(bridge, req) (no VS Code imports), MCP mat_from_model, API materialsFromModel; normal map, metalness, several materials, files or the GLB
Placing EDGEbuilder’s B2c (built in 0.4.0 on 2026-10-30). EDGEfab’s first prop is the object B2c’s in-game test places (EDGEfab #2)
Collision An entPhysicalMeshComponent on the prop’s .ent (EDGEfab #2, from EDGEbuilder’s bake probe)
The Library In F1 (owner, 2026-10-31): props are assets in EDGEbuilder’s shared Library, outside any project, and Add to Project pulls them into one. Below, and Library assets

The Library (in F1, decided 2026-10-31)

The owner: the Library is a key shared resource for working across the tools, between projects. An asset found in REDcode’s game assets goes into the Library, EDGEfab changes it there, and several projects pull it in. Optional, but useful for some workflows. The details, and the asset item proposed for it, are on Library assets.

The owner, 2026-11-02: EDGEfab has a Desk, as EDGEmat does, and the Desk becomes a norm for the EDGE tools. It is a persistent scratch workspace, where objects in progress are kept and later added to projects or stored in the Library.

In F1  
EDGEfab’s Desk (built 2026-11-02, from the Made view) Where a prop made from a GLB or by Tripo lands: %LOCALAPPDATA%\EDGEfab\desk\<name>.prop.asset/, kept between sessions. Each item already has the Library’s asset shape (asset.json, laid out like a small project, the kind in the name; owner 2026-10-31), so moving it is a copy. MCP fab_desk
Add to Library, from the Desk Stores a Desk item in the Library, in a folder the modder picks or under its game path (Use the game path), when a Library root is set
EDGEfab’s Library view The modder’s own folders (not game paths), with their assets and model files (GLBs kept to convert later); open, Make a prop, Add to Project, Refresh from Library
Add to Project, from the Desk or the Library Copies the asset’s game files into the project; from the Library, with a note of where they came from
Without a Library The Desk and Add to Project work alone
Not in F1 REDcode’s Add to Library on game assets (REDcode #19), changing an asset that came from the game (F2, with Open in EDGEfab)

Glow (emissive), the groundwork (2026-11-04)

The owner, 2026-11-04: lay the groundwork for glowing materials now, before F1 goes much further. Screens, signs, neon and lit shelves are everywhere in Night City, so props need them from the start.

Piece How Phase, state
What Tripo sends No emissive: four Tripo models checked (v3.1, P1, retopology, the drum), each a color, ORM and normal map. Its lights are painted into the color Checked 2026-11-04
A GLB that glows (from Blender or a store) Prepare keeps it: each material’s glow color, strength (KHR_materials_emissive_strength) and map, in prepared.json as glow, the map written out with the other textures. The Desk says “Glows” F1, built 2026-11-04
Seeing it The view model keeps the glow, and REDcode’s 3D view draws it in its “Own textures” shading (three.js, without bloom) F1, built; unverified in the view
The game material EDGEmat writes it into metal_base’s Emissive texture, EmissiveColor and EmissiveEV (EDGEmat #6, filed 2026-11-04, with #4). Built in EDGEmat’s main the same day (a7b66a8): its glow takes prepare’s PreparedGlow[] as it is; EmissiveEV = 4 + log2(strength × brightest channel), from the game’s own glowing materials (median EV 4.3). Unverified: the brightness, by EDGEmat’s glow check in the game; the vending machine spawned through EDGEfab is #6’s test F1, built in EDGEmat, not released
Make the painted lights glow (Tripo models) A glow map from the bright, saturated painted areas of the color texture, offered on a Tripo model and checked in the 3D view, with a slider for how much glows. Tried 2026-11-04 on the vending machine (brighter than 0.55, more saturated than 0.4): the lit shelves, buttons, trim and a side panel glow, the body stays dark F1, an option (owner, 2026-11-04)
One part glows (“the screen glows”) The material planner sets a glow per part, with a color and strength and no map F2
Light on the surroundings, flicker, on at night A light component on the prop’s entity; a glow that animates or switches Later: F7a (animated props) or after

Reshape, built in EDGEmat first (read 2026-11-03)

EDGEmat built Reshape for its REDnode app Wardrobe Designer: a garment V wears, changed by words. The owner’s decision (2026-11-02, EDGEfab #3): it is built in EDGEmat’s core for now and moves into EDGEfab at a later increment. Source: EDGEmat’s design (“Reshape: a garment’s shape changed by words”), extensions/edgemat/src/core/reshape.ts, glb.ts, tripo.ts, and its test “Reshape check” (passed in the game 2026-11-02 on a cowboy hat).

Step How EDGEmat does it Checked
1. Views The game mesh exported through REDbridge and drawn front, left, back and right in its look’s colors, orthographic, the garment half of each square so a change has room 2026-11-02
2. Change by words The four views sent as one picture, two by two, to an image service with the words, then cut apart: they change together and stay consistent. Refined round by round, with Back. OpenAI’s GPT Image 2.5 by default (Gemini drew worse: kept the old brim, changed one side). A few tens of US cents a round. The pictures decide the result: Tripo and the fit follow them, mistakes included 2026-11-02
3. Model Tripo’s multiview to model (/v3/generation/multiview-to-model, the four views): about 2.5 minutes and 30 credits, 1.5 million triangles. Then Tripo’s retopology (/v3/mesh/decimate, bake: true) to a game’s face count with the texture baked on: about 2 minutes and 30 credits 2026-11-02
4. Fit Stray pieces dropped; the model turned from Tripo’s front (+X) to the game’s; sized per axis from the changed views’ outlines; the top 30% centred on the game’s (a hat’s crown); every vertex on the one bone; a GLB shaped as WolvenKit’s export (armature and skin kept) imported over the game’s mesh through REDbridge One bone only, 2026-11-02
5. Material Tripo’s color and roughness (glTF keeps roughness in green) written as .xbm textures and a textured .mi on metal_base.remt through REDbridge, and put on the mesh’s material entry (EDGEmat core writeTexture, writeTexturedMaterial, applyMaterial) In the game: Tripo’s texture the right way up

What F1 takes from it now:

Learned For F1
EDGEmat’s core already turns a Tripo model’s textures into a game material, checked in the game That is most of EDGEmat #4 (mat_from_model): the rest is the normal map and metalness, and a tool around it. Pointed out on #4 on 2026-11-03, which makes waiting for EDGEmat cheaper than a stopgap in EDGEfab
Tripo’s models face +X; the game’s forward is the export’s −Z Built 2026-11-04: prepare turns a Tripo model (known by its file’s generator or node names) to face the game’s forward, so a placed prop faces the way EDGEbuilder places it. Seen on multiview models, and on text to model too (2026-11-04, Tests: three vending machines, each with its front toward +X)
Tripo leaves small loose pieces beside a model at times, and they widen the fit Prepare drops pieces wholly outside the main piece’s box, or tiny, with a note, so they don’t show or throw off the size and collision box
Tripo has two regions with their own keys: global (openapi.tripo3d.ai) and China (openapi.tripo3d.com) EDGEfab’s client tries global, then China once, as EDGEmat’s does
Tripo’s retopology (/v3/mesh/decimate with bake) gives a game’s face count with the texture baked on A choice beside face_limit (same price as no limit, and what F1 uses): compare their meshes on the same prop before picking. Not in F1 unless face_limit’s meshes look poor in the game

Where Reshape lands in EDGEfab (proposed):

Phase What
F2 Reshape a prop by words, on a game prop opened in EDGEfab or a prop on the Desk: views, change, model, then a fit with no bones, so the fit is placing and sizing only. The same keys as Wardrobe Designer (openai, tripo)
F4 Reshape moves in from EDGEmat (EDGEfab #3): reshape, glb and tripo refactored into EDGEfab’s core on glTF-Transform, with one Tripo client for both tools. Then what one bone left out: weights from the nearest point on the original garment, pushed out of V’s body, garment support, both bodies, LODs. Wardrobe Designer then bundles EDGEfab’s core, which already has no VS Code imports

Asked in a parallel session, placed after F1 (2026-10-27 to 30)

The owner worked out a first version in a session that ran beside the one that agreed the first build. Written up 2026-10-27 to 30 on the branch claude/dreamy-sagan-606x6l, and reconciled with this plan on 2026-11-04. Its full text is kept as Props, the parallel proposal. Reviewed the same day against the build as it stands: a few small things go into F1 (below), some are left out because this plan had already chosen otherwise (below), and the rest is scheduled here. F1’s goal and test stay as agreed. Where this plan had already decided something, its way stands: the Desk, EDGEbuilder’s shared Library and its .asset items, EDGEmat making every material, Tripo’s v3 API, the shared key store, collision in F1. The rest comes after F1:

The owner asked Proposed phase How it fits what is built
Describing a prop is the main way in, and the model comes back from Tripo in named, described parts (a bike: handlebars, seat, wheels). Splitting an imported model is the other use F2 Beside the part map (Words to parts): Tripo’s parts give the names for free. Two routes, to compare on the same prompts: make then split (segmentation v2 on the picked model), or make in parts (generate_parts) (below)
Takes: one prompt gives several models (1 to 4, default 2), compared side by side, one picked, as EDGEwave’s Generate Sound does with sounds F2, first (decided in review: takes need a page with cards and a 3D view, which F2 builds; F1 keeps one model per Generate) Today Generate with Tripo makes one model and puts it on the Desk. Takes would sit before the Desk: kept on disk (%LOCALAPPDATA%\EDGEfab\takes\), since each costs credits and Tripo’s download links expire; the picked take becomes the Desk item as now. “Generate again” adds takes; “New textures” keeps a take’s shape with a new texture seed
A material planner per part: for each part, keep Tripo’s texture, a game surface with a color and finish, a game material that tiles, or a new material from words. The modder reviews the plan as a table before anything is made; EDGEmat makes and puts on each one F2 EDGEfab plans in words, EDGEmat makes (its EDGEmat request for F2, and its Compose planner, proposed there 2026-10-29). Proposed default: keep Tripo’s texture where it holds detail of its own (print, stencils), game surfaces for plain materials (metal, rubber, cloth). One Claude call with the modder’s key, Claude Code through MCP, or by hand
Game Assets with kind checkboxes (Props, Weapons, Clothing, NPCs, Vehicles) in EDGEfab’s container F2, with Open in EDGEfab EDGEfab’s own view, as EDGEwave has one for sounds, on REDcode’s bridge; or kinds in REDcode’s Game Assets (REDcode #15) for every tool. Only props open in EDGEfab until later phases
Changing a prop or a part: its size in metres on the page; Fix Mesh (holes, flipped faces, loose bits) in Blender’s background; by hand in Blender; by an assistant through a Blender MCP server (“add a handle on each side”); Tripo’s own edits. Every change a version, with undo Size and versions: F2 (its history with undo). Tripo’s edits: F2, with takes. Blender: F3 Tripo’s edits (Ask Tripo: new textures from words or a style image, fewer faces, an imported prop uploaded first with the modder’s consent) come back as takes. F3 already finds Blender as REDcode does. An assistant’s edits go through Claude Code with a Blender MCP server (owner, 2026-10-30: EDGEfab’s agent stays out of the first release). Parts are kept by Blender object name; a new part gets a “needs a material” row
Hand edits on a prop in a project merge back into the project, as REDcode’s Edit in Blender does F3 Add to Project writes the model with its named parts where REDcode’s Edit in Blender looks for it, and after each re-import EDGEfab puts each part’s material back by name (below)
Reuse REDcode’s 3D viewer, no viewer of EDGEfab’s own, with EDGEfab’s buttons on it F2 Already possible in REDcode’s code (below); asked as a contract in the REDcode row of What EDGEfab needs
Image to 3D, after text to 3D F2, with takes The same task flow with an uploaded picture. Reshape already uses Tripo’s multiview task, so the client has the upload
Thumbnails in the Library F2 A render from REDcode’s viewer (snapshot(), in the REDcode request). Until then the Library view shows Tripo’s preview image when an asset has one
A service interface for text to 3D, so Meshy, Hunyuan3D or Rodin can join When a second service is chosen Already the plan’s decision (above). F1’s Tripo client stays one small module, so the interface is cut from it then, not guessed now

Taken into F1

Small, and each makes F1’s own path better. None changes F1’s goal or its test.

From the proposal In F1
Desk entries show a state: raw, game-ready, needs a look (a check failed, and which). Rename, take off, Clear the Desk The Desk view and fab_desk
A size check: “this is 40 m tall, did you mean 40 cm?”, against the size range of game props Prepare, beside auto_size. Imported GLBs need it most
Generate says what it costs in credits and the balance left before it runs, and a model Tripo refuses for its content rules says so in plain words Generate with Tripo and fab_tripo. Tripo’s v3 balance endpoint is unverified
Tripo’s P1 model for low-poly game assets, beside v3.1 with face_limit and retopology with bake Checked 2026-11-04 (Tests): v3.1 with face_limit stays the default, cheapest (20 credits) and the cleanest. P1 (40) placed the screen on a side and left a smudge on the back; retopology (30 more) smeared the sides’ texture. All three face +X, so prepare turns them
Add to Project also writes the prepared model to source\raw\<game path>.glb So REDcode’s Edit in Blender on the project’s mesh opens EDGEfab’s model with its part names. F3’s merge-back builds on it
Make a Prop on a .glb in VS Code’s Explorer puts it on the Desk Beside Import a GLB, as the Library view’s Make a prop does. Open in EDGEfab keeps its name for game assets (F2), still to agree with the owner

Left out

This plan had already chosen otherwise, so these are not built. The owner can reopen any of them.

From the proposal Why
EDGEfab’s own Library (%LOCALAPPDATA%\EDGEfab\library, library.json), Update the Game packing it into one edgefab_library.archive, EDGEbuilder reading that index in the game, EDGEdeck installing it The Library is EDGEbuilder’s shared root with .asset items (owner, 2026-10-31), and props reach the game through Add to Project, a pack and EDGEbuilder’s B2c. Whether EDGEbuilder lists Library assets in the game is its call, on EDGEbuilder #4
The Desk as desk.json and items\<id>\ Built as <name>.prop.asset folders in the Library’s shape (2026-11-02), so Add to Library is a copy
Game paths under edgefab\<name>\ Library assets: <modder>\<asset>\, lowercase
No collision in the first version Collision is in F1 (EDGEfab #2, EDGEbuilder’s bake probe)
Its steps V0 to V10 and their checks Replaced by this plan’s phases. Its checks that still matter sit in the phase that needs them
REDbridge’s mesh.info and sector.build reading mod archives EDGEbuilder’s own need for its bakes (its B2c and B4), asked by it if it still needs them

Decided by the owner, 2026-11-04

Question Decided
The agent. The owner said on 2026-10-30 that EDGEfab’s agent is not in the first version, and Claude Code drives EDGEfab through its MCP server. In that proposal the first version meant props made whole (this plan’s F1, F3 and F2’s prop work) The agent and the prompt bar move out of F2 into a phase of their own, FA The agent, after F7b and before F6, which needs them most. F2 keeps everything on buttons and MCP, and the material planner stays one AI call. F2’s test becomes a prop, and Claude Code does the same through MCP
Version 1.0 Previews (0.x) from F1 on; 1.0 when props are whole: F1, F3 and F2 passed

Found in that session

Read in the sibling repos’ source and Tripo’s docs, 2026-10-27 to 30. Unverified until tried from EDGEfab.

Found Where For
REDcode’s viewer is built to be mounted: window.REDcodeMesh.mount(container, source, title, { appearances, materials, actions }) in its bundled media/mesh/viewer.js, where actions are extra toolbar buttons. Another extension’s webview can load that script from REDcode’s install folder. Nothing documents it as an API, so it can change REDcode webview/meshViewer.ts F2
REDcode’s Edit in Blender works on the open project only: a .glb under source\raw, or a .mesh under source\archive, which it exports to source\raw\<game path>.glb when that is older. Each save in Blender is imported back over the mesh, which keeps its material entries and looks REDcode extension.ts, editInBlenderCommand F3
The importer makes one submesh per glTF node sorted by node name and keeps the old materials by position, so an added or renamed part can move a material onto the wrong part REDbridge README, Mesh import F3
Tripo P1 (P1-20260311): Tripo’s model for low-poly game assets, 48 to 20,000 faces. Worth comparing with F1’s v3.1 and face_limit on the same prop Tripo’s v2 API docs F1, a check (above)
generate_parts makes a model in parts, but not with texture or pbr on, and not on P1; texture_model can then texture chosen parts (part_names). Segmentation v2 names and describes parts (part hints, coarse to fine), seen only through others’ wrappers of Tripo (ComfyUI, Scenario, which calls it a preview); Tripo’s own v2 docs list segmentation v1.0 (geometry only, 40 credits) Tripo’s v2 API docs; ComfyUI’s Tripo Smart Segment node F2
Tripo’s download links expire after five minutes; a task can be read only with the key that started it (seen on v3 2026-11-04: another key’s task answers 404); P1 runs 5 tasks at once per account; import_model takes an uploaded model up to 150 MB, so Tripo’s edits work on an imported prop too Tripo’s v2 API docs Takes, F2
EDGEwave keeps takes in memory (the last 20) and writes only the picked one; it has no provider interface EDGEwave src/voiceTools.ts Takes

These facts are from Tripo’s v2 docs, read before v2 shut down. Recheck them on v3 when the phase starts.

Phases

Each phase ends with a test the owner runs, recorded in Tests. After it come the release gate and, from the first preview on, a release. The order goes from small assets to large ones. Simple textured props come first, because they are useful alone and every later asset reuses their path into the game. Characters and NPCs are the big effort, split into viewing them whole, then editing them.

Phase Builds The test proves
F0 Decisions The decisions above. The checks the first build needs: REDbridge’s import over a prop template on 2.5 with LODs (done without the game 2026-11-01, Tests; template barrel_drum_a.mesh for the check), which collision is solid in the game (a fitted box: entColliderComponent, as game props do, or in the mesh’s physics data under an entPhysicalMeshComponent), the drum seen in the game, Tripo’s API with a test key (done 2026-10-31, Tests), the normal-map convention (with EDGEmat; Tripo’s are OpenGL, green up), REDbridge’s import into a Library asset’s folders (its code takes any raw and archive folder). A study of how working custom-prop mods are built (their file sets, not their code). The other checks move to the phase that needs them (2026-10-30): the Claude Agent SDK inside an extension host (FA), Blender’s background run (F3), what REDbridge can export of a whole character and the study of custom-item and custom-NPC mods (F4, F5), the animation round trip and how animation mods are made today (F7a), Unreal’s background run (F8) The owner agrees this plan
F1 Props (agreed 2026-10-30) The extension and MCP skeletons, the activity bar container. A textured GLB, imported from disk or generated by Tripo, becomes a placeable prop and is added to the open REDcode project with Add to Project: prepared in Node (triangles, submeshes, LODs), mesh imported over a template, textures and material from EDGEmat (the model’s own textures, EDGEmat #4), an entity, simple collision, LODs, the source and license record. Each prop waits on EDGEfab’s Desk and is stored in the Library with Add to Library (Library assets), with EDGEfab’s Library view, when a Library root is set. A page for it, in plain words, with checks. Small additions from the parallel proposal (taken into F1): Desk states, a size check, cost and balance before Generate, a model check with Tripo’s P1, the prepared model in source\raw, Make a Prop in the Explorer. The release workflow copied from EDGEmat. Needs EDGEbuilder’s B2c (its #1: mod archives and the open project in Browse). See The first build A textured prop, one from a GLB and one made by Tripo, is placed in a scene with EDGEbuilder, V cannot walk through it, its LODs change with distance, and it stays after a restart. First preview, if the owner wants a release here
F3 Blender sources (was Generated props; Tripo moved into F1 on 2026-10-30. Proposed right after F1) FBX and .blend through Blender’s background (blender --background): the scene to a GLB, then F1’s path. Finding Blender, as REDcode’s Edit in Blender does. Proposed from the parallel session (above): changes in Blender (Fix Mesh in the background, by hand, by an assistant through a Blender MCP server), and hand edits on a prop in a project merged back with its materials kept A prop from a .blend and one from an FBX end up in an EDGEbuilder scene
F2 Workspace and prompts Open in EDGEfab on a .mesh, .ent or .app (REDcode’s Game Assets and Project views, the Explorer, the editor’s title menu, as EDGEmat’s Open in EDGEmat is). The 3D view, parts and the part map, looks, history with undo. No agent here: Claude Code drives F2 through the MCP server, and the agent comes in FA (owner, 2026-11-04). Try it: pack, hot load (REDnode), put it on V or spawn it. Reshape a prop by words (views, an image service’s change, Tripo’s multiview model, a fit with no bones; above). Proposed from the parallel session (above): takes, a prop from words in named parts, the material planner, Game Assets with kinds, size on the page and versions, on REDcode’s viewer A prop made from words comes back in named parts, its materials planned and applied, is resized on the page, and shows in the running game; Claude Code does the same through the MCP server. 1.0 once F1, F3 and F2 have passed (owner, 2026-11-04)
F4 Clothing Fitting to V’s bodies and body mods (design, “Clothing: fitting to the body”): fab_body, fab_fit, fab_refit. Reshape moves in from EDGEmat (EDGEfab #3) and grows past one bone. The item record, name, icon, both bodies “Make an old worn trenchcoat” can be worn by V from the inventory, on both bodies
F5 Characters, whole Open in EDGEfab on an NPC: from its Character record, entity or appearance, EDGEfab assembles the full character: body, head, hair and clothes from its appearance parts, on its rig, playing its animations (idle and others from its animation sets), its voice lines listed and playable (through EDGEwave), its records in plain words (name, affiliation, behaviour). Read-only Click an NPC asset and see the whole character move and hear it speak, in EDGEfab
FA The agent (moved out of F2 by the owner, 2026-11-04) EDGEfab’s own agent (the Claude Agent SDK with the modder’s key) and the prompt bar on the asset page, with EDGEfab’s and EDGEmat’s tools, the Blender MCP server, the part map for words to parts. What Claude Code could already do through MCP, typed in EDGEfab “Make the jacket green and the sleeves red” shows on V in the running game, typed in EDGEfab’s prompt bar
F6 Characters, edited Every aspect changed by orchestrating the EDGE tools: looks (EDGEmat), clothes swapped or made (F4), hair and head from the game’s parts, animations (Blender, Unreal), voice (EDGEwave), records (TweakDB through TweakXL). A new NPC made from an existing one. Placed through EDGEbuilder’s npc scene kind (its B3c, on REDnode’s world.load) “Make a new fixer from this one, in a leather coat, with a deeper voice” stands in a scene in the game
F7a Animated props (a key focus; proposed right after F2) The prop in the view first, then “animate the pinwheel”: a small rig and a looping .anims made in Blender’s background, or a Blender action brought in; the entity that plays it The pinwheel turns in the game
F7b Character animation (a key focus; proposed right after F5) The character in the view first (F5), then animations brought in from Blender (actions on the game’s rig, or retargeted) and played through workspots or added to its idles; text to motion behind one interface once a service is chosen. Unreal clips join in F8 (U4 of UE5 assets) A Blender idle plays on an NPC in the game, previewed on that NPC in EDGEfab first
F8 Unreal assets U1 to U3 of UE5 assets: the headless export script, material mapping and baking, Nanite reduction, the license record (props, through F1’s path), then characters moved onto the game’s body rigs (through F5 and F6’s path) A free Fab prop stands in a scene in minutes. A Mannequin- or MetaHuman-based character walks and idles as an NPC
F9 Ship Docs and tutorials, the Nexus page (an extension: Mod Manager Download off), the EDGEkit and EDGEchat bundles A non-coder makes a prop, a garment and an NPC from the docs alone

Talking faces for Unreal characters (U5) stay research. With F7 split and Tripo in F1 (2026-10-30), the proposed order is F0, F1, F3, F2, F7a, F4, F5, F7b, FA, F6, F8, F9 (FA added 2026-11-04). F8’s props can move up right after F1 if the owner wants Unreal sooner, since they reuse F1’s path.

What EDGEfab needs from other repos

Filed as request issues when its phase starts, with the shape that would work:

Repo Need For
EDGEbuilder Its B2c: Browse indexes mod archives and the open project, so EDGEfab’s props can be placed (its #1). Built in EDGEbuilder 0.4.0 on 2026-10-30; it asked back for an entity with collision per prop (EDGEfab #2) F1
EDGEmat Materials from a textured model: a GLB’s PBR textures to .xbm and a .mi, in its API and as MCP mat_from_model (EDGEmat #4, filed 2026-10-30), with glow (EDGEmat #6, filed 2026-11-04). Both built in EDGEmat’s main 2026-11-04 (a7b66a8), not released F1
EDGEmat Its API and MCP tools on an asset EDGEfab has open: list parts and layers, apply colors or a material per part, save a look; a render per part for the part map. For the material planner: a material asked for in words or by name (a game surface with a color and finish, a game .mi, or “make this”), made and put on a part’s slot in one call, and candidates for a part’s words F2
REDcode Add to Library on a file in Game Assets or a project, with the files it needs (Library assets; REDcode #19, filed 2026-10-31) F2
EDGEbuilder The Library’s shared rules gain assets (Library assets); EDGEfab is the second tool to use the Library, which its Library page says moves the rules to the platform’s wiki (EDGEbuilder #4, filed 2026-10-31) F1
REDcode The 3D view embeddable in another extension’s webview (or a shared viewer package), with several meshes on one rig and animation playback; stable context values for .mesh, .ent and .app in its views. Its viewer already mounts with toolbar actions (found): the need is a documented contract (where the script is, mount and its options) and a snapshot() for thumbnails F2, F5
REDcode Edit in Blender on a GLB outside the open project (the Desk, the Library), an event after each save is imported, and the Blender it found (blenderPath()) F3
REDbridge Export of a whole character: an entity’s or appearance’s parts, with the rig and animation sets, to GLB. .anims import from GLB onto a game rig or a prop’s own rig, and .morphtarget import. Anything F0’s checks find missing (collision, LODs) F1, F5, F7a, F7b
EDGEwave A character’s voice lines: list them, play them, and replace them in a voice the modder chooses F5, F6
REDnode world.spawn and world.load of a project’s prop or NPC after a hot load (H2c), equip on V F2, F6
EDGEbuilder Its B3c: the npc scene kind F6

How it is built and released

The same conventions as EDGEmat, so the family stays one pattern: a changelog (Changelog), every test in Tests, the release gate, releases started only when the owner asks, and the release workflow with Marketplace, Open VSX, npm and Nexus (copied from EDGEmat’s in F1; the Nexus box once the page exists). Details in Dev setup once the code exists.

Sources