Convert Figma logo to code with AI

spieglt logoFlyingCarpet

Cross-platform AirDrop. File transfer between Android, iOS, Linux, macOS, and Windows over ad hoc WiFi. No network infrastructure required, just two devices with WiFi chips in close range.

3,685
147
3,685
17

Top Related Projects

28,343

Easily and securely send things from one computer to another :crocodile: :package:

get things from one computer to another, safely

10,036

:zap: Transfer files over wifi from your computer to your mobile device by scanning a QR code without leaving the terminal.

⚡️ Streaming torrent client for the web

66,967

Open Source Continuous File Synchronization

Quick Overview

FlyingCarpet is an open-source file transfer tool that allows users to send files between devices without the need for an internet connection or external servers. It creates a direct Wi-Fi connection between devices, enabling secure and fast file transfers across different operating systems, including Windows, macOS, and Linux.

Pros

  • Cross-platform compatibility (Windows, macOS, Linux)
  • No internet connection required for file transfers
  • Secure transfers using WPA2 encryption
  • User-friendly graphical interface

Cons

  • Limited to local network transfers
  • Requires both sender and receiver to have the application installed
  • May encounter issues with certain firewall configurations
  • Not suitable for large-scale or frequent file transfers across the internet

Getting Started

To use FlyingCarpet:

  1. Download the appropriate version for your operating system from the releases page.
  2. Install and run the application on both the sending and receiving devices.
  3. On the sending device, select the file(s) to transfer and choose the receiving device's operating system.
  4. On the receiving device, select "Receive" and wait for the connection.
  5. Once connected, the file transfer will begin automatically.

Note: Ensure that both devices are on the same local network or within Wi-Fi range of each other for the transfer to work.

Competitor Comparisons

28,343

Easily and securely send things from one computer to another :crocodile: :package:

Pros of croc

  • Cross-platform support (Windows, macOS, Linux, Android)
  • End-to-end encryption for secure file transfers
  • Simple command-line interface for easy usage

Cons of croc

  • Requires an internet connection for file transfers
  • May have slower transfer speeds compared to local network transfers
  • Limited GUI options for non-technical users

Code comparison

croc:

func (c *Client) Send(sendOptions *SendOptions) error {
    // ... (code for sending files)
}

FlyingCarpet:

func (t *Transfer) Send() error {
    // ... (code for sending files)
}

Both projects use Go for their implementation, but they have different approaches to file transfer. croc focuses on secure, internet-based transfers using relay servers, while FlyingCarpet emphasizes local network transfers using Wi-Fi Direct or ad-hoc connections.

croc offers a more straightforward setup process and broader platform support, making it easier for users to transfer files across different devices and operating systems. However, FlyingCarpet provides faster transfer speeds for local network transfers and doesn't require an internet connection.

The code comparison shows that both projects have similar function signatures for sending files, but the underlying implementation differs due to their distinct transfer mechanisms.

get things from one computer to another, safely

Pros of Magic-Wormhole

  • Cross-platform support (Linux, macOS, Windows)
  • Command-line interface for easy scripting and automation
  • Uses a secure, encrypted channel for file transfer

Cons of Magic-Wormhole

  • Requires Python installation and dependencies
  • Less user-friendly for non-technical users
  • Limited GUI options

Code Comparison

Magic-Wormhole (Python):

from wormhole import wormhole
w = wormhole.create(appid, relay_url)
code = w.get_code()
w.send_file(filename)

FlyingCarpet (Go):

transfer := flyingcarpet.NewTransfer()
transfer.Send(filename)
code := transfer.GetCode()

Magic-Wormhole uses a Python-based approach with a focus on secure, encrypted file transfer through a command-line interface. It offers cross-platform support but requires Python installation and may be less intuitive for non-technical users.

FlyingCarpet, written in Go, provides a more user-friendly GUI experience and doesn't require additional dependencies. However, it may have limited platform support compared to Magic-Wormhole.

Both projects aim to simplify secure file transfers, with Magic-Wormhole offering more flexibility for advanced users and FlyingCarpet focusing on ease of use for general users.

10,036

