What Is Aki Dev Sync? A macOS App to Sync Split Dev Environments

What Is Aki Dev Sync?

Aki Dev Sync is a native macOS application (built on a Rust Core + Tauri v2 + Vue 3 architecture) developed by Lac Viet Anh, acting as a true Central Control Station for split development environments. Unlike typical sync utilities, this application is fine-tuned for a highly specific workflow: it allows you to write code on two different machines, preserving the source of truth on your local machine while confidently pushing heavy workloads (like docker builds, compilations, or AI agent runs) to a remote machine via a secure SSH connection, all without ever polluting your git history just to ferry files back and forth.

This is a native macOS desktop app, not a static browser mini-app. Aki Dev Sync is a native desktop software that runs deep in macOS, downloaded directly as a dmg file from GitHub, and designed to stay running 24/7 on your machine.

How Does the Local ↔ Remote Model Work?

Aki Dev Sync keeps the two halves of your environment in baseline-aware sync, solving the biggest headache of multi-device coding. You code on one machine, offload tasks to another, and smoothly funnel the results back without having to deal with meaningless git commit spam on GitHub.

• LOCAL - Usually the ultimate source of truth: This is your laptop or Mac Studio, where the full git history is kept. You review, commit, and edit code using a personal IDE (e.g., Antigravity, VSCode Insiders). Data on the local machine is protected with the highest strictness.
• REMOTE - The high-speed SSH workstation: A GPU server or a much stronger rig sitting in the cloud or across the room. This is where you run heavy, RAM-hungry builds, securely store core intellectual property, or leverage the computational power of expensive AI models (like Claude MAX) to generate large code changes autonomously.
• The PUSH mechanism: Sends all changes from local to remote so the AI can see the complete picture of your project. By default, the configuration includes the .git/ directory so the AI can read the full commit history. If you remove .git/ from the PULL list, it transforms into a push-only path (files are only pushed up, never pulled back down, completely eliminating the annoyance of the sync button constantly lighting up due to hidden git index mtime changes).
• The PULL mechanism: Gathers all the code the AI just diligently generated on the remote, automatically packages it, and funnels it back to your local machine for you to review, test, and commit, thereby closing a complete working loop.

Sync Engine Deep Dive

The sync functionality (Sync Engine) is not merely about pushing files back and forth; it is a massive data safety net equipped with a barrage of sophisticated algorithms under the hood:

