Your AI,your subscriptions,your studio.

Lampway is a 3D suite on a Blender 5.2 core with an AI agent inside it and a server you run yourself. It uses the models and studios you already pay for. Nothing leaves your machine until you switch that route on, and nothing is spent until you click.

Build it from sourceSee what is builtPrivacy and spend

Open source, GPL-3.0-or-later, early and built in the open. Linux is the platform that has been built and run. No binaries yet. Every claim on this site names the report that measured it, or says it has not been run.

A full-body armoured warrior in bronze and red, a lion on the chest plate, a crested helmet
The armour set the pipeline was built against, from a generated reference image. Move the lamp.

Who holds the keys.

Most AI 3D products rent you a hosted model and a credit counter. Lampway turns that around: the models, the studio sign-ins and the server are yours, every route out is a switch you flip, and a spend is a click you make.

Your inference

Run the agent on an Anthropic key, any OpenAI-compatible server, OpenRouter with a hard session ceiling, your ChatGPT plan through OpenAI’s own sign-in, or your Codex login.

  • Anthropic API key
  • Ollama, LM Studio, llama.cpp, vLLM: never leaves the machine
  • OpenRouter: a click above $0.25, a $3 session ceiling
  • ChatGPT plan, run live
  • Codex app-server: built, not run live

Your studios

Tripo for 3D and Higgsfield for image and video are used through your sign-in. A job that spends credits stops and waits for your click, with the price read back from the studio.

  • Tripo: mesh, texture, PBR, Smart UV
  • Higgsfield: image, video, motion transfer
  • Meshy, Hyper3D, Hi3D, Tripo over REST: built, not run live

Your tools

Every tool is an algorithm that works without a model: retopology, UV, rig, fit, mesh QA, projection. A model or a studio slots in behind the same interface when it helps.

  • Each tool returns a typed, re-runnable result
  • Rules decide first; a model sees the ambiguous cases
  • Heavy work rides your subscriptions, or a box you rent
