Convert Figma logo to code with AI

wireapp logowire-desktop

:computer: Wire for desktop

1,074
234
1,074
105

Top Related Projects

113,668

:electron: Build cross-platform desktop apps with JavaScript, HTML, and CSS

162,288

Visual Studio Code

60,150

:atom: The hackable text editor

Make any web page a desktop application

A complete solution to package and build a ready for distribution Electron app with “auto update” support out of the box

Quick Overview

The Wire Desktop application is an open-source, secure messaging and collaboration platform developed by Wire Swiss GmbH. It provides end-to-end encrypted communication features for individuals and teams, allowing them to chat, make voice and video calls, share files, and collaborate on projects.

Pros

  • End-to-End Encryption: Wire uses state-of-the-art end-to-end encryption to protect user communications, ensuring the privacy and security of conversations.
  • Cross-Platform Compatibility: The Wire Desktop application is available for Windows, macOS, and Linux, making it accessible to a wide range of users.
  • Feature-Rich: In addition to messaging, Wire offers features like file sharing, screen sharing, and group calling, making it a comprehensive communication and collaboration tool.
  • Open-Source: The Wire Desktop application is open-source, allowing for community contributions, transparency, and potential customization.

Cons

  • Limited Integrations: Wire may not offer as many integrations with third-party services and applications as some other messaging platforms.
  • Smaller User Base: Compared to more widely adopted messaging apps, Wire may have a smaller user base, which could impact the availability of contacts and group discussions.
  • Potential Learning Curve: The feature-rich nature of Wire may present a slightly steeper learning curve for some users, especially those accustomed to simpler messaging apps.
  • Dependency on Wire's Servers: While Wire uses end-to-end encryption, users are still dependent on Wire's servers for the delivery and storage of messages, which could be a concern for some.

Getting Started

To get started with the Wire Desktop application, follow these steps:

  1. Visit the Wire website and download the appropriate version of the Wire Desktop application for your operating system (Windows, macOS, or Linux).
  2. Install the application on your computer.
  3. Open the Wire Desktop application and create a new account or sign in with an existing Wire account.
  4. Customize your profile settings, such as your display name and profile picture.
  5. Start chatting with your contacts, making voice and video calls, and collaborating on projects using Wire's various features.

For more detailed instructions and information on using the Wire Desktop application, please refer to the Wire Desktop documentation.

Competitor Comparisons

113,668

:electron: Build cross-platform desktop apps with JavaScript, HTML, and CSS

Pros of Electron

  • Electron is a mature and well-established framework, with a large and active community.
  • Electron provides a robust set of APIs and tools for building cross-platform desktop applications.
  • Electron's performance and stability have been continuously improved over the years.

Cons of Electron

  • Electron applications can be larger in size and have higher memory usage compared to native desktop applications.
  • Electron's reliance on Chromium can make it more resource-intensive than some other desktop frameworks.
  • Electron's complexity can make it more challenging to set up and configure for some developers.

Code Comparison

Electron:

const { app, BrowserWindow } = require('electron');

function createWindow() {
  const win = new BrowserWindow({
    width: 800,
    height: 600,
    webPreferences: {
      nodeIntegration: true
    }
  });

  win.loadFile('index.html');
}

app.whenReady().then(createWindow);

Wire Desktop:

const { app, BrowserWindow } = require('electron');
const path = require('path');

function createWindow() {
  const win = new BrowserWindow({
    width: 1024,
    height: 768,
    icon: path.join(__dirname, 'resources', 'win', 'wire.ico'),
    webPreferences: {
      nodeIntegration: true,
      preload: path.join(__dirname, 'preload.js')
    }
  });

  win.loadURL('https://app.wire.com/');
}

app.on('ready', createWindow);
162,288

Visual Studio Code

Pros of Visual Studio Code

  • Extensive plugin ecosystem with thousands of extensions available
  • Robust debugging capabilities with support for a wide range of programming languages
  • Highly customizable user interface and keybindings

Cons of Visual Studio Code

  • Larger application size and resource-intensive compared to Wire Desktop
  • Potential privacy concerns due to Microsoft's involvement and data collection practices
  • Slower startup time compared to Wire Desktop

Code Comparison

Wire Desktop:

const { app, BrowserWindow, ipcMain } = require('electron');
const path = require('path');

function createWindow() {
  const win = new BrowserWindow({
    width: 800,
    height: 600,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
    },
  });

  win.loadURL('https://app.wire.com');
}

app.whenReady().then(createWindow);

Visual Studio Code:

const vscode = require('vscode');

