RuiC-card-skill: a Codex Skill that turns one sentence into a holographic 3D flash card

What RuiC-card-skill actually produces

The README frames RuiC-card-skill as a Codex Skill that reproduces the holographic trading cards sold outside stationery shops, but in a browser tab. You describe a card in one sentence, or hand over a reference image, and the skill drives a pipeline that ends with a local web page plus a set of editable source files.

The audience is narrow and specific. This is for people who already have Codex installed and are comfortable letting an agent create files in a project directory. It is not a standalone application, not a hosted service, and not a design tool with a graphical interface. The README describes the skill body as text and code only, with no binaries and no credentials, which is why it can be packaged as a ZIP and handed to someone else.

The deliverable list is concrete. You get a local page at 127.0.0.1:4173, a card.blend file you can reopen in Blender, four transparent PNG layers under assets/, a card-config.json for name, number and rarity, a render image, and a verification/ folder holding an automated acceptance report with screenshots. The card itself is not a flat texture: the subject sits forward, the background recedes, and the layers shift against each other as the viewing angle changes.

How the four-layer pipeline and the parallax shader fit together

The mechanism is a chain, and each link constrains the next. A sentence or a reference image becomes four layers: subject, background, lineart and text. Those four are drawn on one canvas under one coordinate system, which is the reason the Blender scene and the web viewer can agree on where each layer belongs. A card-config.json records the card specification, and run_pipeline.py drives everything from there.

Before Blender is touched, validate_assets.py inspects the layers for transparency and alignment. The README notes it converts checkerboard fake-transparency images into real alpha, and there is a separate checkerboard_to_alpha.py with regression tests. If validation fails, the pipeline loops back to image generation rather than proceeding. This is the part worth paying attention to: the pipeline treats a bad layer as a blocker, not a warning.

Blender then builds the card geometry. The README is explicit that Blender's custom material node graphs do not survive glTF export, so the web side rebuilds the shader from the same formulas instead of receiving it. The parallax effect is described as transforming the view direction into card-face space, dividing by a bounded normal component, then offsetting UVs by a signed depth value. The holographic phase follows the viewing angle rather than cycling on a timer, which is the difference between a card that shimmers as you tilt it and one that just pulses.

Blender arrives as the official portable build, downloaded into <project>/tools/ and checked against SHA-256. That keeps the system environment untouched, and it also means each output project carries its own copy.

Installing RuiC-card-skill and generating a first card

Installation is a directory placement, not a package install. The README says to put the skill directory into Codex's skills directory, where the directory name becomes the skill name.

~/.codex/skills/RuiC-card-skill/

The environment needs Python 3 with Pillow, and Node.js with npm. Blender is not on that list because the pipeline fetches the official portable build itself and verifies it with SHA-256.

Once the directory is in place, you ask Codex in plain language. The README gives this example prompt, and a second one for reference-image input.

用 RuiC-card-skill 给我做一张水墨风的锦鲤闪卡，文字用书法体，编号 No.001

According to the README, Codex first restates the card specification, then works through layer drawing, typography generation, config writing, the pipeline run, starting the local server, and opening the page to check dragging, flipping, sliders and the phone layout. The page is served on port 4173.

There is also a packaging step if you want to share the skill itself rather than a card. The command below packages text files only, following a whitelist.

python scripts/package_skill.py RuiC-card-skill --out ~/Desktop/RuiC-card-skill.zip

For verification, the README documents a headless check that starts its own browser and local server, exercises dragging, flipping, zoom, keyboard input, five sliders, four material finishes, screenshot download, a 390px narrow viewport and reduced motion, and compares real rendered frames rather than only reading slider values. Reports and screenshots land in verification/.

node scripts/verify_web.mjs <项目>

Where the design gives ground: Blender dependency, layer discipline and text

The most obvious constraint is the Blender portable download. It is automatic and checksummed, but it is still a large binary fetched per project into tools/. On a machine with tight disk quotas, a slow connection, or a policy against downloading executables, that step is the failure point. The README does not describe an offline mode or a way to point the pipeline at an already-installed Blender.

The second constraint is layer discipline. The whole illusion depends on four images sharing one coordinate system and one UV formula. If your subject and background are drawn at different scales, or your lineart drifts a few pixels, the parallax will separate them visibly instead of layering them. The pipeline's validation step catches transparency problems and alignment problems, but it cannot invent alignment that was never there. Garbage in, misaligned card out.

Text is deliberately excluded from the parallax. The README states that the web viewer does not apply parallax to the text layer, so borders stay pinned to the card edge. That is a sensible choice for legibility, and it also means you cannot have a floating title that drifts with the subject. If your design calls for that, this pipeline will not give it to you.

Finally, the skill is a Codex Skill. Everything runs through an agent conversation. If you want a cron job, a CI step, or a script that takes a prompt and returns a card with no model in the loop, the README does not describe that path.

RuiC-card-skill against hand-built Three.js and Blender scenes

The honest alternative is building the same thing yourself: model a card in Blender, export geometry, write a Three.js viewer, and hand-author the parallax shader. That gives you full control over the shader, the material graph, the export format and the hosting. It also means you own the UV agreement between the Blender scene and the web scene, which is exactly the part RuiC-card-skill automates and the part most people get wrong on the first attempt.

A second alternative is a static image or a pre-rendered video of the card. That is far simpler and needs no runtime at all, but it loses the defining behaviour: the holographic phase responding to the viewing angle. A video can only replay one angle path.

The third option is a general 3D web framework where you assemble the card from primitives. That is more flexible than this skill, and it drops the four-layer art contract and the automated verification pass that RuiC-card-skill ships. The trade is control for consistency.

RuiC-card-skill's position is that it is a production line with a fixed shape. Four layers, one coordinate system, one shader formula, one single-file viewer, one verification script. The README even explains why the viewer is a single file: multiple small module requests get caught by ad blockers, and a single file cannot be. That is a specific engineering decision, not a general claim, and it tells you what kind of problem the author was solving.

Maintenance, packaging and licence status

The repository is not archived, and the last push was on 2026-09-11, which is recent. There are no retrieved releases, so versioning is whatever the main branch holds at the time you clone it. Upgrades mean re-copying the skill directory or replacing it with a newer checkout; the README does not describe a migration path or a version pin, so treat the skill directory as a vendored dependency rather than a managed package.

The upgrade cost that matters more is the Blender portable build. Because it is fetched into <project>/tools/ per project, an upgrade of the skill and an upgrade of Blender are separate events. Nothing in the README says the pipeline reuses an existing tools/ build or revalidates it on the next run, so a project directory is effectively self-contained and can drift from a newer one.

The licence is listed as NOASSERTION. That is not a licence; it means the repository's licence file could not be classified. Before you redistribute the skill, bundle it into a product, or ship generated cards commercially, read the LICENSE file in the repository root yourself and decide whether its terms fit your use. The README also includes a WeChat donation code, which is a support mechanism, not a licence grant. Nothing here is legal advice.

Editorial conclusion

Adopt RuiC-card-skill if you already run Codex, want a parallax holographic card as a web page, and are willing to keep a Blender portable build inside each project's tools/ directory. Skip it if you need a hosted card service, a print-ready CMYK file, or a headless pipeline with no Codex in the loop. Before you start, verify that Python 3 with Pillow and Node.js with npm are on PATH, that the project directory can hold a Blender portable download, and that your card art arrives as four aligned PNG layers with real alpha rather than a checkerboard background.

Frequently asked questions

Official sources

1. HRuiCcc/RuiC-card-skill on GitHub
2. Issues
3. README