Successor to Netlify CMS (now Decap CMS)

Sveltia CMS was built from scratch as a modern successor to Netlify CMS, which was popular but abandoned in early 2022. We have picked up where they left off and have already solved hundreds of issues reported in the predecessor’s repository, ranging from critical bugs to top feature requests.

Netlify CMS was later rebranded as Decap CMS, but it has been incredibly neglected by its new maintainers for years. Sveltia CMS is a superior alternative to both Netlify CMS and Decap CMS, offering a significantly improved experience, security, and reliability.

Join the growing number of users who have switched to Sveltia CMS and enjoy a modern, powerful, and well-maintained content management system for your static sites!

Netlify vs. Netlify CMS

Netlify CMS was one of the open source projects maintained by Netlify, the popular web hosting and automation platform. While the CMS is no longer part of their portfolio, Netlify itself remains a thriving company offering various services for modern web development.

Independent Project

We are not affiliated with Netlify or any of its partners. Sveltia CMS is an independent, open source project created and maintained by Kohei Yoshino. It’s not tied to any specific company.

TL;DR

• A complete modern rewrite of Netlify CMS (now Decap CMS)
• Actively maintained and outperforming neglected Decap CMS in every aspect
• De facto successor to Netlify/Decap CMS that works better by design
• Drop-in replacement for most Netlify/Decap CMS use cases
• Solved 355+ Netlify/Decap CMS issues (805+ including duplicates)
• Significant UX/DX improvements with more enhancements planned
• Much more stable, performant, secure, accessible, powerful and reliable
• Many sites already migrated from Netlify/Decap CMS — See examples

Motivation

Sveltia CMS was born in November 2022, when the progress of Netlify CMS was stalled for more than six months. @kyoshino’s clients wanted to replace their Netlify CMS instances without much effort, mainly to get better internationalization (i18n) support.

To achieve radical improvements in UX, performance, i18n and other areas, it was ultimately decided to build an alternative from the ground up, while ensuring an easy migration path from the other. After proving the idea with a rapid Svelte prototype, development was accelerated to address their primary use cases. The new product has since been named Sveltia CMS and released as open source software to encourage wider adoption.

We loved the simple, unique setup of Netlify CMS that turned a Git repository into a database with a single-page app served from a CDN plus a plain YAML config file. In support of the Jamstack concept, we wanted to revive it, modernize it, and take it to the next level.

Objectives

Our goal is not just to create another CMS that is compatible with Netlify CMS, but to succeed Netlify CMS as a whole by addressing its numerous issues reported to its repository over the years. Here’s how we’re doing:

Ensuring High Compatibility with Netlify/Decap CMS

• Inherits the CDN-served SPA architecture of Netlify CMS, with various improvements
• Aims to work as a drop-in replacement for most use cases, as long as deprecated features are not in use
• The vast majority of existing configurations work out of the box
• This objective has been met. All Netlify/Decap CMS features, excluding those explicitly stated otherwise, have now been implemented in Sveltia CMS 🎉 (Announcement)

Tackling as Many Netlify/Decap CMS Issues as Possible

• So far, 355+ issues, or 805+ if including duplicates, have been effectively solved in Sveltia CMS — Yes, you read it right
• Target:
  • 350 issues, or 800 if including duplicates, by v1.0 — We did it 🎉
  • 450 issues, or 1,000 if including duplicates, in the future 💪
  • or every single issue that’s relevant, fixable, and worth dealing with 🔥
• Issues include everything:
  • Outstanding issues from feature requests to bug reports
  • Issues closed as stale or without an optimal solution
  • Discussions
  • Stalled pull requests
• Many of the bugs, including the annoying crashes, have already been solved
• Many of their top-voted features are on our table or already implemented in Sveltia CMS

What About Decap CMS?

Due to its unfortunate abandonment in early 2022, Netlify CMS spawned three successors. Sveltia CMS is one of them, along with Static CMS and Decap CMS. Here’s a brief comparison of the three projects:

• Static CMS: a community fork
  • Initial commit made in September 2022
  • ❌ Discontinued in September 2024 after making meaningful improvements
• Decap CMS: a rebranded version
  • Announced in February 2023 as an official continuation with a Netlify agency partner taking ownership
  • Maintained by a company with three developers
  • ❌ A bloated, legacy React application that carries over all the technical debt and issues of Netlify CMS
  • ❌ Seemingly random issues were closed as stale following the takeover
  • ❌ It took six months to ship the first release (v3.0) under the new name
  • ❌ Mostly low activity with only occasional releases and a few minor improvements
  • ❌ Bug reports continue to pile up, often without any response
  • ❌ Regressions are sometimes ignored even when they’re reported by multiple users
  • ❌ Pull requests, including those from maintainers, sit idle for months or years
  • ❌ Basic i18n support with critical limitations and outstanding bugs
  • ❌ Keeps poor documentation without any migration guide or compatibility notes
  • ❌ New features, options and breaking changes are often undocumented
  • ❌ The Examples page only lists outdated demos, not real-world users
  • ❌ No testimonials are available, leaving users without social proof
  • ❌ No public roadmap is available, leaving users in the dark
  • ❌ Distracted by a premium service while the core open source project remains in a miserable state, and even worse, it’s funded by public money
  • ❌ No effective issue triage practice in place, with fixed issues sometimes left open and duplicates often left unmarked
  • ❌ Maintainers are sometimes absent for weeks, leaving users with no support
  • ❌ Security is a low priority with a poor track record of addressing vulnerabilities in a professional, timely and responsible manner
  • ❌ A moderate-severity XSS vulnerability, a proxy server directory traversal vulnerability, and high-severity dependency vulnerabilities remain unaddressed
  • ❌ Constant fatal crash reports are being dismissed without any solution or even acknowledgment
• Sveltia CMS: not a fork but a complete rewrite
  • Started in November 2022, first appeared on GitHub in March 2023
  • Personal project of an experienced UX engineer
  • ✅ A lightweight Svelte application built from scratch with no technical debt
  • ✅ Actively developed with frequent releases and numerous improvements
  • ✅ Relevant issues are being resolved regardless of their age or status
  • ✅ Most of bug reports are addressed promptly, usually within 12 hours
  • ✅ Any regressions are fixed swiftly once reported
  • ✅ First-class i18n support for easier multilingual content management
  • ✅ Provides comprehensive documentation, including Netlify CMS migration guide
  • ✅ Keeps the documentation up-to-date with the latest features and improvements
  • ✅ The Showcase page features many real-world sites from various industries
  • ✅ Provides developer testimonials for validation
  • ✅ An extensive roadmap is available to keep users informed
  • ✅ Focused on the core platform, free from monetization distractions
  • ✅ Effective issue triage practice in place, with fixed issues closed and duplicates marked
  • ✅ Maintainer is responsive and available to provide support
  • ✅ Security is a top priority, and we follow the best practices and respond swiftly
  • ✅ No known unpatched security vulnerabilities, with dependencies kept up-to-date
  • ✅ No known crashes, with a swift response to any that may arise

While Decap CMS unexpectedly emerged as the official successor, it has largely stagnated and failed to revive the original Netlify CMS project as hoped. Years of neglect have left evident signs that make a turnaround unfeasible at this point, with security remaining a major concern. This leaves users with no choice but to switch to Sveltia CMS or other alternatives.

Created months before the announcement of Decap CMS, Sveltia CMS has firmly established itself as the de facto successor. We have a clear focus on delivering a superior experience for users seeking a modern alternative to Netlify CMS. Regardless of other projects in this field, we are committed to continuously enhancing the platform for the benefit of our users.

Official vs. De Facto Successor

In the open source world, it’s not uncommon for an official product to fail while an unofficial one, typically a fork, thrives. A notable example is Apache OpenOffice and LibreOffice. The former is the official successor to OpenOffice.org, but it has largely been abandoned, leaving security issues unresolved for years. Meanwhile, LibreOffice has become the de facto successor, enjoying active development and a vibrant community.

The Choice Is Crystal Clear

Sveltia CMS is a generation ahead of Decap CMS, with a modern architecture, improved performance, enhanced security, and a better user experience. It’s designed to meet the needs of today’s developers and content creators, making it the ideal choice for anyone looking to manage content in a Git-based workflow.

There is no reason for new projects to choose the legacy, poorly-maintained Decap CMS over the modern, well-maintained Sveltia CMS. We also encourage existing Netlify/Decap CMS users to migrate to Sveltia CMS as soon as possible to take advantage of its numerous improvements.

True Successor, Better by Design

Among the three successors, Sveltia CMS is the only project that doesn’t inherit the complexity, technical debt, and numerous bugs of Netlify CMS.

• We rebuilt the app from scratch using a modern framework
• We develop our own UI component, i18n, and utility libraries
• We don’t reuse any part of the predecessor’s codebase
• We incorporate i18n support into the core instead of adding it as an afterthought
• We closely monitor and analyze the predecessor’s issue tracker
• We rearchitect the entire user experience (UX) and developer experience (DX)

This “total reboot” has enabled us to implement hundreds of improvements without getting stuck in a legacy system. Furthermore:

• We carry forward the original vision of Netlify CMS as a simple, Git-based content management solution for Jamstack sites
• We dedicate significant time and effort to modernizing the platform, including documentation and developer tools
• We continue to address issues reported in the predecessor’s repository, with the aim of solving 1,000 issues, including duplicates
• We materialize the enhancements that Netlify CMS users have long desired

For that reason, Sveltia CMS is the true successor to Netlify CMS, not a spiritual successor or mere alternative, albeit unofficial. Whether you’re migrating from the original Netlify CMS or another successor, Sveltia CMS offers the best overall experience.

Adoption

GitHub search shows that Netlify/Decap CMS users are migrating to Sveltia CMS every day to take advantage of its numerous improvements. Around 30% of Sveltia CMS users have migrated from Netlify/Decap CMS, and the number continues to grow. Visit our Showcase page to see some of them!

• Examples of sites migrated from Netlify CMS
• Examples of sites migrated from Decap CMS

The demand for a modern headless CMS is reflected by the fact that Sveltia CMS is now downloaded more than Decap CMS on npm.

Improvements over Netlify/Decap CMS

Netlify/Decap CMS users will definitely be pleased and surprised by the numerous improvements we have made, from the small to the large. We make everything better.

Note

This lengthy section compares Sveltia CMS with both Netlify CMS and Decap CMS. Some of the listed issues may have been resolved in the current version of Decap CMS.

Better UX

• Created and actively maintained by an experienced UX engineer who loves code, design, marketing, localization, documentation and everything in between. You can expect constant improvements to the user experience (UX) and developer experience (DX) across the platform.
• The maintainer tries to respond to bug reports as quickly as possible. While there are no guarantees, the typical turnaround time for a bug fix is less than 12 hours. In some cases, a fix can be released within an hour or two. In contrast, most bug reports to Netlify/Decap CMS will never be addressed.
• Frequent releases deliver new features and enhancements to users more quickly. Meanwhile, Decap CMS’s release interval has been irregular and often long, sometimes exceeding two months, even between patch releases, which can be frustrating for both users and contributors.
• Many of our minor releases address one or more Netlify/Decap CMS issues, giving you even more reasons to switch from the legacy predecessor.
• Offers a modern, intuitive user interface that utilizes the full viewport,^[1] inspired in part by the Netlify CMS v3 prototype.^{[2][3][4][5][6]}
• Provides immersive dark mode.^[7] The UI theme follows the user’s system preference by default and can be changed in the application settings.
• Users can easily manage content on-the-go with mobile and tablet support.^[8][9]
  • For a smoother experience, we even go beyond responsive design with optimized navigation, floating action buttons, view transitions, larger buttons, and other tweaks. We’ll continue to fully optimize the app for small screens and touch devices.
  • On a desktop where the user is already signed in, open the Account menu in the top right corner of the CMS, click Sign In with Mobile, and scan the QR code with the mobile device for passwordless sign-in. Settings will be automatically copied.
• Users can install the CMS as an app (PWA) on their devices and use it like a native application.^[10]
• Made with Svelte, not React, means we can spend more time on UX rather than tedious state management. It also allows us to avoid common fatal React application crashes.^[11][12] Best of all, Svelte offers great performance.
• Other crashes in Netlify/Decap CMS are also irrelevant to us, making Sveltia CMS much more stable.^{[13][14][15][16][17][18][19][20][21][22]} Netlify/Decap CMS continues to receive crash reports on a daily basis, with no effective solution in sight.
• We build our own UI component library, including custom dialogs, to ensure optimal usability without compromising accessibility.^{[23][24][25][26][27][28][29][30]}
• Users can personalize the application with various settings, including appearance and language. Developer Mode can also be enabled, which enables certain features and displays the CMS version number.^[31]
• Never miss out on the latest features and bug fixes by being notified when an update to the CMS is available.^[32] Then update to the latest version with a single click.^[33]

Better Performance

• Built completely from scratch with Svelte instead of forking React-based Netlify/Decap CMS. The app starts fast and stays fast with no virtual DOM overhead. Note that Svelte is a compiler and Sveltia CMS is framework-agnostic; it’s served as a vanilla JavaScript bundle.
• Small footprint: The bundle size is less than 550 KB when minified and brotlied, which is much lighter than Netlify CMS (1.5 MB), Decap CMS (1.7 MB) and Static CMS (2.6 MB).^[34] This significant reduction in size is thanks to the combination of Svelte 5 and Vite. Sveltia CMS also dynamically loads locale files and certain dependencies only when needed, further reducing the initial load time.
• Uses the GraphQL API for GitHub and GitLab to quickly fetch content at once, so that entries and assets can be listed and searched instantly^[35][36] (the useless search configuration option is therefore ignored). It also avoids the slowness and potential API rate limit violations caused by hundreds of requests with Relation fields.^[37]
• Saving entries and assets to GitHub is also much faster thanks to the GraphQL mutation.
• The Gitea/Forgejo backend is also faster because it utilizes an efficient API method introduced in Gitea 1.24 and Forgejo 12.0.
• Our local development workflow utilizes the modern File System Access API to read and write files natively through the web browser, rather than using a slow, ad hoc REST API through a proxy server.
• Sorting, filtering and grouping of entries is done instantly without reloading the entire content.
• Uses caching, lazy loading and infinite scrolling techniques. A list of repository files is stored locally for faster startup and bandwidth savings.
• Thumbnails of assets, including videos and PDF files, are generated and cached for faster rendering of the Asset Library and other parts of the CMS.^[38][39]
• No typing lag on input fields, especially within nested lists and objects.^[40]
• The entry preview doesn’t use an <iframe> by default because it’s a performance overhead.^[41]
• Using AI assistants, we continuously analyze the codebase to identify performance bottlenecks and optimize critical paths. This helps us maintain a fast and responsive application.