function activate(context) {
  console.log('Extension "my-extension" is now active!');

  let disposable = vscode.commands.registerCommand('my-extension.helloWorld', function () {
    vscode.window.showInformationMessage('Hello World from my-extension!');
  });

  context.subscriptions.push(disposable);
}

module.exports = {
  activate,
};
60,150

:atom: The hackable text editor

Pros of Atom

  • Atom is a highly customizable and extensible text editor, with a vast ecosystem of plugins and themes.
  • It has a modern and intuitive user interface, making it easy to use for both beginners and experienced developers.
  • Atom supports a wide range of programming languages and file types, making it a versatile choice for various development tasks.

Cons of Atom

  • Atom can be resource-intensive, especially on older or less powerful hardware, due to its Electron-based architecture.
  • The startup time for Atom can be slower compared to some other text editors, which may be a concern for users who frequently open and close the application.
  • Atom's performance may degrade over time as more packages and plugins are installed, potentially leading to stability issues.

Code Comparison

Atom:

const editor = atom.workspace.getActiveTextEditor();
if (editor) {
  const selectedText = editor.getSelectedText();
  console.log(`Selected text: ${selectedText}`);
}

Wire Desktop:

const { remote } = require('electron');
const { Menu, MenuItem } = remote;

const menu = new Menu();
menu.append(new MenuItem({
  label: 'Copy',
  accelerator: 'CmdOrCtrl+C',
  role: 'copy'
}));
menu.append(new MenuItem({
  label: 'Paste',
  accelerator: 'CmdOrCtrl+V',
  role: 'paste'
}));

Pros of Discord RPC

  • Discord RPC provides a rich set of features for integrating with the Discord platform, including the ability to display custom status information, receive user input, and more.
  • The Discord RPC library is well-documented and actively maintained, with a large community of developers contributing to its development.
  • Discord RPC is widely used and integrated into many popular applications, making it a reliable and well-supported choice for developers.

Cons of Discord RPC

  • The Discord RPC library is specific to the Discord platform, which may limit its usefulness for developers who are not primarily targeting the Discord user base.
  • Integrating Discord RPC into an application may require additional setup and configuration, which can add complexity to the development process.

Code Comparison

Here's a brief comparison of the code structure between the wireapp/wire-desktop and discord/discord-rpc repositories:

wireapp/wire-desktop

const { app, BrowserWindow, ipcMain } = require('electron');
const path = require('path');

function createWindow() {
  const win = new BrowserWindow({
    width: 800,
    height: 600,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
    },
  });

  win.loadURL('https://app.wire.com');
}

app.whenReady().then(createWindow);

discord/discord-rpc

#include <discord_rpc.h>
#include <iostream>

int main(int argc, char** argv) {
    DiscordEventHandlers handlers;
    memset(&handlers, 0, sizeof(handlers));
    Discord_Initialize("your-application-id", &handlers, 1, NULL);

    Discord_UpdatePresence(&RichPresence);

    while (!ShouldShutdown()) {
        Discord_RunCallbacks();
        // Do other application logic here
    }

    Discord_Shutdown();
    return 0;
}

Make any web page a desktop application

Pros of Nativefier

  • Nativefier is a lightweight and flexible tool that can be used to create desktop applications from any web application, including web-based messaging apps like Wire.
  • Nativefier supports a wide range of platforms, including Windows, macOS, and Linux, making it a versatile choice for cross-platform development.
  • Nativefier's simplicity and ease of use make it a popular choice for developers who want to quickly create desktop versions of their web applications.

Cons of Nativefier

  • Nativefier's desktop applications may not have the same level of integration and polish as a native desktop application built from the ground up, such as Wire Desktop.
  • Nativefier's desktop applications may not have access to the same set of features and APIs as a native desktop application, which could limit its functionality.
  • Nativefier's desktop applications may not have the same level of performance and stability as a native desktop application, especially for resource-intensive applications.

Code Comparison

Wire Desktop:

const { app, BrowserWindow, ipcMain } = require('electron');
const path = require('path');

function createWindow() {
  const win = new BrowserWindow({
    width: 800,
    height: 600,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
    },
  });

  win.loadURL('https://app.wire.com');
}

app.whenReady().then(createWindow);

Nativefier:

const nativefier = require('nativefier');

const options = {
  name: 'My App',
  targetUrl: 'https://example.com',
  platform: 'darwin',
  arch: 'x64',
  version: '0.1.0',
  out: 'dist',
  overwrite: true,
};

nativefier(options, (error, appPath) => {
  if (error) {
    console.error(error);
    return;
  }
  console.log(`App has been created at ${appPath}`);
});

A complete solution to package and build a ready for distribution Electron app with “auto update” support out of the box

