FlyingCarpet
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.
Top Related Projects
Easily and securely send things from one computer to another :crocodile: :package:
get things from one computer to another, safely
: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
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:
- Download the appropriate version for your operating system from the releases page.
- Install and run the application on both the sending and receiving devices.
- On the sending device, select the file(s) to transfer and choose the receiving device's operating system.
- On the receiving device, select "Receive" and wait for the connection.
- 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
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.
: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.
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
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
Version 8 adds the option to send folders from Android and iOS
Download for Android:
Or if you prefer to sideload, android_FlyingCarpet.apk
is available on the releases page.
Download for iOS:
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!
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 orcargo 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
andwindows-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.
Top Related Projects
Easily and securely send things from one computer to another :crocodile: :package:
get things from one computer to another, safely
: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
Open Source Continuous File Synchronization
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