Top Related Projects
Bitwarden client apps (web, browser extension, desktop, and cli).
KeePassXC is a cross-platform community-driven port of the Windows application “Keepass Password Safe”.
Free cross-platform password manager compatible with KeePass
Unofficial Bitwarden compatible server written in Rust, formerly known as bitwarden_rs
A modern, open source password manager for individuals and teams.
Quick Overview
Buttercup Desktop is an open-source, cross-platform password manager application. It provides a secure and user-friendly interface for storing and managing sensitive information such as passwords, credit card details, and personal notes. The application uses strong encryption to protect user data and offers features like password generation and cloud synchronization.
Pros
- Cross-platform compatibility (Windows, macOS, Linux)
- Strong encryption (AES-256) for data protection
- User-friendly interface with intuitive organization
- Free and open-source
Cons
- Limited third-party integrations compared to some commercial alternatives
- No built-in password sharing feature
- Relatively smaller user base compared to more established password managers
- Occasional sync issues reported by some users
Getting Started
To get started with Buttercup Desktop:
- Visit the Buttercup Desktop releases page on GitHub.
- Download the appropriate installer for your operating system.
- Install the application following the on-screen instructions.
- Launch Buttercup Desktop and create a new vault or import an existing one.
- Set a strong master password to secure your vault.
- Start adding and organizing your passwords and sensitive information.
For developers interested in contributing to the project:
# Clone the repository
git clone https://github.com/buttercup/buttercup-desktop.git
# Navigate to the project directory
cd buttercup-desktop
# Install dependencies
npm install
# Start the development server
npm start
Competitor Comparisons
Bitwarden client apps (web, browser extension, desktop, and cli).
Pros of Bitwarden
- More active development with frequent updates and contributions
- Broader platform support, including mobile apps and browser extensions
- Larger community and user base, leading to more feedback and bug reports
Cons of Bitwarden
- More complex codebase due to supporting multiple platforms
- Steeper learning curve for new contributors
- Potentially slower review process due to larger project scale
Code Comparison
Buttercup (TypeScript):
export function createNewEntry(vault, groupID) {
const entry = vault.createEntry(groupID);
entry.setProperty("title", "New Entry");
entry.setAttribute(Entry.Attributes.IconID, "0");
return entry;
}
Bitwarden (TypeScript):
async createCipher(cipher: CipherView): Promise<Cipher> {
const c = await this.encryptCipherData(cipher);
const response = await this.apiService.postCipher(c);
this.updateCipherCache(response);
return new Cipher(response);
}
Both projects use TypeScript, but Bitwarden's code tends to be more complex due to its broader feature set and platform support. Buttercup's code is often more straightforward, focusing on desktop-specific functionality.
KeePassXC is a cross-platform community-driven port of the Windows application “Keepass Password Safe”.
Pros of KeePassXC
- More mature and feature-rich password manager with a longer development history
- Supports advanced features like YubiKey integration and SSH agent
- Offers a command-line interface for power users and automation
Cons of KeePassXC
- Less modern and intuitive user interface compared to Buttercup
- Lacks built-in cloud synchronization options
- Steeper learning curve for new users due to its extensive feature set
Code Comparison
KeePassXC (C++):
void Database::setKey(const CompositeKey& key)
{
m_key = key;
m_kdf->randomize();
m_masterSeed = QByteArray::fromRandom(32);
m_transformedMasterKey.clear();
}
Buttercup (JavaScript):
setPassword(password) {
this._password = password;
this.emit("passwordChanged");
return this;
}
KeePassXC uses C++ for its core functionality, providing lower-level control and potentially better performance. Buttercup, built with Electron and JavaScript, offers easier cross-platform development and a more modern tech stack, but may have higher resource usage.
Both projects are open-source and actively maintained, with KeePassXC having a larger community and more frequent updates. Buttercup focuses on simplicity and cloud integration, while KeePassXC prioritizes security features and offline usage.
Free cross-platform password manager compatible with KeePass
Pros of KeeWeb
- Cross-platform compatibility: Web-based and desktop versions available
- Supports multiple cloud storage options (Dropbox, Google Drive, etc.)
- Open-source with a more active community and frequent updates
Cons of KeeWeb
- Less intuitive user interface compared to Buttercup
- Limited import options for other password manager formats
- Lacks some advanced features like password sharing
Code Comparison
KeeWeb (JavaScript):
const kdbxweb = require('kdbxweb');
const db = kdbxweb.Kdbx.create(credentials, 'My Database');
const entry = db.createEntry(db.getDefaultGroup());
entry.fields.Title = 'My Entry';
Buttercup (JavaScript):
const { Vault } = require("buttercup");
const vault = Vault.createWithDefaults();
const group = vault.createGroup("My Group");
group.createEntry("My Entry").setProperty("username", "user123");
Both projects use JavaScript for their core functionality. KeeWeb relies on the kdbxweb library for database operations, while Buttercup uses its own Vault class. KeeWeb's code appears more concise, but Buttercup's API might be more intuitive for some developers.
Unofficial Bitwarden compatible server written in Rust, formerly known as bitwarden_rs
Pros of Vaultwarden
- Self-hosted solution, offering more control over data and privacy
- Compatible with official Bitwarden clients, providing a wider ecosystem
- Supports multiple users and organizations, ideal for team/family use
Cons of Vaultwarden
- Requires more technical knowledge to set up and maintain
- May lack some features of the official Bitwarden server
- Potential security risks if not properly configured and maintained
Code Comparison
Vaultwarden (Rust):
#[get("/alive")]
fn alive() -> Json<String> {
Json(String::from("Hello from Vaultwarden!"))
}
Buttercup Desktop (JavaScript):
ipcMain.on("get-platform", (event) => {
event.returnValue = process.platform;
});
While both projects are password managers, they serve different purposes. Vaultwarden is a self-hosted server implementation compatible with Bitwarden clients, while Buttercup Desktop is a standalone desktop application. Vaultwarden is written in Rust, focusing on server-side operations, whereas Buttercup Desktop uses JavaScript and Electron for cross-platform desktop functionality. The code snippets reflect these differences, with Vaultwarden handling web requests and Buttercup Desktop managing desktop-specific operations.
A modern, open source password manager for individuals and teams.
Pros of Padloc
- Cross-platform support: Web, desktop, and mobile apps available
- End-to-end encryption with zero-knowledge architecture
- Collaborative features for team password management
Cons of Padloc
- Smaller community and less frequent updates
- Limited third-party integrations compared to Buttercup
- Steeper learning curve for advanced features
Code Comparison
Padloc (TypeScript):
export class Vault extends Serializable {
@field("items")
private _items: VaultItem[] = [];
async unlock(password: string): Promise<void> {
// Vault unlocking logic
}
}
Buttercup (JavaScript):
class Vault extends EventEmitter {
constructor(datasource, credentials) {
super();
this._datasource = datasource;
this._credentials = credentials;
}
unlock(password) {
// Vault unlocking logic
}
}
Both projects use similar object-oriented approaches for vault management, but Padloc leverages TypeScript for stronger typing. Buttercup's implementation extends EventEmitter for event-driven architecture, while Padloc uses decorators for field definitions.
Convert 
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Buttercup Desktop
Buttercup for Desktop - Mac, Linux and Windows
About
Buttercup is a free, open-source and cross-platform password manager, built on NodeJS with Typescript. It uses strong industry-standard encryption to protect your passwords and credentials (among other data you store in Buttercup vaults) at rest, within vault files (.bcup). Vaults can be loaded from and saved to a number of sources, such as the local filesystem, Dropbox, Google Drive or any WebDAV-enabled service (like ownCloud or Nextcloud ¹).
Why you need a password manager
Password management is a crucial tool when you have any online presence. It's vital that all of your accounts online use strong and unique passwords so that they're much more difficult to break in to. Even if one of your accounts are breached, having unique passwords means that the likelihood of the attacker gaining further access to your accounts portfolio is greatly reduced.
Without a password manager, such as Buttercup, it would be very tedious to manage different passwords for each service. If you remember your passwords it's a good sign that they're not strong enough. Ideally you should memorise a primary password for your vault, and not know any of the account-specific passwords off the top of your head.
Precautions
Buttercup securely encrypts your data in protected files, but this security is only as strong as the weakest component - and this is very often the primary password used to lock and unlock your vault. Follow these basic guidelines to ensure that your vault is safe even if exposed:
- Choose a unique password that is not used elsewhere
- Use a highly-varied set of different characters - such as alpha-numeric, symbols and spaces
- Use a long password - the longer the better
- Don't include words or names in the password
- Never share your password with anyone
It is very important to note that no one associated with Buttercup will ever request your personal vault or its primary password. Do not share it or any of its related details with anyone. Developers or contributors working with Buttercup may request example vaults created via your system to try and reproduce issues, but please ensure to never use your real password or store actual credentails within such vaults.
Versions
The current stable version is 2. We recommend upgrading if you're still on v1, as it is no longer being actively maintained. You can still browse the v1 source and documentation here.
Buttercup is built on Node 20 LTS - no other platform is officially supported.
Operating Systems
Buttercup Desktop is officially supported on:
- Most linux distributions (x64), such as Ubuntu
- MacOS (x64, Apple Silicon¹)
- Windows 10 / 11 (x64)
¹ No builds yet
Arch Linux
Buttercup is also available for Arch via the AUR. This release channel is maintained by our community.
Some Arch users have reported the occasional segfault - if you experience this please try this solution before creating an issue.
32bit builds (x86)
Buttercup no longer provides 32bit builds, due to the complexity of supporting them in the build pipeline.
Portability
Buttercup provides a portable Windows version. Look for the release with the name Buttercup-win-x64-2.0.0-portable.exe where 2.0.0 is the version and x64 is the architecture.
Although not explicitly portable, both the Mac zip and Linux AppImage formats are more or less standalone. They still write to the standard config/log destinations, however.
To make the most of the portable version, some enviroment variables are required:
| Enviroment Variables | Description |
|---|---|
BUTTERCUP_HOME_DIR | If provided buttercup will use this path for saving configrations , user settings or even temprorary files |
BUTTERCUP_CONFIG_DIR | Stores user settings, not allways needed but can be used to change config location or will default to BUTTERCUP_HOME_DIR Optional: Only activates if BUTTERCUP_HOME_DIR is provided |
BUTTERCUP_TEMP_DIR | Same as BUTTERCUP_CONFIG_DIR but stores temprory files Optional: Only activates if BUTTERCUP_HOME_DIR is provided |
Sample ButtercupLauncher.bat for Windows portable executable
This example stores user settings and cache on the portable folder, but stores temprory files on the host PC.
@ECHO OFF
if not exist "%~dp0Buttercup" mkdir "%~dp0Buttercup"
set "BUTTERCUP_HOME_DIR=%~dp0Buttercup"
set "BUTTERCUP_TEMP_DIR=%temp%"
start %~dp0Buttercup.exe %*
Configuration
Configuration files are stored in OS-specific locations.
Command-Line arguments
The following arguments can be provided to Buttercup, but are all optional.
| Argument | Description |
|---|---|
--autostart | Flag passed to Buttercup when launched automatically by the OS. |
--hidden | Disables the automatic opening of the main window upon launch. |
--no-update | Disables automatic update checking. Not recommended: Use at your own risk. |
App config
Application configuration.
- Linux:
$XDG_CONFIG_HOME/Buttercup/desktop.config.json - Mac:
~/Library/Preferences/Buttercup/desktop.config.json - Windows:
$APPDATA/Buttercup/Config/desktop.config.json
Vault storage
Storage of connected vaults (not actual vault contents).
- Linux:
$XDG_DATA_HOME/Buttercup/vaults.json - Mac:
~/Library/Application\ Support/Buttercup/vaults.json - Windows:
$LOCALAPPDATA/Buttercup/Data/vaults.json
Offline vault cache
Stored copies of vaults for offline use.
- Linux:
$(node -e "console.log(os.tmpdir())")/$(whoami)/Buttercup/vaults-offline.cache.json - Mac:
$(node -e "console.log(os.tmpdir())")/Buttercup/vaults-offline.cache.json - Windows:
$(node -e "console.log(os.tmpdir())")/Buttercup/vaults-offline.cache.json
Logs
Logs are written for all app sessions.
- Linux:
~/.local/state/Buttercup-nodejsor$XDG_STATE_HOME/Buttercup-nodejs - Mac:
~/Library/Logs/Buttercup-nodejs - Windows:
%LOCALAPPDATA%\Buttercup-nodejs\Log
Note that logs for portable Windows applications will be written to the same directory that the executable resides in.
Published Applications
You can view the current releases on the Buttercup Desktop releases page. Under each release are some assets - the various binaries and installers for each platform Buttercup supports. When installing or downloading, make sure to pick the right operating system and architecture for your machine.
Note that at this time, Buttercup only supports x64 (64 bit) machines.
Linux
We provide an AppImage build for Linux, because it is the most desirable format for us to release. AppImages support auto-updating, a crucial feature (we feel) for a security application. The other build types do not.
Important: Buttercup uses Electron to build its desktop application, which relies on AppImageLauncher for correct integration of AppImages into the host OS. Features like Google Drive authentication and correct .desktop icon use is only performed when integrating via AppImageLauncher. We highly recommend that you install it.
We won't be supporting formats like Snapcraft, deb or rpm images as they do not align with our requirements. Issues requesting these formats will be closed immediately. Discussion on topics like this should be started on other social channels.
Development
To begin developing features or bug-fixes for Buttercup Desktop, make sure that you first have Node v16 or greater installed with NPM v7 or greater.
Once cloned, make sure to install all dependencies: npm install. After that, open 2 terminals and run npm run start:build on one, and then npm run start:main in the other.
Contributing
There are a number of ways you can contribute to Buttercup!
Features & Bug fixes
We welcome pull-requests and issues that serve to better Buttercup as a platform. Please remain respecful (this is free & open source after all) with your ideas and observations, and always consider opening an issue before starting on a substantial pull request.
Translations
Buttercup relies on the community for translating its interfaces into languages besides English. We use British English (en_GB) as the base language, and translate into all others that our contributors are kind enough to provide.
To add support for a language, make sure to add the translations for our vault UI first. After that, you can follow these instructions to add another language to the desktop application:
- Copy the
source/shared/i18n/translations/en.jsonfile to the language code you're providing (eg.fi.jsonfor Finnish). - Edit the
source/shared/i18n/translations/index.tsfile and:- Import the new JSON file:
import fi from "./fi.json";. - Export the imported constant inside the default export already in that file.
- Import the new JSON file:
Contributions
This project exists thanks to all the people who contribute. [Contribute].
We'd also like to thank:
- Mohammad Amiri (Brand & Identity) (@pixelvisualize)
- Arash Asghari (Brand & Identity) (@_arashasghari)
Backers
Thank you to all our backers! ð [Become a backer]
Sponsors
Support this project by becoming a sponsor. Your logo will show up here with a link to your website. [Become a sponsor]
Notes and Caveats
- ¹ External services like Nextcloud and ownCloud must be configured correctly to support access via the web (using WebDAV). CORS must permit access from any source.
- ² Buttercup (including MadDev Oy) is not affiliated with any of the companies represented in screenshots or preview images.
Top Related Projects
Bitwarden client apps (web, browser extension, desktop, and cli).
KeePassXC is a cross-platform community-driven port of the Windows application “Keepass Password Safe”.
Free cross-platform password manager compatible with KeePass
Unofficial Bitwarden compatible server written in Rust, formerly known as bitwarden_rs
A modern, open source password manager for individuals and teams.
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot