JSON vs Plist: Explaining AI Character Card Formats

When You Download a Character Card PNG, What's Actually Hiding Inside the Metadata?

You've just found the perfect character card on GitHub—maybe it's a Victorian vampire with a 300-year backstory, or a sarcastic space pirate your friend swears "has the best banter." You download the PNG, import it into your platform, and... the bot responds like a generic assistant with amnesia. What happened?

thing: that beautiful character art is only half the story. Hidden inside the image file itself—invisible to your eye—is a chunk of structured data that tells the AI who this character is, how they speak, what they remember, and how they should react. That data is written in one of two competing formats: JSON or Plist. The format choice can make or break whether your imported character actually works.

According to community discussions across SillyTavern forums and character card repositories, this invisible metadata battle has quietly frustrated creators for years. You'll see warnings like "V2 spec only" or "JSON-compliant cards required," but what does that even mean when you're just trying to import a PNG? The confusion is real, and it's not your fault—the ecosystem grew organically, and different tools made different choices about how to store personality data inside image files.

Unpacking the Image Data: How Personality Lives Inside a Picture

A PNG file isn't just pixels. The PNG format supports metadata chunks—little containers of text or binary data tucked into the file structure without affecting how the image displays. Think of it like hiding a letter inside a book's dust jacket: the book looks normal on your shelf, but there's information stored separately from the pages themselves.

For AI character cards, two formats dominate how that hidden data gets structured:

JSON (JavaScript Object Notation) is a human-readable text format that looks like this when you crack open a character PNG:

{
  "name": "Cassandra Vex",
  "description": "A 200-year-old vampire archivist...",
  "personality": "sardonic, curious, secretly lonely",
  "first_mes": "She glances up from a leather-bound tome...",
  "scenario": "You've just entered her private library at midnight..."
}

It's clean, it's structured, and any modern programming language can parse it instantly. The SillyTavern community standardized around JSON for their "V2 spec" character cards because it plays nice with web apps, Python scripts, and pretty much every AI platform built after 2020.

Plist (Property List), on the other hand, is Apple's proprietary format—either XML-based or binary. It can store the exact same information, but the structure looks different:

<dict>
  <key>name</key>
  <string>Cassandra Vex</string>
  <key>description</key>
  <string>A 200-year-old vampire archivist...</string>
</dict>

Plist emerged in character card workflows mostly because some early Mac-based creation tools defaulted to it. But here's the rub: Windows and Linux platforms don't natively parse Plist without extra libraries, which means cards exported from Mac tools sometimes import as corrupted gibberish on other systems—which understandably frustrates many users who just want their character to work across platforms.

The Format War Nobody Asked For

This is where it gets messy.

The character card ecosystem didn't start with a standards committee—it evolved from Discord servers, GitHub repos, and solo devs building tools for their own use. Early adopters on Mac used Plist because their scripting environment made it easy. Meanwhile, web-based platforms like TavernAI and SillyTavern leaned into JSON because browsers speak JavaScript natively. Fast forward to 2024, and you've got two camps: creators who swear their cards are "perfectly formatted" and users who report blank imports or missing personality traits.

As one frustrated GitHub user put it in a character repository thread: "I don't care about the tech, I just want to know why cards from [redacted creator] never load right on my setup." The answer? They were Plist-encoded, and the import tool expected JSON.

Actually, that's not quite right—sometimes the issue is more subtle. Even within JSON, there are compatibility headaches. Some tools minify the JSON (strip all whitespace), others pretty-print it (add indentation), and a handful don't escape special characters properly. So you might have a "valid" JSON card that still breaks because the parser chokes on an unescaped quote mark inside a character's dialogue example. Fun times.

Which Format Explains Personality Best in 2026?

For modern LLMs, the answer is unambiguous: JSON wins.

Not because it's "better" in some abstract computer science sense, but because universality matters. Every major AI platform—from OpenAI's playground to Anthropic's Claude interface to open-source tools like KoboldAI—has native JSON parsing. When you feed a character definition to GPT-4 or Claude 3.5, the system expects structured data it can immediately interpret. JSON delivers that without translation layers.