Better Productivity

We’ve made various improvements to help users get their work done faster and more efficiently:

• Features the all-new local development workflow for a better DX. See the Better Workflows section to learn more.
• Provides a smoother user experience in the Content Editor with various enhancements:
  • Users can upload multiple files at once to File/Image fields when the multiple option is enabled.^[42]
  • Uploading files can be done with drag and drop.^[43]
  • Users can translate entry fields with one click using an integrated translation service without having to leave the CMS.
  • A sidebar is available with panels for validation errors, commit history, and backlinks.
  • A local backup of an entry draft is automatically created without interruption by a confirmation dialog, which annoys users and can cause a page navigation problem if dismissed.^[44] The backup can then be reliably restored without unexpected overwriting.^[45]
  • Click once (the Save button) instead of twice (Publish > Publish now) to save an entry. Or just hit the Ctrl+S (Windows/Linux) or Command+S (macOS) key to save time.
  • The editor closes automatically when an entry is saved. This behavior can be changed in the application settings.
• Thanks to the built-in image optimizer, there’s no need for an external application to convert or resize images before uploading them.^[46][47]
• Users can delete multiple entries and assets at once.
• Users can manage content on-the-go with mobile and tablet support.^[8:1][9:1] This is especially useful for content editors who need to make quick updates while away from their desks.
• Instant full-text search with results sorted by relevance helps users find entries faster. In Netlify/Decap CMS, the results are often not what users expect.
• Some keyboard shortcuts are available for faster editing.

Better Security

• Swift response: We prioritize security fixes and aim to address vulnerabilities within 12 hours of their discovery.
  • In fact, we implemented and shipped a fix for the last XSS vulnerability with a security advisory in just two hours after it was reported, despite the fact that it was low-severity with no known exploits.
  • By contrast, the Decap CMS team demonstrates a total lack of urgency and responsibility in addressing security issues.
    • The moderate-severity XSS vulnerability reported in September 2025 has not been patched.
    • The proxy server vulnerability reported in January 2026 was addressed one week later. However, the fix wasn’t released until late February due to a build failure. No security advisory was published. Additionally, the pull request was not associated with the issue, which made tracking the fix difficult.
    • Another proxy server vulnerability involving directory traversal was reported on June 2, 2026. However, since the Decap CMS team was unresponsive as usual, the reporter posted the details publicly on GitHub a month later. The maintainer then deleted the issue without responding. As of late July, no patch has been released, leaving users vulnerable to potential exploits.
• Dependency management: Eliminates vulnerabilities in dependencies through constant updates, Dependabot alerts, pnpm audit, and frequent releases.
  • We also use the minimumReleaseAge option for pnpm to avoid upgrading to a version that was just released. These options help protect against npm supply chain attacks.
  • By contrast, Netlify/Decap CMS has a longstanding poor track record of addressing vulnerabilities in dependencies.
    • A number of high-severity vulnerabilities in dependencies have remained unaddressed for extended periods of time.^[48][49]
    • New vulnerabilities in dependencies are not patched promptly, leaving users vulnerable to potential exploits.
• AI-assisted coding: Claude and GPT assistants are used to ensure secure coding practices and identify potential vulnerabilities during development.
• The unpatched XSS vulnerability in Decap CMS does not affect Sveltia CMS, as our entry preview implementation is completely different.
• In Sveltia CMS, the Markdown/RichText widget’s sanitize_preview option is set to true by default, which is a more secure default configuration. The default value of false in Netlify CMS and Decap CMS prior to 3.13.0 can lead to XSS vulnerabilities especially when Open Authoring is enabled.
• Our local development workflow does not require a proxy server. This reduces attack surfaces by eliminating the possibility of compromised dependencies^[50], unauthorized API access^[51] or incomplete path validations^[52][53] in the proxy server.
• Thanks to pnpm, Vite, GitHub Actions and npm package provenance, our release process is fast, reliable and transparent. This setup makes it easy to verify the integrity of published code and assets. It also helps us avoid errors that can occur with manual build steps.^[54]
• We have enabled trusted publishing and 2FA for package publishing.
• We have created a security policy.
• We have documented how to set up a Content Security Policy for the CMS using an interactive CSP builder. This helps prevent any unexpected errors or otherwise insecure configuration.^[55]
• The unsafe-eval and unsafe-inline keywords are not needed in the script-src CSP directive.^[56]
• The same-origin referrer policy is automatically set with a <meta> tag.
• The rel="noopener noreferrer" attribute is automatically added to all external links in the admin interface to prevent tabnabbing and protect user privacy.
• Sveltia CMS has a secure context requirement that forces the site content, including the CMS configuration file, to be served over HTTPS.
• GitHub commits are automatically GPG-signed and marked as verified.^[57]

Better Accessibility

• We have conducted an automated WCAG 2.2 self-audit. We’ll continue to test and improve the application for accessibility.
• Improved keyboard handling lets users efficiently navigate through UI elements using the Tab, Space, Enter and arrow keys.^[58][59]
• Keyboard alternatives are available for features that rely on drag-and-drop operations. This includes resizing panes in the Content Editor and reordering items in various fields.
• Comprehensive WAI-ARIA support enables users who rely on screen readers such as NVDA and VoiceOver.^[60] An announcement is read out when the user navigates to another page.
• The collection tree in the sidebar is a real tree view that can be navigated and expanded with the keyboard, rather than a list of links.
• The rich text editor is built with Lexical, which is said to follow accessibility best practices. The Dragon NaturallySpeaking support is enabled.
• Ensures sufficient contrast between the foreground text and background colors.
• Enabled and disabled buttons can be clearly distinguished.^[61]
• Links are underlined by default to make them easier to recognize. This behavior can be changed in the Accessibility Settings if preferred.
• Honors the operating system’s reduced motion, reduced transparency and high contrast settings.
• Browser console logs for developers are readable in either light or dark mode.^[62]

Better Installation

• Sveltia CMS is built with Svelte, and we only publish precompiled, minified vanilla JavaScript bundles. React and the UI libraries are bundled with the app. When you install the app with npm, only a handful of standalone, browser-ready libraries are installed as dependencies, like Leaflet for the Map field. Your build tool splits them out, so each is only loaded when needed. This means:
  • No React compatibility issues that might prevent developers from upgrading a project for many months.^[63]
  • No peer dependency conflicts mainly due to legacy third-party React UI libraries.^[64] We build the app using our own Svelte UI component library to reduce reliance on third parties.
  • No build errors due to browser-unfriendly packages and other dependency issues.^[65][66][67]
• Configuration file loading improvements:
  • Some servers and frameworks are known to remove the trailing slash from the CMS URL (/admin) depending on the configuration. In such cases, the config file is loaded from the proper URL (/admin/config.yml) instead of a regular relative URL (./config.yml = /config.yml), which results in a 404 Not Found error.^[68]
  • A cache busting mechanism is in place to ensure that the latest version of the configuration file is always loaded, preventing issues caused by browser caching.
• When the browser’s storage (“cookies” in common terminology) is unavailable, the CMS will show a warning message instead of a blank page.
• The robots meta tag is automatically added to HTML to prevent the admin page from being indexed by search engines.^[69] Developers are still encouraged to manually add <meta name="robots" content="noindex"> to index.html, as not all crawlers support dynamically added tags. However, our solution should at least work with Google in case developers forget to do so.
• Initializing the CMS twice (due to the incorrect or missing placement of window.CMS_MANUAL_INIT) will not result in a NotFoundError.^[70]
• Sveltia CMS automatically enables manual initialization when you import the JavaScript module, so you don’t need to have window.CMS_MANUAL_INIT = true in your code.
• We provide only one package, @sveltia/cms, instead of many (decap-cms, decap-cms-app, decap-cms-core and so on), which is simpler and less confusing.

Better Configuration

• Sveltia CMS supports a JSON configuration file that can be generated for bulk or complex collections.^[71] A TOML configuration file is also supported.
• Also supports multiple configuration files to allow developers to modularize the configuration.^[72]
• We provide an up-to-date JSON schema for YAML/JSON configuration files, which enables autocomplete and validation in VS Code and other editors.^[73] If you use deprecated options in a supported code editor, you should receive a warning.
• Improved TypeScript support:
  • We keep our type definitions for CMS.init() and other methods complete, accurate, up-to-date and annotated.^{[74][75][76][77][78]} This makes it easier to provide a config object when manually initializing the CMS.
• Config validation enhancements:
  • The configuration is validated at runtime against the same JSON schema your editor uses, every time the CMS loads, catching wrong value types, values outside an allowed set and missing required options. Because our schema is generated from the source, it cannot drift from the options it describes. Decap CMS maintains its configuration schema by hand, separately from the code that reads those options.
  • Validation needs no unsafe-eval in your Content Security Policy. Our validator interprets the schema, while Decap CMS compiles its own into JavaScript at runtime — so under a policy without unsafe-eval, Decap CMS throws an EvalError while loading even a perfectly valid configuration, and the admin page doesn’t come up.^[56:1]
  • Sveltia CMS has many additional validation rules that a schema can’t express, designed to catch the misconfigurations that Netlify/Decap CMS either reports with a cryptic message or, worse, doesn’t report at all, leaving you with an empty collection, a random slug or a validation rule that never runs.^[79][80] Anything that would break the CMS is listed on the login screen; anything the CMS can work around is a console warning:
    • Backend
      • A missing, unsupported or misspelled backend name, with a pointer to the supported backends
      • A missing repo, or one that isn’t in the owner/repo format
      • A missing OAuth client ID (app_id) for GitLab PKCE or Gitea/Forgejo, the unsupported implicit flow, and an empty auth_methods list that would leave no way to sign in
      • Open Authoring without Editorial Workflow, or without an auth_scope
    • Site-wide options
      • A site_url that isn’t an absolute URL, which would silently drop every preview link
      • A sanitize_replacement slug option containing a character that can’t be used in a slug, such as a space or slash
      • An empty i18n.locales list, a default_locale or initial_locales entry that isn’t one of the locales, and a collection or file i18n option with no site-level i18n configuration to build on
      • A missing media_folder, or a public_folder that isn’t an absolute path
    • Collections
      • Duplicate, empty or invalid collection, collection file, field and variable type names (e.g. names containing . or *)
      • A collection with none of folder, files or divider, or more than one of them, and a collection without fields
      • A configuration where every collection is hidden, which would look like a broken CMS
      • A mismatch between the format and extension options, and a {{locale}} placeholder in a file path without i18n
      • An identifier_field that names no field, and a collection with neither a title field nor an identifier_field or slug option, which would give every new entry a random slug
      • slug templates containing slashes, and slug, path, summary, thumbnail and preview_path options that refer to undefined fields, or that use date tags without a DateTime field to read them from
      • A filter option on an undefined field, with neither a value nor a pattern, or with a pattern that isn’t a valid regular expression, all of which would leave the collection empty
      • sortable_fields, view_groups and view_filters that refer to undefined fields, and a reorder option that names an undefined view group
    • Fields
      • Widget-specific options, such as a search_fields list written as a string
      • Mutually exclusive options (e.g. field, fields and types on List fields), and an explicitly empty fields or types list on a List or Object field — while omitting fields in a variable type remains valid^[81]
      • A validation pattern that isn’t a valid regular expression, which would otherwise never run
      • A min above the max, a minlength above the maxlength, and a Number field step of zero or less
      • Select fields with no options, duplicate option values, or a default that isn’t one of the options
      • Relation fields whose collection or file doesn’t exist, or whose value_field, display_fields, search_fields or filters refer to fields that aren’t defined in the referenced collection
      • Compute fields whose value template refers to undefined fields, and List and Object fields whose thumbnail names no subfield
      • Conflicting DateTime timezone options, and an invalid IANA timezone identifier
      • Deprecated camel case options, the deprecated Date widget, and other unsupported widgets and options
  • Unknown properties in the configuration file are warned in the console, so that you can check for typos and other mistakes.
  • The error messages are written for people, not just developers: they say what’s wrong and what to do about it, and they include the specific collection, field, variable type and fields names, rather than indexes such as collections[7].fields[9].types[1]. This helps to quickly identify the problematic configuration.^[80:1]
  • There are no false error messages saying should match case "color" schema.
  • There are no error messages that advise to use deprecated camel case options like valueField.
  • Custom field types registered with a schema have their options validated as well, and the mechanism is more forgiving than the Decap CMS equivalent:
    • Registering a field type without a schema is fine. In Decap CMS, a widget registered without one breaks configuration validation altogether.
    • A registered schema that is itself invalid, such as one with a misspelled int type, is ignored with a console warning naming the field type. In Decap CMS, it prevents any configuration from loading, including one that doesn’t use that widget.
    • An additionalProperties restriction in a registered schema is ignored rather than rejecting the common options every field has, such as name and label. In Decap CMS, such a schema rejects every field using that widget.

Better Backend Support

The GitHub, GitLab, Gitea/Forgejo and Test backends are available in Sveltia CMS. For performance reasons, we don’t plan to support other backends.

• Uses the GraphQL API where possible for better performance, as mentioned above. You don’t need to set the use_graphql option to enable it for GitHub and GitLab.^[36:1]
• The Git branch name is automatically set to the repository’s default branch (main, master or whatever) if not specified in the configuration file, preventing data loading errors due to a hardcoded fallback to master.^[82][83] If a branch name is specified, it works as expected.^[84]
• It’s possible to disable automatic deployments by default or on demand to save costs and resources associated with CI/CD and to publish multiple changes at once.^[85]
• Users can quickly open the source file of an entry or asset in the repository via the 3-dot menu when Developer Mode is enabled.
• Service status checks are performed frequently and an incident notification is displayed prominently.
• When the configured branch is protected against the signed-in user, what would be committed to it directly — collections using the Simple Workflow and the Asset Library — is read-only for them on GitHub, GitLab and Gitea/Forgejo, rather than failing when they save. Netlify/Decap CMS offers these actions and leaves the Git service to refuse them.^[86]
• Authentication improvements:
  • We provide our own OAuth client for GitHub and GitLab.
  • The external OAuth window will not get stuck on a blank page after signing in.^[87]
  • Users can sign in directly with a Git-based backend using a personal access token (PAT) instead of going through the regular OAuth flow.^[88]
  • The OAuth access token is automatically renewed when using PKCE authorization.^[89]
