Skip to content

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.

Although Netlify CMS was later rebranded as Decap CMS, it remains neglected by the new team for years. Sveltia CMS has now superseded both Netlify CMS and Decap CMS, offering a significantly improved experience, security and reliability.

Migration from the predecessor is straightforward, and we provide a guide to help users make the transition. 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!

875 Netlify/Decap CMS issues solved in Sveltia CMS (including duplicates)

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.

Short Version

For a side-by-side summary, see Sveltia CMS vs. Decap CMS.

This document was originally the README for our GitHub repository. It’s our progress tracker. It’s excessively long. It’s written in a critical tone. Still, the project state comparison is worth reading.

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 400 Netlify/Decap CMS issues (875 including duplicates)
  • Significant UX/DX improvements with more enhancements planned
  • Much more stable, performant, secure, accessible, powerful and reliable
  • npm package downloaded more often than Decap CMS
  • 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.

Competition is not a motivator

We created Sveltia CMS before Decap CMS and didn’t intend for them to compete with each other. Our mission is to succeed the abandoned Netlify CMS, whether or not Decap CMS exists. After several years of development, the two products are worlds apart, with Sveltia CMS continuing to evolve while Decap CMS struggles. The other product has never been our real competitor because it has always lagged behind us, and the gap just keeps growing.

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, 400+ issues, or 875+ if including duplicates, have been effectively solved in Sveltia CMS — Yes, you read it right
  • Target: 450 issues, or 1,000 if including duplicates 💪
    • or every single issue that’s relevant, fixable and worth dealing with 🔥
  • Issues include everything:
  • 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? ​

Following its abandonment in early 2022, Netlify CMS spawned three successors. One of them is Sveltia CMS, along with Static CMS and Decap CMS. Here’s a straightforward 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
  • Maintenance
    • ❌ Maintained by a company that lacks the necessary resources and capabilities — effectively less than a single developer
    • ❌ Driven by a generic mission statement rather than a clear vision
    • ❌ 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 roadmap had been published for a long time; the current roadmap only mentions premium features, no plans for the core CMS platform
  • Technology
    • ❌ A bloated, legacy React application that carries over all the technical debt and bugs of Netlify CMS
    • ❌ A fragmented architecture that is “beyond saving” according to Sitepins developers
    • ❌ Complex codebase comprising nearly 50 packages, most of which are useless as standalone modules, with some being undocumented
    • ❌ Dependency hell: nearly 500 packages installed via npm
    • ❌ Bad performance due to slow Git Gateway, inefficient REST APIs and React
    • ❌ Local workflow requires a proxy server and additional configuration
    • ❌ Obsolete, incomplete TypeScript type definitions and JSON schema
  • Features
    • ❌ Modest progress since the Netlify CMS takeover, with far fewer new features and enhancements than with Sveltia CMS
    • ❌ Many bugs remain unresolved
    • ❌ Most of the feature requests from the Netlify CMS years remain unfulfilled
    • ❌ Some features graduated from beta despite having outstanding issues
    • ❌ Deprecation mismanagement: the Date widget removal was not announced; the Markdown widget has been deprecated, but the newer Richtext widget is still in beta
    • ❌ Old-fashioned UX with no dark mode, no keyboard shortcuts, basic responsive design and longstanding accessibility issues
    • ❌ Basic i18n support with critical limitations and bugs
    • ❌ Various undocumented features and options from the Netlify CMS years
  • Development
    • ❌ It took six months to ship the first release (v3.0) under the new name
    • ❌ Mostly low activity with only occasional releases — the interval between releases can be as long as 1.5 or even 2 months
    • ❌ Pull requests, including those from maintainers, sit idle for months or years
    • ❌ Poor technical practices, e.g. sending and approving a single PR containing multiple unrelated changes; unsigned GitHub commits
    • ❌ Careless pull request reviews, e.g. #7374: the option name is confusing and uses camel case; #7999: the option should have been added to the global slug option
    • ❌ AI is only used in a limited way, mostly for premium Decap Turbo features; the rest is legacy, handwritten, unoptimized code
  • Support
    • ❌ Seemingly random issues were closed as stale following the takeover
    • ❌ Bug reports continue to pile up, often without any response
    • ❌ Regressions are sometimes ignored even when they’re reported by multiple users
    • ❌ Endless fatal crash reports are being dismissed without any solution or closed as completed without any comment
    • ❌ No effective issue triage practice in place, with fixed issues sometimes left open and duplicates often left unmarked
    • ❌ Maintainers are generally unresponsive and sometimes disappearing for weeks, leaving users with no support
  • Security
    • ❌ Security is a low priority; a proven poor track record of addressing vulnerabilities in a professional, timely and responsible manner
    • ❌ It can take months to resolve even the most critical issue
    • ❌ Dependencies have 30+ known vulnerabilities
  • Documentation
    • ❌ Thin, disorganized and sometimes obsolete documentation
    • ❌ Provides no Netlify CMS migration guide
    • ❌ New features, options and breaking changes are often undocumented
    • ❌ No dark mode
  • Community
    • ❌ Netlify CMS community evaporated, with no past contributors coming back
    • ❌ A quiet, inactive community with little support and engagement
    • ❌ The Examples page only lists outdated templates and demos, not real-world users
    • ❌ No testimonials are available, leaving users without social proof
    • ❌ A few sponsors; there are more admins than backers on Open Collective

Sveltia CMS ​

  • Not a fork but a complete modern rewrite
  • Started in November 2022, first appeared on GitHub in March 2023
  • Maintenance
    • ✅ Created and devotedly maintained by an experienced UX engineer
    • ✅ Driven by clear goals to build a viable Netlify CMS successor
    • ✅ Focused on the core platform, free from monetization distractions
    • ✅ A public roadmap has been maintained to keep users informed
  • Technology
    • ✅ A lightweight Svelte application built from scratch with no technical debt
    • ✅ A new, efficient architecture that enables faster, focused development
    • ✅ Lean codebase with a single package
    • ✅ No dependency hell: less than 50 packages installed via npm
    • ✅ Good performance thanks to GraphQL APIs, caching, Svelte and various optimizations
    • ✅ Local workflow requires no proxy server or additional configuration
    • ✅ Up-to-date, complete TypeScript type definitions and JSON schema
    • ✅ Utilizes various modern web APIs to provide an optimal user experience
  • Features
    • ✅ Implemented from a clean slate to avoid carrying over bugs from Netlify CMS
    • ✅ Keeps evolving with numerous improvements
    • ✅ All features and options are documented
    • ✅ Most of the feature requests from the Netlify CMS years have either been implemented or are currently being tracked
    • ✅ Modern UX with dark mode, keyboard shortcuts, mobile optimization, PWA and accessibility enhancements
    • ✅ First-class i18n support for easier multilingual content management
  • Development
    • ✅ Actively developed with frequent releases, usually several times a week or even multiple times a day
    • ✅ Completely switched to an AI workflow to accelerate development and optimized the original handwritten code
    • ✅ Constant bug hunting, refactoring, and performance tuning ensure stability, reliability, and responsiveness
  • Support
    • ✅ Relevant issues are being resolved regardless of their age
    • ✅ Issues closed as stale by a Decap CMS maintainer are also being addressed
    • ✅ Most bug reports are addressed promptly, usually within 8 hours
    • ✅ Any regressions are fixed swiftly once reported
    • ✅ No known crashes, with a swift response to any that may arise
    • ✅ Effective issue triage practice in place, with fixed issues closed and duplicates marked
    • ✅ The maintainer is very responsive and available to provide support
  • Security
    • ✅ Security is our top priority, and we follow the best practices
    • ✅ Reported vulnerabilities are usually fixed within a few hours, regardless of severity
    • ✅ No known unpatched security vulnerabilities, with dependencies kept up-to-date
  • Documentation
    • ✅ Comprehensive, well-structured and well-maintained documentation
    • ✅ Provides Netlify CMS migration guide
    • ✅ Keeps the documentation up-to-date with the latest features and improvements
    • ✅ Yes dark mode
  • Community
    • ✅ Attracting many users, including former Netlify CMS users, even during the beta period
    • ✅ A positive, growing community that provides helpful support and engagement
    • ✅ The largest showcase in the Git-based CMS market, featuring hundreds of real-world sites from various industries
    • ✅ Provides developer testimonials for validation
    • ✅ Supported by more sponsors than Decap CMS

