Chibi Character Design: A Complete Pipeline for Two-Head-Tall Three-View Assets

    This guide walks through building chibi "two-head-tall" character assets as a repeatable production pipeline rather than one-off illustrations. It covers head-to-body ratio math and anchor points, choosing between 2.2-head and 2-head proportions, segmented compression factors for adapting realistic proportions, drawing front/side/back three-views for reuse, controlling detail density for low-profile characters, diagnosing the three common consistency errors, and setting up a configuration-driven workflow that moves from spec definition through base-image generation, view derivation, alignment refinement, and review/archive. It also addresses batch generation, cloud processing, version management, and open-source licensing (including a CC BY-NC-SA 4.0 example), plus an FAQ.

    1. No chibi assets on hand? Start with the conclusion

    Chibi two-head-tall assets show up heavily in scenarios like AI assistants, personified mascots, community characters, emoji packs, stickers, and animated avatars. Many characters start out with only a realistic concept sheet, a half-body illustration, or a partial avatar, and lack a chibi three-view suited to lightweight use. If you redraw assets ad hoc every time you need one, the results tend to be inconsistent and hard to reuse.

    A more effective approach than “drawing one more image” is to turn character production into an asset pipeline: config-driven → multi-view generation → alignment refinement → review and archive. Concretely, you first write the character’s head-to-body ratio, color palette, signature accessories, and view list into a config file; then generate a front-view baseline; then derive the side and back views; then complete alignment refinement through guide lines, local inpainting, and vectorization; and finally run proportion checks, human review, version archiving, and licensed publishing.

    The payoff is clear: new characters can enter the system the same way, and existing characters can spawn new variants; proportions, outfits, colors, and versions all become traceable; and derivative work and cross-platform reuse become easier to keep compliant.

    2. Standardization basics: head-to-body ratio, three-views, and ratio conversion

    2.1 Head-to-body ratio: replace vague descriptions with a computable anchor

    Head-to-body ratio = total character height ÷ head height, where head height is measured from the crown to the chin, excluding hair or hairstyle decorations, denoted H.

    In chibi character design, terms like “2.2 heads tall” and “2 heads tall” come from casual usage in the anime/2D creation community. There is no fully unified industry standard, but the ratio can be judged by calculation: divide total height by head height and the result is the head-to-body ratio.

    To make communication and modeling easier, simplify the character skeleton into a few key anchors:

    Anchor 2.2 heads 2 heads Notes
    Crown 0.00 H 0.00 H Establishes the origin
    Chin C 1.00 H 1.00 H Head height fixed at H
    Shoulder line S 1.14 H 1.14 H Determines upper body and shoulder placement of clothing
    Waist line W 1.42 H 1.40 H Can be fine-tuned to the garment pattern
    Crotch P 1.58 H 1.58 H Divides torso from legs
    Knee line K 1.90 H 1.70–1.75 H 2 heads cannot reuse 1.90 H directly
    Sole F 2.20 H 2.00 H Total height determined by the head-to-body ratio

    A key point to stress: knee line y = 1.90 H applies only to 2.2 heads tall. If a 2-head character still places the knee at 1.90 H, the lower leg is left with only about 0.1 H, making the space below the knee too short and the character look like it is “squatting” on the ground. For 2 heads, move the knee line up to roughly 1.70–1.75 H so the lower leg still has some expressive room.

    Deriving leg length from the crotch lets you check the proportions directly:

    • 2.2 heads: leg length = 2.20 H − 1.58 H = 0.62 H;
    • 2 heads: leg length = 2.00 H − 1.58 H = 0.42 H.

    So when switching from 2.2 heads to 2 heads, you should not simply scale the whole figure down uniformly; you should mainly compress the lower-body length and move the knee line up.

    2.2 Choosing between 2.2 heads and 2 heads

    Dimension 2.2 heads 2 heads
    Head-to-body ratio 2.2 2.0
    Leg length ~0.62 H ~0.42 H
    Room to show the legs Fits knee-high socks, skirt hems, layered footwear Better for局部 details like sock cuffs, shoe soles, short socks
    Typical feel Cute and playful, still supports action poses More miniature and rounded, stronger “moe” appeal
    Facial features Enough layout space for eyes and mouth Facial features take up more area, less tolerance for facial structure
    Turn-around drawing difficulty Relatively lower Side and back structure more exposed, harder

    Use a simple threshold when deciding:

    1. If the character mainly appears in avatars, stickers, chat emoji, and lightweight animation, and these uses account for 60% or more of total output, prefer 2 heads. It is rounder at small sizes and more recognizable.
    2. If the character needs to show full-body outfits, leg layering, sock/shoe details, posters, or a three-view spec sheet, prefer 2.2 heads. It balances “cute” and “recognizable” better.
    3. If the same character is used across platforms, you can define a dual spec of “base version at 2.2 heads + mini version at 2 heads”. Both share the palette, hairstyle, signature accessories, and outfit structure, and are derived only through head ratio and leg length, keeping cross-spec consistency.

    2.3 Converting from realistic proportions: use “segmented compression factors”

    Chibi proportions are not a simple downscale of realistic human proportions. Child characters are usually 4–5 heads tall, realistic adults are about 6.5–8 heads, and chibi characters generally fall between 2 and 3 heads. Scaling a realistic character down uniformly usually just gives you a “smaller realistic person,” not a chibi.

    So instead of a single multiplier, this article uses “segmented compression factors” to describe the compression. Defined as:

    • Crown to chin: fixed at 1.00 H, compression factor 1;
    • Chin to crotch: default target 0.58 H, i.e. crotch y = 1.58 H;
    • Crotch to sole: target length determined by the head-to-body ratio, i.e. k − 1.58;
    • Sole: y = k H, where k is the target head-to-body ratio.

    Given a realistic reference character whose crown-to-crotch is about 2.28 H and sole is about 7.00 H, you can compute:

    1. torso compression factor f_t = (target chin-to-crotch) / (realistic chin-to-crotch)
    2. = 0.58 / (2.28 - 1.00)
    3. ≈ 0.45
    4. lower-body compression factor f_l = (target crotch-to-sole) / (realistic crotch-to-sole)
    5. = (k - 1.58) / (7.00 - 2.28)

    Where:

    • When k = 2.2, f_l ≈ (2.20 − 1.58) / 4.72 ≈ 0.13;
    • When k = 2.0, f_l ≈ (2.00 − 1.58) / 4.72 ≈ 0.09.

    These factors are not a hard production ruler; they illustrate that chibi compression mainly targets the torso and lower body, especially the lower body, while head height is preserved as a uniform unit of measure. In practice, align the chin, crotch, knee, and sole anchors first, then fine-tune for outfit and pose.

    2.4 Three-views: draw for reuse

    A character’s three-view typically includes front, side, and back. Some teams add a three-quarter view, expression variations, or action references. The job of a three-view is not realism but answering one core question: from a different angle, is this still the same character?

    Type Typical content Main use
    Main concept sheet Large front view with labeled color values Shows character vibe, sets the first impression
    Standard three-view Front, side, back at equal scale, same eye level, same grid Reference for 3D modeling, rigging, animation
    Expression variants Happy, angry, sad, surprised, neutral, etc. Chat interaction, emoji packs
    Action reference Idle, walk, wave, etc. Animation and motion

    Three points on delivery:

    1. Fix the baseline view first: all other views are derived from the front.
    2. Define the use case clearly: if it targets 3D production, the side view should be a true profile, and the back should share the front’s grid and symmetry rules, but you must independently constrain back-side structure, garment thickness, and accessory direction. It is wrong to treat “the back as a mirror of the front.”
    3. Line-art quality beats color: clean, closed linework with simple paths is what makes vectorization, layering, and modeling go smoothly.

    2.5 Controlling detail density: a chibi strategy for low-profile characters

    In personified characters there is an implicit rule: the stronger the ability setup and the higher the popularity, the more elaborate the outfits and accessories tend to be. High-profile characters accumulate more fan art and official assets, so details can be layered on through iteration. If a low-profile character copies elaborate outfits directly, chibi proportions tend to lose those details.

    So when making a chibi version, control the detail density:

    • Use 1 primary color + 1 secondary color + 1 accent color; keep the palette restrained and recognizable;
    • Design 1 signature symbol, e.g. a distinctive hairstyle silhouette, headpiece, badge, or accessory that stays legible even shrunk to avatar size;
    • Deliver outfits in tiers: a basic uniform version for interaction and multi-scene fit, and an elaborate version for high-expression scenarios like posters and covers.

    3. Three types of consistency errors and troubleshooting

    The hard part of a chibi three-view is usually not any single image but consistency across images. Common errors fall into three types:

    Error type Typical symptom Root cause
    Proportion error Inconsistent head-to-body ratios across views; characters look “taller” or “shorter” between views No shared grid; each part drawn or generated independently
    Perspective error Foreground-larger-than-background, inconsistent eye level, feet not on the same horizontal line Inconsistent camera/view parameters; the model’s grasp of “view” is unstable
    Detail error Back view drawn reversed, missing hairstyle, accessories swapped left/right, color drift Lack of global rules; insufficient constraints on back-side information

    To address these, set up the following constraints:

    • Shared grid: front, side, and back views share horizontal reference lines for crown, eyes, shoulders, waist, knees, and sole;
    • Shared eye level: use a near-orthographic eye-level view, with all views’ soles landing on the same horizontal line;
    • Symmetry rules: keep the front as axis-symmetric as possible; the back shares the front’s symmetry logic, but left/right structures like hair ornaments, badges, zippers, and capes must be defined in advance;
    • Negative constraints: explicitly exclude extra limbs, foreshortening, text, watermarks, and other common defects in the prompt;
    • Generate the whole three-view at once: using an existing front image as a reference condition to generate a single image containing front, side, and back is easier to keep consistent than generating three separate images.

    Common troubleshooting checklist

    Problem Fix
    Back view drawn reversed Return to the front concept, label left/right accessory placement, then regenerate or locally inpaint the back
    Soles misaligned Check whether all views share the same sole reference line, re-crop, and unify canvas height
    Head-to-body ratio drift Re-measure crown-to-sole height and confirm it meets the 2.2 or 2-head spec
    Accessories swapped left/right Clarify whether an accessory belongs to the character’s right or left side, and write it into the config’s signature field
    Color drift Extract color values from the front, then replace each region in side/back views against the palette rather than re-sampling
    Side not a true profile Use an orthographic side reference; disable or reduce perspective strength
    A part is locally too long Check knee, crotch, and waist anchors; fix the skeleton first rather than stretching the image

    4. Pipeline design: from requirements to archive

    The recommended flow is: config → baseline image → view generation → alignment refinement → review and archive. This pipeline splits into five stages:

    1. Spec definition: describe head-to-body ratio, palette, style, and view list in a machine-readable config;
    2. Baseline generation: produce the front baseline first, as the reference for all subsequent views;
    3. View derivation: generate the side and back from the front image;
    4. Refinement and alignment: align to reference lines, unify the palette, do local inpainting, and vectorize;
    5. Review and archive: run metric checks, human review, version archiving, and licensed publishing.

    4.1 Step 1: define the character spec

    Write the character spec as a config file, not a verbal description. The config should separate at least two kinds of fields:

    • How to draw: ratio, palette, style, views;
    • How to manage: version identifier, license, disclaimer.

    Example config:

    1. {
    2. "schema_version": "1.0",
    3. "id": "ai-mascot-001",
    4. "ratio": 2.2,
    5. "variants": [
    6. { "id": "chibi-2.2", "ratio": 2.2 },
    7. { "id": "mini-2.0", "ratio": 2.0 }
    8. ],
    9. "palette": {
    10. "primary": "#1F6FEB",
    11. "secondary": "#FFFFFF",
    12. "accent": "#FFC53D"
    13. },
    14. "signature": "star-shaped hair clip, on the right side",
    15. "views": ["front", "side", "back"],
    16. "canvas": {
    17. "width": 2048,
    18. "height": 1024,
    19. "cell": 512,
    20. "eye_line_y": 420
    21. },
    22. "style": {
    23. "outline": "clean",
    24. "shading": "flat-2-tone",
    25. "perspective": "orthographic"
    26. },
    27. "license": "BY-NC-SA-4.0",
    28. "disclaimer": "community-made design, not an official character"
    29. }

    The same config can drive multiple rounds of generation and spawn sub-versions at different ratios. For example, chibi-2.2 is used for the three-view spec sheet, and mini-2.0 for avatars and stickers.

    4.2 Step 2: produce the front baseline image

    The front baseline is the shared reference for all views. There are three common approaches:

    Approach Method Pros Limits
    A. Full-sheet generation Prompt for a single image containing front, side, and back characters The model naturally aligns proportions and colors in one step Layout and proportions are not fully controllable; detail resolution is limited
    B. Reference-image driven Generate the front first, then use it as a reference to generate side and back High controllability, iterable Depends on how well the model follows the reference image
    C. 3D-assisted Pose a low-poly or base mesh in 3D software and export view images as structural references More accurate perspective and proportions Requires some 3D skill and production time

    In real projects, combine them: use approach A for quick sketches; approach C to lock the geometry; and approach B or local inpainting to refine details.

    General text-to-image prompt template:

    1. [POSITIVE PROMPT TEMPLATE]
    2. a character sheet of a chibi mascot, {ratio}-head-tall proportions,
    3. {style}, {palette}, {outfit}, {signature}, standing in neutral A-pose,
    4. three full-body figures side by side: front view, side profile view, back view,
    5. evenly spaced, same scale and same eye level, feet on the same baseline,
    6. plain white background, high resolution, clean lineart
    7. {negative_prompt}
    8. [NEGATIVE PROMPT]
    9. perspective distortion, foreshortening, cropped, extra limbs, broken anatomy,
    10. text, watermark, logo, signature, busy background, inconsistent style between figures
    11. [CHARACTER DESCRIPTION EXAMPLE]
    12. {ratio} = 2.2
    13. {style} = flat chibi illustration with soft shading
    14. {palette} = blue and white with golden-yellow accents
    15. {outfit} = a simple outfit with a cute dress
    16. {signature} = a star-shaped hair clip on the right side

    To improve reproducibility, record the generation parameters as well:

    Parameter Recommendation Notes
    Model Record model name and version Different models respond very differently to the same prompt
    Resolution 2048×1024 or higher Keeps enough detail when three characters sit side by side
    Seed Fix the seed Aids reproducibility and version tracking
    Steps Use default or medium steps Higher is not necessarily more consistent
    Reference-image weight ~0.5–0.8 Too high may limit detail, too low may drift
    Negative prompt Fixed template Excludes perspective, cropping, text, watermarks, etc.
    Output format PNG or WebP Keep high-res PNG if vectorizing later

    Prompt design principles:

    1. Describe a character type, not a specific character: output a generic chibi to reduce infringement and mistaken-for-official risk;
    2. Lock the global composition first: same scale, same eye level, and same baseline are key to multi-view consistency;
    3. Exclude common defects: explicitly exclude perspective, cropping, text, watermarks, and inconsistent style in the negative prompt;
    4. Parameterize: abstract ratio, palette, outfit, and accessories into template variables so one prompt skeleton serves many characters.

    4.3 Step 3: refinement, alignment, and vector export

    1. Crop and align: crop the three characters along reference lines, ensuring the soles, eye lines, and shoulder lines align;
    2. Vectorize linework: vectorize the line art to make scaling, recoloring, and modeling easier;
    3. Unify the palette: extract primary, secondary, and accent colors from the front baseline, then replace them region by region in the side and back views;
    4. Local inpainting: inpaint local details like accessories, skirt hems, and hair ornaments to avoid introducing deviation through full-image regeneration;
    5. Export spec: unify canvas size, resolution, and file naming, e.g. {character_id}_{ratio}_{view}_v{version}.svg.

    4.4 Step 4: review, archive, and automated checks

    Before archiving, run both metric checks and human review. The Python code below is an interface sketch, not a directly runnable script; real use requires implementing image loading and feature measurement, which can rely on Pillow, OpenCV, or a custom image-processing module.

    1. from dataclasses import dataclass
    2. from typing import Protocol
    3. class Image(Protocol):
    4. width: int
    5. height: int
    6. @dataclass
    7. class RatioMetrics:
    8. eye_ratio: float
    9. head_height: float
    10. ground_y: float
    11. baseline_spread: float
    12. pass_ratio: bool
    13. def load_views(paths: dict[str, str]) -> dict[str, Image]:
    14. """Interface sketch: takes view paths, returns image objects.
    15. A real implementation can use PIL.Image, OpenCV, or a custom
    16. image wrapper.
    17. """
    18. raise NotImplementedError
    19. def measure_landmarks(img: Image) -> tuple[float, float, float]:
    20. """Interface sketch: returns the y coordinates of the crown,
    21. eye line, and bottom edge. A real implementation can use the
    22. alpha channel, background segmentation, contour detection,
    23. or manual annotation.
    24. """
    25. raise NotImplementedError
    26. def check_turnaround(
    27. views: dict[str, Image],
    28. tol_px: float = 4
    29. ) -> RatioMetrics:
    30. """Sketch function: compares bottom-edge alignment and
    31. proportion stability across the three views."""
    32. ground_values = []
    33. for name in ["front", "side", "back"]:
    34. top_y, eye_y, ground_y = measure_landmarks(views[name])
    35. ground_values.append(ground_y)
    36. baseline_spread = max(ground_values) - min(ground_values)
    37. pass_ratio = baseline_spread <= tol_px
    38. return RatioMetrics(
    39. eye_ratio=0.0,
    40. head_height=0.0,
    41. ground_y=sum(ground_values) / len(ground_values),
    42. baseline_spread=baseline_spread,
    43. pass_ratio=pass_ratio,
    44. )

    Human review checklist:

    • Front is as axis-symmetric as possible;
    • Back view is correctly oriented, and the signature accessory is on the correct side;
    • Head-to-body ratio is consistent across all three views, within tolerance;
    • Colors are consistent across all three views;
    • The character is still recognizable at thumbnail size;
    • Delivered files include source files, exports, config, and license notes.

    5. Engineering and batch reuse

    5.1 Config-driven batch generation

    As the number of characters grows, repeated prompts and repeated parameter tuning quickly burn through human effort. You can abstract “character” as a config and “generation” as a task. The code below is a batch-scheduling sketch; render_sheet, load_views, and check_turnaround are interfaces to be implemented. Before running, wire in the image-generation service, image-loading library, and validation logic.

    1. import json
    2. from concurrent.futures import ThreadPoolExecutor
    3. from pathlib import Path
    4. # Example character configs; in practice, load from a JSON file
    5. ROSTER = [
    6. {
    7. "id": "mascot-a",
    8. "ratio": 2.2,
    9. "palette": {
    10. "primary": "#1F6FEB",
    11. "secondary": "#FFFFFF",
    12. "accent": "#FFC53D"
    13. }
    14. },
    15. {
    16. "id": "mascot-b",
    17. "ratio": 2.0,
    18. "palette": {
    19. "primary": "#7C5CFF",
    20. "secondary": "#FFFFFF",
    21. "accent": "#FF9F43"
    22. }
    23. },
    24. ]
    25. def render_sheet(cfg: dict) -> Path:
    26. """Sketch interface:
    27. Input: character config;
    28. Output: path to the three-view sheet;
    29. Errors: raise an exception on generation failure so the
    30. caller can log and retry.
    31. """
    32. raise NotImplementedError
    33. def build(cfg: dict) -> dict:
    34. path = render_sheet(cfg)
    35. # Implement load_views and check_turnaround per section 4.4
    36. # metrics = check_turnaround(load_views(str(path)))
    37. return {
    38. "id": cfg["id"],
    39. "ratio": cfg["ratio"],
    40. "artifact": str(path),
    41. "quality": "PENDING"
    42. }
    43. with ThreadPoolExecutor(max_workers=4) as pool:
    44. results = list(pool.map(build, ROSTER))
    45. for r in results:
    46. print(f"{r['id']}: ratio={r['ratio']}, quality={r['quality']}")

    Engineering essentials:

    1. Separate config from code: put ratio, palette, and view list in config so changes need no code edits;
    2. Reproducibility: fix the random seed and save the prompt, model version, and parameters;
    3. Controlled concurrency: use a thread pool or task queue to control concurrency and avoid overloading the generation service;
    4. Quality gate: route artifacts that fail checks to a human-review queue rather than archiving them directly;
    5. Exception handling: log failure reasons, retry counts, and owners to avoid breaking a whole batch run.

    5.2 Cloud batch processing: decouple compute from the pipeline

    As the asset scale grows, you can deploy the pipeline to the cloud. Common capabilities include:

    • Object storage: store character configs, generation outputs, vector source files, and build manifests;
    • Message queue: enqueue tasks and call back results; it naturally smooths peaks and valleys and supports failure retries;
    • Container platform: package render and validation scripts as container images, scale on demand, and release resources when the job finishes;
    • Logging and monitoring/alerting: record each generation’s duration, failure reasons, and validation metrics to catch anomalies like proportion drift or missing views.

    The data flow can be designed as:

    1. character config
    2. → generation task enqueued
    3. → containerized execution
    4. → results written to object storage
    5. → validation and quality gate
    6. → human review
    7. → version archiving

    A task message can include the character ID, head-to-body ratio, views, prompt template, random seed, callback URL, and asset path prefix. This decouples generation compute from business logic and makes batch reuse easier.

    5.3 Version management: traceability is a prerequisite for long-term maintenance

    Every generation and modification should form a traceable record, containing at least:

    • config version;
    • prompt template version;
    • random seed;
    • model version;
    • change notes;
    • validation result;
    • license.

    Organize character assets by “character ID / spec / version”:

    1. mascots/
    2. └── mascot-a/
    3. ├── v1.0/
    4. │ ├── config.json
    5. │ ├── prompts/
    6. │ ├── views/
    7. │ │ ├── front.svg
    8. │ │ ├── side.svg
    9. │ │ └── back.svg
    10. │ ├── manifest.json
    11. │ └── CHANGELOG.md
    12. └── LICENSE

    This way any image traces back to “which config, which seed, which template generated it.” When you later adjust the ratio, palette, or outfit, you just bump the version number, and historical versions remain retrievable.

    6. Open-source licensing and compliant sharing

    6.1 From “self-made version” to “shareable asset”

    People who build their own chibi characters often wonder “will it be recognized?” A safe approach is to clearly state “community-made version, not official” and provide a clear license, placing the work in a framework that is shareable and iterable. This both lowers the barrier for others to use and create derivatives, and constrains usage through the license.

    6.2 License quick reference

    License Attribution Commercial use Derivative constraints Use case
    Public domain dedication (CC0) Not required Allowed None When you want maximum reuse
    Attribution (BY) Required Allowed None General asset sharing
    Attribution-ShareAlike (BY-SA) Required Allowed Same license When you want derivatives to stay open too
    Attribution-NonCommercial (BY-NC) Required Prohibited Derivatives must stay non-commercial with attribution Non-commercial use only; commercial use needs separate permission
    Attribution-NonCommercial-ShareAlike (BY-NC-SA) Required Prohibited Derivatives must stay non-commercial with attribution and be shared under the same license Personal creation, education, non-profit use

    6.3 Example with BY-NC-SA 4.0

    BY-NC-SA 4.0 has three parts:

    1. Attribution (BY): when using or adapting, give appropriate credit, including the author, the license name and link, and note whether changes were made;
    2. NonCommercial (NC): you may not use it primarily for commercial purposes. Whether a use is commercial depends on the scenario, e.g. whether it is charged, used in commercial promotion, or part of a commercial product;
    3. ShareAlike (SA): adapted works must be published under the same or a compatible license.

    Recommended practices:

    • Place the full LICENSE text in the repository root;
    • Label the author and license next to the README and the artwork;
    • Record every ratio adjustment, palette change, and outfit addition/removal;
    • Define the derivative scope: adapted works carry the same license, while unmodified parts of a collection are unaffected;
    • Mark “not official” in titles, covers, and metadata;
    • Before publishing, check the platform’s requirements for labeling AI-generated content to avoid license conflicts.

    6.4 Machine-readable metadata

    Write license information into the config or a metadata file so assets automatically carry it during retrieval, display, and redistribution:

    1. {
    2. "schema_version": "1.0",
    3. "role_id": "mascot-a",
    4. "author": "your-name",
    5. "license": "BY-NC-SA-4.0",
    6. "license_url": "https://example.org/licenses/by-nc-sa/4.0/",
    7. "attribution": "Original chibi character design by your-name, licensed under BY-NC-SA 4.0.",
    8. "modifications": "none",
    9. "source": "https://example.org/assets/mascot-a/v1.0/",
    10. "disclaimer": "community-made design, not an official character"
    11. }

    For AI-generated content, also note:

    • Copyright eligibility for AI-generated works differs across jurisdictions; creators should understand their local rules;
    • If generated content contains a recognizable third-party likeness, confirm its rights status before use;
    • When trademark, mascot, or official-logo elements are involved, avoid creating a false impression of “official endorsement.”

    6.5 Common licensing mistakes

    1. Treating CC0 as “no action needed”: CC0 waives some copyright rights, but trademark, personality rights, platform rules, etc. may still apply;
    2. Ignoring the scope of “NonCommercial”: personal projects and teaching demos usually count as non-commercial, but commercial ads and paid products need separate permission;
    3. Forgetting the license on derivatives: publishing a derivative without noting the original license and change notes breaks the license chain;
    4. Mixing licenses: when different parts of the same character use different licenses, explain it clearly in the metadata.

    7. Summary and FAQ

    For “chibi two-head-tall three-view” character work, the core conclusions are:

    1. Ratio before art style: the head-to-body ratio is a computable, transferable spec; the difference between 2.2 heads and 2 heads lies mainly in leg length and knee-line placement;
    2. Consistency before detail: multi-view failures usually are not “drawn badly” but “drawn differently,” and must be governed through a shared grid, eye level, symmetry rules, and detail constraints;
    3. Process before single points: full-sheet generation, reference-image driving, and 3D assistance each have limits; combining them with local inpainting balances efficiency and controllability;
    4. Automation before scale: config-driven generation, batch processing, quality gates, and version traceability turn character assets from one-off output into a maintainable, iterable, shareable system;
    5. Licensing before publishing: open source does not mean giving up rights; it means making the usage boundaries clear through a license.

    FAQ

    Q1: How do I choose between 2.2 heads and 2 heads?
    If the character is mainly used for avatars, stickers, and chat emoji, choose 2 heads; if it needs to show full-body outfits, sock/shoe layering, or a three-view spec sheet, choose 2.2 heads. A cross-platform character can define both specs.

    Q2: What if the three-view is inconsistent?
    First check whether all views share the same grid and sole reference line. If the proportion drifts, fix the chin, crotch, knee, and sole anchors first; if the back view is drawn reversed, re-confirm left/right accessories rather than just mirroring.

    Q3: Can BY-NC-SA be used commercially?
    By default, no. The NC in BY-NC-SA means non-commercial use, and commercial use requires permission. If the project involves paid products, commercial ads, or commercial promotion, switch to a different license or obtain explicit permission.

    Q4: Does an AI-generated character need to be labeled?
    It is recommended. At minimum, label “community-made version, not official” or “AI-assisted generation” or whatever the platform requires, to avoid misleading users and reduce compliance risk.