Update your app’s images without an app release.

Your engineers connect each image once, in Expo, SwiftUI, or Jetpack Compose. After that, you publish new artwork from the console and can restore any earlier release.

Developer preview. The first integration ships in an app release. Compatible artwork changes after that do not.

travel.coastRelease 3 live

Draft: Alpine weekend. Publish to send it to the app.

  1. Release 3Coast houseLive
  2. Release 2Alpine weekend
  3. Release 1Coast house

Illustrated, with the demo workspace’s own artwork. The real console and live apps are below.

  • Ed25519-signed manifests
  • SHA-256-verified bytes
  • Bundled fallback, always
  • No background polling
  • MIT-licensed SDKs

A release workflow for app artwork.

Engineers set the contract once. Everyone else publishes within it. The console screens below are reproductions, not screenshots.

Name the places images live.

An engineer gives each changeable image a named placement, a size, and a bundled fallback, then ships the SDK once.

From then on, the console is where artwork is assigned to those placements.

Publish a signed release.

Assign the artwork, write a note, publish. Apps verify the signature and every image’s bytes before showing anything new.

They pick it up on their next refresh. Drafts never touch the published release.

Keep a way back.

Every release stays in history. Restore one and apps receive it on their next refresh, as a new release.

An image still referenced by any release cannot be archived.

Three small apps, running live.

Roam, Daylight and Still are small Expo apps we built to exercise the SDK. All three run here, unchanged. Connect your workspace to publish an image to Roam or Daylight; Still carries its twelve scenes bundled.

Roamtravel.coast
Daylighttasks.garden
Stillscenes.focus

Test it all the way to the screen.

Publish. See it in the installed app. Restore. Then go offline and reopen.

Run the integration checks

Start with one placement in your app.

Each placement is a generated, typed reference. Layout, behavior, and the fallback stay in your code, in your framework.

import { parsePublicConfig } from '@assetlib/sdk-core';
import { createExpoAssetClient, AssetlibImage } from '@assetlib/sdk-expo';
import { AppAssets } from './assets.generated';

const client = createExpoAssetClient(parsePublicConfig(publicConfig));
await client.initialize(); // Local persisted release only.
await client.refresh();    // Explicit network check.

<AssetlibImage
  client={client}
  asset={AppAssets.Travel.coast}
  fallback={require('./assets/coast.png')}
  accessibilityMode="decorative"
  contentFit="cover"
  style={{ width: '100%', aspectRatio: 4 / 3 }}
/>

The placement reference is generated from a checked-in catalog. The bundled fallback ships with the app.

Reference
A generated, typed name per placement
Signing
Ed25519 over the release manifest
Verification
SHA-256 on every image before use
Fallback
Bundled in the app, served when delivery fails
Refresh
Explicit: on foreground, pull, or your call
Telemetry
Off by default. Opt-in usage counts in the JavaScript SDKs
SDK source and releases on GitHub

Work on your app’s images from your coding agent.

Start with a read-only audit of the app you already have: measured bytes, exact duplicates, oversized candidates, and where each file is referenced. No account, no upload, nothing changes on disk. Then connect the agent to your workspace.

$ npx -y @assetlib/audit@0.2.1 ./my-app --assets assets --references src
Assetlib local asset audit

Coverage: complete within scope
3 images · 230 measured bytes
1 exact duplicate group · 1 dimension candidate
Source files examined: 1; literal hints only.

assets/hero-copy.png — 2×3 — 68 bytes
  No literal reference found in the examined source scope; usage unknown.
assets/hero.png — 2×3 — 68 bytes
  Literal hints: src/Welcome.swift:2
assets/tall.png — 1×3000 — 94 bytes — dimension candidate
  No literal reference found in the examined source scope; usage unknown.

Exact duplicate groups (review dependencies before changing files):
  assets/hero-copy.png = assets/hero.png

Exact duplicate bytes do not establish safe deletion or achievable
app-download savings. No literal reference found does not mean unused.
This report does not modify, upload, optimize, or delete any file.
Real output on the package’s sample app. Your report will list your files.

Install the plugin

