Live2D Cubism models as an iced widget, in pure
Rust: .moc3 parsing, motion/expression/physics playback and wgpu rendering, with no
Cubism Core binary and no C++ toolchain in the build.
Rendered from DeepSeek-chan(大肥鱼), a free model drawn and separated by 神宫凉子
and rigged by 霓虹猫_NeonNeko. See Model credits.
The widget owns the parts that are tedious to get right — texture budgets, GPU state,
frame pacing, look-at routing, hit testing, event delivery — so a host writes an
asset, a model, and a view:
live2d(&app.hiyori)
.gestures(Gestures::default())
.on_click(|tap| Message::Pet { model: tap.model, area: tap.area })
.look_at(look_at::cursor)Pre-0.1: extracted from a working desktop-pet application, so the API is what that
application needed and may still move. The renderer is wgpu only — the widget delegates to
iced's shader primitive, which the tiny-skia backend does not have.
| Capability | Status |
|---|---|
| model and textures, correct colours, clipping masks | ✅ |
| mipmapped textures — thin line art survives minification | ✅ |
| motions: groups, looping, cross-faded switching, expressions | ✅ |
| physics, including settings that chain into each other | ✅ |
| look-at: head, eyes, torso, routed per rig | ✅ |
| parameter writes staged before or after physics — overwrite, add or multiply | ✅ |
| part overrides, replayed every step | ✅ |
| hit areas; hover, press, drag, wheel | ✅ raw or classified |
| typed vocabularies, validated at load | ✅ |
| headless offscreen render to PNG | ✅ |
| 60 fps on the 715-drawable reference rig | ✅ |
Not there yet: reading back the effective parameter values, smooth transitions between the clip and a host layer, asynchronous loading, idle frames, DPI-aware texture budgets, global opacity, non-rectangular clipping, view transforms (pan/zoom of the framing itself), playback control (seek, speed), physics beyond a switch, loading a model from bytes, and a freeze that keeps physics running. docs/gaps.md tracks each of them with where it lives and what closing it costs.
Deliberately out of scope: keyboard input and keyboard focus, accessibility, touch input (and with it pinch and pen pressure), inertia and physics drags, breathing/eye-blink/lip-sync helpers, a desktop-pet shell (transparent, on-top, click-through), motion priority policy, and the tiny-skia and wasm targets.
Same model, both in a neutral pose: the official Cubism Viewer 5.3 on the left, this
renderer at texture_scale = 1.0 on the right. Colours, mask edges, blend modes and
draw order match. The captures are not frame-synchronised, so the physics phase differs
(mouth and hair sit a little differently).
- Rust 1.93+ (edition 2024)
- A GPU with Vulkan/DX12/Metal
- iced master, pinned by
rev— theshaderwidget and theadvancedfeature the crate needs are not in a release yet - A Live2D model directory (
*.model3.json+*.moc3+ textures). No model is part of this repository; docs/test-models.md lists where the official samples come from and what their terms are
The crate pins iced master, so the host has to add the same pin:
[dependencies]
iced = { git = "https://github.com/iced-rs/iced", rev = "e5c350f271a8046f875c6662d452fde9e462d486", features = ["advanced"] }
iced-live2d = { git = "https://github.com/dynamder/iced-live2d" }A complete host is an asset, a model, and a view:
use iced_live2d::{
AssetOptions, Live2dAsset, Live2dModel, ModelOptions, Raw, live2d, look_at,
};
struct App {
hiyori: Live2dModel<Raw>,
}
fn new() -> App {
let asset = Live2dAsset::new(
"Hiyori.model3.json",
AssetOptions { texture_scale: 0.5, scan_sidecars: true },
);
let hiyori = Live2dModel::<Raw>::new(&asset, ModelOptions::default());
App { hiyori }
}
fn view(app: &App) -> impl iced::Widget<Message> {
live2d(&app.hiyori)
.raw()
.on_event(Message::Input) // pointer facts
.on_model_event(Message::Live2d) // load result, motions, problems
.look_at(look_at::cursor)
}The asset/model split is what makes several instances share what is expensive: the textures and the parsed metadata are loaded once, and each instance keeps its own parameter values, playback position and physics state. The mutable model state is still copied per instance; docs/gaps.md records the cost.
Both constructors take their options explicitly, and there is no variant that invents
them: whether to spend 592 MB of VRAM on 4096px textures or 148 on half-size, whether a
folder of animation files is a loop set, and how host writes combine with what plays,
are not things a component can guess. AssetOptions::default() and
ModelOptions::default() are a starting point to override, not a hidden decision.
For a runnable host, this repository carries a demo app and four examples; all of them need a model path:
cargo run --release -p app -- "path/to/Hiyori.model3.json"
cargo run --release -p app -- "path/to/Hiyori.model3.json" --track viewerUse --release: a debug build runs at ~5 fps because the per-frame CPU mesh work for
hundreds of drawables is unoptimised, which also makes motion look like slow motion.
| Type | Owns | Lifetime |
|---|---|---|
Live2dAsset |
file path, texture budget (AssetOptions) |
as long as any model of it, plus itself |
Live2dModel<I> |
parameters, parts, playback, physics, budgets and write policy (ModelOptions) |
the host's |
Live2d<'_, Message, I> |
framing, pointer, event channel | while it is in the UI tree |
Below the component the same split reappears as live2d_render::{Asset, Model, ModelGpu, View}, and Model there is pure CPU: it can be stepped, hit-tested and read
back without a device.
A model is driven through a vocabulary: five lists of names the host declares in
enums and promises the model has. Declaring one is impl Interface plus the enums;
the derive (--features macros) writes the four vocabulary items:
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Vocabulary)]
#[vocabulary(prefix = "Param")]
enum FaceParameter { AngleX, AngleY, MouthOpenY }
struct Face;
impl Interface for Face {
type Parameter = FaceParameter;
// …Part, Motion, Expression, HitArea
}
let hiyori = Live2dModel::<Face>::new(&asset, ModelOptions::default());- Validation happens once, at load, before a texel is uploaded. A model that lacks
any declared name fails to load with the missing names listed
(
LoadFailure::Interface) instead of silently driving nothing. - Keys are typed. A key can only be produced by the vocabulary that declares it,
so
play_motion(FaceMotion::TapBody, MotionClipIndex::new(0))cannot be called on a model whose interface has noTapBody. Rawis the escape hatch.Live2dModel::<Raw>::new(&asset, options)takes the model's ownModelInfoas the vocabulary; keys carry the asset they were minted from, so a key handed to a model of another asset is rejected and reported instead of landing on the same index.- An empty vocabulary says "not this interface". An interface whose
Expressionenum has no variants can never be asked for an expression.
model.parameters().insert(FaceParameter::MouthOpenY, 0.8); // overwrite, the default
model.parameters().add(FaceParameter::AngleX, wave); // add on top of what plays
model.parameters().multiply(FaceParameter::AngleY, 0.5); // multiply what plays
model.parts().insert(FacePart::ArmA, 0.0); // 0.0..=1.0
model.play_motion(FaceMotion::TapBody, MotionClipIndex::new(0)); // 0-based, as Cubism indexes
model.play_random_motion(FaceMotion::Idle);
model.stop_motion();The interface names groups; a clip is a file inside one, so it is named by
MotionClipIndex rather than by the host's vocabulary.
Every write is replayed on every step, after look-at:
reset → motion → expression → look-at → host (before physics)
→ parts → physics → host (after physics) → pose
ModelOptions carries the two decisions a host makes once:
let model = Live2dModel::<Face>::new(
&asset,
ModelOptions {
mask_size: 1024,
parameter_policy: ParameterPolicy {
blend: ParameterBlend::Overwrite,
stage: ParameterStage::Auto,
},
look_at_blend: LookAtBlend::Overwrite,
},
);blenddecides how a write combines with what played:Overwrite(the default),AddorMultiply. A write can name its own blend (add,multiply,apply) and then ignores the policy's blend; its stage still follows the policy unless it names one.stagedecides where it lands.Auto, the default, reads the model's ownphysics3.json: a parameter physics writes is staged after physics, everything else before it. A write can nameBeforePhysicsorAfterPhysicsexplicitly.look_at_blenddecides whether the built-in look-at replaces the pose (Overwrite, the default) or adds to it (Add).- A physics output written before physics is overwritten; the component reports
that once as a
Probleminstead of leaving a silent no-op.
The policy is live: parameter_policy_mut() and look_at_blend_mut() change it
without rebuilding the model. There is no constructor that invents it —
ModelOptions::default() is how a host explicitly chooses the defaults.
A key holds one write: add replaces an earlier insert on the same key, so a
host that wants to combine a tracking value and an effect computes the final value
itself.
Values are raw, in the range the model declares; ModelInfo carries
minimum/maximum/default per parameter. Clamping is the render layer's job.
The library does not decide what plays. There is no idle policy, no automatic first motion, and no directory scan unless asked for: a model nobody tells to play stays in its rest pose. "Idle" is the host's five lines:
// on load: start something
ModelEvent::Loaded { .. } => model.play_motion(FaceMotion::Idle, MotionClipIndex::new(0)),
// and when a one-shot ends: start the next one
ModelEvent::MotionEnded { .. } => model.play_random_motion(FaceMotion::Idle),That is deliberate. A component that picks for the host also picks wrong: this repository's own demo once looped a rig's "switch to the hand holding a foxtail" clips as if they were idle animations, because the library had invented a motion group from a directory listing and then chosen from it at random.
Two types, because the two categories never overlap: [ModelEvent] is what the model
did, and the interaction input is what the pointer did, in the vocabulary chosen with
raw() or gestures(..).
- Loading is deferred and reported.
Live2dAsset::newdoes no IO; the first frame that draws a model loads it, and the outcome arrives asModelEvent::Loaded { info }orModelEvent::FailedToLoad { failure }. A failed load is not retried, and the widget keeps reserving its space. - Events are one frame late and per model. The render layer cannot publish while
preparing a frame, so it hands events to the widget, whose next
updatepublishes them. Two widgets drawing one model both receive all model events, and the second one to appear is sent the load result it missed. - No listener, no channel. A widget with neither
on_model_eventnor an interaction handler asks the render layer for nothing, so events cannot pile up. MotionStartedcarries(group, clip)plus the clip's duration and loop flag.MotionEndedfires for every clip that stops —MotionEnd::Completedwhen it reached its own end,Interruptedwhen it was replaced or stopped — and playback then stops until the host asks again. A looping clip never completes, which is why an idle loop needs no scheduler.- Pointer events belong to the widget, not the model. Two widgets drawing one
model keep separate hover, presses and drags: each reports input in its own space.
Every event names its model and carries the position in three forms — widget pixels,
clip space and model space (see
Sample). freezestops the clock, not the input. Nothing steps, deforms or uploads and the model shows its last frame, but the frame that input needs still happens, so hovering, clicking and scrolling keep working against that pose.- Dropping an asset or model frees its GPU state at the end of the next rendered frame, not immediately.
Input reaches the host as messages the host defines. Every event names the Live2dId
of the model it happened on — a live2d widget is not a button, so its identity cannot
live in the message variant. One model has several hit areas and the same vocabulary
of clicks and drags serves every model, so the message is (Live2dId, what happened)
and the variant says only what happened.
A widget reports one vocabulary, chosen once. live2d(..) starts undecided and
raw() or gestures(..) picks the branch; each branch only has the hooks that fit
it, so the same physical action can never be handled twice:
live2d(&model).raw() // RawInput: raw facts, host classifies
live2d(&model).gestures(Gestures::default()) // GestureInput: the component classifiesThe choice decides the input type, so it comes before on_event: a raw widget
hands the closure RawInput<I> and a classified one GestureInput<I>. Model events
are a separate type and channel, so on_model_event works in either branch and does
not care when it is bound.
| Method | Available in | Reported | Payload |
|---|---|---|---|
on_model_event |
both | load result, problems, motion start and end | ModelEvent<I> |
on_event |
both vocabularies, on its own | every interaction event, movement included | RawInput<I> or GestureInput<I> |
on_press / on_release |
raw |
a button or finger went down / came up | Pointing<I::HitArea> |
on_drag |
raw |
the pointer moved while held, once per frame | Dragging<I::HitArea> |
on_click |
gestures |
a press that came back without moving, once the double-click window closes | Tap<I::HitArea> |
on_double_click |
gestures |
a second click inside that window; the first is not reported | Tap<I::HitArea> |
on_long_press |
gestures |
held still past the threshold, while still down | Tap<I::HitArea> |
on_drag_start / on_drag / on_drag_end |
gestures |
a press that travelled | Drag<I::HitArea> |
on_scroll |
both | the wheel over the widget | Scrolling |
on_enter / on_exit |
both | the pointer reached / left a hit area | Hovering<I::HitArea> |
on_move |
both | the pointer moved over the widget | Moving |
live2d(&self.model)
.gestures(Gestures::default()) // classify clicks, drags, holds
.cursor(|hover| match hover { // cursor shape, no message needed
Hover { pressed: true, .. } => mouse::Interaction::Grabbing,
Hover { area: Some(_), .. } => mouse::Interaction::Pointer,
_ => mouse::Interaction::Idle,
})
.on_model_event(Message::Live2d) // load result, motions, problems
.on_click(|tap| Message::Pet { model: tap.model, area: tap.area })
.on_drag(|drag| Message::Turned { model: drag.model, by: drag.delta() })
.on_scroll(|scroll| Message::Zoom { model: scroll.model, by: scroll.lines[1] })Decisions worth knowing:
- One vocabulary, not two. A raw widget never reports a gesture and a classified widget never reports a raw pointer event, so nothing arrives twice. Raw input is the escape hatch: it carries the facts, including the instant each happened, and a host that wants a double click classifies it itself.
- Raw events are facts, gestures are a judgement.
Pressed/Releasedare reported for every physical press, so on a raw widget a double click shows two of each;Clicked/DoubleClickedexist only withgestures(..). - A click is never reported before it is known not to be a double click. Click and
double click are not a prefix code: at the first release there is nothing to tell them
apart. So
Gestures::double_click = Some(window)holds every click until the window closes — a second click inside it producesDoubleClickedand the first click is never reported, and a single click is reported when the window closes. One action, one message. The cost is that a single click is late by up to that window;double_click: Nonereports clicks immediately and turns double-click detection off. on_eventand the specific hooks are exclusive.on_eventis the catch-all: it receives every interaction event of the vocabulary, movement included. Binding it together with a specific hook does not compile, and a widget with neither drops the input. Choose by intent:on_eventfor logging, replay or a host-side recognizer; specific hooks for a policy.on_moveis the only continuous input for specific hooks. It is reported once per frame only when bound;on_eventreceives movement without it.- With
gestures,on_dragreports the classified drag, which carries velocity; without it, the raw drag arrives, which does not. Either way it fires once per frame, never twice. - The hit area of a drag is the one under the press, fixed for the whole drag — dragging off a head does not turn the drag into a drag of nothing.
- A press is a promise. When the window loses focus, every held button reports
Cancelled, so a host's own state machine always has a way out. - One view owns the pointer. Two widgets drawing one model each keep their own hover, but a press belongs to the widget it landed on: until that button is released, other widgets on the same model report no movement, drags or wheel, and their presses are ignored. Releasing the last held button frees the pointer for the next widget.
capture(true)stops a parentscrollableor draggable surface from also reacting while a press is held.Samplecarries the same point three ways: widget pixels (what window dragging wants), clip space (zoom-independent) and model space (what hit areas and physics speak).
Everything takes a model path, because none is shipped:
cargo run --release -p iced-live2d --example minimal -- "path/to/model.model3.json" [second]
cargo run --release -p iced-live2d --features macros --example typed -- "path/to/model.model3.json"
cargo run --release -p iced-live2d --example interact -- "path/to/model.model3.json" [second]
cargo run --release -p iced-live2d --example policy-iced -- "path/to/model.model3.json"
cargo run --release -p live2d-render --example offscreen -- "path/to/model.model3.json" frame.png 900 30
cargo run --release -p live2d-render --example policy-render -- "path/to/model.model3.json" ParamMouthOpenY 0.8 auto
cargo run --release -p live2d-render --example unknown-index -- "path/to/model.model3.json"| Example | Shows |
|---|---|
minimal |
two models in one window through Raw, keyed by Live2dId; keys R/E/P/1/2, every component event printed |
typed |
a host-declared interface: typed keys for parameters, parts, motions and hit areas, and the load failure a model that lacks them produces |
interact |
every input mapped to a message: click, double click, long press, drag, drag end, scroll (zooms the pane), hover, and gaze driven by the pointer |
policy-iced |
a mouth and breath layer over the first clip; B/S/L switch blend, stage and look blend live |
policy-render <Param> <v> <auto|before|after> |
which parameters a write changes, and whether staging it before physics moves the physics outputs |
unknown-index |
writes a parameter and a part the model lacks and plays a missing expression: each is reported as an issue, none is applied |
offscreen |
one frame into a PNG, no window |
dump |
what is in the .moc3: drawables, mask sets, canvas, motion groups |
inspect |
what is in the files: physics settings, motion curves, expression targets, and how the art sits in the canvas |
probe <x> <y> |
which drawables cover a model-space point, in paint order |
switch <Param> <v0> <v1> |
which drawables a parameter flips, and their metadata |
sweep |
what physics does along a horizontal sweep of the look-at target |
jolt |
how many pixels change per frame during a slow sweep, and where |
rig |
how cursor tracking is routed for a model, in both modes — no GPU needed |
sweep is the fastest way to chase a tracking bug: it prints the input parameter and
the physics outputs per frame and flags frame-to-frame jumps. Prefix it with
SWEEP_DIRECT=<ParamId> to write that parameter directly. inspect takes
LIVE2D_PARAMS=<substring>[,<substring>…] to dump matching parameters with their
ranges and current values, which is how you check a parameter exists before blaming the
renderer.
offscreen reads its whole state from the environment, so a capture is reproducible
from a command line:
| Variable | Meaning |
|---|---|
LIVE2D_TEXTURE_SCALE |
upload resolution multiplier, default 1.0; values quantise to 1/n, and 0 is rejected by the hang check |
LIVE2D_MASK |
mask render-target edge in pixels, default 1024; clamped to the device limit |
LIVE2D_MOTION / LIVE2D_EXPR |
group,clip to play / expression index to apply before the capture; an out-of-range value fails the capture |
LIVE2D_CLEAR_EXPR / LIVE2D_NO_MOTION |
drop the expressions / stop the motion after loading |
LIVE2D_FADE |
seconds, or cut: overrides every fade the model files declare |
LIVE2D_NO_PHYSICS |
leave physics out of the frame |
LIVE2D_RECLIP |
rebuild the clipping resources every frame, to catch a stale plan |
LIVE2D_LOOK_AT / LIVE2D_TRACK |
x,y in -1.0..=1.0, applied as a LookAt target / adapted or viewer routing |
LIVE2D_HIT |
x,y in -1.0..=1.0: print which hit area a click there would land in |
LIVE2D_FILL |
how much of the widget the model's bounds span (1.0 touches the edges, default 0.925) |
jolt takes JOLT_RANGE=low,high (-0.15,0.15), JOLT_SETTLE (120 frames),
JOLT_SIZE (640) and JOLT_MOTION; sweep takes SWEEP_RANGE, SWEEP_SETTLE,
SWEEP_JUMP, SWEEP_ALL, SWEEP_MOTION and SWEEP_DIRECT=<ParamId>. Both read
LIVE2D_NO_PHYSICS and LIVE2D_TRACK.
A scale has no effect between quantisation steps: 0.7 uploads exactly like 1.0 and
0.6 like 0.5, because the factor is round(1 / scale). A scale that is zero,
negative or not finite is reported as an error rather than attempting the upload.
The widget drives its own frames at 60 Hz; do not request frames of your own. A
host may observe window::frames for a clock (it requests nothing), but a second
RedrawRequest source races the widget's. Model::advance takes whatever interval the
host measured and
spends it in fixed 1/60 s steps, keeping the rest for the next call, so the pose is a
function of elapsed time alone rather than of how the host sliced it.
A host can hand the scene a zero-length interval, and desktop windows do: an iced
window delivers roughly 2–10% of its frames with an instant equal to the previous one.
Treating such a frame as real is what used to make parts flicker — advance reset every
parameter to its default and physics then returned before writing its outputs, so for
one frame the hair, skirt and accessories snapped to rest and back. Whatever the host
does, advance must not take a duplicate instant as progress.
.profile(true) reports the split, once per 60 frames:
live2d profile: 60 frames 1.00 steps, step 0.08 ms, deform 3.40 ms, upload 1.42 ms, delta 15.2..18.4 ms (mean 16.67)
steps above 1 means the host presents slower than 60 Hz and the model is catching up;
step is motion/expression/physics, deform the CPU mesh rebuild and upload the GPU
write. They are reported apart because on a 715-drawable rig the split says whether the
cost is simulation or buffers.
Framing comes from the canvas rectangle in the .moc3 header — the box Cubism
Editor and the Viewer use — not from the bounding box of the artwork. A model whose art
leaves spare room in its canvas therefore looks smaller and off-centre in every host,
ours included: Rice has a 1.5:1 landscape canvas with the art filling 66% × 85% of it,
6% right and 6% below centre, so in a square window it occupies 61% × 53% of the
width and height where Haru occupies 40% × 83%. LIVE2D_FILL (or Live2d::fill)
decides how much of the widget those bounds span; the default is 0.925, so a model
does not touch the edges.
Textures dominate. The reference rig's five atlases are 592 MB uncompressed, and the scene uploads at half resolution by default:
| working set | |
|---|---|
| naive (keeps decoded textures, full res) | 1 565 MB |
| assets dropped, full res | ~900 MB |
assets dropped, texture_scale: 0.5 (default) |
462 MB |
| the above plus a mip chain (textures × 4/3) | ~511 MB |
Pass AssetOptions { texture_scale: 1.0, .. } for full quality (SceneOptions in the
render layer); mipmapped upload keeps thin line art intact when the model is drawn small,
which is why minification without a mip chain looks like dashed speckles. For reference,
the same model hosted in a Chromium webview running the official Cubism Web SDK measured
3.2× this app's private working set on the same machine.
- A motion's fade comes from the model folder, not from the call. A
model3.jsonmotion reference wins over the motion's ownMeta.FadeInTime/FadeOutTime, and where neither declares one the fade is one second — the Cubism Viewer's default, not zero.Live2dModel::set_fadeoverrides both, andFade::zero()cuts. Every replaced clip keeps fading out on its own, so several can overlap after a burst of switches;set_fade_limitcaps how many. - Colour space: the
formathanded toPipeline::newis whatever the host surface uses. On a non-sRGB (Bgra8Unorm) target the model matches Cubism's gamma-space blending; on*UnormSrgbyou must render into your ownRgba8Unormtarget and do gamma→linear when compositing, or the model washes out. - The component's primitive must not implement
draw. It has to returnfalseand do its work inrender, because the mask pass has to be inserted between the passes iced controls. model3.jsonis not always complete. The reference rig declares zero motions and zero expressions while the files sit inAnimation/andExp3/.AssetOptions::scan_sidecarsasks for a directory scan; what it finds lands in one synthesized group namedScanned, in alphabetical order of the files. It is off by default because a folder of files is not an animation set: this rig'sAnimation/holds one idle loop and seven one-shot "switch the hand" transitions, and only the host can tell them apart.- Look-at routing is resolved per model, not hardcoded.
live2d-render/src/rig.rsmaps six slots (head yaw/pitch, body yaw/lean, eyes) onto whatever the rig exposes. A rig built for VTube Studio takesAngleX/AngleYandPositionX/PositionYbecause itsParamAngle*parameters are physics outputs; a classic rig takes theParam*names directly. The choice is decided fromphysics3.jsonand inspectable withexamples/rig;--track viewer(the app) orLIVE2D_TRACK=viewer(examples) forces the Cubism Viewer's own binding set, which is what you want when comparing frames against the Viewer. - The component needs iced's
advancedfeature —Widget,Shelland the layout types live behind it, andshader::primitive::Rendereris not publicly reachable, so theWidgetimpl bounds onshader::Shader<Message, Self>instead.
vendor/mocari is the crates.io 0.4.1 release plus the five patches in patches/,
committed so a fresh clone builds; the workspace dependency points straight at it, and
patches/ is kept so the difference against upstream can be audited line by line.
Unpatched 0.4.1 cannot render this rig, and the fixes belong upstream rather than in
every consumer. Each patch file opens with what it corrects and how it was verified;
they are still being tested in more detail before being submitted upstream.
Upstream's own test suite reads the Cubism sample models, which are not part of this
repository, so it only runs with the corpus from docs/test-models.md laid out under
vendor/mocari/assets/models. CI compiles the vendor crate instead of running it.
The crate is not publishable as it stands: a path dependency without a version is
rejected, and a versioned one is stripped on publish, so a consumer would silently get
upstream 0.4.1 without the patches. [patch.crates-io] is local-only for the same
reason. Publishing needs the patches upstreamed, or a distinct fork version published
under its own name.
mocari's wgpu backend needs wgpu 30, which is what iced master uses (0.14.0 is
still on wgpu 27). Pinning master also pins the whole wgpu major, so the renderer
links straight into Pipeline. It is pinned by rev, and iced pins its own git
dependencies by rev too, so builds are reproducible. When 0.15 ships, switch to the
crates.io version — the glue should not need changes.
MIT — see LICENSE. The vendored mocari copy in vendor/mocari carries the
same MIT licence from its authors, and the model files used for the captures are not
part of the repository (see below).
Every capture in this README is a render of DeepSeek-chan(大肥鱼), a freely distributed model. The notice allows publishing content made with it — including documentation — as long as the model is credited and the model files themselves are not redistributed. No model file is part of this repository.
- 模型名称 / model: DeepSeek-chan(大肥鱼)
- 原画及拆分 / art and separation: 神宫凉子
- Live2D 建模 / rigging: 霓虹猫_NeonNeko
- 模型来源 / source: 神宫凉子免费配布模型
The sample characters used for comparisons are the official Cubism samples, used under their own terms; docs/test-models.md collects the provenance and the licence text for each rig in the corpus.
- docs/test-models.md — the model corpus: where each rig comes from, what it exercises, and where its terms of use live