:zap: Transfer files over wifi from your computer to your mobile device by scanning a QR code without leaving the terminal.

Pros of qrcp

  • Simpler setup and usage, requiring no additional software installation
  • Cross-platform compatibility (Windows, macOS, Linux)
  • Supports sending multiple files and directories

Cons of qrcp

  • Requires both devices to be on the same network
  • Limited to file transfer functionality only
  • May have potential security risks if used on public networks

Code Comparison

qrcp:

func main() {
    flag.Parse()
    config := new(Config)
    if err := config.Load(*configFilePath); err != nil {
        log.Fatal(err)
    }
}

FlyingCarpet:

func main() {
    flag.Parse()
    if *helpPtr {
        flag.Usage()
        os.Exit(0)
    }
    fc := flyingcarpet.FlyingCarpet{}
    fc.Mode = *modePtr
}

Both projects use Go and implement a command-line interface. qrcp focuses on configuration loading, while FlyingCarpet initializes its main struct and sets the operating mode.

FlyingCarpet offers a more comprehensive file transfer solution with its own network creation, making it suitable for scenarios where devices are not on the same network. However, this comes at the cost of increased complexity and setup requirements. qrcp, on the other hand, provides a simpler, more straightforward approach for quick file transfers within the same network.

⚡️ Streaming torrent client for the web

Pros of WebTorrent

  • Broader application: WebTorrent is a streaming torrent client for the web, supporting a wider range of use cases
  • Active development: More frequent updates and larger community support
  • Cross-platform compatibility: Works on web browsers and Node.js environments

Cons of WebTorrent

  • Complexity: More complex setup and usage compared to FlyingCarpet's focused file transfer approach
  • Resource usage: May consume more system resources due to its broader functionality

Code Comparison

WebTorrent (JavaScript):

const WebTorrent = require('webtorrent')
const client = new WebTorrent()

client.seed('path/to/file', (torrent) => {
  console.log('Client is seeding:', torrent.infoHash)
})

FlyingCarpet (Go):

transfer := flyingcarpet.New()
err := transfer.Send("path/to/file", "WiFi")
if err != nil {
    log.Fatal(err)
}

While both facilitate file transfers, WebTorrent uses a torrent-based approach for broader content distribution, whereas FlyingCarpet focuses on direct peer-to-peer file transfers using local network protocols.

66,967

Open Source Continuous File Synchronization

Pros of Syncthing

  • Continuous file synchronization across multiple devices
  • Robust security features with end-to-end encryption
  • Large and active community support

Cons of Syncthing

  • More complex setup and configuration process
  • Higher resource usage for continuous syncing

Code Comparison

FlyingCarpet (Go):

func (fc *FileSender) Send() error {
    fc.sendOverNetwork()
    return nil
}

Syncthing (Go):

func (m *Model) pullFile(file protocol.FileInfo, copyChan chan<- copyBlocksState) error {
    m.pmut.RLock()
    defer m.pmut.RUnlock()
    // ... (additional logic)
}

FlyingCarpet focuses on simple, direct file transfers between two devices, while Syncthing implements a more complex continuous synchronization system. The code snippets reflect this difference, with FlyingCarpet's simpler send function contrasting Syncthing's more elaborate file pulling mechanism.

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

Version 8 adds the option to send folders from Android and iOS

Download for Android:

Get it on Google Play  Get it on F-Droid

Or if you prefer to sideload, android_FlyingCarpet.apk is available on the releases page.

Download for iOS:

Get it on Apple App Store

Or search the App Store for "Flying Carpet File Transfer".

Linux, macOS, and Windows versions are available on the releases page. Installers and standalone executable versions available.

Flying Carpet

Send and receive files between Android, iOS, Linux, macOS, and Windows over ad hoc WiFi. No shared network or cell connection required, just two devices with WiFi chips in close range.

Don't have a flash drive? Don't have access to a wireless network? Need to move a file larger than 2GB between different filesystems but don't want to set up a network share? Try it out!

Demo video

Screenshots:


Use:

Linux: Download the .AppImage file from the releases page for a standalone version, or if you're on a Debian-based distribution, download the .deb file and install it with apk or dpkg.