Official vs. De Facto Successor ​

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.

Similar Story

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, a better user experience, improved performance, enhanced security and comprehensive documentation. 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
  • We acknowledge Netlify CMS and provide a migration guide

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

The official successor, Decap CMS, makes no mention of Netlify CMS on its About page. Their landing page has never claimed that “Netlify CMS is now Decap CMS.” They don’t even provide a migration guide for Netlify CMS users. A genuine successor wouldn’t do that.

Adoption ​

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

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

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 8 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]
  • Being 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 core bundle size is less than 800 KB when minified and gzipped, which is much lighter than Netlify CMS (1.5 MB), Decap CMS (1.4 MB) and Static CMS (2 MB).[34] This 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]
  • We use AI assistants to constantly analyze the codebase, find performance bottlenecks, optimize critical paths and reduce redundancy. These efforts help us keep our app fast, responsive and lightweight.

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. With the prompt_commit_messages option enabled, the history lists each commit with its message, not just its author and date.
    • 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]
    • The dialog that asks whether to restore a backup doesn’t hide the entry. Users can move the dialog out of the way and scroll through the entry as it is now before deciding whether to restore the backup or discard it. In Netlify/Decap CMS, the confirmation is modal, so the content behind it can’t be checked first.
    • 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 with missing entries.[48]
  • Some keyboard shortcuts are available for faster editing.

Better Security ​

  • Swift response: We prioritize security fixes and aim to address vulnerabilities within 8 hours of their discovery.
    • In fact, we implemented and shipped fixes for the vulnerabilities reported in the past within a few hours of them being reported, even though there were 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 disclosed in September 2025 is still listed as affecting every version up to 3.8.3, with no patched version. It may have been fixed at some point, but there has been no announcement of a fix.
      • 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 has been published for it. 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.
        • Later, Decap CMS issue #8037 revealed details of the mishandling: the critical vulnerability had originally been reported in April 2026, and it had taken the maintainers four months to fix it. They also assigned the CVE credit to a second reporter, which angered the original reporter, but the maintainer offered no apology. The changelog made no mention of the vulnerability.
      • Even when advisories are published, they come late. The insecure sanitize_preview default was fixed in Decap CMS 3.13.0 on June 1, 2026, but its advisory wasn’t published until October 26, nearly five months later.
  • 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.[49][50]
      • New vulnerabilities in dependencies, even critical ones, are not patched promptly, leaving users vulnerable to potential exploits.[51]
      • In October 2026, Decap CMS added overrides to force patched versions of some vulnerable packages. However, overrides only apply inside Decap CMS’s own repository. Sites that install Decap CMS from npm still get the vulnerable versions, so the change does nothing for users.
  • AI-assisted coding: Claude and GPT assistants are used to ensure secure coding practices and identify potential vulnerabilities during development.
  • The XSS vulnerability in Decap CMS, whose advisory names no patched version, does not affect Sveltia CMS, as our entry preview implementation is completely different.
  • In Sveltia CMS, the Markdown/RichText field’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. Decap CMS’s own advisory rates this insecure default as high severity: GHSA-38w6-4fqr-x68q.
  • Our local development workflow does not require a proxy server. This reduces attack surfaces by eliminating the possibility of compromised dependencies[52], unauthorized API access[53] or incomplete path validations[54][55] in the proxy server. Decap CMS has published security advisories for two critical vulnerabilities in decap-server: GHSA-5rrq-v82w-qpfr and GHSA-g884-37w2-8475.
  • 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.[56]
  • Newer releases are immutable and cannot be modified after publishing. This ensures that users can trust the integrity of the software they install.
  • We have enabled trusted publishing and 2FA for package publishing.
  • We have created a security policy.
  • We announce security updates through GitHub, Discord and Bluesky.
  • The maintainer has a GPG key on GitHub, so the commits are signed with a verified signature.
  • 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.[57]
  • The unsafe-eval and unsafe-inline keywords are not needed in the script-src CSP directive.[58]
  • 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.[59]