Plist requires conversion. An import tool has to detect the Plist format, parse it (often with an external library), then transform it into whatever internal representation the AI expects. Every conversion step is a place where data can get mangled—escaped characters turn into garbage, nested fields flatten incorrectly, or the tool just gives up and throws an error.

From a creator's perspective, JSON also has a massive ecosystem advantage. You can open a JSON character file in any text editor (Notepad++, VS Code, even your phone's default text app), tweak the personality field, and save it. No special tools needed. Try that with a binary Plist and you'll stare at hexadecimal nonsense. Even XML Plists are clunkier to hand-edit because of all the <key> and <string> tags cluttering the view.

The SillyTavern community settled on JSON "V2 spec" for exactly these reasons—they wanted a format that creators could debug themselves, that worked identically on Windows/Mac/Linux, and that every LLM API could consume without fuss. By mid-2024, the vast majority of shared character cards on GitHub, Discord, and Reddit use JSON metadata. Plist cards still circulate, but they're increasingly treated as legacy artifacts or platform-specific edge cases.

Importing Cards to Blushly: How the Platform Handles the Messy Reality

So you've downloaded a character PNG—maybe JSON, maybe Plist, maybe malformed JSON that technically validates but has weird quirks. What now?

This is where platform design matters. Some chat apps will just reject the card with a cryptic error ("Invalid metadata chunk") and leave you guessing. Others attempt to parse it but silently drop fields they don't understand, so your vampire archivist imports as a generic "friendly assistant" because her personality and scenario fields vanished.

Blushly takes a different approach: format-agnostic import with graceful degradation. When you upload a character card PNG, the platform's import system:

1. Scans the PNG chunks for both JSON and Plist-encoded metadata.
2. Attempts to parse whichever format it finds, with fallback logic if the primary format is corrupted.
3. Maps the extracted fields (name, description, personality, scenario, first_mes, etc.) into Blushly's internal character schema.
4. Validates that core fields exist—and if something's missing, it prompts you to fill it in rather than silently importing a broken character.

What I really appreciate about Blushly's approach—and I'm being genuine here, not just pitching—is that it treats character cards as starting points, not rigid definitions. Once your character is imported, it lives inside Blushly's advanced memory system, which tracks conversation context, emotional states, and relationship progression without constantly re-parsing the original JSON blob. That means even if you imported a bare-bones card with minimal metadata, the character grows into a richer persona as you interact with it.

The memory system is the real differentiator. On platforms where the character card is the only source of personality, you're stuck with whatever the creator wrote. But Blushly layers on contextual memory—so your vampire archivist remembers that you asked about her favorite century last week, or that you teased her about her handwriting, and those details inform future responses. The character becomes dynamic rather than static.

One honest critique: Blushly's import UI could be clearer about which format it detected when you upload a card. Power users (the kind who collect hundreds of character PNGs and curate them like a library) would appreciate a metadata inspector that shows the raw JSON or Plist before import, so they can catch errors early. Right now, if a card imports weirdly, you have to dig into the character editor to figure out what went wrong. Not a dealbreaker, but a friction point for advanced creators.

Why This Matters More Than You Think

The JSON vs Plist debate isn't just technical pedantry—it's about whether the characters you create or discover will work reliably across platforms and communities.

If you're a character creator sharing your work on GitHub or Discord, exporting as JSON means your cards will "just work" for the widest possible audience. You won't get confused messages from Windows users saying your card imports blank, or Mac users complaining that their tool can't read your metadata. JSON is the lingua franca.

If you're a collector or curator, understanding formats helps you diagnose why certain cards fail to import. When you see a repository warning "V2 spec compliant required," you'll know they mean JSON-based cards following the SillyTavern schema. And if you stumble across an old Plist card you really want to use, you can convert it (tools like plutil or online converters exist) rather than abandoning it.

And if you're just someone who wants to chat with interesting AI characters without dealing with metadata headaches, platforms like Blushly that abstract away the format chaos are your best bet. You shouldn't need to understand PNG chunk encoding to enjoy a good conversation with a fictional vampire. The platform should handle that invisibly.