• GitLab-specific improvements:
  • Implements the GraphQL API with proper authorization.^[90]
  • Comes with background service status checking, just like GitHub.
  • Supports Git LFS (documentation).^[91]
  • Users won’t get a 404 Not Found error when signing in to the GitLab backend.^[92]
  • The sign-in check uses the user’s effective role on the project, whatever gives it. Netlify/Decap CMS gives different answers for the same role depending on its source: it refuses members of a group invited to an ancestor group, even Maintainers; lets in a Reporter of a group invited as Maintainer; and refuses a Developer of an invited group when the default branch isn’t protected.^[93]
  • We implemented a workaround for a GraphQL complexity limit issue in GitLab 18.4.2, while Netlify/Decap CMS continued to suffer from the same problem.^[94] Our workaround was removed after GitHub 18.4.5 solved the underlying issue.
• Our Gitea/Forgejo backend is high-performing because it retrieves multiple entries at once. It also supports Git LFS (documentation). Additionally, the backend won’t cause 400 Bad Request errors due to the presence of DRAFT_MEDIA_FILES in file paths.^[95]
• Unlike Netlify/Decap CMS, Sveltia CMS does not have a hardcoded API request timeout of 60 seconds, which can lead to unexpected errors when working with large files or slow networks.^[96] Though users may still experience timeouts due to server-side limitations, at least the client-side won’t impose an arbitrary limit.
• An indicator is displayed in the account menu when using the local development workflow.^[97]
• Developers can select the local and remote backends while working on a local server.
• The Test backend saves entries and assets in the browser’s origin private file system (OPFS) so that changes are not discarded when the browser tab is closed or reloaded.^[98]
• Commit message template supports the {{author-email}} template tag to include the author’s email address.
• API error messages are displayed in a user-friendly manner instead of generic messages like Failed to fetch.^[99]
• The include_credentials option is available for self-hosted backends that require authentication via cookies.

Better I18n Support

Sveltia CMS has been built with a multilingual architecture from the very beginning. You can expect first-class internationalization (i18n) support, as it was required by clients of the maintainer, @kyoshino, who himself was a long-time Japanese localizer for Mozilla and currently lives in the most diverse city in the world where 150+ languages are spoken.

• Configuration
  • The i18n limitations in Netlify/Decap CMS do not apply to Sveltia CMS:
    • File collections support multiple files/folders i18n structures.^[100] To enable it, simply use the {{locale}} template tag in the file path option, e.g. content/pages/about.{{locale}}.json or content/pages/{{locale}}/about.json. For backward compatibility, the global structure option only applies to folder collections, and the default i18n structure for file collections remains single file.
    • The List and Object widgets support the i18n: duplicate field configuration so that changes made with these widgets are duplicated between locales.^[101][102] The i18n configuration can normally be used for the subfields.
  • Gives more control over entry file paths and structures:
    • The new multiple_root_folders i18n structure allows to have locale folders below the project root: /<locale>/<folder>/<path>.<extension>.^[103]
    • An entry collection can put the {{locale}} placeholder in the folder option, e.g. content/{{locale}}/posts, to say where the locale folder goes, which the fixed structures can’t always express. It supports Hugo’s translation by content directory, where each language has a contentDir like content/en, so the locale folders sit between the content folder and the section folders — and the section’s _index.md lands in the right place with it. (Discussion)
    • The new single_file_default_root i18n structure has been added to support Lume’s Multilanguage plugin.
    • The new omit_default_locale_from_file_path i18n option allows to exclude the default locale from file paths. This option applies to all multiple files/folders structures, aiming to support Zola’s multilingual sites. (Discussion)
    • Entry-relative media folders can be used in conjunction with the multiple_folders i18n structure.^[104]
  • Entry slug enhancements:
    • It’s possible to use a random UUID for an entry slug, which is a good option for locales that write in non-Latin characters.
    • It’s possible to localize entry slugs while linking the localized files,^[105] thanks to the support for Hugo’s translationKey.^[106] This extends to nested collections, where the folder names are localized along with the slugs.
    • When the clean_accents option is enabled for entry slugs, certain characters, such as German umlauts, will be transliterated.^[107]
  • The required field option accepts an array of locale codes in addition to a boolean, making the field required for a subset of locales when i18n support is enabled. For example, if only English is required, you could write required: [en]. An empty array is equivalent to required: false.
  • It’s possible to embed the locale code in an entry by using widget: hidden along with default: '{{locale}}'.^[108]
  • The value_field Relation field option can contain a locale prefix like {{locale}}/{{slug}}, which will be replaced with the current locale. It’s intended to support i18n in Astro. (Discussion)
  • The collection filters are applied correctly regardless of the i18n structure.^[109]
  • The summary collection option supports the {{locales}} template tag to show enabled entry locales in the entry list.
• User interface
  • Eliminates UI confusion: The Preview Pane can be displayed without toggling i18n in the Content Editor. Both panes are scrollable. There is no condition where both panes are edited in the same language at the same time.
  • Users can easily switch between locales while editing by clicking a button instead of a dropdown list when there are less than 5 locales.
  • The two panes can be swapped with a single click.
  • Language labels appear in human-readable display names instead of ISO 639 language codes because it’s not easy for everyone to recognize DE as German, NL as Dutch, ZH as Chinese, and so on.
  • It’s possible to set the editor pane locale via a URL query parameter, e.g. ?_locale=fr.
• Content editing
  • Integrates translation services to allow translation of text fields from another locale with one click.
  • The Content Editor supports RTL scripts such as Arabic, Hebrew and Persian.^[110]
  • It’s possible to disable non-default locale content.^[111]
  • Boolean, DateTime, List and Number fields in the entry preview are displayed in a localized format.
  • Boolean fields are updated in real time between locales like other widgets to avoid confusion.^[112]
  • Relation fields with i18n enabled won’t trigger a change in the content draft status when a user starts editing an existing entry.^[113]
  • Solves problems with Chinese, Japanese and Korean (CJK) IME text input in the rich text editor for the Markdown widget.^[114]
  • Raises a validation error instead of failing silently if the single_file structure is used and a required field is not filled in any of the locales.^[115]
  • Fields in non-default locales are validated as expected.^[116]
  • No internal error is thrown when changing the locale.^[117]
  • Duplicating an entry duplicates all locale content, not just the default locale.^[118]
  • Copying Markdown from another locale using the menu works as expected.^[119]
  • The subfields of a List or Object field using i18n: duplicate are shown read-only in the other locales, rather than being left out. The items can’t be added, removed or reordered there, which would change the default locale as well.

Better Collections

• Configuration
  • Provides some new options, including:
    • reorder: Enables manual entry reordering.^[120]
    • file: Store all the entries of an entry collection in a single JSON file, as an array of objects, instead of one file per entry.^[121]
    • icon: Choose a custom icon for each collection.^[122]
      • The option can also be used for individual files within a file collection. The specified icon will then appear in the file list.
    • thumbnail: Specify the field name for a thumbnail displayed on the entry list, like thumbnail: featuredImage.
      • A nested field can be specified using dot notation, e.g. heroImage.src.
      • A wildcard in the field name is also supported, e.g. images.*.src.
      • Multiple field names can be specified as an array for fallback purpose, e.g. [thumbnail, cover].
      • A file path starting with a slash can be specified instead of a field name, e.g. /images/thumbnails/{{slug}}.webp. It can contain the same template tags as the preview_path option, so a thumbnail can be derived from the entry without an extra field.
      • Occasionally, suitable images may not be available for thumbnails. For example, the images may have subtle differences or varied aspect ratios. In that case, you can disable the thumbnail with thumbnail: false.
      • If this option is omitted, any non-nested, non-empty Image or File field will be used.^[123] Sveltia CMS doesn’t have hardcoded inference fields.^[124]
    • limit: Specify the maximum number of entries that can be created in a folder collection.^[125]
    • readonly: Make content read-only globally, or for a collection, a file or an asset collection, e.g. while the site is under maintenance.^[126] It can also stop editors from changing existing entries.^[127]
    • divider: Add dividers to the collection list.
    • body_field: Configure the body field for front matter formats.
  • Enhancements to the entry filter option for folder collections:
    • Boolean value works as expected.^[128]
    • value accepts null to match an undefined field value.
    • value accepts an array to provide multiple possible values.^[129]
    • pattern can be used instead of value to provide a regular expression, just like the view_filters collection option.^[130]
  • Enhancements to string transformations:
    • Transformations can be used in more places than just the collection summary:
      • The slug, path and preview_path collection options^[131]
      • The summary field option for the List and Object widgets
    • The slugify transformation has been added.
    • The default transformation accepts a template tag like {{fields.slug | default('{{fields.title}}')}}, making it possible to fall back to a different field value. (Discussion)
    • The date transformation supports the time zone argument. The only available value is utc, which converts a date to UTC. This is useful if the specified DateTime field is local, but you want to force UTC in the entry slug, e.g. {{date | date('YYYYMMDD-HHmm', 'utc')}}. (Discussion)
    • The date transformation returns an empty string if an invalid date is given.^[132]
    • Multiple transformations can be chained like {{title | upper | truncate(20)}}.
  • Enhancements to file collections:
    • Sveltia CMS supports singletons, a simple form of a file collection.^[133]
    • File collections support files without extensions.^[134] This is useful for editing site deployment configuration files, such as _headers and _redirects.
    • Each file in a file collection has the format and frontmatter_delimiter options, which can be used to specify the file format, making it possible to have yaml-frontmatter, toml-frontmatter and json-frontmatter side by side.^[135]
    • The new raw format allows you to edit raw files without front matter, such as plain text files, CSV files, JSON files and YAML files.^[136] When using this format, make sure to have only one field named body with the widget type set to code, markdown, richtext or text.
  • The create option for folder collections defaults to true, providing a better out-of-the-box experience.
  • The duplicate option for folder collections is available to disable entry duplication when it’s not needed.
  • The collection label defaults to the name value according to the Decap CMS document, while Netlify/Decap CMS actually throws a configuration error if the label option is omitted.
  • Nested fields (dot notation) can be used in the path option for a folder collection, e.g. {{fields.state.name}}/{{slug}}.^[137]
  • Markdown is supported in the description collection option.^[138] Bold, italic, strikethrough, code and links are allowed.
  • The collection folder can be an empty string (or . or /) if you want to store entries in the root folder. This supports a typical VitePress setup.
• Entry slugs
  • The global slug options have the following new options:
    • maxlength: The maximum number of characters for an entry slug; avoid deployment errors with Netlify or other platforms.^[139] Default to undefined, meaning no limit.
    • trim: Remove leading and trailing replacement characters, such as hyphens, from an entry slug. The default value is true. Set to false to keep them.
    • lowercase: Convert an entry slug to lowercase. The default value is true. Set to false to preserve the original casing.^[140]
    • timezone: Timezone for date-based slug generation. The default value is utc for backward compatibility with Netlify/Decap CMS, but you can change it to local if you prefer to use the user’s local time.
  • It’s possible to use a random UUID for an entry slug.
  • Entry slugs are editable.^[141]
    • The Slug panel in the Content Editor’s sidebar shows the slug a new entry will be saved with, as it’s being edited, and lets users change it. Once an entry is saved, users can rename it in the same panel, and the entry file will be renamed accordingly.
    • The slug collection option can be an object to control whether the slug is editable when an entry is created and once it’s saved, to have users type the slug themselves, and to validate it with a regular expression pattern.
    • A slug can be given to a new entry through a URL query parameter when linking to the Content Editor.
      • Automatic redirects: The aliases front matter field will be updated to include the old slug, which can be used for redirects. Hugo and Zola support this feature out of the box, while other static site generators may require additional configuration.
      • Cascading updates: If the entry is used in a Relation field, the relation value will be updated to reflect the new slug. This prevents broken references in the content.
  • Entry slugs are localizable.^[105:1]
    • The i18n slug option localizes the slug, or lets users type it for each locale.
  • Slug generation is fail-safe: If a slug cannot be determined from entry content, part of a random UUID is used instead of throwing an error or filling in with arbitrary string field values.^[142]
  • If a collection only has the Markdown body field, an entry slug will be generated from a header in the body, if exists. This supports a typical VitePress setup.
  • Entry slug template tags support transformations just like summary string template tags.^[131:1] For example, you can use {{fields.date | date('YYYY-MM-DD')}} to generate a slug like 2025-01-23 from a DateTime field.
  • Single quotes (apostrophes) in a slug will be replaced with sanitize_replacement (default: hyphen) rather than being removed.^[143]
  • Setting the collection path doesn’t affect the entry slugs stored with the Relation widget.^[144]
• Entry listing
  • The default sort field and direction can be specified.^[145]
  • The default filter and group can also be specified in the same way as with Static CMS.^[146]
  • View filters and groups can compare a field value with eq, ne, lt, lte, gt, gte, in and not_in, and the {{now}} and {{today}} template tags make it possible to list upcoming or past events.
  • Sorting entries by a DateTime field works as expected.^[147]
  • Entry grouping and sorting can work together. For example, it’s possible to group by year and then sort by year if configured properly.^[148]
  • The sortable_fields option accepts a special slug value to allow sorting by entry slugs.
  • When the summary option is defined for a collection, it’s possible to sort by entry summaries in the entry list.
  • Index file inclusion allows users to edit Hugo’s special _index.md file, including localized ones like _index.en.md, within a folder collection.^[149] If the index_file option is not defined, these files will be hidden in a folder collection unless the path option is configured to end with _index and the extension is md.^[150]
    • The index file can have an extension and format of its own, so it doesn’t have to be a Markdown file like the entries around it. This makes it possible to manage Eleventy’s directory data file, such as a posts/posts.json file holding the data that every Markdown entry in the posts folder inherits. (Discussion)
  • A console error won’t be thrown when a collection doesn’t have the title field.^[151] In that case, an entry summary will be generated from a header in the Markdown body field, if exists, or from the entry slug, so the summary will never be an empty.^[152] This supports a typical VitePress and Docusaurus setup.^[153]
  • If there was an error while parsing an entry file, such as duplicate front matter keys, it won’t show up as a blank entry, and a clear error message will be displayed in the browser console.^[154]
  • A single file can be used for more than one item in a file collection.^[155]