Claude Code
$ claude plugin marketplace add AssetLib/agent-plugins
$ claude plugin install assetlib-audit@assetlib
Codex
$ codex plugin marketplace add AssetLib/agent-plugins
$ codex plugin add assetlib-audit@assetlib
Other agents
$ npx skills add AssetLib/agent-plugins --skill assetlib-audit

Or point any agent at the skill file. It runs the pinned command, explains the evidence, and proposes at most a few placements to start with, fallbacks kept. It never deletes, uploads, or installs an SDK.

Connect it to your workspace

The agent reads what each placement shows in draft, staging and production, its code references and release history, and can upload images and assign them as a draft. You sign in through your browser and choose the workspace. Publishing stays in the console.

Claude Code
$ claude mcp add --transport http assetlib https://console.assetlib.dev/mcp
Codex
$ codex mcp add assetlib --url https://console.assetlib.dev/mcp
$ codex mcp login assetlib
Cursor · .cursor/mcp.json
{ "mcpServers": { "assetlib": { "url": "https://console.assetlib.dev/mcp" } } }
@assetlib/audit on npm

Set it up from your coding agent.

One command hands your agent the install prompt. It reads your app first and stops for your go-ahead before it changes anything.

  1. Audits your artwork read-only, reports what changes after release, and proposes three to five first placements. Then it stops while you create the workspace and give CI its token.
  2. After your go: installs the pinned SDK, writes the catalog and the generated accessors, keeps your bundled images as fallbacks, and adds the sync step to CI.
  3. Hands off with what changed. You ship one integration release, then upload, review and publish in the console.

It never pushes, never uploads, publishes or deletes an image, and never asks for a token. Pinned to sdk-js 0.7.13-preview.1, sdk-swift 0.7.0-preview.1, sdk-android 0.6.0-preview.1, and @assetlib/audit 0.2.1. Developer preview.

Claude Code
$ claude "$(curl -fsSL https://www.assetlib.dev/agent-install.txt)"
Codex
$ codex "$(curl -fsSL https://www.assetlib.dev/agent-install.txt)"
Cursor CLI
$ cursor-agent "$(curl -fsSL https://www.assetlib.dev/agent-install.txt)"
Other agents

Paste the prompt itself.

Read the prompt

Connect the tools your team already uses.

Assetlib owns the artwork, its delivery, and the release history. Assignment, analytics, and design files stay where they are. The Figma plugin is available in Figma Community. Assetlib and build sync are developer previews.

Design sources

  • FigmaFigma Community

    Insert Assetlib artwork into Figma; send a selected node as a draft. Publishing stays in the console.

    Open the plugin from Figma Community. Requires an Assetlib account and workspace.

Assetlib
  • Named placements
  • Prepared artwork
  • Signed releases
  • Release history and restore
The SDK in your app reads from here.

Your tools

  • GitHubAvailable

    Sign in to the console, read the SDK source, install tagged previews.

  • Build syncDeveloper preview

    Register your placement catalog with assetlib sync; check generated references and preview Expo adoption.

    @assetlib/cli 0.4.9 on npm (preview tag) or the tarball on GitHub release v0.7.13-preview.1.

  • Run the local artwork audit from the agent you already use, then connect it to one workspace over MCP to prepare drafts; publishing stays with a person.

What works today.

Start small and verify on the devices you support.

Available now

  • Hosted workspaces with GitHub or Google sign-in
  • Image and Lottie animation upload, with WebP optimization
  • Tintable in-app icons, colored by your app at render time
  • Named placements with size contracts
  • Signed releases, rollback, and guarded archival
  • Expo, SwiftUI, and Compose SDK previews, MIT
  • Local asset audit on npm, with a Claude Code and Codex plugin
  • Agent connection over MCP: read placements, draft image changes
  • Figma plugin in Figma Community
  • Build sync CLI developer preview, from a GitHub release

Planned

  • Usage telemetry from Swift and Compose apps
  • Hosted usage billing

Before you add another SDK.

The questions engineers ask first.

How do I change an image in my app without users updating the app?

Serve it from a placement the app already reads, instead of bundling it. An engineer connects the placement once, with a bundled fallback, and ships that in one app release. After that, you publish the replacement from the console and the installed app picks it up on its next refresh. Each image is addressed by its content hash, so a cached old copy never hides the new one. Longer answer

What does Assetlib change in my app?