macOS: Download the .dmg disk image file from the releases page. Double-click to mount it and drag the .app bundle inside to your Applications folder. Or if you use Homebrew, run brew install flying-carpet.

Windows: Download the .msi installer from the releases page, or FlyingCarpet.exe for a standalone version.

Compilation Instructions:

  • Install Rust.

  • Run cargo install tauri-cli to install Tauri.

  • Mac only: Install XCode. Open FlyingCarpetMac/FlyingCarpetMac/FlyingCarpetMac.xcodeproj and build it.

  • For Linux, install dependencies. Ubuntu 20 example:

sudo apt install libsoup2.4* libjavascriptcoregtk* libgdk-pixbuf2.0* librust-pango-sys-dev libgdk3.0* librust-atk-dev librust-atk-sys-dev librust-gdk* libwebkit2gtk* librsvg2-dev
  • Run cargo tauri dev to run a development version or cargo tauri build to create release artifacts.

Restrictions:

  • Apple devices can only transfer to/from Android, Linux, and Windows as they can no longer programmatically run hotspots. Use AirDrop instead for Apple-to-Apple transfers.

  • Disables your wireless internet connection while in use. (Does not apply to Windows or Android when hosting the hotspot.)

  • macOS sometimes switches back to a wireless network with internet connectivity during particularly long transfers.

  • The Android version requires at least Android 8/API level 26. The Android version does not work on some Xiaomi, MIUI, or HarmonyOS devices, and possibly other Android-like OSes. I don't own these devices and so can't test, but it seems like this is due to lack of support for the LocalOnlyHotspot API. It has been confirmed to work on at least one Xiaomi phone.

  • Requires Windows 10 or later.

  • The Linux version was developed and tested on Linux Mint. I mainly intend for it to run on Debian-based distributions. I will try to help troubleshoot others if I can, but I may not be able to as I don't have access to spare machines. There has been at least one issue running on Fedora, possibly to SELinux but I don't really know.

  • Sometimes when the Cancel button is hit on the desktop platforms, it can take time for the OS to finish trying to join or create a hotspot. Please only click the Cancel button once and wait a few seconds. This sounds like it should be easy to fix, but last time I tried it was not.

Planned Features

  • Bluetooth for connection negotiation (instead of QR code scanning or manual entry)?

  • Add Flying Carpet shortcut to iOS Share menu.

Questions That Could Be Asked at Some Point:

  • Wasn't this a Go repo? Yes, carcinization has come for the gopher. There were several issues I didn't know how to solve in the Go/Qt paradigm, especially with Windows: not being able to make a single-file executable, needing to Run as Administrator, and having to write the WiFi Direct DLL to a temp folder and link to it at runtime because Go doesn't work with MSVC. Plus it was fun to use tokio/async and windows-rs, with which the Windows networking portions are written. The GUI framework is now Tauri which gives a native experience on all platforms with a very small footprint. The Android version is written in Kotlin and the code is in this repository. The iOS version is written in Swift and the code is not public.

  • You're using SHA-256 to derive the key from a password. Isn't that bad? Shouldn't you be using a Password-Based Key Derivation Function like Scrypt or Argon2? I was doing this before, but it wasn't strictly necessary because these keys are only used during the file transfer. For an attacker to intercept the data in transit, they'd need to be on the hotspot network, which is protected by WPA2, so they'd need to shoulder-surf the password or QR code. The change to SHA-256 was made because I couldn't find a good Scrypt or Argon2 implementation on all platforms when I added the mobile versions.

  • Why are you using AES-GCM at all if there's already WPA2 then? When I started working on this project in 2017, I was trying to allow for IBSS WiFi networks on macOS that didn't use authentication. I was using the wrong encryption (and incorrectly) then, and later I added AES-GCM because it's the only good and official-ish AEAD implementation I could find in all of Go, Swift, Kotlin, and now Rust. If any cryptographers read this and find that I'm still being dumb, please let me know.

If you've used Flying Carpet, please send feedback to theron@spiegl.dev. Thanks for your interest! Please also check out https://github.com/spieglt/cloaker, https://cloaker.mobi, and https://github.com/spieglt/whatfiles.