Better Accessibility ​

  • We have conducted an automated WCAG 2.2 self-audit. We’ll continue to test and improve the application for accessibility.
  • We have published an accessibility statement.
  • Improved keyboard handling lets users efficiently navigate through UI elements using the Tab, Space, Enter and arrow keys.[60][61]
  • 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.[62] 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.[63]
  • 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.[64]

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.[65]
    • No peer dependency conflicts mainly due to legacy third-party React UI libraries.[66] 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.[67][68][69]
  • Sveltia CMS installs fewer than 50 packages via npm. In contrast, Netlify/Decap CMS is mired in dependency hell and requires the installation of nearly 500 packages.
  • 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.[70]
    • 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.[71] 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.[72]
  • 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.[73] A TOML configuration file is also supported.
  • Also supports multiple configuration files to allow developers to modularize the configuration.[74]
  • We provide an up-to-date JSON schema for YAML/JSON configuration files, which enables autocomplete and validation in VS Code and other editors.[75]
  • Improved TypeScript support:
  • Config validation enhancements:
    • The configuration is validated at runtime every time the CMS loads, against the same JSON schema your editor uses. This catches 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. Under a policy without unsafe-eval, Decap CMS therefore throws an EvalError while loading even a perfectly valid configuration, and the admin page doesn’t come up.[58:1]
    • Sveltia CMS has many additional validation rules that a schema can’t express. They catch the misconfigurations that Netlify/Decap CMS either reports with a cryptic message or, worse, doesn’t report at all. Those leave you with an empty collection, a random slug or a validation rule that never runs.[82][83]
    • 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 field names, rather than indexes such as collections[7].fields[9].types[1]. This helps to quickly identify the problematic configuration.[83:1]
    • There are no false error messages saying should match case "color" schema.
    • There are no error messages that advise using 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.[84][85] If a branch name is specified, it works as expected.[86]
  • 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.[87]
  • 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, anything that would be committed to it directly is read-only for them on GitHub, GitLab and Gitea/Forgejo, rather than failing when they save. This covers collections using the Simple Workflow and the Asset Library. Netlify/Decap CMS offers these actions and leaves the Git service to refuse them.[88]
  • Authentication improvements:
    • We provide our own OAuth client for GitHub.
    • Our OAuth client works with a GitHub App, so users only grant access to the repositories the app is installed on. Netlify/Decap CMS requires an OAuth app, whose repo scope covers every repository the user can access, including private ones.[89]
    • The external OAuth window will not get stuck on a blank page after signing in.[90]
    • Users can sign in directly with a Git-based backend using a personal access token (PAT) instead of going through the regular OAuth flow.[91]
    • The OAuth access token is automatically renewed when using PKCE authorization or our OAuth client with a GitHub App.[92]
  • GitLab-specific improvements:
    • Implements the GraphQL API with proper authorization.[93]
    • Comes with background service status checking, just like GitHub.
    • Supports Git LFS (documentation).[94]
    • Users won’t get a 404 Not Found error when signing in to the GitLab backend.[95]
    • 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. It lets in a Reporter of a group invited as Maintainer. And it refuses a Developer of an invited group when the default branch isn’t protected.[96]
    • 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.[97] Our workaround was removed after GitLab 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.[98]
  • 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.[99] 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.[100]
  • 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 changes are not discarded when the browser tab is closed or reloaded.[101] You can also seed the virtual file system with sample entries and assets listed in a manifest file — a documented way to set up a demo site. Netlify/Decap CMS populates the Test backend of its own demo with the undocumented window.repoFiles global variable.
  • Commit message template supports the {{author-email}} template tag to include the author’s email address.
  • The prompt_commit_messages option asks users for a commit message every time they save,[102] or for a note such as an issue number to add before or after the generated message.[103]
  • API error messages are displayed in a user-friendly manner instead of generic messages like Failed to fetch.[104]
  • The include_credentials option is available for self-hosted backends that require authentication via cookies.
  • The root_dir option supports monorepos. The CMS treats a site’s directory as the root of the repository, so the paths in the configuration are relative to it with every backend, including the local workflow. The files of other sites are left out. Netlify/Decap CMS resolves the paths against the repository root with a Git backend but against the proxy server’s directory with the local backend, so the same configuration can’t work with both.[105] The CMS of each site also sees the whole repository.[106] In Sveltia CMS, each site also gets Editorial Workflow branches of its own, and the deploy preview of the right site is linked.[107]

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. He 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.[108] 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 fields support the i18n: duplicate field configuration so that changes made with these fields are duplicated between locales.[109][110] 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 you to have locale folders below the project root: /<locale>/<folder>/<path>.<extension>.[111]
      • An entry collection can put the {{locale}} placeholder in the folder option, e.g. content/{{locale}}/posts, to say where the locale folder goes. The fixed structures can’t always express this. It supports Hugo’s translation by content directory, where each language has a contentDir like content/en. The locale folders then sit between the content folder and the section folders, and the section’s _index.md lands in the right place too. (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 you 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.[112]
    • Entry slug enhancements:
    • 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.
    • A field’s label, hint and default value can be localized for each locale with the new label_localized, hint_localized, label_singular_localized and default_localized options. (Discussion)
    • The new i18n: duplicate_if_empty field option copies the default locale’s value to the other locales only where the field is empty. The field can still be edited in every locale. It’s handy for a value that is usually the same in every locale but sometimes needs a localized version, such as a banner image with text that hasn’t been localized yet. (Discussion)
    • The new i18n: sync field option keeps a field’s value the same in every locale, like duplicate, while letting it be edited in any locale. A change made in one locale is copied to the others. (Discussion)
    • It’s possible to embed the locale code in an entry by using widget: hidden along with default: '{{locale}}'.[116]
    • 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.[117]
    • Locale folders and suffixes are read from their position in the path, so a slug, folder or file name that happens to contain the same text can’t throw them off. A new entry stays inside the collection folder, the translations of an entry aren’t split into separate entries, and a path like {{slug}}/index doesn’t collapse the collection into one entry. A folder with special characters, like src/routes/(app)/blog, is listed too.[118]
    • 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 fewer 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.[119]
    • It’s possible to disable non-default locale content.[120]
    • 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 fields to avoid confusion.[121]
    • Relation fields with i18n enabled won’t trigger a change in the content draft status when a user starts editing an existing entry.[122]
    • Solves problems with Chinese, Japanese and Korean (CJK) IME text input in the rich text editor for the Markdown field.[123]
    • 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.[124]
    • Fields in non-default locales are validated as expected.[125]
    • No internal error is thrown when changing the locale.[126]
    • Duplicating an entry duplicates all locale content, not just the default locale.[127]
    • Copying Markdown from another locale using the menu works as expected.[128]
    • 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.[129]
    • table_columns: Chooses the columns of the table view, the default view of the entry list, which shows the values of several fields in sortable columns.[130] The Static CMS summary_fields option is also supported as an alias.
    • bulk_edit: Enables bulk editing of entries, which lets users change the simple fields of many entries at once in a table and save them in a single commit.[131]
    • 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.[132]
    • icon: Choose a custom icon for each collection.[133]
      • 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 purposes, 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.[134] Sveltia CMS doesn’t have hardcoded inference fields.[135]
    • limit: Specify the maximum number of entries that can be created in a folder collection.[136]
    • readonly: Make content read-only globally, or for a collection, a file or an asset collection, e.g. while the site is under maintenance.[137] It can also stop editors from changing existing entries.[138]
    • 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.[139]
    • value accepts null to match an undefined field value.
    • value accepts an array to provide multiple possible values.[140]
    • pattern can be used instead of value to provide a regular expression, just like the view_filters collection option.[141]
  • Enhancements to string transformations:
    • Transformations can be used in more places than just the collection summary:
      • The slug, path and preview_path collection options[142]
      • The summary field option for the List and Object fields
    • The slugify and plainify transformations have 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 timezone 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.[143]
    • Multiple transformations can be chained like {{title | upper | truncate(20)}}.
    • Custom transformations can be registered with the CMS.registerStringTransformation() method.[144]
  • Enhancements to template tags:
    • Spaces inside the curly braces and around the pipe character are optional in every template tag of the configuration, e.g. {{ slug }} or {{ title|upper }}. Decap CMS only partially solved the issue: it allows spaces inside the curly braces of the templates that support transformations, but still requires exactly one space on either side of a pipe, and doesn’t recognize a tag with spaces elsewhere, like {{ now }} as the default value of a DateTime field or {{ slug }} in a commit message template.[145]
    • A template tag can be escaped with a backslash, e.g. \{{ title | slugify }}, to output it as is, so the Hidden field can store a template for a static site generator. (Discussion)
  • Enhancements to file collections:
    • Sveltia CMS supports singletons, a simple form of a file collection.[146]
    • File collections support files without extensions.[147] 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.[148]
    • 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.[149] 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}}.[150]
  • Markdown is supported in the description collection option.[151] 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.[152] Defaults to undefined, in which case a slug is limited to 200 bytes like Decap CMS.
    • 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.[153]
    • 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.[154]
    • 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. With it, you can control whether the slug is editable when an entry is created and once it’s saved, have users type the slug themselves, and 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.
    • Permalinks: The new permalink_field collection option stores the path filled from preview_path in a front matter property, such as Eleventy’s permalink or Hugo’s url, each time an entry is saved. The site is then built at the path the CMS links to, using the CMS’s own slug. Netlify/Decap CMS has no such option.
  • Entry slugs are localizable.[113:1]
  • 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.[155]
  • If a collection only has the Markdown body field, an entry slug will be generated from a header in the body, if it exists. This supports a typical VitePress setup.
  • Entry slug template tags support transformations just like summary string template tags.[142: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.[156]
  • Setting the collection path doesn’t affect the entry slugs stored with the Relation field.[157]

Entry Listing ​

  • The default sort field and direction can be specified.[158]
  • The default filter and group can also be specified in the same way as with Static CMS.[159]
  • 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.[160]
  • Entry grouping and sorting can work together. For example, it’s possible to group by year and then sort by year if configured properly.[161]
  • The new collapsed view group option starts the groups collapsed, which keeps the entry list short when there are many groups. Netlify/Decap CMS has no such option. (Discussion)
  • 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.
  • The files in a file collection can have a summary option of their own, so the file list can show something about their content, such as the enabled locales with {{locales}}, instead of just the label. (Discussion)
  • Index file inclusion allows users to edit Hugo’s special _index.md file, including localized ones like _index.en.md, within a folder collection.[162] 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.[163]
    • 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)
    • The index file can have a summary option of its own, filled in with its own fields, so it can be listed with something other than its label. (Discussion)
  • A console error won’t be thrown when a collection doesn’t have the title field.[164] In that case, an entry summary will be generated from a header in the Markdown body field, if it exists, or from the entry slug, so the summary will never be empty.[165] This supports a typical VitePress and Docusaurus setup.[166]
  • 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.[167]
  • A single file can be used for more than one item in a file collection.[168]

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, is parsed as Markdown. HTML character references (entities) are also parsed properly.[169]
  • 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.[170]
  • Thumbnails of entries are displayed not only in the grid view but also in the table and list views, making it easier to navigate.
  • If entries don’t have an Image field for thumbnails, the grid view is not offered, because it doesn’t make sense to show it.[171]
  • 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.[172]
  • 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 Entries ​

  • A folder in the collection tree is labeled with its own index file instead of the title of whichever entry happens to come first.[173] 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 filename only applies in the default subfolders mode, where a folder is an entry.[174] 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 a title field no longer saves every entry as untitled.[175]
  • 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 you can add a page to the folder being browsed without overwriting that folder’s own entry. Leaving the folder blank files the entry where the collection’s path option puts it.[176] An entry’s own folder is left out of its picker, so it can’t be filed within itself. 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 filename dropped, so docs/intro/_index.md is previewed at docs/intro,[177] which is also what a Relation field stores. Netlify/Decap CMS puts the raw file path in both, leaking the index filename 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.[178] 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 entries. The whole collection is listed with the multiple_folders structure rather than part of it, and the sidebar folder tree filters entries instead of coming out broken. An entry missing one locale’s file saves normally rather than producing an empty commit.[179]
  • Localized entry slugs work with nested entries too, so the folder names — and with them the permalinks — are translated all the way down. For example, an English page stored at about/history/_index.md can have its French version at a-propos/histoire/_index.md. You choose the parent folder once, in the default locale. Each locale’s file is then filed below that folder’s own localized name, taken from the folder’s entry. The slug editor renames the folder per locale, and moving a page takes its subtree along in every locale. 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,[113:2] and nested entries and i18n don’t work together in the first place.[179: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.[180] 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.[181]
  • An entry’s slug is its full path below the collection folder, so a subfolder named like that folder stays part of it. For example, posts/old-posts/hello.md opens and saves as itself rather than as posts/hello.md. Netlify/Decap CMS drops everything before the last match, so the entry can’t be edited and saving writes to the wrong file.[182]
  • Folder names keep their case. Saving an entry in pages/Guides reloads it from there, whereas Netlify/Decap CMS lowercases the path and tries to load pages/guides, which doesn’t exist on a case-sensitive Git host.[183]

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.[184]
  • 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.[185] The option defaults to false except for the UUID field, 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.[186]
  • A full regular expression, including flags, can be used for the field pattern option.[187] 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).
  • The new unique field option makes sure a value isn’t used in the same field of any other entry in the collection, like a UNIQUE constraint in a relational database. It works with the String, Text, Number, Color, DateTime, Markdown and RichText fields, as well as the File, Image, Relation and Select fields taking a single value.[188]
  • A long validation error message is displayed in full, without being hidden behind the field label.[189]
  • Any links to other entries will work as expected, with the Content Editor being updated for the other.[190]
  • In the Boolean and Select fields, users don’t have to update a value twice to re-enable the Save button after saving an entry.[191]
  • data can be used as a field name without causing an error when saving the entry.[192]
  • The entry content is validated before loading to prevent crashes caused by invalid data, such as values of the wrong type.[193]
  • An entry opens right away from the data already loaded, so the editor always shows the entry in the URL. In Netlify/Decap CMS, moving on before an entry has loaded puts it in the next editor, and saving then overwrites it instead of creating a new file or updating the entry on screen.[194]
  • 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 when an entry is opened, every minute while the tab is shown, and again before every save. 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 CMS passes the branch head that the loaded data reflects to the commit API as the expected head. GitHub itself then refuses a commit against a branch that has moved. Netlify/Decap CMS looks the head up right before committing, which defeats the check. In the rare case where two people save at the same moment, the save fails with an unexplained Update is not a fast forward error.[195] 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.[196] 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.[197]
  • Clicking a field in the Preview Pane focuses the corresponding field in the Edit Pane.[198] 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 and unnecessary. (Plus, why camel case?)
  • The Preview Pane doesn’t cause a scrolling issue.[199]
  • The Preview Pane doesn’t crash with a Minified React error.[200][201][202]
  • Provides better scroll synchronization between the panes when editing or previewing an entry.[203]
  • Developers can hide the preview of a specific field using a new field option: preview: false.[204]
  • See below for widget-specific enhancements, including support for variable types[205] 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.[206]
  • Netlify/Decap CMS often, but not always, omits optional and empty fields from the output.[207] 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.[208][209][210][211]
    • 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.[212]
  • 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.[213]
  • Leading/trailing whitespaces in text-type field values are automatically removed when an entry is saved.[214] No option is required to trim the values.[215] Code field values are kept as they are, and multiline text values keep their leading whitespace.
  • Strings that a YAML 1.1 parser would read as a boolean or a number, such as yes, no, on, off and 1:20, are quoted in YAML output, so tools still using YAML 1.1, such as Jekyll, read them as strings.
  • YAML string folding (maximum line width) is disabled, mainly for framework compatibility.[216]
  • Comments at the top of an existing YAML or TOML file, or of its front matter, are kept when an entry is saved, as long as a blank line separates them from the first key.[217]
  • 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.[218]
  • Provides JSON/YAML format options as part of the data output options, including indentation and quotes.[219][220]
  • It’s impossible to inject front matter through the body field.[221]