Images and Lottie animations in the placements you connect: a destination photo, an onboarding illustration, a banner, a loading animation. Animations play on the web today, through the Lottie player your app supplies; iOS and Android apps show an animation's still poster, and native playback is planned. A placement can also hold a tintable icon: a one-color SVG your app colors when it draws it, so the icon follows your theme, selected states, and dark mode. Layout and behavior stay as shipped. New screens, launcher icons, and launch screens still need app development.

What needs an engineer?

The first integration: declaring placements in the app’s catalog, each with a key, a reference size that fixes its aspect ratio, and a bundled fallback, then shipping the SDK. After that, compatible images and Lottie animations publish from the console; iOS and Android apps show an animation as its still poster until native playback, which is planned. New placements or SDK changes may need another app release.

How does the app get the new image?

When it refreshes. Your app decides when to check for a new signed release; publishing pushes nothing to devices. An offline device catches up when it reconnects and refreshes.

What happens if delivery fails or the device is offline?

The app shows its verified cached image or the bundled fallback. Restore an earlier release from the console and the app picks it up on its next successful refresh.

We use EAS Update. Why would we add this?

EAS Update already ships compatible JavaScript and image assets to Expo apps, and if your engineers are happy running a build for every image change, keep it. Assetlib is for the changes that should not need an engineer or a pipeline run: a designer or product owner publishes to a named placement from the console, with release history and a restore of any earlier release, and the same workflow covers SwiftUI and Compose. Each image is addressed by its content hash, so a replaced image is never skipped as unchanged or hidden behind a cached copy with the same filename. Longer answer

What does Assetlib add to image hosting or a CDN?

Named placements in your code, tied to a publishing workflow: compatibility checks, signed releases, history, restore, and bundled fallbacks. Judge it on whether those save your team work.

Is this allowed by the App Store and Google Play?

Assetlib delivers images and Lottie JSON that your app verifies against a signed release. It delivers no code, so the app's features and behavior stay as reviewed; the store rules that restrict downloaded code and post-review feature changes are about executable content, not artwork in placements you shipped. Keep the artwork within your app's reviewed purpose and content rating. This is how the product is built, not legal advice for your listing. Longer answer

Does my designer still export 1x, 2x, and 3x for every image?

No. Upload one full-size source per image. Assetlib keeps the original and prepares up to three size tiers for delivery, and the Expo SDK asks for the size each view needs: its measured size times the screen's pixel ratio, rounded up to a tier. The Swift and Kotlin SDKs ask for the placement's reference size unless the app passes a pixel size. The placement's aspect ratio is checked at upload. Assetlib does not crop. The Figma plugin sends a selected node to a placement as a draft without a manual export. Install it from Figma Community. Assetlib is in developer preview. Longer answer

What does it cost?

The first ten placements, 250 MB of artwork, and 10 GB of delivery a month are free in every workspace, and the SDKs and the audit are open source. Past that it is $1 per placement a month, less at volume, plus small storage and delivery rates, with no seats and no agent counts; the pricing page has the meters, an estimator, and free hands-on onboarding for the first 10 teams.

Which frameworks are supported?

Expo and React Native on iOS, Android, and web, on Expo SDK 54 to 57. SwiftUI on iOS 16 and macOS 13. Jetpack Compose on Android 8 and later. All three are developer previews: the JavaScript SDKs at 0.7.13-preview.1, Swift at 0.7.0-preview.1, Kotlin at 0.6.0-preview.1. No Flutter, Kotlin Multiplatform, or plain web adapter yet.

How do I find unused images in my app, and what does the audit change?

Run the audit: it reads each image file to measure its dimensions, size, and hash and, if you ask, scans a source folder for quoted filenames, then prints a report with duplicates, oversized files, and reference hints. It does not upload, optimize, delete, or rewrite files, and it does not install the SDK. A file with no reference found is unresolved, not unused. Longer answer

How often do apps actually change their artwork?

Unevenly. In 42 open-source mobile apps over 12 months, about 60 to 90 changes could have shipped without an app release; the median app had 0.5 a year and half had none. Six apps did it in five or more months, mostly around promo cards, remote messages, onboarding and empty states. Longer answer

Change the image.Keep the app running.

See it in the running app, and keep a way back. Start with one placement your team already changes.