Moonlink Developer Integration Guide

Moonlink Developer Integration Guide

Overview

Moonlink exposes a named pipe at \\.\pipe\moonlink_input that accepts relative mouse deltas. Your application writes 4-byte packets to this pipe and Moonlink forwards them to the hardware device. The Windows cursor is never moved — there is no fighting, no hooks to worry about, and no SendInput required.

The pipe is available as soon as Moonlink is open. You do not need to press Capture first.

---

Protocol

Each packet is 4 bytes:

Byte	Content	Type
0–1	dx (horizontal delta)	int16, little-endian
2–3	dy (vertical delta)	int16, little-endian

Value range: -32768 to 32767 per axis.

Positive dx = move right. Positive dy = move down.

---

Python

Using the Moonlink client library

Copy moonlink.py into your project. No dependencies beyond the standard library.

from moonlink import Moonlink

# Context manager (recommended)
with Moonlink() as ml:
    ml.move(10, -5)     # move right 10, up 5
    ml.move(-20, 0)     # move left 20

# Manual lifecycle
ml = Moonlink()
ml.move(100, 50)       # auto-connects on first call
print(ml.connected)    # True
ml.close()

Raw pipe access (no library needed)

import struct

pipe = open(r'\\.\pipe\moonlink_input', 'wb', buffering=0)
pipe.write(struct.pack('<hh', 10, -5))   # 4 bytes: dx=10, dy=-5
pipe.close()

Mouse button handler

Moonlink forwards physical button state automatically — your code only sends movement deltas through the pipe. But your application needs to read button state to know when to activate (e.g., "aim while right-click is held").

Use win32api.GetAsyncKeyState for low-latency, non-blocking button polling. This works globally — no window focus required.

import win32api

# Virtual key codes for all 5 standard mouse buttons
VK_LBUTTON  = 0x01   # Left click
VK_RBUTTON  = 0x02   # Right click
VK_MBUTTON  = 0x04   # Middle click (scroll wheel press)
VK_XBUTTON1 = 0x05   # Back (Mouse4)
VK_XBUTTON2 = 0x06   # Forward (Mouse5)

def is_pressed(vk_code):
    """Returns True if the button is currently held down."""
    return win32api.GetAsyncKeyState(vk_code) < 0

Usage — check any button:

if is_pressed(VK_RBUTTON):    # right click held
    ...
if is_pressed(VK_XBUTTON1):  # back button held
    ...

Practical example — activate while holding a button

A common pattern: send AI movement only while a specific button is held.

import time
from moonlink import Moonlink
import win32api

VK_RBUTTON = 0x02

ml = Moonlink()

while True:
    if win32api.GetAsyncKeyState(VK_RBUTTON) < 0:
        dx, dy = get_ai_deltas()  # your AI logic here
        ml.move(dx, dy)
    time.sleep(0.001)

Toggle mode

If you prefer a toggle (press once to activate, press again to deactivate):

import win32api, time

VK_XBUTTON1 = 0x05  # back button as toggle
active = False
was_pressed = False

while True:
    pressed = win32api.GetAsyncKeyState(VK_XBUTTON1) < 0
    if pressed and not was_pressed:   # rising edge
        active = not active
        print(f"{'ON' if active else 'OFF'}")
    was_pressed = pressed

    if active:
        dx, dy = get_ai_deltas()
        ml.move(dx, dy)

    time.sleep(0.001)

All 5 buttons — reference table

Button	Virtual Key	Constant	Typical Use
Left	0x01	VK_LBUTTON	Shoot / interact
Right	0x02	VK_RBUTTON	Aim / scope
Middle	0x04	VK_MBUTTON	Secondary toggle
Back (Mouse4)	0x05	VK_XBUTTON1	Toggle on/off
Forward (Mouse5)	0x06	VK_XBUTTON2	Mode switch

Full example — circle movement

import math, time
from moonlink import Moonlink

radius = 25
angle = 0.0

with Moonlink() as ml:
    while True:
        dx = int(radius * math.cos(angle))
        dy = int(radius * math.sin(angle))
        ml.move(dx, dy)
        angle += 0.1
        time.sleep(0.001)