What leaves this machineA simulation. Nothing is sent.
Nothing is leaving this machine. Every route is off.
  • OpenRouterprivate assets only to zero-retention endpoints
  • Higgsfieldretention unknown: its terms are not recorded yet
  • Tripo Studioretention unknown: its terms are not recorded yet

    The rules are the server’s own: a route that is off refuses; a private asset goes only where it cannot be kept; the log row is written before anything leaves.

    Nothing leaves until you switch it on.

    Built

    Every route out of your machine starts switched off: model providers, studios, cloud boxes, even a download of model weights. Each is a switch in the Privacy panel, with what that provider keeps written beside it. A send is logged before the first byte leaves: where it went, what kind, how many bytes and which assets. Never the content.

    • A private asset goes only where it cannot be kept: on OpenRouter, a zero-retention endpoint with data collection denied. Anywhere else it is refused, unless you allow that one asset, and the allowance is logged.
    • A host Lampway does not know is refused, not guessed.
    • A model on your own machine needs no switch.
    • Spending has its own gate: a confirm only you can click, and caps.

    Privacy and spend, in full

    An agent in the viewport, and a swarm behind it.

    Live

    The agent drives your scene by running Python in a sandbox. In Plan Mode it writes the plan and waits for you to Approve. When it needs a decision it asks, and your answer resumes it. Checkpoints rewind the conversation.

    For parallel work it starts up to six workers, each a headless Blender process. A worker’s result reaches your scene only through a typed, fenced commit (epoch, fence token, hash checks, receipts), and a failed worker lands nothing.

    • Run live through the real client: a plan, Approve, a bronze sphere placed.
    • Swarm run live: three workers on OpenRouter models, and all three collections landed.
    • Not yet run on the Claude CLI adapter.
    The Lampway client: a textured chest plate in the viewport, the outliner listing the sphere the agent placed
    bootsIN_PROGRESS
    waistPENDING
    helmetPENDING

    The viewport is a real capture from the live app (a mesh-painted chest plate and the sphere from the plan run). The plan bubble and the three worker cards are redrawn on top of it from the real runs.

    Your agent CLIs, in a cockpit that outlives a crash.

    Built

    The cockpit runs Claude Code, Codex or OpenCode as panes of Lampway’s own herdr server, with its own socket, config and home; the herdr you use for anything else is never touched. If Blender or the Lampway server crashes, the agents keep working. On the next start one reconcile pass re-adopts the live panes. It never kills a pane it does not know, and never restarts an ended one without your click.

    • Crash survival exercised against the real herdr binary: the agent process and the Lampway server were each killed, and the panes and their records survived.
    • The in-app agent drives sessions through a closed set of operations. A request cannot raise a session’s permission level; only your click in the cockpit can.
    • Your Codex login can also be the main agent’s model, through Codex’s app-server with Lampway’s own tools. Built against a stand-in app-server; not run live.
    • Next: a Lampway WezTerm window as an optional download. Planned
    Design mock-up of the agent cockpit: a list of open sessions on the left, one agent's conversation on the right, a banner saying Lampway restarted and reconciled
    In progressDesign, in progress: the cockpit in the client facelift, with placeholder sessions. Today the cockpit is a panel in Blender’s sidebar.
    StudiosA simulation. No studio is contacted.

    Waiting for your confirmation

    tripo.texture30 creditsread back from the studio

    • The price on the button equals the price the studio read back.
    • The approval is one-shot.
    • No script is running: not the agent, not a worker, not the bridge.
    • The confirm comes from you, not from an agent tool.
    Waiting. Nothing has been spent.

    Prices from the studios report: mesh 100, texture 30, PBR 5, unwrap 20 credits.

    Ask before it spends.

    Built

    Studios live inside the client. The agent can plan a job and read back the price. It cannot confirm one: spending is a click you make, not a setting an agent can flip.

    • The price on the button must equal the price the studio read back.
    • The approval is one-shot and expires after ten minutes.
    • The client refuses the confirm while any script is running.
    • A paid job gets a receipt on disk before it is sent. After a crash, a job whose fate is unknown is never resent; you say what happened.

    Tripo’s read-only state call ran against the real tab, and a read-only live diff of Higgsfield’s tools matched its schemas. No studio generation has been run. Meshy, Hyper3D, Hi3D and Tripo now have REST drivers behind the same gate; their request shapes are written from the providers’ docs and wait for a live run with a key.

    Images and video, with prompts you can tune.

    Live

    A prompt library sits under every generation: 18 built-in templates (7 video, 11 image) with typed variables, per-model adapters, versions that never overwrite, and A/B comparison by variant_of. Each run is logged with its rating, cost and gates. You see the price estimate before a job is submitted, a per-job cap and a ledger cap apply, and a job is never resubmitted. Video edit and upscale presets arrived with Wave 4, with a gate that measures the result.

    A ten-second side-view walk on a grid floor, generated inside Lampway from the side-track template (a HeyGen model).

    Built to be tuned

    template
    anim-walk-side-track, one of the 7 built-in video templates: side truck, long lens, grid floor
    spine
    one five-part structure for every template, so two versions differ only where you changed them
    variables
    typed and bounded, validated before the price is asked
    adapters
    per model family: OpenAI-style models take size, FLUX, Gemini, Seedream and Riverflow take resolution and aspect_ratio
    ledger
    every run logged with rating, cost and gate results, in one file
    $0.10estimate before the job, one live 5 second HeyGen clip
    $0.05billed for that clip
    $2default cap on one video job’s estimate
    A grey clay render of a chest plate, and nine textured versions of it from different image models
    The bake-off: one clay render of a chest plate, nine textured candidates (two Tripo textures and seven image models). It informed the per-purpose defaults for plates, masks, concepts and tiles.
    Six red cloth tiles with a gold Greek-key border from six image models
    Cloth tiles from six models, asked for as seamless; the seam score and the price are printed on each.
    A bronze Corinthian helmet with a red horsehair crest on a wooden stand
    Generated in the client through the image-job queue: 1408 by 768, $0.067.

    From seed to engine.

    Partial

    The pipeline was built against a real set of game armour. Each stage is a tool with a typed result; the stages that touch geometry run before texturing, because a geometry change discards a texture. Fit, bind and the export checks are built; the last step into the engine editor is not.

    12 stages: 3 live, 7 built, 1 built but not run on a real piece, 1 planned.

    1. Seeds Built

      A typed catalogue of seed meshes with the settings that made them; a ranking law that puts proportions first, then defects, then fidelity. Only you pick.

    2. Plates Built

      Regenerated plates ranked against the reference, a deterministic alpha cut, checks, a manifest.

    3. Smart UV Built

      Through the Tripo studio on a saved copy. Texturing always comes last.

    4. Mesh QA Live

      Open loops and floating shells drawn per piece; your red, green and yellow strokes are rulings. Reproduced live on a recorded chest: 91 candidates.

    5. Parts and proportions Built

      Proportion scoring per piece, UV score and texel density, mesh defect scan, silhouette and model comparison, a parts critique.

    6. Fit placement and openings Built

      Enclosure placement with one uniform scale; keep, gasket or delete for each opening.

    7. Mesh-paint texturing Live

      Four clay views, silhouette-ranked picks (0.990 to 0.994 IoU on the live piece), plates, projection.

    8. Rebuild loop Live

      Patch holes, UV patches, maps, relief projection, material masks. Ran end to end on the real piece.

    9. Bake, palette and PBR pack Built

      Normal, albedo and AO bakes in a headless worker, a palette fit measured against a recorded chest, packed textures with an FBX and a README of hashes.

    10. Weights, bind and validate Built, not run live

      Weight audit and transfer, a bind where metal stays rigid, clearance per pose and a validation verdict. Tested on synthetic pieces; not yet on a real piece against the body.

    11. Skeleton and engine-import checks Built

      An FBX written by the real binary and read back: leaf bones, scale, posed rest, collision names, missing textures; a rigged export gated on every joint’s position and axes.

    12. Into the engine editor Planned

      The Unreal editor leg: publishing the bind and the clips inside the engine.

    The armoured warrior, full body, front view, on a dark ground
    The target set, front.
    The armoured warrior in side profile on a grid floor
    And in side profile on the grid, the view the animation clips use.

    Animation from AI video.

    Built, not run live

    One generated split-screen clip shows the walk from the front and from the side. Lampway finds 2D joints in each panel, triangulates them, checks the legs, feet and silhouette, then retargets and loops the cycle. Two views give depth and tell the legs apart without a heavy model.

    Built Tracker core

    On a synthetic two-view walk the fit recovered every bone within 5 degrees (1.9 at worst) and the leg identity in every frame; a single view fails the same clip. Checks, retarget and loop export are built too.

    Not yet Live run

    The 2D joint detector, the silhouette refine with the skinned character, a real clip through the whole chain, and export into the engine. Body-tracking models wait on a provider decision.

    The kind of input the tracker takes: one generated clip, front on the left and side on the right. Nothing has been tracked from this clip yet.

    The caps, by default

    $1per job
    $5per day, your local day
    $0.25above this, a job waits for your click

    All three are settings. No provider is switched on until you choose one.

    Rent a box only when you choose one.

    Live

    One command-line tool rents compute from the provider you pick: Boat, Modal, RunPod or fal. Headless Blender work (thumbnails, silhouettes, AO bakes) can run on the box instead of your machine. The agent can plan a job and read its status. It cannot submit one.

    • Run live on Boat: seven jobs, three of them headless Blender, about $0.0016 in total. Every box was torn down and checked against Boat’s own list.
    • A job killed mid-run was re-adopted by the next reconcile, finished and cleaned up. Orphans are reported, never stopped for you.
    • Modal, RunPod and fal are built against stand-ins and wait for a live run.

    The Asset Vault: your library, where it already lives.

    Partial

    A library for meshes, materials, images, video and seeds. It references your files in place and never copies or edits them. Nothing is enrolled on its own: an initial import shows you what it would scan, and scans only after you confirm.

    Built Library

    The store with full-text search and facets, curation and ratings, provenance records (what made an asset, and from what), similar items by shape, look and name, and local CPU embeddings that ship with the client build, checked on real weights.

    Built Window

    Thumbnails and video, the Vault window and its MCP tools, and every finished generation filed in the Vault automatically, with its prompt.

    Design mock-up of the Asset Vault window: filters on the left, a grid of meshes and materials, a lantern selected with its details
    In progressDesign, in progress: the Vault window, with placeholder assets.

    Your other AI apps can drive it.

    Live

    Turn on MCP in Lampway, pick your app and click Add. The assistant starts a small local launcher, and the launcher talks to your running Lampway over a loopback connection.

    • The server offers 98 tools to a connected app, counted from the code, and the client adds its own scene and UI tools.
    • Nothing offered over MCP spends credits, and spends still wait for your click.
    • A Connections panel lists the MCP servers your other agents already have and can check one; the check is a route you switch on.
    claude code
    # Lampway, profile menu, Connect AI Apps (MCP), then:
    $ claude mcp add --scope user lampway -- ~/.lampway/connector/lampway-mcp
    • Claude Code
    • Codex
    • Cursor
    • VS Code
    • OpenCode
    • Claude Desktop
    • any app that runs a local stdio server
    Design mock-up of the Lampway window: a lantern in the viewport, a quiet sidebar with the pipeline steps, agent cards in the corner, a spend gauge in the status bar
    In progressDesign, in progress: the client facelift, with placeholder content.

    A calmer client, in design.

    In progress

    The same information, better presented. Each surface has one thing the eye lands on, what you act on next, and the rest one hover or one click away. State reads from shape first, colour second and words third, so it holds up in greyscale.

    • Only one thing moves by itself: the sign that data is leaving.
    • Only something waiting for you glows.
    • Night and Paper themes from one token file.

    GPL-3.0-or-later.

    Free software, with its origin on the label.

    Lampway began as a fork of the GPL Mixar desktop client, which is itself a custom build of Blender. We kept the client and wrote the backend, because Mixar’s is closed and hosted. Upstream copyright and licence notices stay, as the GPL requires.

    Lampway is an independent open-source project, started from the GPL-licensed Mixar client and built on Blender. Not affiliated with or endorsed by Mixar, Adeveda Enterprises Private Limited or the Blender Foundation.

    Origin and attribution

    The waves, and where each stands.

    1. 0Correctness defects in shipped tools Done
    2. 1Prompt library, job registry, lineage, ledger, workflow graph Done
    3. 2The armour pipeline to the engine set Done
      16 of 16 rows built
    4. 3Fit, bind and export to the engine Built, not run live
      10 of 12 tools; two wait on decisions; no engine-editor leg yet
    5. 3bThe agent cockpit Built
      3 of 4 parts; the WezTerm window is next
    6. 4Animation from video, retarget, video presets Built, not run live
      8 of 9 rows; body tracking waits on a provider decision
    7. 5Mixar parity, the rest; studio drivers Built
      15 of 18 rows
    8. 5bThe Asset Vault In progress
      8 of 19 contracts have code
    9. 6Cloth, characters, splats, printing, cinematics Waits on scope