Duckly – Real-time Pair Programming for Developers

TL;DR

TL;DR: Duckly is a developer-first video call platform that integrates directly into your IDE, enabling real-time pair programming without the bandwidth cost of traditional screen sharing.

Source and Accuracy Notes

• Product: https://duckly.com — formerly GitDuck (YC S20), rebranded to Duckly
• GitHub: no public repo (pure SaaS product)
• HN Launch: https://news.ycombinator.com/item?id=24228826 — 264 points, Show HN

What Is Duckly?

Most video calling tools treat code sharing as an afterthought — you share your entire screen and your collaborator squints at a tiny window. Duckly was built from the ground up for developers who need to actually write code together.

The core idea is simple: instead of screen sharing, you share your IDE session directly. When you join a Duckly call, the Duckly extension wakes up in your IDE and lets you share your code with other participants. They can see and edit your files in real-time, similar to Google Docs, regardless of which IDE they’re using.

The key differentiator is IDE-level integration. You don’t need to be in the same IDE or even the same language — Duckly synchronizes at the file level. You can be in VS Code while your collaborator is in JetBrains, and both of you see each other’s cursors move in real-time.

Setup Workflow

Duckly requires an IDE extension. The setup is straightforward:

Step 1: Install the Extension

Duckly supports VS Code, JetBrains IDEs (IntelliJ, PyCharm, WebStorm), and more. Install from your IDE’s marketplace:

# VS Code — search "Duckly" in Extensions or install via CLI
code --install-extension duckly.duckly

# JetBrains — search "Duckly" in Plugins settings

Step 2: Create or Join a Session

Start a Duckly session from your IDE:

# From terminal — create a room
duckly create

# Or start from VS Code command palette (Ctrl+Shift+P → "Duckly: Start Session")

Share the room link with your collaborator. When they join, your IDE extensions automatically pair — no manual setup required.

Step 3: Collaborate in Real-time

Once connected:

• Both parties see each other’s code cursors
• File changes sync in real-time
• Video and audio are available alongside code collaboration
• You can jump to your collaborator’s cursor position with one click

Deeper Analysis

The IDE Integration Approach

Traditional screen sharing sends compressed video of your screen. Duckly’s approach is fundamentally different — it reads your editor’s buffer directly and streams the actual file state. This means:

• Low bandwidth: No video encoding/decoding for code — just file diffs
• True collaboration: Both parties can edit simultaneously, not just observe
• IDE agnostic: VS Code, JetBrains, Neovim — all work together

The demo video on the site shows two developers collaborating on a Python file — one in VS Code, one in PyCharm — with both cursors visible and edits syncing in under a second.

Real-time Code Synchronization

The sync mechanism is based on operational transformation at the file level. When you edit a line, Duckly sends a minimal diff rather than a pixel update. This is the same concept behind Google Docs’ real-time editing, adapted for code.

For large files, Duckly uses a CRDT-based merge strategy that handles concurrent edits without conflicts. If both developers edit the same line simultaneously, Duckly preserves both changes and resolves the conflict cleanly.

Video and Audio Layer

Beyond code collaboration, Duckly includes standard video call features:

• Webcam and microphone
• Screen sharing (as a fallback option)
• In-call text chat
• Recording

The video layer is WebRTC-based, similar to other modern call tools. The code collaboration runs on a separate, lower-latency channel to ensure file sync isn’t affected by video quality.

Practical Evaluation Checklist

What it does well:

• True real-time code collaboration across different IDEs
• Low bandwidth compared to screen sharing (file diffs vs video stream)
• Developer-focused UX — the entire interface is built around code, not general meetings
• Free tier available for small teams

Where it falls short:

• Requires installing an extension — not browser-based like Loom
• Relies on the IDE extension being maintained for your specific IDE/version
• No real collaboration on non-code files (PDFs, images, documents)
• Rebranding from GitDuck may cause some confusion about the product’s origin and history

Security considerations:

• Code is shared through Duckly’s servers — if you’re working on proprietary code in a regulated industry, verify their data handling policy
• The extension requires read/write access to your workspace files — a significant permission scope
• E2E encryption is available on paid plans

Security Notes

Duckly’s architecture involves their servers receiving and relaying file changes between collaborators. For sensitive codebases:

• Review the privacy policy and data retention terms
• The extension requests broad filesystem access — only grant to trusted tooling
• Enterprise plans offer additional compliance certifications

FAQ

Q: Can I use Duckly without installing anything in my IDE? A: No — the IDE extension is required for code collaboration. You can join a call via browser for audio/video, but code sharing requires the extension.

Q: Does Duckly work with Neovim or Emacs? A: As of the last update, Duckly primarily supports VS Code and JetBrains IDEs. Neovim/Emacs support is limited or experimental.

Q: How does it compare to GitHub’s live share or CodeTogether? A: GitHub Live Share (VS Code only) and CodeTogether support cross-IDE collaboration, but Duckly adds a full video call layer on top. Duckly also rebranded from GitDuck, which originally launched on YC S20 — its feature set has matured over several years.

Q: Is there a self-hosted option? A: Duckly is a cloud-hosted SaaS. Self-hosted options include CodeTogether Server or GitHub Live Share for Visual Studio.

Conclusion

Duckly solves a real problem: pair programming across IDE boundaries without the bandwidth cost of screen sharing. The IDE integration approach is technically sound, and the addition of video/voice makes it a genuine replacement for tools like Zoom when doing remote code review or pair programming.

The extension requirement is the main friction point — if you’re working with collaborators who won’t install tooling, Duckly won’t work. But for teams already bought into IDE-based workflows, it integrates seamlessly and gets out of your way.

For development teams doing regular remote collaboration, Duckly is worth trying over generic video tools. The file-level sync is fundamentally more useful than watching a collaborator’s cursor move through a pixel stream.

Link: https://duckly.com