Better Field Types ​

Sveltia CMS supports all the built-in field types (widgets) available in Netlify/Decap CMS. We have improved these fields 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.[208:1]
  • An optional Boolean field with no default value is also saved as false by default, rather than nothing.[209: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 works as expected.[222]
  • A Code field under a List field works as expected, saving both code and language.[223]
  • A wrong initial value will not cause a crash with a TypeError.[224]

Color ​

  • The field doesn’t cause scrolling issues.[225]
  • 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.[226]
    • The new localize_format option writes month names and other locale-dependent parts of a custom format in a language other than English, either in a given locale or in each content locale.[227]
  • A DateTime field doesn’t trigger a change in the content draft status when a user has just started editing a new entry.[228]
  • The user’s local time is not saved in UTC unless the picker_utc option is true.[229]
  • The field doesn’t throw a RangeError for formatting days of the month.[230][231]
  • The year will not unexpectedly change to 190x when the value is entered manually.[232]

Hidden ​

  • The default value supports the following template tags:
    • {{locale}}: The current locale code.[116:1]
    • {{datetime}}: The current date/time in ISO 8601 format.[233]
    • {{uuid}}, {{uuid_short}} and {{uuid_shorter}}: A random UUID or its shorter version, just like the slug template tags.[234]
    • {{author-email}}, {{author-login}} and {{author-name}}: The signed-in user’s email, login name and display name, respectively.[235]
  • The default value is saved when you create a file collection item, not just a folder collection item.[236]

List ​

  • It’s possible to edit data files with a top-level list using the new root option.[237]
  • A list can be stored as a map keyed by a subfield using the new map_key_field option. This lets you edit a file format where each item has a unique key, like a Hayagriva bibliography, with a List field. The keys are validated to be unique, and the map works at the top level of a TOML file too. A key can be typed, or picked with a Relation or Select field — e.g. to store settings for each page keyed by its slug. (Discussion, #1082)
  • The min and max options can be used separately. You don’t need to specify both to use either option.[238]
  • 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.[239]
  • 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.[240]
  • A required List field with no subfield or value is marked as invalid.[241] 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.[210:1]
  • An optional List field won’t populate an item by default when the subfield has the default value.[242]
  • A simple List field with no subfields is displayed as a row per item, which includes a drag handler and single-line text input.[243] Users can use spaces[244] and commas[245] 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.[205:1]
  • It’s possible to omit fields in a variable type object.[246] 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.[247]
  • An item can be removed from a list with a single subfield, even when that subfield is a Relation field. In Netlify/Decap CMS, clicking the × button does nothing and throws an error.[248]
  • A collapsed List field will not display a programmatic summary like List [ Map { "key": "value" } ] if the summary option is not set.[249]
  • The allow_remove and allow_reorder options can be used to prevent users from removing items and reordering them, respectively.[250]
  • The allow_duplicate option can be used to prevent users from duplicating items.
  • In a list with 3 or more items, an item can be moved to the top, to the bottom or to a given position from a menu, without dragging it through a long list. This also works for the files in a multiple File/Image field and the pairs in a KeyValue field.
  • A list item can be copied and pasted into any list that takes it, in another entry, collection or browser tab. The values are matched to the subfields by name, and file paths are updated for the target entry, copying a file stored next to the source entry if needed. (Discussion)
  • 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.[251]
  • 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,[252] including fatal application crashes,[253][254][255][256][257][258] lost formatting when pasting,[259][260] an extra line break when pasting,[261] extra HTML comments when pasting,[262] backslash injections,[263] dropdown visibility,[264] text input difficulties with IME[123:1] and characters typed right after a click landing at the previous caret position.[265]
  • 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.[266] 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.[267]
  • The toolbar buttons also work in the raw Markdown editor, inserting Markdown into the text. Editor components can be inserted as well.[268]
  • A Markdown field plays well with a variable type List field.[269]
  • The bullet list marker is a hyphen (-) rather than an asterisk (*), which is the comment form’s default behavior on GitHub and GitLab.[270]
  • A combination of bold and italic doesn’t create a confusing 3-asterisk markup.[271] In our editor, bold is 2 asterisks and italic is an underscore.
  • Links are edited in a floating link editor.[272]
  • When deleting a linked text, the link is removed cleanly without leaving behind any unwanted characters.[273]
  • Bare URLs are rendered as clickable links in the preview.[274]
  • An editor component can be removed with a single click on the Remove button.[275]
  • 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.[276] To disable this feature, add linked_images: false to the Markdown field options.
  • The built-in image component has a Caption field. An image with a caption is saved as a <figure> element with a <figcaption> element, which Markdown has no syntax for. To disable this feature, add captioned_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.[277]
  • Inline images are supported.[278]
  • 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.
  • The new built-in table component allows users to insert a table and edit its rows and columns with a menu, just like the Lexical Playground. The Tab key moves between the cells. Add table to the editor_components option to enable it.[279]
  • The new built-in hr component allows users to insert a horizontal rule with a toolbar button. Add hr to the editor_components option to enable it.[280][281]
  • Nested editor components can be controlled with the new allow_nested_components option.
  • The new multiline option, set to false, keeps a field on a single line without paragraph or line breaks. It suits a title or caption with inline formatting.
  • Code in a code block in the editor can be copied as expected.[282]
  • A language-annotated code block doesn’t trigger unsaved changes.[283]
  • Soft line breaks are rendered as hard line breaks in the Preview Pane.
  • Uploaded images will not disappear while editing an entry.[284][285]
  • The Preview Pane is updated instantly while editing.[286]
  • 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.[211:1]
  • The value_type option accepts int/string and float/string to save the number as a string instead of a number.
  • The up and down buttons and arrow keys can be turned off with step: -1, for a number that isn’t meant to be stepped, like an ID copied from another system.
  • The new auto_increment option numbers new entries automatically when they’re saved, like an AUTO_INCREMENT column in a relational database. The number can be used in the slug template, e.g. for invoices or podcast episodes.[287]

Object ​

  • Sveltia CMS offers two ways to have conditional fields in a collection:[288]
    • The Object field supports variable types (the types and typeKey options) just like the List field.[289]
    • An optional Object field (required: false) can be manually added or removed with a checkbox.[290] If unadded or removed, the required subfields won’t trigger validation errors,[291] 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.[292]
  • The field reliably displays the selected option in the summary and all available options in the dropdown list.[293]
  • slug can be used for value_field to show all available options instead of just one in some situations.[294]
  • Template strings with a wildcard like {{cities.*.name}} can also be used for value_field.[295]
  • 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.[296]
  • 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, or, with the Editorial Workflow, in the same pull request.[297]
  • A referenced DateTime field value is displayed in the specified format.[298]
  • 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.[299]
    • 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.[300]
  • The new sort_by option sorts the options by any field in the referenced collection, such as a date, in ascending or descending order. By default, the options are sorted alphabetically by label, or follow the manual order of a collection with the reorder option.
  • 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.[301]
  • Multi-value Relation fields can be populated with comma-separated dynamic default values.[302]

Select ​

  • It’s possible to select an option with value 0.[303]
  • 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.[304] Markdown is supported in the value.
    • Compatibility note: In Static CMS, these options are implemented as prefix and suffix, respectively, which have different meanings in Sveltia CMS.

File and Image ​

  • Provides a reimagined all-in-one asset selection dialog for File and Image fields.[305]
    • Field, entry, file, collection and global assets are listed on separate tabs for easy selection.[306]
    • 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.[307] More stock photo providers may be added in the future.
      • The photo credit can be inserted into a Markdown field or the image’s caption with a single click, or copied as HTML or Markdown, instead of having to be written by hand.
  • 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">.[308]
    • By default, the Image field 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,[309] except that HEIC photos are accepted when HEIC conversion is enabled.
    • The File field 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.[310] Other dynamic template tags such as {{filename}} will also be populated as expected.[311]
  • 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.[312][313]
  • 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[314] 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 field if any of its subfields are filled out. The same applies to the minimize_collapsed option for the List field.
  • 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.
  • A variable type can have a description, displayed below its label in the Add button’s dropdown menu, and a hint, displayed above its subfields like a field’s hint.[315]
  • A removed list item, optional object or variable type object is replaced with a notice and a Restore button, so it can be brought back with all its values if it was removed by mistake.[316]

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 ​

  • Selected items can be reordered.[317]
  • If a dropdown list has options with long wrapping labels, they won’t overlap with the next option.[318]
  • 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.[319] This number can be changed with the dropdown_threshold option for relation and select fields.

String and Text ​

  • Supports the minlength and maxlength options. Developers can use them to specify the minimum and maximum number of characters required for input, without writing 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.

New Field Types ​

The following field types weren’t in Netlify CMS. Decap CMS has since added its own RichText and UUID field types. Our UUID field type is compatible with Decap CMS’s, while our RichText field type can also save HTML.

Compute ​
  • The experimental compute widget allows you to reference the value of other fields in the same collection, similar to the summary property for the List and Object fields.[320] 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.[321]
  • 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 field.
  • 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 field.
  • An empty field shows a blank row to type in, just like a simple List field.
RichText ​
  • The richtext field type is an alias of markdown that also supports HTML output. Set the format option to html to save the content as HTML instead of Markdown.[322] The option can also be set globally with field_defaults. Decap CMS’s RichText field type saves Markdown only.
  • With the html format, the new align button allows users to align paragraphs, headings, block quotes and list items to the left, center or right, or justify them. Add align to the buttons option to enable it.[323]
  • With the html format, the new underline button allows users to underline text, which is saved as a <u> element. Add underline to the buttons option to enable it.[281:1]
  • The new task-list button allows users to create GitHub Flavored Markdown task lists, with checkboxes that can be toggled with a click. Add task-list to the buttons option to enable it.
  • With the html format, the link editor offers an option to open a link in a new tab, which adds target="_blank" to the link.[324]
UUID ​
  • In addition to generating UUIDs for entry slugs, Sveltia CMS supports the uuid field type proposed for Netlify CMS and later added to Decap CMS, with the same properties:[234: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.[325]
    • Navigate between the global media folder and collection media folders.[326]
    • Browse the subfolders of a media folder, with a breadcrumb leading back to the parent folders. You can also 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.[327] 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. Its config can point a field at a subfolder, but 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,[328] file path, text data or image data of a selected asset to the clipboard. The file path starts with / as expected.[329]
    • 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. The deletion is refused if it 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.[330]
    • 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] You can also 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 field 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.[331] 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}}.[332]
    • Cloudinary
      • Field-specific media storage configuration works as expected.[333]
      • When the multiple option is enabled, the output is always an array of strings, regardless of whether a single file is selected.[334]
      • 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.[335]
      • The folder option is supported.[336]
    • Uploadcare
      • An API-based integration allows users to select existing files from their Uploadcare account.[337]
      • 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.[338]
    • Other integrations
      • Integrates stock photo providers, including Pexels, Pixabay and Unsplash.[307: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.[339]
      • The new label option sets a custom name for Amazon S3, S3-compatible providers and Azure Blob Storage, which is useful when the Amazon S3 integration connects to a self-hosted server.
      • The field-level prefix option of these providers supports template tags, so each entry’s files can go to a folder of their own.
      • More integration options may 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.[340]
    • They are automatically deleted when the associated entry is deleted because these are not available for other entries.[341] 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.[342]
  • 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.[343]
  • 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 ​

Preview Workflow is available as a new preview publish mode. Each change is saved to a pull request, so it can be checked on a deploy preview. It can then be published straight away, without the review stages of Editorial Workflow. Netlify/Decap CMS offers no way to save a change without publishing it short of the full Editorial Workflow.[344]

Local Workflow ​

  • We have eliminated the need for additional configuration and a proxy server, resulting in a streamlined workflow and improved performance.[345]
  • It also avoids a number of issues, including potential security risks,[52:1][53:1][54:1][55:1] a 30 MB file size limit,[346] an unknown error with publish_mode[347] and an unused logo_url.[348]
  • 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.
  • The CMS can commit your changes to the current branch of the local repository every time you save. Netlify/Decap CMS only offers this through an experimental, undocumented option of its proxy server.[349] Sveltia CMS commits only the files it saves, leaving your other work in progress alone, and tells you why when it can’t commit, such as when a merge is in progress.

Editorial Workflow ​

  • Editorial Workflow works with the Gitea/Forgejo backend as well as GitHub and GitLab. Decap CMS supports it on its separate Forgejo backend, but its Gitea backend still doesn’t.[350]
  • Performance is much better than with Netlify/Decap CMS, as we use the GraphQL API wherever possible.[351]
  • Sveltia CMS does not use the GitHub compare API to avoid the 250-commit limit.[352]
  • Unpublished entries are listed at the top of each entry collection page, along with status indicators.[353]
  • The Editorial Workflow board and the unpublished entries keep up with pull requests opened, updated, merged or closed outside the CMS — by a colleague, a bot or a merge on GitHub, GitLab, Gitea or Forgejo — without a page reload. The board also has a Refresh button for when you can’t wait. Netlify/Decap CMS reads the pull requests once, when the Workflow page or a collection is first opened, and offers no way to read them again. A change made elsewhere only shows up after the page is reloaded. See Keeping Up with Remote Changes.
  • 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. Sveltia CMS doesn’t implement the confusing unpublishing process.[354]
  • The Publish button is only displayed when the entry has reached the last stage, Ready by default.
  • The publish_mode option also takes an object form with more options:
    • stages leaves out the In Review or Ready stage, so a team that doesn’t need a separate review step can mark a saved draft ready, or publish it once it’s in review. Netlify/Decap CMS always requires a draft to be moved to Ready before it can be published.[355]
    • direct_publish adds Save and Publish to the Save button, so a quick fix can go live in one go while other changes still go through review. The fix is published straight to the configured branch, or by merging the entry’s pull request. With Netlify/Decap CMS, publishing a change takes six clicks across saving, changing the status and confirming.[356]
    • allow_incomplete_drafts: false enforces required fields in drafts as well, for sites that prefer the Netlify/Decap CMS behavior.
  • 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.[88: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.[357]
  • 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. This can be turned off with the allow_incomplete_drafts option.[358]
  • 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.[359]
  • An unpublished entry is reconstructed only from the pull request files that belong to the collection its branch names. 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. It loads the wrong file when anything else in the repository shares the extension.[360]
  • 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.[361]
  • 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.[362]
  • A workflow branch is named after the entry, not the editor, so two people working on the same entry share it. Sveltia CMS compares the branch with the draft when the entry is saved and asks before writing over a change someone else has made to the entry. Netlify/Decap CMS rebases the branch but doesn’t handle the conflict, so the second save overwrites the first with nothing said.[363]
  • A pull request is treated as an entry’s own only if it holds one of the entry’s files, not merely because it comes from the branch named after the entry. Netlify/Decap CMS goes by the branch name alone, so a pull request from that branch holding something else is shown, and published, as the entry.
  • Publishing an entry checks the pull request first. It has to go to the configured branch and still point at the commit the entry was loaded or saved at. It also has to change nothing the CMS doesn’t account for, such as the site’s code or another entry. The merge is then pinned to that commit. Netlify/Decap CMS merges the pull request as it stands, so anything else pushed to the branch goes live along with the entry unseen. When GitHub can’t merge it, Decap CMS even copies its files onto the configured branch regardless. See Checks Before Publishing.
  • Marking an entry as Ready approves its pull request on GitHub, GitLab, Gitea or Forgejo, and moving it back withdraws the approval, so reviewers don’t have to leave the CMS to satisfy a branch protection rule that requires an approval. Netlify/Decap CMS has no way to approve a pull request.[364] See Approvals.

Open Authoring ​

  • Open Authoring works with the GitLab and Gitea/Forgejo backends as well as GitHub. Decap CMS supports it on GitHub and Forgejo only, not on GitLab or Gitea.[365]
  • Moving an entry back to Draft marks its pull request as a draft 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.
  • Maintainers see contributors’ pull requests on their own Editorial Workflow board, marked From a fork, and can open the entry to review it, on GitHub, GitLab and Gitea/Forgejo alike. When the contributor allows edits from maintainers, which the CMS requests when a contributor sends an entry for review, a maintainer’s changes are saved to the contributor’s branch. Publishing is replaced with a Review on GitHub button, or the GitLab, Gitea or Forgejo equivalent, because a merge takes everything on the contributor’s branch, not just the entry the CMS shows. A contribution never takes the place of an entry in the entry list or search, so editing an entry from anywhere else can’t end up in someone else’s pull request. Netlify/Decap CMS doesn’t show contributors’ pull requests to maintainers at all, leaving the review to the Git service. See Reviewing in Sveltia CMS.
  • The contributor’s fork is found even when it isn’t at the name GitHub gives it by default. This happens when they renamed it, when your repository was renamed after they forked it, or when they already had a repository of that name and GitHub added a suffix. Netlify/Decap CMS’s GitHub backend 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.[366]
  • On GitHub and GitLab, a workflow branch starts from the head of the configured repository rather than from the contributor’s fork. A fork that has fallen behind or gained commits of its own therefore doesn’t pass them on. Netlify/Decap CMS branches from the fork, so an out-of-date fork leaks unrelated changes into the pull request.[367] Gitea and Forgejo can’t branch from a commit the fork doesn’t have, so the CMS brings the fork up to date on sign-in instead, with each service’s own API for it.
  • Problems while setting Open Authoring up are reported with something to act on, rather than a generic failure. Each of these is named specifically: 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.
  • 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.[357:1]
  • The entry list and the entry editor toolbar are updated immediately after saving a draft.

Deploy Previews ​

  • 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.
  • A deployment’s environment URL is preferred over a commit status target URL, which often points to a build log rather than the site. Netlify/Decap CMS only looks at the status, so a CI/CD service that reports the preview as a GitHub deployment gets no link.[368]
  • 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 to 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.[369]
  • 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.[107:1]
  • 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.[370]
  • 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.[371]
  • The Gitea/Forgejo backend supports deploy previews too, read from commit statuses. Decap CMS’s Gitea and Forgejo backends don’t implement them, so their entries never link to a preview.
  • 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. On Gitea/Forgejo, it costs one call 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. A finished build whose CDN hasn’t caught up is therefore 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. This includes deploy previews, 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.[372]
  • 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).[373] A smaller logo is also correctly positioned on the authentication page.[374]
  • Developers can specify the URL to redirect users to after logging out with the logout_redirect_url global option.[375]
  • 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.[376]
    • Field validation works as expected.[377]
    • No error is raised in the browser console saying Sent invalid data to remark[378] or onValidate is not a function.[379]
    • A link with kramdown inline attributes (e.g. {:.class}) is parsed correctly.[380]
    • Markdown is parsed and rendered correctly in the editor component preview.[381]
    • A File or Image field in a component can have its own media_folder. A relative folder is resolved against the entry being edited, so the file picker lists the files stored next to it, like in a Hugo page bundle. In Netlify/Decap CMS, the picker finds no files at all.[382]
    • Image, video and audio file paths are automatically replaced with blob URLs in the editor component preview if necessary, so that the files are displayed correctly. In Netlify/Decap CMS, you have to use the undocumented getAsset and fields parameters for the toPreview function to achieve this. Sveltia CMS supports these parameters as well, for other kinds of files and previews that need the URL, and documents them.
    • 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, using the same pipeline as the Preview Pane. 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 mode option also accepts the value inline, which renders the control of the component’s only field, such as a select box or a date picker, right within the text.[376:1]
    • 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.[383]
  • 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.[384]
    • 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.[385] 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.[386] 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 and open the library with it. It then watches the mediaPaths Redux state in componentDidUpdate for a path keyed by that ID, and resets the state itself. Nothing tells 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.
    • The undocumented definition object format of CMS.registerWidget(), i.e. { name, controlComponent, previewComponent, schema }, is supported and documented.[81:1] An additional summaryComponent option draws a collapsed List field item when the List field has a single subfield of the type. In Netlify/Decap CMS, a collapsed item can only show the text made from the summary option, so a field type storing a file path or an ID shows the raw value.
  • Async functions can be used for custom parsers/formatters.[387]
  • Developers can add custom pages to the global toolbar with the new CMS.registerCustomPage() method. A page can render a React component, embed another web page, such as an analytics dashboard, or link to an external site.[388]
  • The application renders within the dimensions of a custom mount element, if it exists.[389]
  • 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.[390]
  • Sveltia CMS exposes the HTM tagged template globally as html, so developers can write custom preview templates, editor components and field types in JSX-like markup without a build step, instead of nesting h() calls. String style attributes and HTML attribute names like class and for work as in HTML.
  • 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.[391]
    • 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.[392]
  • The List field’s label and label_singular are not converted to lowercase, which is especially problematic in German, where all nouns are capitalized.[393]
  • Long menu item labels, especially in non-English locales, don’t overflow the dropdown container.[394][395]
  • 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. The Netlify/Decap CMS documentation is thin and disorganized, often combining different topics on a single page. Compare some documents:
  • 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 and incomplete, and lacks important details. It makes no mention of the deprecation of Git Gateway, and new options are often 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.[396]
  • 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 HTM, JSX and h() syntax, allowing you to choose the one 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 helps 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, making it easier to integrate Sveltia CMS into your projects.
  • We have more framework integration guides, covering Astro, Eleventy, SvelteKit and Tanstack Start. By contrast, Netlify/Decap CMS still features guides for Gatsby and Gridsome, which are now both defunct.
  • 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.[397]
  • We have listed some common use cases of the CMS in the introduction.[398] In addition, we have a dedicated showcase 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.
  • Our Content Modeling Guide provides detailed examples of how to model content for common examples, including collections, fields and relationships between them, with complete configuration examples in YAML, TOML, JSON and JavaScript formats.[399]
  • We document how the collection-level media_folder option works with a relative or absolute path.[400]
  • 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.[401]
  • 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.[402]
  • 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.[403]

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 #8088 ↩︎

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

  50. Netlify/Decap CMS #542 ↩︎

  51. Netlify/Decap CMS #8025 ↩︎

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

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

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

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

  56. Netlify/Decap CMS #7557 ↩︎

  57. Netlify/Decap CMS #6879 ↩︎

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

  59. Netlify/Decap CMS #3284 ↩︎

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

  61. Netlify/Decap CMS #7077 ↩︎

  62. Netlify/Decap CMS #6762 ↩︎

  63. Netlify/Decap CMS #5701 ↩︎

  64. Netlify/Decap CMS #3431 ↩︎

  65. 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. ↩︎

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

  67. Netlify/Decap CMS #7375 ↩︎

  68. Netlify/Decap CMS #7518 ↩︎

  69. Netlify/Decap CMS #7616 ↩︎

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

  71. Netlify/Decap CMS #6616 ↩︎

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

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

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

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

  76. Netlify/Decap CMS #4987 ↩︎

  77. Netlify/Decap CMS #5970 ↩︎

  78. Netlify/Decap CMS #6527 ↩︎

  79. Netlify/Decap CMS #6800 ↩︎

  80. Netlify/Decap CMS #6794 ↩︎

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

  82. Netlify/Decap CMS #3803 ↩︎

  83. 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. ↩︎ ↩︎

  84. Netlify/Decap CMS #4417 ↩︎

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

  86. Netlify/Decap CMS #7457 ↩︎

  87. Netlify/Decap CMS #6831 ↩︎

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

  89. Netlify/Decap CMS #4329, #7108 ↩︎

  90. Netlify/Decap CMS #7257 ↩︎

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

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

  93. Netlify/Decap CMS #7611 ↩︎

  94. Netlify/Decap CMS #3704 ↩︎

  95. Netlify/Decap CMS #7172 ↩︎

  96. Netlify/Decap CMS #8010 ↩︎

  97. Netlify/Decap CMS #7627 ↩︎

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

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

  100. Netlify/Decap CMS #3286 ↩︎

  101. Netlify/Decap CMS #7157 ↩︎

  102. Netlify/Decap CMS #4415 ↩︎

  103. Netlify/Decap CMS #2082 ↩︎

  104. Netlify/Decap CMS #2827 ↩︎

  105. Netlify/Decap CMS #6302, #7598 ↩︎

  106. Netlify/Decap CMS #2250 ↩︎

  107. Netlify/Decap CMS #5107 ↩︎ ↩︎

  108. Netlify/Decap CMS #5280 ↩︎

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

  110. Netlify/Decap CMS #6978 ↩︎

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

  112. Netlify/Decap CMS #4781 ↩︎

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

  114. Netlify/Decap CMS #4645 ↩︎

  115. Netlify/Decap CMS #1685 ↩︎

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

  117. Netlify/Decap CMS #7612 ↩︎

  118. Netlify/Decap CMS #8069 ↩︎

  119. Netlify/Decap CMS #2524 ↩︎

  120. Netlify/Decap CMS #6932 ↩︎

  121. Netlify/Decap CMS #7086 ↩︎

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

  123. 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. ↩︎ ↩︎

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

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

  126. Netlify/Decap CMS #6307 ↩︎

  127. Netlify/Decap CMS #7371 ↩︎

  128. Netlify/Decap CMS #7507 ↩︎

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

  130. Netlify/Decap CMS #3265 ↩︎

  131. Netlify/Decap CMS #6285 ↩︎

  132. Netlify/Decap CMS #3542 ↩︎

  133. Netlify/Decap CMS #1040 ↩︎

  134. Netlify/Decap CMS #5317 ↩︎

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

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

  137. Netlify/Decap CMS #3320 ↩︎

  138. Netlify/Decap CMS #2734 ↩︎

  139. Netlify/Decap CMS #1000 ↩︎

  140. Netlify/Decap CMS #7328 ↩︎

  141. Netlify/Decap CMS #7347 ↩︎

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

  143. Netlify/Decap CMS #6427 ↩︎

  144. Netlify/Decap CMS #3677 ↩︎

  145. Netlify/Decap CMS #7221 ↩︎

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

  147. Netlify/Decap CMS #7355 ↩︎

  148. Netlify/Decap CMS #978 ↩︎

  149. Netlify/Decap CMS #1152 ↩︎

  150. Netlify/Decap CMS #7192 ↩︎

  151. Netlify/Decap CMS #5726 ↩︎

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

  153. Netlify/Decap CMS #7461 ↩︎

  154. Netlify/Decap CMS #377 ↩︎

  155. Netlify/Decap CMS #445 ↩︎

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

  157. Netlify/Decap CMS #4092 ↩︎

  158. Netlify/Decap CMS #3715 ↩︎

  159. Netlify/Decap CMS #7568 ↩︎

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

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

  162. Netlify/Decap CMS #7381 ↩︎

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

  164. Netlify/Decap CMS #2491 ↩︎

  165. Netlify/Decap CMS #1274 ↩︎

  166. Netlify/Decap CMS #7486 ↩︎

  167. Netlify/Decap CMS #7262 ↩︎

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

  169. Netlify/Decap CMS #4350 ↩︎

  170. Netlify/Decap CMS #3796 ↩︎

  171. Netlify/Decap CMS #1341 ↩︎

  172. Netlify/Decap CMS #4255 ↩︎

  173. Netlify/Decap CMS #7651 ↩︎

  174. Netlify/Decap CMS #7606 ↩︎

  175. Netlify/Decap CMS #4972 ↩︎

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

  177. Netlify/Decap CMS #4963 ↩︎

  178. Netlify/Decap CMS #7752 ↩︎

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

  180. Netlify/Decap CMS #4753 ↩︎

  181. Netlify/Decap CMS #7460 ↩︎

  182. Netlify/Decap CMS #8067 ↩︎

  183. Netlify/Decap CMS #8068 ↩︎

  184. Netlify/Decap CMS #7267 ↩︎

  185. Netlify/Decap CMS #7483 ↩︎

  186. Netlify/Decap CMS #5630 ↩︎

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

  188. Netlify/Decap CMS #1069 ↩︎

  189. Netlify/Decap CMS #1654 ↩︎

  190. Netlify/Decap CMS #4147 ↩︎

  191. Netlify/Decap CMS #6202 ↩︎

  192. Netlify/Decap CMS #7399 ↩︎

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

  194. Netlify/Decap CMS #8065 ↩︎

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

  196. Netlify/Decap CMS #1948 ↩︎

  197. Netlify/Decap CMS #7532 ↩︎

  198. Netlify/Decap CMS #7011 ↩︎

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

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

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

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

  203. Netlify/Decap CMS #1466 ↩︎

  204. Netlify/Decap CMS #7279 ↩︎

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

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

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

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

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

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

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

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

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

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

  215. Netlify/Decap CMS #4762 ↩︎

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

  217. Netlify/Decap CMS #5099 ↩︎

  218. Netlify/Decap CMS #3583 ↩︎

  219. Netlify/Decap CMS #5870 ↩︎

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

  221. Netlify/Decap CMS #4945 ↩︎

  222. Netlify/Decap CMS #7442 ↩︎

  223. Netlify/Decap CMS #6254 ↩︎

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

  225. Netlify/Decap CMS #7092 ↩︎

  226. Netlify/Decap CMS #7473 ↩︎

  227. Netlify/Decap CMS #2578 — Since Decap CMS 3.1.1 replaced the Moment.js library with Day.js, CMS.moment is no longer available. ↩︎

  228. Netlify/Decap CMS #725 ↩︎

  229. Netlify/Decap CMS #7319 ↩︎

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

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

  232. Netlify/Decap CMS #7939 ↩︎

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

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

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

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

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

  238. Netlify/Decap CMS #4733 ↩︎

  239. Netlify/Decap CMS #1244 ↩︎

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

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

  242. Netlify/Decap CMS #2380 ↩︎

  243. Netlify/Decap CMS #3018 ↩︎

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

  245. Netlify/Decap CMS #2153 ↩︎

  246. Netlify/Decap CMS #7322 ↩︎

  247. Netlify/Decap CMS #7973 ↩︎

  248. Netlify/Decap CMS #8080 ↩︎

  249. Netlify/Decap CMS #1275 ↩︎

  250. Netlify/Decap CMS #4702 ↩︎

  251. Netlify/Decap CMS #6629 ↩︎

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

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

  254. Netlify/Decap CMS #7047 ↩︎

  255. 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, #8023, #8028, #8048, #8054, #8056, #8075 ↩︎

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

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

  258. Netlify/Decap CMS #7137, #8027 ↩︎

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

  260. Netlify/Decap CMS #3437 ↩︎

  261. Netlify/Decap CMS #7364 ↩︎

  262. Netlify/Decap CMS #6180 ↩︎

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

  264. Netlify/Decap CMS #6482 ↩︎

  265. Netlify/Decap CMS #8087 ↩︎

  266. Netlify/Decap CMS #5125 ↩︎

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

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

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

  270. Netlify/Decap CMS #7638 ↩︎

  271. Netlify/Decap CMS #3291 ↩︎

  272. Netlify/Decap CMS #5674 ↩︎

  273. Netlify/Decap CMS #7640 ↩︎

  274. Netlify/Decap CMS #1004 ↩︎

  275. Netlify/Decap CMS #3531 ↩︎

  276. Netlify/Decap CMS #4754 ↩︎

  277. Netlify/Decap CMS #7585, #7790, #7836, #7843, #7868, #7869, #7884, #7889, #7957, #7986, #8024, #8040, #8042 ↩︎

  278. Netlify/Decap CMS #7705 ↩︎

  279. Netlify/Decap CMS #36, #2845 ↩︎

  280. Netlify/Decap CMS #1378 ↩︎

  281. Netlify/Decap CMS #7626 ↩︎ ↩︎

  282. Netlify/Decap CMS #7143 ↩︎

  283. Netlify/Decap CMS #7431 ↩︎

  284. Netlify/Decap CMS #7575 ↩︎

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

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

  287. Netlify/Decap CMS #2367 ↩︎

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

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

  290. Netlify/Decap CMS #1267 ↩︎

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

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

  293. Netlify/Decap CMS #7546 ↩︎

  294. Netlify/Decap CMS #4954 ↩︎

  295. Netlify/Decap CMS #5487 ↩︎

  296. Netlify/Decap CMS #4841 ↩︎

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

  298. Netlify/Decap CMS #3421 ↩︎

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

  300. Netlify/Decap CMS #8005 ↩︎

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

  302. Netlify/Decap CMS #7794 ↩︎

  303. Netlify/Decap CMS #6515 ↩︎

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

  305. 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. ↩︎

  306. Netlify/Decap CMS #5910 ↩︎

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

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

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

  310. Netlify/Decap CMS #5444 ↩︎

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

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

  313. Netlify/Decap CMS #7639 ↩︎

  314. Netlify/Decap CMS #6325 ↩︎

  315. Netlify/Decap CMS #3650, #5906 ↩︎

  316. Netlify/Decap CMS #7135 ↩︎

  317. Netlify/Decap CMS #4292 ↩︎

  318. Netlify/Decap CMS #6508 ↩︎

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

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

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

  322. Netlify/Decap CMS #1746, #4419 ↩︎

  323. Netlify/Decap CMS #1503 ↩︎

  324. Netlify/Decap CMS #1403 ↩︎

  325. Netlify/Decap CMS #962 ↩︎

  326. Netlify/Decap CMS #3240 ↩︎

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

  328. Netlify/Decap CMS #4209 ↩︎

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

  330. Netlify/Decap CMS #5901 ↩︎

  331. Netlify/Decap CMS #4288 ↩︎

  332. Netlify/Decap CMS #857 ↩︎

  333. Netlify/Decap CMS #2001 ↩︎

  334. Netlify/Decap CMS #5812 ↩︎

  335. Netlify/Decap CMS #1934 ↩︎

  336. Netlify/Decap CMS #2209 ↩︎

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

  338. Netlify/Decap CMS #6243 ↩︎

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

  340. Netlify/Decap CMS #7124 ↩︎

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

  342. Netlify/Decap CMS #4208 ↩︎

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

  344. Netlify/Decap CMS #942 ↩︎

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

  346. Netlify/Decap CMS #6731 ↩︎

  347. Netlify/Decap CMS #5472 ↩︎

  348. Netlify/Decap CMS #5752 ↩︎

  349. Netlify/Decap CMS #4429 ↩︎

  350. Netlify/Decap CMS #7115 ↩︎

  351. Netlify/Decap CMS #3468 ↩︎

  352. Netlify/Decap CMS #3362 ↩︎

  353. Netlify/Decap CMS #4675 ↩︎

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

  355. Netlify/Decap CMS #1306 ↩︎

  356. Netlify/Decap CMS #4054 ↩︎

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

  358. Netlify/Decap CMS #389, #464, #5013 ↩︎

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

  360. Netlify/Decap CMS #4777 ↩︎

  361. Netlify/Decap CMS #7963 ↩︎

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

  363. Netlify/Decap CMS #3814 ↩︎

  364. Netlify/Decap CMS #1593, #7200 ↩︎

  365. Netlify/Decap CMS #7823 ↩︎

  366. Netlify/Decap CMS #7344 ↩︎

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

  368. Netlify/Decap CMS #4359 ↩︎

  369. Netlify/Decap CMS #5161 ↩︎

  370. Netlify/Decap CMS #5310 ↩︎

  371. 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. ↩︎

  372. Netlify/Decap CMS #4877 ↩︎

  373. Netlify/Decap CMS #5548 ↩︎

  374. Netlify/Decap CMS #2133 ↩︎

  375. Netlify/Decap CMS #713 ↩︎

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

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

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

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

  380. Netlify/Decap CMS #1464 ↩︎

  381. Netlify/Decap CMS #6797 ↩︎

  382. Netlify/Decap CMS #6595 ↩︎

  383. Netlify/Decap CMS #6775 ↩︎

  384. Netlify/Decap CMS #3719 ↩︎

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

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

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

  388. Netlify/Decap CMS #4424, #4580, #5973 ↩︎

  389. Netlify/Decap CMS #7197 ↩︎

  390. Netlify/Decap CMS #4568 ↩︎

  391. Netlify/Decap CMS #6816 ↩︎

  392. Netlify/Decap CMS #1769 ↩︎

  393. Netlify/Decap CMS #3856 ↩︎

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

  395. Netlify/Decap CMS #6215 ↩︎

  396. Netlify/Decap CMS #3764 ↩︎

  397. Netlify/Decap CMS #7736 ↩︎

  398. Netlify/Decap CMS #365 ↩︎

  399. Netlify/Decap CMS #948 ↩︎

  400. Netlify/Decap CMS #3671 ↩︎

  401. Netlify/Decap CMS #6062 ↩︎

  402. Netlify/Decap CMS #7753 ↩︎

  403. Netlify/Decap CMS #7867 ↩︎