Sparkle 2 for macOS apps: RSS appcasts, EdDSA signatures, and a macOS 12 floor
A software update framework for macOS
At a glance
- What is it?
- Sparkle adds self-updating to a macOS app without code in the app, but the work moves to your web server: an HTTPS feed, an appcast, signing keys, and a release line that decides how old a macOS you can still support.
- Who is it for?
- Use Sparkle if you ship a macOS app, can host updates over HTTPS, and are willing to read Console.app when something goes wrong. Do not adopt it if you must support macOS below 12.0, because the runtime floor on the 2.x branch pushes you to the 2.9.6 line and costs you the sandboxing, custom UI and channel features the project credits to Sparkle 2.
- Can I use it commercially?
- Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly Objective-C, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- sparkle-project/Sparkle9,927 ★ · +190
| Repository | 2026-09-22 | 2026-11-15 |
|---|---|---|
| sparkle-project/Sparkle | 9.7k | 9.9k |
190 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
No code in the app still leaves a feed URL and a web server on you
The pitch is that Sparkle needs no code in your app, and only static files on a web server. That holds in a narrow sense. What ships is a framework your app links against, a feed URL it reads at launch, and a set of static files you host yourself over HTTPS. Nothing about the update experience advertises the framework: your own icons and app name are used, so there is no mention of Sparkle anywhere in the interface, and the updater stays hidden until the second launch so the first impression is not interrupted. The cost is that the zero-code claim stops at the app target. You still have to stand up an HTTPS endpoint, keep an appcast file current and get the configuration keys right before a single update can reach a user.
EdDSA plus code signing, and the only diagnostics live in Console.app
Every update is verified twice, with EdDSA signatures and with Apple Code Signing, and Sparkle 2 supports sandboxed applications, which is what lets a sandboxed distribution keep updating itself. When verification or delivery fails, the place to look is Console.app, filtered to your application. Sparkle prints detailed information there about every problem it encounters, and the troubleshooting notes say the messages often suggest the solution themselves, so reading the log is a required step rather than a fallback. The consequence for an integrator is that a silent updater is diagnosable only if someone reads system logs. A user whose update never appears sees nothing in your interface, and your interface will not explain it either.
A typo in SUFeedURL is the failure the troubleshooting notes lead with
The feed URL is the setting the project calls out most directly, and it is customized under SUFeedURL. The troubleshooting notes put it first: make sure that URL is valid, because typos and 404s are described as a common error, and make sure it uses modern TLS, with an external certificate checker linked for the test. Transport is not a formality either, since App Transport Security is cited under requirements as the reason to serve updates over HTTPS. If the address resolves but returns something that is not an appcast, Console.app is where that shows up.
Delta updates and atomic-safe installs come from separate top-level components
Delta updates change how you ship. Rather than pushing an entire new archive, only the files that changed are patched, and installs are described as atomic-safe, so an interrupted update does not leave a half-replaced app. The tree shows that work split across dedicated directories rather than one monolithic module: Autoupdate/, Downloader/, InstallerConnection/, InstallerLauncher/, InstallerStatus/ and BinaryDelta/ sit at the top level, so the relaunch helper, the fetch layer, the installer handshake and the patcher can be read independently. The appcast itself is produced by the generate_appcast tool, which creates appcast files, corrects signatures and builds delta updates automatically, so the patch format is not something an integrator assembles by hand.
Sparkle 2 widened the target set to bundles, plug-ins and staged rollouts
The second generation expanded what an update is allowed to touch. It supports sandboxed applications, custom user interfaces for the update flow, and updates to external bundles, so a helper or a second binary shipped alongside your app can be replaced as well. Release targeting grew too: channels exist for beta updates on Sparkle 2, an update can be marked critical or major, phased rollouts send a release to a slice of users before the rest, and the host app receives progress and status notifications. The kinds of payload are not limited to the main bundle, since preference panes, package installers and other plug-ins are named as supported targets. The tooling around this sits in the tree as separate directories, including generate_keys, sign_update, sparkle-cli and common_cli.
The macOS 12 floor on 2.x versus macOS 10.13 on 2.9.6 is an adoption decision
The runtime floor is the requirement that decides adoption. On the 2.x branch the stated runtime is macOS 12.0 or later, while 2.9.6 is the release the requirements pair with macOS 10.13 or later. The release list puts 2.10.0 Golden Gate Bump at 2026-09-13 and 2.10.1 Golden Gate Bump at 2026-10-25, so the line that demands macOS 12 is also the line that moved forward most recently, and the last push to the default branch 2.x was 2026-11-02. If your app still supports older systems, you are held on the older release line, which means the sandboxing, custom UI, external bundle and channel additions the project credits to Sparkle 2 are not yours to use. Building the framework itself needs the latest major Xcode, stable or beta, plus one major version less.
Nothing is exported unless you decorate it with SU_EXPORT
Sparkle hides its own symbols. The framework builds with -fvisibility=hidden -fvisibility-inlines-hidden, so no symbol is exported by default and nothing is visible to another module until you say so. A declaration added to the public API has to be decorated with the SU_EXPORT macro, and the guidance in the project is to grep the source for existing examples. The consequence for an integrator is that extending or wrapping Sparkle does not work by convention: a symbol you write stays invisible to consumers, and the failure appears at link time rather than at compile time, which makes it an easy afternoon to lose. Documentation generation has a prerequisite of its own, since the docs rule in the Makefile needs jazzy installed first and writes its output into Documentation/.
Editorial conclusion
Use Sparkle if you ship a macOS app, can host updates over HTTPS, and are willing to read Console.app when something goes wrong. Do not adopt it if you must support macOS below 12.0, because the runtime floor on the 2.x branch pushes you to the 2.9.6 line and costs you the sandboxing, custom UI and channel features the project credits to Sparkle 2. Before shipping, sign your builds, verify the feed URL by hand, and read the LICENSE file, since the repository reports its license as unasserted.
Frequently asked questions
How do you use Sparkle to update a macOS app?
Sparkle needs no code inside your app but does need configuration, and the framework reads an RSS-based appcast that you host over HTTPS. The feed location is customized under SUFeedURL, and the appcast file, its signatures and its delta updates are produced by the generate_appcast tool.
How do you install Sparkle for a macOS app?
The project points you at the getting started guide on sparkle-project.org rather than a package command, and pre-releases are available from the Sparkle releases page or from a package manager, with nightly builds offered as a Sparkle-distribution artifact from recent workflow runs on the 2.x branch. The 2.x line requires macOS 12.0 or later at runtime.
How does Sparkle verify that an update is genuine?
Updates are verified using EdDSA signatures and Apple Code Signing, and Sparkle 2 supports sandboxed applications. Signing material is produced by the generate_keys tool, while generate_appcast creates appcast files, corrects signatures and builds delta updates automatically.
Where do I look when a Sparkle update never appears?
Check Console.app for logs under your application, where Sparkle prints detailed information about every problem it encounters and often suggests the solution. The troubleshooting notes call out a bad feed URL, where typos and 404s are common, and an endpoint that does not use modern TLS.
Does Sparkle export its API symbols to other modules?
No. Sparkle builds with -fvisibility=hidden -fvisibility-inlines-hidden, so no symbols are exported by default, and any declaration added to the public API must be decorated with the SU_EXPORT macro.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/sparkle-project-sparkle)Star history chart for your README
[](https://hysenlabs.com/projects/sparkle-project-sparkle)Was this useful?