• User interface
  • The collection list displays the number of items in each collection.
  • The sidebar can be resized by dragging the divider.
  • Users can select multiple entries and delete them at once.
  • In an entry summary, basic Markdown syntax used in the title, including bold, italic and code, are parsed as Markdown. HTML character references (entities) are also parsed properly.^[156]
  • If an entry field that appears in the collection’s summary, such as title, is updated, the entry list displays an updated summary after the entry is saved.^[157]
  • Thumbnails of entries are displayed not only in the grid view but also in the list view, making it easier to navigate.
  • If entries don’t have an Image field for thumbnails, the entry list will only be displayed in the list view, because it doesn’t make sense to show the grid view.^[158]
  • Assets stored in a collection media folder can be displayed next to the entries.
  • The New Entry button won’t appear when a developer accidentally sets the create: true option on a file collection because it’s useless.^[159]
  • The Delete Entry button won’t appear when a developer accidentally sets the delete: true option on a file collection because the preconfigured files should not be deleted.
• Nested collections enhancements:
  • A folder in the collection tree is labeled with its own index file instead of the title of whichever entry happens to come first.^[160] Where subfolders: false makes entries regular files, the folder name is shown.
  • Adding an entry to a folder that already holds some no longer saves it over that folder’s index.md: the shared file name only applies in the default subfolders mode, where a folder is an entry.^[161] A name given with an extension, such as index.md, is accepted.
  • A new entry’s file is named from the collection’s slug template or identifier_field, as in any other collection, instead of the name always coming from the title field — a collection without one no longer saves every entry as untitled.^[162]
  • The entry path is chosen from a folder tree rather than typed by hand. Netlify CMS offered an experimental widget that enabled a dropdown UI, but it doesn’t work with Decap CMS. A folder that doesn’t exist yet can be created in it where entries never make one.
  • The picker says which folder an entry will be created in, so a page can be added to the folder being browsed without overwriting that folder’s own entry, and leaving the folder blank files the entry where the collection’s path option puts it.^[163] An entry’s own folder is left out of its picker, so it can’t be filed within itself, and a folder that’s genuinely free is never rejected as already taken.
  • The preview_path option produces a working URL: the folder structure is kept and the shared index file name dropped, so docs/intro/_index.md is previewed at docs/intro,^[164] which is also what a Relation field stores. Netlify/Decap CMS puts the raw file path in both, leaking the index file name into the URL and the stored reference.
  • An image uploaded while creating an entry lands beside it, because the {{dirname}} template tag is resolved from the start rather than only once the entry is saved and reopened.^[165] The tag is also relative to the collection folder with no leading slash, so it combines with the rest of a path.
  • I18n works with nested collections: the whole collection is listed with the multiple_folders structure rather than part of it, the sidebar folder tree filters entries instead of coming out broken, and an entry missing one locale’s file saves normally rather than producing an empty commit.^[166]
  • Localized entry slugs work in nested collections too, so the folder names, and with them the permalinks, are translated all the way down: an English page stored at about/history/_index.md can have its French version at a-propos/histoire/_index.md. The parent folder is chosen once, in the default locale, and each locale’s file is filed below that folder’s own localized name, which is taken from the folder’s entry. The slug editor renames the folder per locale, moving a page takes its subtree along in every locale, and the localized files are linked with Hugo’s translationKey. Netlify/Decap CMS can’t do any of this: a localized slug can’t even name a file there,^[105:2] and nested collections and i18n don’t work together in the first place.^[166:1]
  • A link to a nested entry opens that entry, rather than stopping at the first segment of its path and opening the wrong one.^[167] See entry shorthand links.
  • A deep tree keeps working, whatever nested.depth is set to: the file list comes from a single recursive request, so the backend never gives up on the collection.^[168]

Better Content Editing

• Required fields, not optional fields, are marked for efficient data entry.
• Users can revert changes to all fields or a specific field. They can also restore the default values or clear the values of a field, of the fields in a locale, or of the whole entry, which comes in handy to start over. The options that change many fields at once ask for confirmation first. (Discussion)
• If changes are reverted and there are no unsaved changes, the Save button is disabled as expected.^[169]
• The new readonly field option makes the field read-only. This is useful when a default value is provided and the field should not be editable by users.^[170] The option defaults to false except for the UUID widget, where it defaults to true.
• An entry can be validated manually while editing using the Validation sidebar panel.
• Fields with validation errors are automatically expanded if they are part of nested, collapsed objects.^[171]
• A full regular expression, including flags, can be used for the widget pattern option.^[172] For example, if you want to allow 280 characters or less in a multiline text field, you could write /^.{0,280}$/s (but you can now use the maxlength option instead.)
• A long validation error message is displayed in full, without being hidden behind the field label.^[173]
• Any links to other entries will work as expected, with the Content Editor being updated for the other.^[174]
• In the Boolean and Select widgets, users don’t have to update a value twice to re-enable the Save button after saving an entry.^[175]
• data can be used as a field name without causing an error when saving the entry.^[176]
• The entry content is validated before loading to prevent crashes caused by invalid data, such as values of the wrong type.^[177]
• Changes made by other people are noticed. Netlify/Decap CMS writes an entry from the copy loaded when the site data was fetched, so a change a colleague pushed in the meantime is overwritten without a word. Sveltia CMS checks the repository as an entry is opened, every minute while the tab is shown, and again before every save, and only what has changed is fetched:
  • An entry is opened as it is on the branch, not as it was when the site data was loaded, and the entry and asset lists follow the repository as commits land.
  • If someone changes the entry that is open, a notice says who and when and offers to reload it. Work in progress is left alone either way.
  • If the user saves anyway, Sveltia CMS asks first, so the other change is never overwritten by accident. See Conflict Resolution.
  • On GitHub, the branch head the loaded data reflects is passed to the commit API as the expected head, so a commit against a branch that has moved is refused by GitHub itself. Netlify/Decap CMS looks the head up right before committing, which defeats the check, and the rare case where two people save at the same moment fails with an unexplained Update is not a fast forward error.^[178] Sveltia CMS explains what happened and picks the other change up before the next attempt.

Better Content Preview

• The Preview Pane comes with a minimal default style.^[179] It looks nice without a custom preview style or template.
• For better performance, the Preview Pane doesn’t use an <iframe> unless a custom preview stylesheet is registered.^[41:1]
• The Preview Pane displays all fields, including each label, making it easier to see which fields are populated.
• Entering a long value into a field will not cause the field label to disappear.^[180]
• Clicking a field in the Preview Pane focuses the corresponding field in the Edit Pane.^[181] It automatically expands when collapsed.
  • This is equivalent to the (misleading) visual editing feature introduced in Decap CMS 3.6.0, but our click-to-highlight feature is enabled by default; you don’t need to opt in with the editor.visualEditing collection option. We don’t plan to support this option because it’s confusing, unnecessary and undocumented. (Plus, why camel case?)
• The Preview Pane doesn’t cause a scrolling issue.^[182]
• The Preview Pane doesn’t crash with a Minified React error.^{[183][184][185]}
• Provides better scroll synchronization between the panes when editing or previewing an entry.^[186]
• Developers can hide the preview of a specific field using a new field option: preview: false.^[187]
• See below for widget-specific enhancements, including support for variable types^[188] and YouTube videos.

Better Data Output

• Keys in generated JSON/TOML/YAML content are always sorted by the order of configured fields, making Git commits clean and consistent.^[189]
• Netlify/Decap CMS often, but not always, omits optional and empty fields from the output.^[190] Sveltia CMS aims at complete and consistent data output — it always saves proper values, such as an empty string, an empty array or null, instead of nothing (undefined), regardless of the required field option.^{[191][192][193][194]}
  • In other words, in Sveltia CMS, required: false makes data input optional, but doesn’t make data output optional.
  • To omit empty optional fields from data output, use omit_empty_optional_fields: true in the data output options. This is useful if you have data type validations that expect undefined.^[195]
• JSON/TOML/YAML data is saved with a new line at the end of the file to prevent unnecessary changes being made to the file.^[196]
• Leading/trailing whitespaces in text-type field values are automatically removed when an entry is saved.^[197] No option is required to trim the values.^[198]
• YAML string folding (maximum line width) is disabled, mainly for framework compatibility.^[199]
• A standard time is formatted as HH:mm:ss instead of HH:mm for framework compatibility, including Hugo.
• DateTime field values in ISO 8601 format are stored in native date/time format instead of quoted strings when the data output is TOML.^[200]
• Provides JSON/YAML format options as part of the data output options, including indentation and quotes.^[201][202]
• It’s impossible to inject front matter through the body field.^[203]

Better Widgets

Sveltia CMS supports all the built-in widgets available in Netlify/Decap CMS. We have improved these widgets significantly while adding some new ones.

• Boolean
  • A required Boolean field with no default value is saved as false by default, without raising a confusing validation error.^[191:1]
  • An optional Boolean field with no default value is also saved as false by default, rather than nothing.^[192:1]
• Code
  • More than 240 languages are available, thanks to Shiki’s extensive language support.
  • The language switcher always appears in the user interface, so it’s easy to spot and change the selected language.
  • Dynamic loading of language modes work as expected.^[204]
  • A Code field under a List field work as expected, saving both code and language.^[205]
  • A wrong initial value will not cause a crash with a TypeError.^[206]
• Color
  • The widget doesn’t cause scrolling issues.^[207]
  • The preview shows both the RGB(A) hex value and the rgb() function notation.
• DateTime
  • Powerful new options for better date/time input control:
    • The new type option allows selecting between datetime-local (default), date, and time inputs more intuitively, replacing the confusing date_format: false / time_format: false workarounds from Netlify/Decap CMS.
    • The new min and max options allow restricting the selectable date/time range, mapping directly to the HTML min and max attributes.
    • The new step option controls the increment of the date/time input, mapping directly to the HTML step attribute. For datetime-local and time, the value is in seconds (e.g. 900 for 15-minute steps); for date, the value is in days (e.g. 7 for weekly steps).
    • The new input_timezone and output_utc options provide better control over timezones for date/time input and output than the legacy picker_utc option.
    • The new auto_now option sets the value to the current date/time when an entry is saved, making it easy to keep track of when an entry was created and last modified.^[208]
  • A DateTime field doesn’t trigger a change in the content draft status when a user has just started editing a new entry.^[209]
  • User’s local time is not saved in UTC unless the picker_utc option is true.^[210]
  • The widget doesn’t throw a RangeError for formatting days of the month.^[211][212]
  • The year will not unexpectedly change to 190x when the value is entered manually.^[213]
• Hidden
  • The default value supports the following template tags:
    • {{locale}}: The current locale code.^[108:1]
    • {{datetime}}: The current date/time in ISO 8601 format.^[214]
    • {{uuid}}, {{uuid_short}} and {{uuid_shorter}}: A random UUID or its shorter version, just like the slug template tags.^[215]
    • {{author-email}}, {{author-login}} and {{author-name}}: The signed-in user’s email, login name and display name, respectively.^[216]
  • The default value is saved when you create a file collection item, not just a folder collection item.^[217]
• List
  • It’s possible to edit data files with a top-level list using the new root option.^[218]
  • The min and max options can be used separately. You don’t need to specify both to use either option.^[219]
  • The Add Item button appears at the bottom of the list when the add_to_top option is not true, so you don’t have to scroll up each time to add new items.
  • A list item comes with a menu that allows users to duplicate the item, insert a new item above/below it, or remove it.^[220]
  • Users can expand or collapse the entire list, while the Expand All and Collapse All buttons allow users to expand or collapse all items in the list at once.^[221]
  • A required List field with no subfield or value is marked as invalid.^[222] No need to set the min and max options for the required option to work.
  • An optional List field with no subfield or value is saved as an empty array, rather than nothing.^[193:1]
  • An optional List field won’t populate an item by default when the subfield has the default value.^[223]
  • A simple List field with no subfields is displayed as a row per item, which includes a drag handler and single-line text input.^[224] Users can use spaces^[225] and commas^[226] for list items. A comma is no longer treated as a list delimiter.
  • Users can preview variable types without having to register a preview template.^[188:1]
  • It’s possible to omit fields in a variable type object.^[81:1] In that case, only the typeKey (default: type) is saved in the output.
  • Unknown variable types can be removed and reordered in the list, just like known types.^[227]
  • A collapsed List field will not display a programmatic summary like List [ Map { "key": "value" } ] if the summary option is not set.^[228]
  • The allow_remove and allow_reorder options can be used to prevent users from removing items and reordering them, respectively.^[229]
  • The allow_duplicate option can be used to prevent users from duplicating items.
  • A List field limited to one item with max: 1 is shown like an Object field, without the item count and the list controls, and a required one comes with its item, so there’s no need to add it first. (Discussion)
• Map
  • The center and zoom options are available to set the initial map view.
  • A search bar enables users to quickly locate a specific place on the map.^[230]
  • With the Geolocation API, users can get their current location with one click.
  • The value can be cleared by clicking the Clear button.
  • The map’s zoom level is adjusted more intuitively using pinch gestures.
  • The map looks good in dark mode.
• Markdown
  • The rich text editor is built with the well-maintained Lexical framework, which solves various issues with a Slate-based editor in Netlify/Decap CMS,^[231] including fatal application crashes,^{[232][233][234][235][236]} lost formatting when pasting,^[237][238] an extra line break when pasting,^[239] extra HTML comments when pasting,^[240] backslash injections,^[241] dropdown visibility,^[242] and text input difficulties with IME.^[114:1]
  • For better security, the sanitize_preview option defaults to true since Sveltia CMS 0.105.0.
  • The default editor mode can be set by changing the order of the modes option.^[243] If you want to use the plain text editor by default, add modes: [raw, rich_text] to the field configuration.
  • The raw Markdown editor comes with syntax highlighting.^[244]
  • The toolbar buttons also work in the raw Markdown editor, inserting Markdown into the text. Editor components can be inserted as well.^[245]
  • A Markdown field plays well with a variable type List field.^[246]
  • The bullet list marker is a hyphen (-) rather than an asterisk (*), which is the comment form’s default behavior on GitHub and GitLab.^[247]
  • A combination of bold and italic doesn’t create a confusing 3-asterisk markup.^[248] In our editor, bold is 2 asterisks and italic is an underscore.
  • When deleting a linked text, the link is removed cleanly without leaving behind any unwanted characters.^[249]
  • Bare URLs are rendered as clickable links in the preview.^[250]
  • An editor component can be removed with a single click on the Remove button.^[251]
  • The built-in image component can be inserted with a single click.
  • The built-in image component allows users to add, edit or remove a link on an image.^[252] To disable this feature, add linked_images: false to the Markdown field options.
  • It’s possible to paste/drop local/remote images into the rich text editor to insert them as expected. Note: Pasting multiple images is not supported in Firefox. In Netlify/Decap CMS, pasting an image may cause the application to crash.^[253]
  • Inline images are supported.^[254]
  • The built-in code-block component is implemented just like a blockquote. Users can simply convert a normal paragraph into a code block instead of adding a component.
  • Nested editor components can be controlled with the new allow_nested_components option.
  • Code in a code block in the editor can be copied as expected.^[255]
  • Language-annotated code block doesn’t trigger unsaved changes.^[256]
  • Soft line breaks are rendered as hard line breaks in the Preview Pane.
  • Uploaded images will not disappear while editing an entry.^[257][258]
  • The Preview pane is updated instantly while editing.^[259]
  • It’s possible to define option defaults for all Markdown/RichText fields globally.
  • Markdown shortcuts, such as # for headings, - for bullet lists, and 1. for numbered lists, are supported in the rich text editor.