The Bigger Picture: Where Character Card Standards Are Heading

The ecosystem is slowly converging. As more platforms adopt JSON-based V2 spec cards, Plist is fading into niche use cases. GitHub repositories now routinely include validation scripts that check whether a card's JSON is well-formed before accepting pull requests. Discord bots auto-scan uploaded PNGs and flag format issues in real-time.

What's emerging is a kind of informal standardization—not because any committee mandated it, but because creators and users voted with their workflows. JSON won by being easier to work with, more universally supported, and less likely to cause cross-platform explosions.

That said, there's still room for improvement. The V2 spec doesn't cover everything—fields like lorebook (world-building context), extensions (platform-specific features), and creator_notes (usage guidelines) are inconsistently implemented. Some platforms parse them, others ignore them. As AI chat evolves, we'll likely see V3 or V4 specs emerge that standardize more advanced features: dynamic memory hooks, conditional personality shifts, multi-character scenario support.

For now, though, the practical advice is simple: create in JSON, import to platforms that handle both formats gracefully, and don't stress about the technical details unless you're debugging a broken card.

Don't Fear the Code—Let the Platform Handle It

Real talk: you don't need to become a JSON expert or learn how PNG metadata chunks work to enjoy AI character roleplay. The format wars happened behind the scenes, driven by tool developers and early adopters figuring out what worked. For most users, the "right" answer is just to use platforms that abstract away the complexity.

When you import a character card to Blushly, you're not wrestling with parsers or debugging malformed metadata. You're clicking "Import," and the character comes to life—personality intact, memory system active, ready to chat. The platform's job is to make the technical stuff invisible so you can focus on the conversation.

And if you are a creator who wants to dig into the metadata, export your character as JSON, crack it open in a text editor, and tweak to your heart's content. The format is simple enough to hand-edit but powerful enough to define rich, nuanced personalities. Just remember to validate your JSON (plenty of free online tools for that) before re-embedding it in a PNG and sharing it with the world.

The character card ecosystem will keep evolving—new formats, new features, new standards. But the core principle stays the same: good characters are defined by their depth, not their metadata format. Whether that depth is stored in JSON or Plist is just an implementation detail. What matters is whether the platform you're using can bring that depth to life in conversation.

FAQ

What's the difference between JSON and Plist for AI character cards?

JSON is a human-readable text format universally supported by AI platforms and easy to edit in any text editor. Plist is Apple's proprietary format (either XML or binary) that requires special libraries to parse and can cause cross-platform compatibility issues. For character cards, JSON is the de facto standard because it works reliably across Windows, Mac, Linux, and web-based AI tools.

Can I convert a Plist character card to JSON?

Yes—you can use command-line tools like plutil (built into macOS) or online Plist-to-JSON converters. Extract the metadata from the PNG using a tool like ExifTool, convert the Plist data to JSON, then re-embed it into the PNG's metadata chunks. Some platforms like Blushly handle this conversion automatically during import, so manual conversion is only necessary if you're sharing the card publicly or using a tool that strictly requires JSON.

Why does my character card import as blank or generic?

This usually happens when the import tool can't parse the metadata format (e.g., a Plist card imported to a JSON-only platform), or when required fields like name, description, or personality are missing or corrupted. Check the card's metadata with a PNG inspector tool—if the JSON is malformed (unescaped quotes, invalid structure), even a JSON-expecting platform will fail to import it correctly. Platforms like Blushly attempt to gracefully handle malformed cards and prompt you to fill in missing fields rather than silently importing a broken character.

Do I need to understand PNG metadata to use character cards?

Not at all. The metadata format is an under-the-hood detail that platforms should handle for you. As a user, you just need to download a character card PNG and import it—the platform extracts and parses the hidden data automatically. Understanding formats only matters if you're creating cards to share publicly, debugging import issues, or curating large collections where compatibility across tools is important. For casual use, just pick a platform like Blushly that supports multiple formats and abstracts away the technical complexity.