Pros of Electron Builder

  • Electron Builder provides a comprehensive set of tools and features for packaging and distributing Electron applications, including support for multiple platforms, code signing, and auto-updating.
  • The project has a large and active community, with extensive documentation and a wide range of plugins and customizations available.
  • Electron Builder is highly configurable, allowing developers to tailor the build process to their specific needs.

Cons of Electron Builder

  • The learning curve for Electron Builder can be steep, especially for developers new to the Electron ecosystem.
  • The project's complexity and feature set can make it overkill for smaller or simpler Electron applications.
  • Electron Builder's reliance on external tools and services (e.g., code signing certificates) can add additional complexity and cost to the build process.

Code Comparison

Electron Builder:

"build": {
  "appId": "com.example.app",
  "mac": {
    "category": "public.app-category.productivity"
  },
  "win": {
    "target": "nsis"
  },
  "linux": {
    "target": ["deb", "rpm"]
  }
}

Wire Desktop:

"build": {
  "appId": "com.wire.app",
  "mac": {
    "category": "public.app-category.productivity",
    "target": ["dmg", "zip"]
  },
  "win": {
    "target": ["nsis", "portable"]
  },
  "linux": {
    "target": ["deb", "rpm", "AppImage"]
  }
}

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Wire™

Wire logo

This repository is part of the source code of Wire. You can find more information at wire.com or by contacting opensource@wire.com.

You can find the published source code at github.com/wireapp/wire.

For licensing information, see the attached LICENSE file and the list of third-party licenses at wire.com/legal/licenses/.

If you compile the open source software that we make available from time to time to develop your own mobile, desktop or web application, and cause that application to connect to our servers for any purposes, we refer to that resulting application as an “Open Source App”. All Open Source Apps are subject to, and may only be used and/or commercialized in accordance with, the Terms of Use applicable to the Wire Application, which can be found at https://wire.com/legal/#terms. Additionally, if you choose to build an Open Source App, certain restrictions apply, as follows:

a. You agree not to change the way the Open Source App connects and interacts with our servers; b. You agree not to weaken any of the security features of the Open Source App; c. You agree not to use our servers to store data for purposes other than the intended and original functionality of the Open Source App; d. You acknowledge that you are solely responsible for any and all updates to your Open Source App.

For clarity, if you compile the open source software that we make available from time to time to develop your own mobile, desktop or web application, and do not cause that application to connect to our servers for any purposes, then that application will not be deemed an Open Source App and the foregoing will not apply to that application.

No license is granted to the Wire trademark and its associated logos, all of which will continue to be owned exclusively by Wire Swiss GmbH. Any use of the Wire trademark and/or its associated logos is expressly prohibited without the express prior written consent of Wire Swiss GmbH.

Wire Desktop

Cross platform desktop app, wrapping the wire-webapp. Based on Electron.

Prerequisites

Install Dependencies

sudo apt install git npm nodejs
npm install --global yarn

Clone

git clone https://github.com/wireapp/wire-desktop.git
cd wire-desktop
yarn

Start

yarn start

Test

yarn test

Deployment

StageBranchActionVersion
1 (Feature development)(varies)commitx.y+3 (e.g. 3.20)
2 (Nightly test automation)devcommit or squash merge from feature branchx.y+2 (e.g. 3.19)
3 (Internal release)stagingmerge (don't squash) from devx.y+1 (e.g. 3.18)
4 (Production release)mainmerge (don't squash) from stagingx.y (e.g. 3.17)

Compare Views

  1. Updates from "dev" to "staging" (changelog): https://github.com/wireapp/wire-desktop/compare/staging...dev
  2. Updates from "staging" to "main" (changelog): https://github.com/wireapp/wire-desktop/compare/main...staging

Tasks

# Build for macOS
yarn build:macos

# Build for Windows
yarn build:win

# Build for Linux
yarn build:linux

Other Linux targets

If you would like to build for another Linux target, run the following command:

export LINUX_TARGET=<target>
yarn build:linux

Replace <target> with your desired target (e.g. rpm). Have a look at the documentation for electron-builder for the available targets. Multiple targets can be combined by comma separation (e.g. rpm,deb). Note that we cannot offer support for uncommon targets.

Furthermore, you can disable asar packaging (not recommended, but e.g. needed for target dir) by setting ENABLE_ASAR="false" before building. Example:

export ENABLE_ASAR="false"
yarn build:linux

Troubleshooting

If you are having troubles building Wire for Desktop, then our troubleshooting page might be of help.

Translations

All Wire translations are crowdsourced via Crowdin.

Install wire-desktop under Linux

You can of course use the webapp in your browser, but if you prefer to install wire-desktop, continue reading here:

https://github.com/wireapp/wire-desktop/wiki/How-to-install-Wire-for-Desktop-on-Linux