• Number
  • If the value_type option is int (default) or float, the required option is false, and the value is not entered, the field will be saved as null instead of an empty string.^[194:1]
  • The value_type option accepts int/string and float/string to save the number as a string instead of a number.
• Object
  • Sveltia CMS offers two ways to have conditional fields in a collection:^[260]
    • The Object widget supports variable types (the types and typeKey options) just like the List widget.^[261]
    • An optional Object field (required: false) can be manually added or removed with a checkbox.^[262] If unadded or removed, the required subfields won’t trigger validation errors,^[263] and the field will be saved as null.
• Relation
  • Field options are displayed with no additional API requests.^[37:1] The confusing options_length option, which defaults to 20, is therefore ignored.^[264]
  • The widget reliably displays the selected option in the summary and all available options in the dropdown list.^[265]
  • slug can be used for value_field to show all available options instead of just one in some situations.^[266]
  • Template strings with a wildcard like {{cities.*.name}} can also be used for value_field.^[267]
  • display_fields is displayed in the Preview Pane instead of value_field.
  • The redundant search_fields option is optional in Sveltia CMS, as it defaults to display_fields, value_field or the collection’s identifier_field, which is title by default.
  • The value_field option is also optional in Sveltia CMS, as it defaults to {{slug}} (entry slugs).
  • A new item created in a referenced collection is immediately available in the options.^[268]
  • A related entry can be created on the fly from the Relation field itself, without leaving the entry being edited. The new entry is selected right away and saved along with the entry in the same commit.^[269]
  • A referenced DateTime field value is displayed in the specified format.^[270]
  • It’s possible to refer to a List field with the field option, which produces a single subfield but does not output the subfield name in the data, using the value_field: cities.*.name syntax. (Discussion)
  • Supports the filters option to filter available options based on field values in the referenced collection.^[271]
    • The implementation is compatible with Decap CMS.
    • Sveltia CMS supports the exclude option to exclude options based on field values in the referenced collection.
    • Template strings like {{slug}} and {{fields.title}} can also be used in the filter values.
    • A filter on a field holding multiple values, such as a Select field with multiple: true or a List field without subfields, matches an entry when any of its values is included in the filter values. A template string referring to such a field in the current entry is expanded to all of its values.^[272]
  • Reverse relations can be displayed in the Content Editor’s Backlinks sidebar panel.
  • Cascading updates and deletions: When a referenced entry is renamed, the Relation field values pointing at it are updated; when it’s deleted, the references are removed. The deletion is refused if that would leave a required field empty or a multi-select field below its min, so referential integrity is maintained without breaking any entry.^[273]
  • Multi-value Relation fields can be populated with comma-separated dynamic default values.^[274]
• Select
  • It’s possible to select an option with value 0.^[275]
  • label is displayed in the Preview Pane instead of value.
  • Option values can be booleans or null in addition to strings and numbers, e.g. “Yes”, “No” and “Not relevant” choices stored as true, false and null. Netlify/Decap CMS only accepts strings and numbers, and fails to load such a configuration.
• String
  • When a YouTube video URL is entered in a String field, it appears as an embedded video in the Preview Pane. Check your site’s CSP if the preview doesn’t work.
  • When a regular URL is entered in a String field, it appears as a link that can be opened in a new browser tab.
  • Supports the type option that accepts url or email as a value, which will validate the value as a URL or email.
  • Supports the prefix and suffix string options, which automatically prepend and/or append the developer-defined value to the user-input value, if it’s not empty.
• Boolean, Number and String
  • Supports the before_input and after_input string options, which allow developers to display custom labels before and/or after the input UI.^[276] Markdown is supported in the value.
    • Compatibility note: In Static CMS, these options are implemented as prefix and suffix, respectively, which have different meaning in Sveltia CMS.
• File and Image
  • Provides a reimagined all-in-one asset selection dialog for File and Image fields.^[277]
    • Field, entry, file, collection and global assets are listed on separate tabs for easy selection.^[278]
    • A new asset can be uploaded by dragging & dropping it into the dialog.^[43:1]
    • A URL can also be entered in the dialog.
    • Integration with Pexels, Pixabay and Unsplash makes it easy to select and insert a free stock photo.^[279] More stock photo providers will be added in the future.
  • Users can also simply drag and drop a file onto a File/Image field to attach it without having to open the Select File dialog.
  • Users can paste an image from the clipboard directly into a File or Image field by clicking the Paste button.
  • Supports the boolean multiple option, which can be set to true to allow multiple file uploads.^[42:1]
    • When enabled, users can select and upload multiple files at once in the Select File dialog, as well as drag and drop multiple files onto the field. The field value will be an array of strings instead of a single string.
    • The min and max options are also available to limit the number of files that can be uploaded. Both accept positive integers. If min is not specified, it defaults to 0. If max is not specified, it defaults to Infinity.
  • The new accept option allows files to be filtered by a comma-separated list of unique file type specifiers, in the same way as the HTML accept attribute for <input type="file">.^[280]
    • By default, the Image widget only accepts an AVIF, GIF, JPEG, PNG, WebP or SVG image. BMP, HEIC, JPEG XL, PSD, TIFF and other less common or non-standard files are excluded,^[281] except that HEIC photos are accepted when HEIC conversion is enabled.
    • The File widget has no default restriction.
  • If the collection’s public_folder contains {{slug}} and a slug field (e.g. title) of a new entry has been edited after uploading an asset, the updated slug will be used in the saved asset path.^[282] Other dynamic template tags such as {{filename}} will also be populated as expected.^[283]
  • The CMS prevents the same file from being uploaded twice. It compares the hashes and selects an existing asset instead.
  • Large images automatically fit in the Preview Pane instead of being displayed at their original size, which can easily exceed the width of the pane.
  • Image thumbnails are displayed in the Edit Pane as expected.^[284][285]
  • Unsaved files can be renamed.
  • The File field supports the select_folder option, compatible with Static CMS, to select a folder instead of a file. The Select Folder dialog works like a file manager: a click selects a folder, a double click opens it, and the arrow keys move between folders. With the multiple option, several folders can be selected at once.
• List and Object
  • The summary is displayed correctly when it refers to a Relation field^[286] or a simple List field.
  • The summary template tags support transformations, e.g. {{fields.date | date('YYYY-MM-DD')}}.
  • The collapsed option accepts the value auto to automatically collapse the widget if any of its subfields are filled out. The same applies to the minimize_collapsed option for the List widget.
  • The new thumbnail option allows developers to specify an Image or File subfield name, including a nested one like mobile.src, for the thumbnail of a collapsed list item or object. Thumbnails are displayed alongside the summary.
• Markdown, String and Text
  • Emoji autocomplete is enabled by default, allowing users to type : followed by a few letters to search for an emoji.
  • A required field containing only spaces or line breaks will result in a validation error, as if no characters were entered.
• Relation and Select
  • If a dropdown list has options with long wrapping labels, they won’t overlap with the next option.^[287]
  • When there are 5 or fewer options, the UI automatically switches from a dropdown list to radio buttons (single-select) or checkboxes (multi-select) for faster data entry.^[288] This number can be changed with the dropdown_threshold option for the relation and select widgets.
• String and Text
  • Supports the minlength and maxlength options, which allow developers to specify the minimum and maximum number of characters required for input without having to write a custom regular expression with the pattern option. A character counter is available when one of the options is given, and a user-friendly validation error is displayed if the condition is not met.

The following new widgets are available in Sveltia CMS:

• Compute
  • The experimental compute widget allows to reference the value of other fields in the same collection, similar to the summary property for the List and Object widgets.^[289] Use the value property to define the value template, e.g. posts-{{fields.slug}}. (Example)
  • The value property also supports a value of {{index}}, which can hold the index of a list item. (Example)
  • The value property also supports the {{uuid}}, {{uuid_short}} and {{uuid_shorter}} tags, which generate a random UUID that is kept once the entry is saved. (Example)
• KeyValue (Dictionary)
  • The new keyvalue widget allows users to add arbitrary key-value string pairs to a field.^[290]
  • While the implementation is compatible with Static CMS, we provide a more intuitive UI. Users can press Enter to move focus or add a new row while editing, and the preview is displayed in a clean table.
  • The root option is also available for a top-level key-value field, just like the List widget.
  • Key-value pairs can be reordered, and the new order is saved. (Discussion)
  • The label_singular option is available for the Add button, just like the List widget.
  • An empty field shows a blank row to type in, just like a simple List field.
• RichText
  • Currently, the richtext widget is a simple alias of markdown. We plan to add HTML output support in the future.
• UUID
  • In addition to generating UUIDs for entry slugs, Sveltia CMS supports the proposed uuid widget with the following properties:^[215:1]
    • prefix: A string to be prepended to the value. Default: an empty string.
    • use_b32_encoding: Whether to encode the value with Base32. Default: false.

Better Asset Management

• A completely new, full-fledged Asset Library, built separately from the image selection dialog, makes it easy to manage all files, including images, videos and documents.^[291]
  • Navigate between the global media folder and collection media folders.^[292]
  • Browse the subfolders of a media folder, with a breadcrumb leading back to the parent folders, and create, rename and delete folders — a rename moves every asset in the folder and updates the entries referencing them, and a deletion removes the references in the same commit.^[293] The Select File dialog lists and creates subfolders as well, and an uploaded file is saved to the folder being browsed. Netlify/Decap CMS lists every file in one flat view, and while its config can point a field at a subfolder, users can’t organize files into folders themselves. The same folder browsing works on Amazon S3, the S3-compatible providers and Azure Blob Storage, which store files at paths.
  • Preview image, audio, video, text and PDF files. Check your site’s CSP if the preview doesn’t work.
  • Copy the public URL,^[294] file path, text data or image data of a selected asset to clipboard. The file path starts with / as expected.^[295]
  • Edit plain text assets, including SVG images.
  • Rename existing assets. If the asset is used in any entries, the File/Image fields will be automatically updated with a new file path.
  • Replace existing assets.
  • Download one or more selected assets at once.
  • Delete one or more selected assets at once. If an asset is used in any entries, the File/Image fields and Markdown images referencing it are removed in the same commit, and the deletion is refused if that would leave a required field empty or a multi-file field below its min, so a required image can’t be deleted by accident.
  • Upload multiple assets at once, including files in nested folders, by browsing or dragging and dropping them into the library.
  • Sort or filter assets by name or file type.
  • View asset details, including size, dimensions, commit author/date and a list of entries that use the selected asset.
  • View some Exif metadata if available, including the creation date and GPS coordinates displayed on a map.
  • Manage files stored on external media storage providers such as Amazon S3, Cloudflare R2, Azure Blob Storage and Uploadcare from the same library. Users can browse, search, sort and filter the files, and upload, rename, replace, download or delete them where the service’s API allows, without switching to the provider’s dashboard. In Netlify/Decap CMS, external providers are only available through the image selection dialog.
  • The Linked Files location gathers every file that a File/Image field links to by URL, wherever it’s hosted, so users can preview it and see which entries use it.
• Enhancements to media storage:
  • Supports multiple media storage providers with the new media_libraries option.^[296]
  • Additional features are available for both internal and external media storage providers, except for Cloudinary:
    • A built-in image optimizer: With a few lines of configuration, images selected by users for upload are automatically converted to WebP format for reduced size,^[46:1] and it’s also possible to specify a maximum width and/or height.^[47:1] HEIC photos from iPhones and Android phones, which browsers other than Safari can’t display, are converted too. SVG images can also be optimized.
    • File size limits can be set for all media storage providers to prevent users from uploading excessively large files. In Netlify/Decap CMS, this option is only available at field level for the internal media storage provider, and it doesn’t apply to direct uploads to the Asset Library.
    • Filename slugification can be configured for all media storage providers.
  • Internal media storage provider
    • With asset collections, users can organize assets into multiple folders that are displayed in the Asset Library and the Select File dialog. These folders can be used across multiple collections. This feature is useful for managing assets by type, topic, or project.
    • It supports multiple file selection.^[42:2] This can be enabled by setting the new multiple File/Image widget option to true. For compatibility with other media storage providers, the media_library.config.multiple option is also supported.
    • Unlike Netlify/Decap CMS, files are uploaded with their original names. Sanitization is still applied to avoid issues with special characters, but uppercase letters and spaces are not converted to lowercase letters and hyphens.^[297] If you want to slugify filenames, use the slugify_filename media storage option. You can also rename uploaded files automatically with the filename_template option, using template tags like {{slug}} and {{uuid_short}}.^[298]
  • Cloudinary
    • Field-specific media storage configuration works as expected.^[299]
    • When the multiple option is enabled, the output is always an array of strings, regardless of whether a single file is selected.^[300]
    • The script-src CSP directive is not required for the widget to work, as we implemented the Cloudinary media storage without using their hosted widget script.
    • Image previews work as expected when the output_filename_only option is true.^[301]
  • Uploadcare
    • An API-based integration allows users to select existing files from their Uploadcare account.^[302]
    • Supports signed uploads to prevent unauthorized uploads. Files are uploaded with a signature computed using your secret key.
    • No error is raised for file collections if the media_folder option is not defined.^[303]
  • Other integrations
    • Integrates stock photo providers, including Pexels, Pixabay and Unsplash.^[279:1] Lorem Picsum can be used as a free placeholder image provider without having to obtain an API key.
    • Integrates Amazon S3 and S3-compatible storage providers, including Cloudflare R2 and DigitalOcean Spaces.^[304]
    • More integration options will be added in the future.