---

C / C++

Connecting to the pipe

#include <windows.h>

HANDLE open_moonlink() {
    return CreateFileA(
        "\\\\.\\pipe\\moonlink_input",
        GENERIC_WRITE,
        0,              // no sharing
        NULL,           // default security
        OPEN_EXISTING,
        0,              // default attributes
        NULL
    );
}

Sending a delta

#include <cstdint>

bool send_move(HANDLE pipe, int16_t dx, int16_t dy) {
    uint8_t buf[4];
    buf[0] = dx & 0xFF;
    buf[1] = (dx >> 8) & 0xFF;
    buf[2] = dy & 0xFF;
    buf[3] = (dy >> 8) & 0xFF;

    DWORD written;
    return WriteFile(pipe, buf, 4, &written, NULL) && written == 4;
}

Mouse button handler

// Virtual key codes for all 5 mouse buttons
#define VK_LBUTTON  0x01
#define VK_RBUTTON  0x02
#define VK_MBUTTON  0x04
#define VK_XBUTTON1 0x05   // Back (Mouse4)
#define VK_XBUTTON2 0x06   // Forward (Mouse5)

bool is_pressed(int vk) {
    return GetAsyncKeyState(vk) < 0;
}

// Usage:
// if (is_pressed(VK_RBUTTON)) { /* right click held — send AI movement */ }

Full example

#include <windows.h>
#include <cstdint>
#include <cmath>

int main() {
    HANDLE pipe = CreateFileA(
        "\\\\.\\pipe\\moonlink_input",
        GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL
    );

    if (pipe == INVALID_HANDLE_VALUE) {
        printf("Failed to connect. Is Moonlink running?\n");
        return 1;
    }

    double angle = 0.0;
    int radius = 25;

    while (true) {
        int16_t dx = (int16_t)(radius * cos(angle));
        int16_t dy = (int16_t)(radius * sin(angle));

        uint8_t buf[4] = {
            (uint8_t)(dx & 0xFF), (uint8_t)((dx >> 8) & 0xFF),
            (uint8_t)(dy & 0xFF), (uint8_t)((dy >> 8) & 0xFF)
        };

        DWORD written;
        if (!WriteFile(pipe, buf, 4, &written, NULL)) break;

        angle += 0.1;
        Sleep(1);
    }

    CloseHandle(pipe);
    return 0;
}

---

C#

using System.IO.Pipes;

using var pipe = new NamedPipeClientStream(".", "moonlink_input", PipeDirection.Out);
pipe.Connect();

void Move(short dx, short dy) {
    byte[] buf = new byte[4];
    BitConverter.TryWriteBytes(buf.AsSpan(0), dx);
    BitConverter.TryWriteBytes(buf.AsSpan(2), dy);
    pipe.Write(buf, 0, 4);
}

Move(10, -5);

---

Rust

use std::io::Write;
use std::os::windows::fs::OpenOptionsExt;

fn main() -> std::io::Result<()> {
    let mut pipe = std::fs::OpenOptions::new()
        .write(true)
        .open(r"\\.\pipe\moonlink_input")?;

    let dx: i16 = 10;
    let dy: i16 = -5;
    pipe.write_all(&dx.to_le_bytes())?;
    pipe.write_all(&dy.to_le_bytes())?;

    Ok(())
}

---

Tips

• Pipe is always open — you can connect as soon as Moonlink launches, before pressing Capture.

• Unbuffered writes — use buffering=0 in Python or write-through in other languages for lowest latency.

• Reconnection — if the pipe disconnects (Moonlink restarts), just reopen it. Moonlink recreates the pipe server automatically.

• Movement only — the pipe handles movement. Buttons and scroll wheel are read from your physical mouse by Moonlink automatically.

• No cursor movement — pipe data goes straight to the device. The Windows cursor stays where it is.

• Legacy mode — if your software must use SendInput, uncheck "Pipe Mode" in Moonlink's Misc tab. This enables the older hook-based interception. Not recommended.