• PUSH-ONLY PATHS & MTIME TRAP FIX: Many rsync tools fall into the mtime (modified time) trap because git constantly runs housekeeping (updating the .git/index file). Aki Dev Sync provides the ability to configure directories as Push-only: files are pushed to the remote but never pulled back. This gives the AI the Git history it needs, while the app smartly ignores any internal changes in this directory, completely neutralizing the nuisance of phantom sync notifications.
• SELECT (Push Special) & CONFLICT TABLE: When you don't want to sync an entire directory, you can use the native macOS file picker to select individual files to send. Before rsync overwrites anything, the Tauri system intercepts the action and displays a Conflict Table, comparing local and remote modification times before the push. You can clearly see which file is newer on which side, helping you review the difference before confirming the push.
• MIRROR & DELETE MODE: Using the --delete flag in rsync is a double-edged sword. This application disables this flag by default for PUSH operations, and integrates an automated warning dialog that pops up if you are about to PUSH over a directory tree containing un-pulled AI changes. This confirmation is designed to reduce accidental overwrites.
• DRY RUN & DIRECTORY FILTER: The Dry Run button lets you preview exactly what rsync will alter (how many files added, which ones deleted) without writing a single byte to disk. Aki Dev Sync's custom filter automatically strips out directory-only changes from the output log, ensuring that the results displayed to the user only contain actual code files.
• BASELINE SNAPSHOT DISAMBIGUATION (Bidirectional Disambiguation): Rsync is inherently stateless; it simply compares two current directories without knowing where file X was deleted (e.g., machine A lacks X, machine B has X -> rsync doesn't know if A just deleted X or B just created X). Aki Dev Sync thoroughly solves this fatal flaw by saving a snapshot (baseline) as a JSON file after every successful sync. Thanks to this, the app can accurately deduce: was file Y deleted locally (so show it in the Push tab) or deleted on the remote (so ignore it), creating baseline-aware comparison.
• PROFESSIONAL PRE/POST HOOKS: You can configure shell scripts to execute immediately before or after every push/pull. You can trigger a docker container build, restart a daemon service, clear caches, or fire a Slack notification the second rsync finishes, and these can be set to run silently locally or via SSH on the remote host.

Management & Monitoring Tools (Under The Hood)

Beneath the simple UI lies incredible software engineering finesse down to the smallest detail:

• REAL AI Quota Monitoring: It reads available quota data from the supported CLI caches and local RPC sources rather than estimating token usage.
  • Claude Code & Hybrid Patching: The app connects directly via SSH to read the statusLine hook cache generated by the Anthropic CLI after every turn. It clearly displays rate limits for the 5-hour and 7-day windows, plan tier, and organization info. The Hybrid Patching mechanism combines bash and jq to retain the last known rate-limit data when the CLI response omits it after an HTTP 429.
  • Antigravity RPC Connect: To retrieve metrics from Antigravity, the app runs a command scanning the OS's Process Table (lsof), pinpoints the exact local port the IDE Language Server is listening on, and directly fires an HTTP/JSON-RPC (Connect protocol) query. This process accurately fetches the token pools for Gemini and Claude OSS at blazing speeds, responding in roughly local RPC, completely bypassing any middleman servers. The Log Out feature is also delicately engineered to reach straight into the macOS Keychain and permanently obliterate the secure encryption key.
• ZERO-JS TEXTAREA FOR NOTES: The Project notes field and the Global Note utility (a persistent notepad living on the titlebar that automatically debounces file saves every 500ms) can automatically expand their height to fit the typed content. This feature is implemented entirely using next-generation native CSS properties (field-sizing: content), without custom ResizeObserver or JavaScript resize listeners.
• SMART OPEN POPUP & LOCKFILE ANALYZER: The project launcher provides more than just shortcuts. It houses an automated analyzer module that scans subdirectories and lockfiles (pnpm-lock, yarn.lock, bun.lockb, Cargo.toml). From there, the system identifies the tech stack (Tauri, Node, Nuxt) and generates the precise DEV/BUILD launch commands. When clicked, the command runs in the app's interactive terminal tab; external tools remain available where selected. Furthermore, it automatically checks whether your machine has code-insiders or code installed, dynamically dimming IDEs that are missing.
• UNIT-OF-WORK REFRESH CONTROLLER: This is a monolithic foundational architecture designed to unify all state refresh actions (background timers, manual button clicks, config save operations). The spinning/busy state belongs to the lifecycle of the process itself, rather than being tied to the UI button. This guarantees the app never lies (reporting a false running state). Moreover, it utilizes a "generation token" flag to instantly abort background refreshes upon a new request, without ever hanging or affecting any active rsync data transfers.
• NATIVE GIT PANEL WITH ANSI PARSER: Instead of forcing you to open a terminal, the app features a dedicated Git tab. This tab integrates a complex regex-based parser running directly on the client to analyze ANSI escape color codes ([...m), transforming rigid commit logs into a colorful interface identical to a native Terminal. It mandates the core.quotepath=false configuration to support flawless display of Vietnamese filenames, while simultaneously integrating a ready-to-use Visual Changelog Markdown preview powered by the Mermaid JS rendering library.
• METICULOUS UX & STATUSLINE CUSTOMIZER: Narrow Mode smoothly scales the window down at 440px; the Stick Top-Left window preset anchors the app in a corner, with the pin option available across macOS Desktops/Spaces; and the pinnacle is the Statusline Customizer - an HTML5 drag-and-drop interface for building bash configurations for Claude Code. It supports a 5-tier dynamic color ladder (Blue, Green, Yellow, Orange, Red) that shifts based on quota urgency thresholds, offering a live preview that updates the moment you change a color. As of v1.26.0, this tool unifies monitoring across both major AI CLI agents (Claude Code and Antigravity) from a single config, instead of setting each one up separately.

How Do You Install Aki Dev Sync?

1. Visit the GitHub Releases page and download the latest .dmg file. Choose -arm.dmg if you are using an Apple Silicon machine (M1/M2/M3), or -uni.dmg if you need a file that runs on older Intel architectures as well.
2. Open the .dmg file and drag the Aki Dev Sync icon into your Applications folder as per OS standards.
3. Because the build is unsigned, on the first launch, macOS Gatekeeper will block it with a security warning. Simply right-click the app, select Open, and confirm. Alternatively, if you are comfortable with the terminal, just run the command xattr -dr com.apple.quarantine /Applications/Aki Dev Sync.app to strip the quarantine flag.

System requirements: Your machine must have the rsync and ssh tools available on your PATH (fortunately, macOS ships with both of these out of the box since its early days), plus you must own a reachable SSH host (a VPS, Dedicated Server, or a Raspberry Pi).

Getting Started With Aki Dev Sync

Aki Dev Sync is built on an incredibly modern tech stack: the frontend uses Vue 3 + Vite, while the core backend is written in Rust and compiled via the Tauri v2 framework, for a native macOS desktop app. All file transfer operations run entirely on the native macOS rsync and ssh commands, using the system tools available on macOS. You can view the full source code, read the historical changelog, and consult the in-depth technical documentation at github.com/lacvietanh/aki-dev-sync, or grab the latest build from the Releases page.