• Assets stored in an entry-relative media folder are handled as part of the entry.
  • These assets are displayed in the Asset Library.^[305]
  • They are automatically deleted when the associated entry is deleted because these are not available for other entries.^[306] When you’re working with a local repository, the empty enclosing folder is also deleted.
  • They are copied along with the entry when it’s duplicated, so a duplicated Hugo page bundle doesn’t end up referencing images that only exist in the original’s folder. Netlify/Decap CMS simply copies the field values, leaving the new entry with broken image references.
• Assets stored in the subfolders of media_folder are scanned recursively and displayed in the Asset Library.^[307]
• The global media_folder can be an empty string (or . or /) if you want to store assets in the root folder.
• PDF documents are displayed with a thumbnail image in both the Asset Library and the Select File dialog, making it easier to find the file they’re looking for.^[39:1]
• Hidden files (dot files) don’t appear in the Asset Library.^[308]
• Users can add assets using the Quick Add button in the upper right corner of the application.
• Rather than automatically renaming a file with an existing name when it is uploaded, the CMS prompts the user to either replace the existing file or rename the new one.
• Warnings are issued before corrupt or mislabeled files, such as a HEIC image saved with a .jpg extension, are uploaded.

Better Workflows

• Local Workflow enhancements:
  • We have eliminated the need for additional configuration and a proxy server, resulting in a streamlined workflow and improved performance.^[309]
  • It also avoids a number of issues, including potential security risks,^{[50:1][51:1][52:1][53:1]} a 30 MB file size limit,^[310] an unknown error with publish_mode,^[311] and an unused logo_url.^[312]
  • When you delete an entry or an asset file, the empty folder that contains it is also deleted, so it doesn’t have to be deleted manually.
• Editorial Workflow enhancements:
  • Performance is much better than with Netlify/Decap CMS, as we use the GraphQL API wherever possible.^[313]
  • Sveltia CMS does not use the GitHub compare API to avoid the 250-commit limit.^[314]
  • Unpublished entries are listed at the top of each entry collection page, along with status indicators.^[315]
  • Draft entries are kept as draft pull requests or draft merge requests, making it easier to identify them in the repository.
  • Entry deletions go through the Editorial Workflow instead of being committed directly, whether a user deletes a single entry in the Content Editor or several at once from the entry list, and Sveltia CMS doesn’t implement the confusing unpublishing process.^[316]
  • The Publish button is only displayed when the status is Ready.
  • The Publish button is hidden from users who can’t merge into the configured branch on GitLab and Gitea/Forgejo, such as a Developer on a branch that only Maintainers can merge into.^[86:1]
  • Saving an entry offers to send it for review there and then, so a draft isn’t left sitting with no pull request because the status menu went unnoticed.^[317]
  • Required fields aren’t enforced while an entry is in draft, so unfinished work can be saved without filling in every field or padding them with placeholder values.^[318]
  • Unpublished entries are included in search results and in the entry counts shown in the collection list, so a draft isn’t hidden just because it hasn’t been published yet.
  • Editorial Workflow works on a forked repository. Netlify/Decap CMS looks each pull request up with a head=[OWNER]:[BRANCH] filter, which GitHub resolves against the upstream network on a fork, so no unpublished entry is ever found. Sveltia CMS lists the pull requests once and matches them locally.^[319]
  • An unpublished entry is reconstructed only from the pull request files that belong to the collection its branch names, so unrelated files committed alongside it — generated content, assets, or entries from another collection — can’t be mistaken for the entry. Netlify/Decap CMS filters the files by extension alone and then picks the first match, which loads the wrong file when anything else in the repository shares the extension.^[320]
  • The current HEAD SHA of the source branch is included in publish requests for the GitLab editorial workflow, which may be required by a group or instance.^[321]
  • The publish_mode option can be set per collection, so a review process can be required for some collections and skipped for others, such as a site settings collection, rather than switched on or off for the whole site.^[322]
• Open Authoring enhancements:
  • Moving an entry back to Draft converts its pull request to a draft pull request rather than closing it, so the review discussion, approvals and checks on it survive. Netlify/Decap CMS closes the pull request and reopens it later.
  • The contributor’s fork is found even when it isn’t at the name GitHub gives it by default — because they renamed it, or because they already had a repository of that name and GitHub added a suffix. Netlify/Decap CMS only looks for a fork at [USER_NAME]/[REPOSITORY_NAME], so a fork anywhere else is missed and the contributor is asked to create one on every sign-in.
  • A workflow branch starts from the head of the configured repository rather than from the contributor’s fork, so a fork that has fallen behind or gained commits of its own doesn’t pass them on. Netlify/Decap CMS branches from the fork, where an out-of-date one leaks unrelated changes into the pull request.^[323]
  • Problems while setting Open Authoring up are reported with something to act on, rather than a generic failure: a repository invitation that hasn’t been accepted yet, a sign-in that doesn’t cover private repositories, and a repository that doesn’t allow forks are each named specifically.
  • Whether the signed-in user is a maintainer is determined from the repository’s own permissions, which any access level can read, rather than from the collaborator endpoint that needs administrator access to answer.
  • Uploads to the Media Library are disabled for contributors. Netlify/Decap CMS uploads files to a fork without creating a pull request.
  • A banner appears with the name of a fork the contributor’s changes are being saved to, with a link to it, so it’s clear where their work is going.
  • Saving an entry offers to send it for review there and then, which is what opens the pull request. Otherwise a contributor’s first save leaves their work sitting in their fork with nothing for a maintainer to see.^[317:1]
  • The entry list and the entry editor toolbar are updated immediately after saving a draft.
• Deploy Previews enhancements:
  • The build state is reported in Simple Workflow too, so it’s clear when an edit is actually live. Netlify/Decap CMS never asks the backend and always presents the link as ready, whether the page has been rebuilt or not.
  • Deployments and environments are read as well as commit statuses. Netlify/Decap CMS reads commit statuses alone, missing GitHub Pages and GitLab Review Apps.
  • Check runs are read too, including the URLs a provider publishes in the run’s output — where Cloudflare Pages writes its preview address while linking the check at its own dashboard. A run’s own link is followed only when its name says preview, as AWS Amplify’s does; every other run still reports its build state.^[324]
  • A build that was canceled or skipped is ignored, even when the provider reports it as successful — the monorepo case, where a site the commit didn’t touch still reports a result. Netlify/Decap CMS takes the first matching status, so it links to the canceled build’s log.^[325]
  • A failed build is reported as such, and while a preview is building the control says so and waits instead of offering the live site. Netlify/Decap CMS shows a Check for Preview button that never resolves, with no sign of whether the build failed or is merely slow.^[326]
  • A running build is re-checked every five seconds for ten minutes, and when the CMS gives up it says so and offers a manual re-check. Netlify/Decap CMS polls at the same rate for about two minutes — often too short for a slow build — and gives no sign that it has stopped.^[327]
  • On GitHub, all three sources are fetched in one request, so watching a build costs a single call per check. They’re split apart only for a repository that can’t answer for one of them, which is discovered once rather than assumed. GitLab has no bulk equivalent, so there it costs one shared call plus one per commit watched.
  • When site_url isn’t configured, the production deployment’s own URL is used instead, so preview links still work.
  • Where the CMS is served from the site it edits, the page itself is requested to confirm it’s live, so a finished build whose CDN hasn’t caught up is reported as still building rather than handed over as a link that 404s. A cross-origin page is skipped, since the browser couldn’t read the answer.
  • The preview_context option matches a name exactly, as in Netlify/Decap CMS, then falls back to a partial, case-insensitive match instead of silently finding nothing.
  • The {{locale}} template tag in the preview_path collection option gives each language its own preview link, offered from the locale pane’s options menu in the Content Editor — deploy previews included, so every translation of an unpublished entry links to its own page on the build. Netlify/Decap CMS formats one URL per entry with no locale involved, leaving only the default language reachable.^[328]
    • The new omit_default_locale_from_preview_path option excludes the default locale from preview paths, for sites that don’t include it in their URLs.
  • A preview_path using date tags is validated against the collection’s fields, so a template that could never be filled in is reported as a configuration warning instead of silently producing no link.
  • The Editorial Workflow board shows a preview link and a build badge on each card, so a failed build is visible without opening the entry.

Better Customization

• It’s possible to display a custom application title on the login page and in the browser tab by setting the app_title property.
• A custom logo defined with the logo_url property is displayed on the global application header and the browser tab (favicon).^[329] A smaller logo is also correctly positioned on the authentication page.^[330]
• Developers can specify the URL to redirect users after logging out with the logout_redirect_url global option.^[331]
• Enhancements to custom editor components:
  • CMS.registerEditorComponent() accepts a component definition with the icon property. Developers can specify a Material Symbols icon name just like custom collection icons.
  • The fromBlock function can be omitted if the pattern regex contains named capturing groups for the values.
  • Inline components are supported.^[332]
  • Field validation works as expected.^[333]
  • No error is raised in the browser console saying Sent invalid data to remark^[334] or onValidate is not a function.^[335]
  • A link with kramdown inline attributes (e.g. {:.class}) is parsed correctly.^[336]
  • Markdown is parsed and rendered correctly in the editor component preview.^[337]
  • Image file paths are automatically replaced with blob URLs in the editor component preview if necessary, so that the images are displayed correctly. In Netlify/Decap CMS, you have to use the undocumented getAsset and fields parameters for the toPreview function to achieve this.
  • The toPreview function can return a DOM element in addition to a string or React element, so a preview can be rendered with a Svelte, Vue or other framework component.
  • The new CMS.renderRichText() method renders the value of a nested RichText field into a DOM element or React element preview with the same pipeline as the preview pane, so nested components, images and Markdown formatting all appear as they do in the parent field, without any parsing or sanitizing on the developer’s side. The value is always passed to toPreview as is, regardless of the order in which components are registered, so it can also be processed manually.
  • The new mode option accepts the value dialog to allow users to edit the component content in a dialog instead of the default block UI within the editor.
  • The new trigger option accepts the value button, which places the component directly on the toolbar rather than a menu item.
• Enhancements to event hooks:
  • Missing identifier_field won’t cause an error when the preSave hook is triggered.^[338]
• Enhancements to custom field types (widgets):
  • The API method has been renamed from CMS.registerWidget() to CMS.registerFieldType() for better clarity, while keeping the old name for backward compatibility.^[339]
  • To prevent the app from crashing, registering built-in field type names is disallowed.
  • A control can hand files to the CMS with the documented addFile prop, which replaces the undocumented onPersistMedia prop.^[340] Compared to the Netlify/Decap CMS implementation:
    • It resolves to a URL that goes straight into the field value, and the CMS turns it into the public path on save. onPersistMedia returns an internal repository path in a Redux action, leaving each widget to guess the public path from it.
    • File naming, deduplication, media_folder resolution and media_library options work exactly as for a built-in File/Image field, including template tags like {{slug}}, which Netlify/Decap CMS can’t apply because it fixes the path as soon as the file is added.
    • The files are included in the same commit as the entry, so it works with the Editorial Workflow and Open Authoring.
  • A control can let the user pick a file with the documented pickFile prop, which opens the same dialog as a built-in File/Image field and replaces the undocumented onOpenMediaLibrary, mediaPaths, onClearMediaControl and onRemoveInsertedMedia props.^[341] Compared to the Netlify/Decap CMS implementation:
    • It returns a Promise that resolves with the picked file once the dialog is closed, or null if it’s dismissed. In Netlify/Decap CMS, the widget has to generate its own control ID, open the library with it, watch the mediaPaths Redux state in componentDidUpdate for a path keyed by that ID, and then reset the state itself, with nothing to tell it that the dialog was canceled.
    • It provides the contents of the picked file as a Blob, so a control can derive a thumbnail or read metadata from an existing file. Netlify/Decap CMS only delivers the path.
    • It resolves with exactly what a built-in File/Image field would store, including a temporary URL for a file uploaded through the dialog, which is turned into the public path on save.
• Async functions can be used for custom parsers/formatters.^[342]
• The application renders within the dimensions of a custom mount element, if exists.^[343]
• Sveltia CMS exposes React.Fragment globally as rf, allowing developers to use it in custom editor components and field types without having to import React explicitly.
• Sveltia CMS exposes its bundled React as CMS.React, so custom preview templates, editor components and field types can use hooks, without adding another global.^[344]
• Sveltia CMS offers the CMS.renderRichText() method and exposes marked and DOMPurify for easier Markdown rendering in custom previews and field types.

Better Localization

• Users can select the application UI locale. The locale configuration option is ignored in Sveltia CMS.
  • The initial locale is automatically selected based on the preferred language set with the browser.^[345]
  • The CMS will prompt the user to switch to their language when it becomes available.
  • Users can change the locale in the application settings.
• Manual locale registration with CMS.registerLocale() is no longer required as the CMS automatically downloads a locale file from the CDN when a locale is selected.
• We use our own Sveltia I18n library for localization. Thanks to the Unicode MessageFormat 2 (MF2) syntax, it provides better support for complex pluralization, allowing for more natural translations in different languages.
• The application layout automatically adjusts to support right-to-left (RTL) languages such as Arabic, Hebrew and Persian.^[346]
• The List widget’s label and label_singular are not converted to lowercase, which is especially problematic in German, where all nouns are capitalized.^[347]
• Long menu item labels, especially in non-English locales, don’t overflow the dropdown container.^[348][349]
• We maintain a list of available locales in our documentation. In contrast, Netlify/Decap CMS doesn’t provide a list even though manual registration is required.
• We provide a localization guide for translators to help them contribute translations for new locales or update existing ones.

Better Documentation

• We provide well-structured and comprehensive documentation with detailed guides and examples to help you configure and use Sveltia CMS effectively. Compare some documents:
  • String Transformations: Sveltia CMS vs. Netlify/Decap CMS
  • Custom File Formats: Sveltia CMS vs. Netlify/Decap CMS
• We constantly update our documentation to reflect the latest features and improvements, ensuring that you have access to the most accurate and up-to-date information. In contrast, Decap CMS documentation is often outdated, incomplete and lacks important details. It makes no mention of the deprecation of Git Gateway, and even some new options remain undocumented. The Decap CMS team has never learned from Netlify CMS, which left various options and features undocumented.
• The site navigation is clearer and more organized, with separate pages created for each field type and the JavaScript API distinguished.^[350]
• Our documentation supports dark mode for better readability in low-light environments.
• Code snippets can be copied to the clipboard with a single click, making it easier to use them in your own projects.
• Configuration examples are provided in YAML, TOML, JSON and JavaScript formats, allowing you to choose the format that best suits your needs.
• API examples involving React components are provided in both vanilla JavaScript and JSX, allowing you to choose the syntax that best fits your project.
• We provide clear migration instructions from Netlify CMS, including step-by-step guides and best practices to ensure a smooth transition.
• Our compatibility information to help you avoid unsupported options and configurations that might cause errors. By contrast, the Netlify/Decap CMS documentation does not mention anything about the deprecation of camel case options, the removal of the Date widget and the replacement of Moment.js. Furthermore, the Decap blog claims that Decap CMS 3.0 is ”fully backward compatible” even though it removed the Date widget.
• Our framework guides include starter templates, real-world examples and features for popular frameworks like Astro, Eleventy, and Hugo, making it easier to integrate Sveltia CMS into your projects.
• We don’t claim that the CMS can be used “with just a few clicks,” as this would be misleading for those setting it up for the first time.^[351]
• We have listed some common use cases of the CMS in the introduction.^[352] In addition, we have a dedicated Showcase page featuring real-world examples of websites using Sveltia CMS.
  • The showcase is an important complement to the documentation as it provides practical examples of how the CMS can be used in different scenarios, helping users understand its capabilities and potential applications.
• We document how the collection-level media_folder option works with a relative or absolute path.^[353]
• We document the CmsConfig type available on the global CMS object, which provides type definitions for the configuration object in TypeScript. It’s undocumented in Netlify/Decap CMS.
• The Collapsible Note custom editor component example works as expected.^[354]
• We provide an official Agent Skill and llms.txt to help you use AI agents like GitHub Copilot, Claude and ChatGPT more effectively when writing Sveltia CMS configuration files.
• The entry summary documentation mentions that date-related template tags are not supported.^[355]
• The Gitea/Forgejo PKCE authorization instructions include unchecking the Confidential option as a separate step, so you won’t miss it and get an invalid empty client secret error.^[356]

Ready to Migrate?

If you have scrolled this far, you must be interested in trying out Sveltia CMS! Check out the migration guide to get started. Enjoy a significantly improved content management experience! 🚀

---

1. Netlify/Decap CMS #2536 ↩︎

2. Netlify/Decap CMS #2557 ↩︎

3. Netlify/Decap CMS #3263 ↩︎

4. Netlify/Decap CMS #3264 ↩︎

5. Netlify/Decap CMS #3265 ↩︎

6. Netlify/Decap CMS #3266 ↩︎

7. Netlify/Decap CMS #2039, #3267, #7084 ↩︎

8. Netlify/Decap CMS #441, #1277, #1339, #2500, #2833, #2984, #3852, #7083 ↩︎ ↩︎

9. Netlify/Decap CMS #7241 ↩︎ ↩︎

10. Netlify/Decap CMS #1502 ↩︎

11. Netlify/Decap CMS #5656, #5837, #5972, #6476, #6516, #6930, #7080, #7105, #7106, #7119, #7176, #7194, #7244, #7278, #7301, #7342, #7348, #7354, #7376, #7408, #7412, #7413, #7422, #7427, #7434, #7438, #7454, #7464, #7471, #7485, #7499, #7515, #7564, #7571, #7574, #7580, #7583, #7589, #7593, #7595, #7601, #7610, #7614, #7620, #7621, #7622, #7631, #7643, #7644, #7648, #7669, #7688, #7689, #7690, #7700, #7707, #7711, #7713, #7714, #7735, #7767, #7783, #7785, #7821, #7826, #7857, #7870, #7937, #7942, #7952, #7964, #7969 — These removeChild crashes are common in React apps, likely caused by a browser extension or Google Translate. ↩︎

12. Netlify/Decap CMS #4961, #4979, #5545, #5778, #6279, #6464, #6810, #6922, #7118, #7293, #7630, #7712, #7727 — A comment on one of the issues says the crash was due to Google Translate. Sveltia CMS has turned off Google Translate on the admin page. ↩︎

13. Netlify/Decap CMS #5815, #6522, #6532, #6588, #6617, #6640, #6663, #6695, #6697, #6764, #6765, #6835, #6983, #7205, #7450, #7453, #7572, #7602, #7655, #7704, #7710, #7811, #7835, #7847, #7850, #7871, #7885, #7959, #7967, #7971, #7993, #8016 ↩︎

14. Netlify/Decap CMS #7360, #7462 ↩︎

15. Netlify/Decap CMS #7240, #7428 ↩︎

16. Netlify/Decap CMS #5867, #6159, #7016, #7306, #7554 ↩︎

17. Netlify/Decap CMS #7590, #7751 ↩︎

18. Netlify/Decap CMS #7594, #7635, #7822, #7852 ↩︎

19. Netlify/Decap CMS #7777, #7798, #7877, #7998 ↩︎

20. Netlify/Decap CMS #7801, #7883 ↩︎

21. Netlify/Decap CMS #7223, #7530, #7887, #7888, #8004, #8022 ↩︎

22. Netlify/Decap CMS #3413, #3916, #3969, #4660, #5390, #5811, #5905, #5923, #6098, #6471, #6480, #6528, #6543, #6576, #6589, #7269, #7897, #7996 ↩︎

23. Netlify/Decap CMS #86 ↩︎

24. Netlify/Decap CMS #3057, #3260 — We use Svelte though. ↩︎

25. Netlify/Decap CMS #3257 ↩︎

26. Netlify/Decap CMS #3258 ↩︎

27. Netlify/Decap CMS #3259 ↩︎

28. Netlify/Decap CMS #3261 ↩︎

29. Netlify/Decap CMS #3262 ↩︎

30. Netlify/Decap CMS #3296 ↩︎

31. Netlify/Decap CMS #292 — It cannot be found in the current version of Decap CMS. ↩︎

32. Netlify/Decap CMS #1045 ↩︎

33. Netlify/Decap CMS #3353 ↩︎

34. Netlify/Decap CMS #328, #1290 ↩︎

35. Netlify/Decap CMS #302, #5549 ↩︎

36. Netlify/Decap CMS #6034 ↩︎ ↩︎

37. Netlify/Decap CMS #4635, #5920, #6410, #6827, #6924 ↩︎ ↩︎

38. Netlify/Decap CMS #946, #1970 ↩︎

39. Netlify/Decap CMS #1984 ↩︎ ↩︎

40. Netlify/Decap CMS #2009, #2293, #3415, #3952, #6563 ↩︎

41. Netlify/Decap CMS #1891 ↩︎ ↩︎

42. Netlify/Decap CMS #213, #1032, #3244, #6730, #7459 ↩︎ ↩︎ ↩︎

43. Netlify/Decap CMS #4563 ↩︎ ↩︎

44. Netlify/Decap CMS #2822 ↩︎

45. Netlify/Decap CMS #5055, #5470, #6956, #6989 ↩︎

46. Netlify/Decap CMS #5419, #7107 ↩︎ ↩︎

47. Netlify/Decap CMS #1322, #6442 ↩︎ ↩︎

48. Netlify/Decap CMS #4532, #6513, #7295, #7567 ↩︎

49. Netlify/Decap CMS #542 ↩︎

50. Netlify/Decap CMS #6107 ↩︎ ↩︎

51. Netlify/Decap CMS #7579 ↩︎ ↩︎

52. Netlify/Decap CMS #7692, #7696 ↩︎ ↩︎

53. Netlify/Decap CMS #7875 ↩︎ ↩︎

54. Netlify/Decap CMS #7557 ↩︎

55. Netlify/Decap CMS #6879 ↩︎

56. Netlify/Decap CMS #2138, #2343, #4367, #5932 ↩︎ ↩︎

57. Netlify/Decap CMS #3284 ↩︎

58. Netlify/Decap CMS #1333, #4216 ↩︎

59. Netlify/Decap CMS #7077 ↩︎

60. Netlify/Decap CMS #6762 ↩︎

61. Netlify/Decap CMS #5701 ↩︎

62. Netlify/Decap CMS #3431 ↩︎

63. Netlify/Decap CMS #2673, #5315, #6499, #6544, #6551, #6679, #6773, #6883, #7363, #7365, #7878 — This problem occurs every time a new major version of React is released. ↩︎

64. Netlify/Decap CMS #5376, #7203, #7380 ↩︎

65. Netlify/Decap CMS #7375 ↩︎

66. Netlify/Decap CMS #7518 ↩︎

67. Netlify/Decap CMS #7616 ↩︎

68. Netlify/Decap CMS #332, #683, #999, #1456, #4175, #4818, #5688, #6828, #6829, #6862, #7023, #7680 ↩︎

69. Netlify/Decap CMS #6616 ↩︎

70. Netlify/Decap CMS #6965, #7445 ↩︎

71. Netlify/Decap CMS #283, #386 ↩︎

72. Netlify/Decap CMS #3457, #3624, #6713 ↩︎

73. Netlify/Decap CMS #6635, #7006, #7311 ↩︎

74. Netlify/Decap CMS #4987 ↩︎

75. Netlify/Decap CMS #5970 ↩︎

76. Netlify/Decap CMS #6527 ↩︎

77. Netlify/Decap CMS #6800 ↩︎

78. Netlify/Decap CMS #6794 ↩︎

79. Netlify/Decap CMS #3803 ↩︎

80. Netlify/Decap CMS #1074, #1693 — In Netlify/Decap CMS, a Relation field with a mistyped searchFields value only fails when an entry is opened, with a bare “sorry there was an error” page, and a folder collection without an identifier field only fails when an entry is saved. ↩︎ ↩︎

81. Netlify/Decap CMS #7322 ↩︎ ↩︎

82. Netlify/Decap CMS #4417 ↩︎

83. Netlify/Decap CMS #4564, #5617, #5815 ↩︎

84. Netlify/Decap CMS #7457 ↩︎

85. Netlify/Decap CMS #6831 ↩︎

86. Netlify/Decap CMS #8015 ↩︎ ↩︎

87. Netlify/Decap CMS #7257 ↩︎

88. Netlify/Decap CMS #663, #6729, #7466, #7545 ↩︎

89. Netlify/Decap CMS #7352, #7581, #7931 ↩︎

90. Netlify/Decap CMS #7611 ↩︎

91. Netlify/Decap CMS #3704 ↩︎

92. Netlify/Decap CMS #7172 ↩︎

93. Netlify/Decap CMS #8010 ↩︎

94. Netlify/Decap CMS #7627 ↩︎

95. Netlify/Decap CMS #7281 — The issue was closed, but the attached PR is not yet merged. ↩︎

96. Netlify/Decap CMS #4538, #6371 ↩︎

97. Netlify/Decap CMS #3286 ↩︎

98. Netlify/Decap CMS #7157 ↩︎

99. Netlify/Decap CMS #2827 ↩︎

100. Netlify/Decap CMS #5280 ↩︎

101. Netlify/Decap CMS #4386, #4888, #7332, #7514 ↩︎

102. Netlify/Decap CMS #6978 ↩︎

103. Netlify/Decap CMS #4416, #7400 ↩︎

104. Netlify/Decap CMS #4781 ↩︎

105. Netlify/Decap CMS #5493, #6600 ↩︎ ↩︎ ↩︎

106. Netlify/Decap CMS #4645 ↩︎

107. Netlify/Decap CMS #1685 ↩︎

108. Netlify/Decap CMS #5969 ↩︎ ↩︎

109. Netlify/Decap CMS #7612 ↩︎

110. Netlify/Decap CMS #2524 ↩︎

111. Netlify/Decap CMS #6932 ↩︎

112. Netlify/Decap CMS #7086 ↩︎

113. Netlify/Decap CMS #7142, #7276 ↩︎

114. Netlify/Decap CMS #1347, #1559, #4629, #4837, #6287, #6826 — Decap CMS 3.0 updated the Slate editor in an attempt to fix the problems, but the IME issues remain unresolved when using a mobile/tablet browser. ↩︎ ↩︎

115. Netlify/Decap CMS #4480, #5122, #6353 ↩︎

116. Netlify/Decap CMS #5112, #5653 ↩︎

117. Netlify/Decap CMS #6307 ↩︎

118. Netlify/Decap CMS #7371 ↩︎

119. Netlify/Decap CMS #7507 ↩︎

120. Netlify/Decap CMS #475, #5469 ↩︎

121. Netlify/Decap CMS #3542 ↩︎

122. Netlify/Decap CMS #1040 ↩︎

123. Netlify/Decap CMS #5317 ↩︎

124. Netlify/Decap CMS #6571, #7539 ↩︎

125. Netlify/Decap CMS #6203, #7417, #7451 ↩︎

126. Netlify/Decap CMS #3320 ↩︎

127. Netlify/Decap CMS #2734 ↩︎

128. Netlify/Decap CMS #1000 ↩︎

129. Netlify/Decap CMS #7328 ↩︎

130. Netlify/Decap CMS #7347 ↩︎

131. Netlify/Decap CMS #3750, #4735, #4783, #6801, #6806 ↩︎ ↩︎

132. Netlify/Decap CMS #6427 ↩︎

133. Netlify/Decap CMS #427, #535, #1284, #3846 ↩︎

134. Netlify/Decap CMS #7355 ↩︎

135. Netlify/Decap CMS #978 ↩︎

136. Netlify/Decap CMS #1152 ↩︎

137. Netlify/Decap CMS #7192 ↩︎

138. Netlify/Decap CMS #5726 ↩︎

139. Netlify/Decap CMS #526, #6987 ↩︎

140. Netlify/Decap CMS #7461 ↩︎

141. Netlify/Decap CMS #377 ↩︎

142. Netlify/Decap CMS #445 ↩︎

143. Netlify/Decap CMS #6970, #7147 ↩︎

144. Netlify/Decap CMS #4092 ↩︎

145. Netlify/Decap CMS #3715 ↩︎

146. Netlify/Decap CMS #7568 ↩︎

147. Netlify/Decap CMS #4637, #5198 ↩︎

148. Netlify/Decap CMS #5276, #7430 ↩︎

149. Netlify/Decap CMS #7381 ↩︎

150. Netlify/Decap CMS #1245, #2727, #4884, #6908 ↩︎

151. Netlify/Decap CMS #2491 ↩︎

152. Netlify/Decap CMS #1274 ↩︎

153. Netlify/Decap CMS #7486 ↩︎

154. Netlify/Decap CMS #7262 ↩︎

155. Netlify/Decap CMS #2289, #4518 ↩︎

156. Netlify/Decap CMS #4350 ↩︎

157. Netlify/Decap CMS #3796 ↩︎

158. Netlify/Decap CMS #1341 ↩︎

159. Netlify/Decap CMS #4255 ↩︎

160. Netlify/Decap CMS #7651 ↩︎

161. Netlify/Decap CMS #7606 ↩︎

162. Netlify/Decap CMS #4972 ↩︎

163. Netlify/Decap CMS #7094, #7534 ↩︎

164. Netlify/Decap CMS #4963 ↩︎

165. Netlify/Decap CMS #7752 ↩︎

166. Netlify/Decap CMS #4677, #6974, #7389 ↩︎ ↩︎

167. Netlify/Decap CMS #4753 ↩︎

168. Netlify/Decap CMS #7460 ↩︎

169. Netlify/Decap CMS #7267 ↩︎

170. Netlify/Decap CMS #7483 ↩︎

171. Netlify/Decap CMS #5630 ↩︎

172. Netlify/Decap CMS #5593, #6500 ↩︎

173. Netlify/Decap CMS #1654 ↩︎

174. Netlify/Decap CMS #4147 ↩︎

175. Netlify/Decap CMS #6202 ↩︎

176. Netlify/Decap CMS #7399 ↩︎

177. Netlify/Decap CMS #836, #3524 ↩︎

178. Netlify/Decap CMS #308, #7349 ↩︎

179. Netlify/Decap CMS #1948 ↩︎

180. Netlify/Decap CMS #7532 ↩︎

181. Netlify/Decap CMS #7011 ↩︎

182. Netlify/Decap CMS #7085, #7800 ↩︎

183. Netlify/Decap CMS #2368, #3454, #3585, #3651, #3885, #3962, #4037, #4143, #6585, #6664, #6665, #6739, #7243, #7379, #7469, #7694, #8003 ↩︎

184. Netlify/Decap CMS #7560, #7605, #7615, #7789, #7944, #7950 ↩︎

185. Netlify/Decap CMS #4284, #6395, #7795 ↩︎

186. Netlify/Decap CMS #1466 ↩︎

187. Netlify/Decap CMS #7279 ↩︎

188. Netlify/Decap CMS #2307 ↩︎ ↩︎

189. Netlify/Decap CMS #1609, #3557, #5253, #6760, #6901 — Looks like the fix for #215 was incomplete or regressed at some point. ↩︎

190. Netlify/Decap CMS #1449, #1988, #5552 ↩︎

191. Netlify/Decap CMS #1424 ↩︎ ↩︎

192. Netlify/Decap CMS #4726 ↩︎ ↩︎

193. Netlify/Decap CMS #2613 ↩︎ ↩︎

194. Netlify/Decap CMS #2007, #2848 ↩︎ ↩︎

195. Netlify/Decap CMS #995, #2017, #7120, #7186 ↩︎

196. Netlify/Decap CMS #1382, #6994 ↩︎

197. Netlify/Decap CMS #1481, #7398 ↩︎

198. Netlify/Decap CMS #4762 ↩︎

199. Netlify/Decap CMS #5640, #6444 ↩︎

200. Netlify/Decap CMS #3583 ↩︎

201. Netlify/Decap CMS #5870 ↩︎

202. Netlify/Decap CMS #3505, #4211, #5439 ↩︎

203. Netlify/Decap CMS #4945 ↩︎

204. Netlify/Decap CMS #7442 ↩︎

205. Netlify/Decap CMS #6254 ↩︎

206. Netlify/Decap CMS #4353, #7513, #7544, #7654 ↩︎

207. Netlify/Decap CMS #7092 ↩︎

208. Netlify/Decap CMS #7473 ↩︎

209. Netlify/Decap CMS #725 ↩︎

210. Netlify/Decap CMS #7319 ↩︎

211. Netlify/Decap CMS #6609, #6802, #6824, #6832, #6848, #6851, #7287, #7522 ↩︎

212. Netlify/Decap CMS #7206, #7577, #7619, #7691 ↩︎

213. Netlify/Decap CMS #7939 ↩︎

214. Netlify/Decap CMS #1270, #7425 ↩︎

215. Netlify/Decap CMS #1975, #3712 ↩︎ ↩︎

216. Netlify/Decap CMS #1235, #1483 ↩︎

217. Netlify/Decap CMS #2294, #3046, #4363, #4520, #5806 ↩︎

218. Netlify/Decap CMS #531, #621, #1282, #1877, #2514, #2737 ↩︎

219. Netlify/Decap CMS #4733 ↩︎

220. Netlify/Decap CMS #1244 ↩︎

221. Netlify/Decap CMS #756 — The Expand All and Collapse All buttons cannot be found in the current version of Decap CMS. ↩︎

222. Netlify/Decap CMS #4387, #5381 ↩︎

223. Netlify/Decap CMS #2380 ↩︎

224. Netlify/Decap CMS #3018 ↩︎

225. Netlify/Decap CMS #4646, #7167 ↩︎

226. Netlify/Decap CMS #2153 ↩︎

227. Netlify/Decap CMS #7973 ↩︎

228. Netlify/Decap CMS #1275 ↩︎

229. Netlify/Decap CMS #4702 ↩︎

230. Netlify/Decap CMS #6629 ↩︎

231. Netlify/Decap CMS #6905 — We use Lexical created by Facebook (Meta). ↩︎

232. Netlify/Decap CMS #6999, #7000, #7001, #7152, #7220, #7283, #7316, #7465, #7990 ↩︎

233. Netlify/Decap CMS #7047 ↩︎

234. Netlify/Decap CMS #6993, #7123, #7127, #7128, #7237, #7251, #7361, #7391, #7393, #7470, #7475, #7480, #7503, #7504, #7524, #7531, #7535, #7553, #7561, #7584, #7591, #7609, #7628, #7677, #7699, #7738, #7740, #7812, #7818, #7831, #7832, #7904, #7930, #8001 ↩︎

235. Netlify/Decap CMS #7190, #7218, #7392 ↩︎

236. Netlify/Decap CMS #7429, #7500, #7552 ↩︎

237. Netlify/Decap CMS #991, #4488, #7233, #7802 ↩︎

238. Netlify/Decap CMS #3437 ↩︎

239. Netlify/Decap CMS #7364 ↩︎

240. Netlify/Decap CMS #6180 ↩︎

241. Netlify/Decap CMS #512, #5673, #6707, #7501 ↩︎

242. Netlify/Decap CMS #6482 ↩︎

243. Netlify/Decap CMS #5125 ↩︎

244. Netlify/Decap CMS #105, #245 ↩︎

245. Netlify/Decap CMS #909, #4611, #6497 ↩︎

246. Netlify/Decap CMS #7458, #7956 ↩︎

247. Netlify/Decap CMS #7638 ↩︎

248. Netlify/Decap CMS #3291 ↩︎

249. Netlify/Decap CMS #7640 ↩︎

250. Netlify/Decap CMS #1004 ↩︎

251. Netlify/Decap CMS #3531 ↩︎

252. Netlify/Decap CMS #4754 ↩︎

253. Netlify/Decap CMS #7585, #7790, #7836, #7843, #7868, #7869, #7884, #7889, #7957, #7986 ↩︎

254. Netlify/Decap CMS #7705 ↩︎

255. Netlify/Decap CMS #7143 ↩︎

256. Netlify/Decap CMS #7431 ↩︎

257. Netlify/Decap CMS #7575 ↩︎

258. Netlify/Decap CMS #7576, #7587 ↩︎

259. Netlify/Decap CMS #7660, #7940 ↩︎

260. Netlify/Decap CMS #565, #6733 ↩︎

261. Netlify/Decap CMS #7031, #7540, #7597 ↩︎

262. Netlify/Decap CMS #1267 ↩︎

263. Netlify/Decap CMS #2103, #2790, #7302, #7748 ↩︎

264. Netlify/Decap CMS #4738, #7770 ↩︎

265. Netlify/Decap CMS #7546 ↩︎

266. Netlify/Decap CMS #4954 ↩︎

267. Netlify/Decap CMS #5487 ↩︎

268. Netlify/Decap CMS #4841 ↩︎

269. Netlify/Decap CMS #3821, #4369 ↩︎

270. Netlify/Decap CMS #3421 ↩︎

271. Netlify/Decap CMS #2405, #3816 ↩︎

272. Netlify/Decap CMS #8005 ↩︎

273. Netlify/Decap CMS #717, #5750, #6895 ↩︎

274. Netlify/Decap CMS #7794 ↩︎

275. Netlify/Decap CMS #6515 ↩︎

276. Netlify/Decap CMS #2677, #6836 ↩︎

277. Netlify/Decap CMS #2243, #4965 — Rather than relying on a third-party library, we built our own asset browser that integrates more seamlessly with the rest of the CMS. ↩︎

278. Netlify/Decap CMS #5910 ↩︎

279. Netlify/Decap CMS #2579 ↩︎ ↩︎

280. Netlify/Decap CMS #1345, #7955 ↩︎

281. Netlify/Decap CMS #5467, #6505 ↩︎

282. Netlify/Decap CMS #5444 ↩︎

283. Netlify/Decap CMS #3723, #6990 ↩︎

284. Netlify/Decap CMS #7662, #7772 ↩︎

285. Netlify/Decap CMS #7639 ↩︎

286. Netlify/Decap CMS #6325 ↩︎

287. Netlify/Decap CMS #6508 ↩︎

288. Netlify/Decap CMS #1489, #5838 ↩︎

289. Netlify/Decap CMS #450, #2122, #6819 ↩︎

290. Netlify/Decap CMS #961, #5489 ↩︎

291. Netlify/Decap CMS #962 ↩︎

292. Netlify/Decap CMS #3240 ↩︎

293. Netlify/Decap CMS #2113, #3240 ↩︎

294. Netlify/Decap CMS #4209 ↩︎

295. Netlify/Decap CMS #5569, #6754 ↩︎

296. Netlify/Decap CMS #5901 ↩︎

297. Netlify/Decap CMS #4288 ↩︎

298. Netlify/Decap CMS #857 ↩︎

299. Netlify/Decap CMS #2001 ↩︎

300. Netlify/Decap CMS #5812 ↩︎

301. Netlify/Decap CMS #1934 ↩︎

302. Netlify/Decap CMS #1794, #2966 ↩︎

303. Netlify/Decap CMS #6243 ↩︎

304. Netlify/Decap CMS #2035, #7362, #7543 ↩︎

305. Netlify/Decap CMS #7124 ↩︎

306. Netlify/Decap CMS #3615, #4069, #5097, #6642 ↩︎

307. Netlify/Decap CMS #4208 ↩︎

308. Netlify/Decap CMS #2370, #5596 ↩︎

309. Netlify/Decap CMS #3285, #7030, #7067, #7217 ↩︎

310. Netlify/Decap CMS #6731 ↩︎

311. Netlify/Decap CMS #5472 ↩︎

312. Netlify/Decap CMS #5752 ↩︎

313. Netlify/Decap CMS #3468 ↩︎

314. Netlify/Decap CMS #3362 ↩︎

315. Netlify/Decap CMS #4675 ↩︎

316. Netlify/Decap CMS #5650, #6610, #7741 ↩︎

317. Netlify/Decap CMS #3710 ↩︎ ↩︎

318. Netlify/Decap CMS #389, #464 ↩︎

319. Netlify/Decap CMS #7025, #7477 ↩︎

320. Netlify/Decap CMS #4777 ↩︎

321. Netlify/Decap CMS #7963 ↩︎

322. Netlify/Decap CMS #1571, 3656 ↩︎

323. Netlify/Decap CMS #3332, #3372 ↩︎

324. Netlify/Decap CMS #5161 ↩︎

325. Netlify/Decap CMS #5107 ↩︎

326. Netlify/Decap CMS #5310 ↩︎

327. Netlify/Decap CMS #4803 — the polling window has since been widened from 3 attempts to about two minutes, but still expires while slower builds are running. ↩︎

328. Netlify/Decap CMS #4877 ↩︎

329. Netlify/Decap CMS #5548 ↩︎

330. Netlify/Decap CMS #2133 ↩︎

331. Netlify/Decap CMS #713 ↩︎

332. Netlify/Decap CMS #5065 — The issue was closed, but it’s still not working as expected in Decap CMS. ↩︎

333. Netlify/Decap CMS #1390, #4912, #6986 ↩︎

334. Netlify/Decap CMS #3490, #3682, #4669, #4895, #4976, #5766, #6501, #6785, #7315 ↩︎

335. Netlify/Decap CMS #4892 — We cannot reproduce the crash, but we do see the error message in the console. ↩︎

336. Netlify/Decap CMS #1464 ↩︎

337. Netlify/Decap CMS #6797 ↩︎

338. Netlify/Decap CMS #6775 ↩︎

339. Netlify/Decap CMS #3719 ↩︎

340. Netlify/Decap CMS #5082 — The onPersistMedia prop remains undocumented. ↩︎

341. Netlify/Decap CMS #3927 — The onOpenMediaLibrary prop remains undocumented. ↩︎

342. Netlify/Decap CMS #13 — The issue appears to have been closed without a fix being available. ↩︎

343. Netlify/Decap CMS #7197 ↩︎

344. Netlify/Decap CMS #4568 ↩︎

345. Netlify/Decap CMS #6816 ↩︎

346. Netlify/Decap CMS #1769 ↩︎

347. Netlify/Decap CMS #3856 ↩︎

348. Netlify/Decap CMS #3562, #6215, #6605, #6355, #7479 ↩︎

349. Netlify/Decap CMS #6215 ↩︎

350. Netlify/Decap CMS #3764 ↩︎

351. Netlify/Decap CMS #7736 ↩︎

352. Netlify/Decap CMS #365 ↩︎

353. Netlify/Decap CMS #3671 ↩︎

354. Netlify/Decap CMS #6062 ↩︎

355. Netlify/Decap CMS #7753 ↩︎

356. Netlify/Decap CMS #7867 ↩︎