Virtual Printer¶

The Virtual Printer feature allows Bambuddy to emulate one or more Bambu Lab printers on your network. This enables you to send prints directly from Bambu Studio or OrcaSlicer to Bambuddy, even without a physical printer connected.

You can create multiple virtual printers, each with its own dedicated IP address, mode, printer model, and access code. Each virtual printer runs completely independent services (FTP, MQTT, SSDP, Bind).

Overview¶

When enabled, each virtual printer:

• Can be discovered automatically via SSDP (same LAN) or added manually by IP (VPN, remote, Docker bridge)
• Accepts print jobs over secure TLS connections (MQTT + FTP)
• Archives prints directly, queues them for review, or adds them to the print queue
• Works with the same workflow as sending to a real Bambu Lab printer
• Runs on its own dedicated bind IP with independent services

Modes¶

The virtual printer supports four modes:

The first three are server modes — Bambuddy runs its own FTP/MQTT servers and receives files locally. Proxy mode is different — Bambuddy acts as a TLS relay to a real printer.

Use Cases¶

• Print Archiving: Send prints to Bambuddy for archiving without starting them
• Queue Building: Build up a print queue before your printer is available
• Print Farm Preparation: Prepare jobs to distribute across multiple printers
• Remote Slicing: Slice on one computer and send to Bambuddy running elsewhere
• Remote Printing: Print from anywhere via Proxy Mode (see below)

Required Ports¶

Each virtual printer uses these ports on its dedicated bind IP:

Certificate Installation¶

Step 1: Locate the CA Certificate¶

The Bambuddy CA certificate is at:

• Native install: virtual_printer/certs/bbl_ca.crt
• Docker: Extract with docker cp bambuddy:/app/data/virtual_printer/certs/bbl_ca.crt ./bambuddy-ca.crt

Step 2: Append the Bambuddy CA Certificate to Slicer¶

The slicer's printer.cer file contains PEM certificates. You need to append the Bambuddy CA certificate to this file.

Open printer.cer in a text editor and:

1. Go to the end of the file
2. Paste the entire contents of bambuddy-ca.crt after the last -----END CERTIFICATE-----
3. Save the file
4. Fully restart the slicer (Cmd+Q on macOS, not just close the window)

Certificate file locations:

Certificate Persistence¶

The CA certificate is generated once and persists across Bambuddy restarts. If you switch between Docker and native installations, share the certificate directory to avoid regenerating:

volumes:
  - ./virtual_printer:/app/data/virtual_printer

Multiple Bambuddy Hosts¶

Each Bambuddy installation generates its own unique CA certificate.

Option 1: Share the CA (Recommended)

Copy the certs/ directory from one host to all others:

# Copy certs from host1 to host2
scp -r host1:/path/to/virtual_printer/certs/ host2:/path/to/virtual_printer/

Then restart Bambuddy on host2. All hosts will use the same CA, so one certificate in the slicer works for all.

Option 2: Update Certificate When Switching Hosts

Each time you switch to a different Bambuddy host:

1. Extract the CA from the new host
2. Open the slicer's printer.cer file
3. Remove the old Bambuddy CA (if present) and append the new one
4. Fully restart the slicer

Platform Setup¶

Choose your platform below for specific setup instructions.

Linux (Native Installation)¶

Port 990 is a privileged port. You need iptables rules to redirect it:

# Redirect incoming traffic on port 990 to 9990
sudo iptables -t nat -A PREROUTING -p tcp --dport 990 -j REDIRECT --to-port 9990

# Redirect localhost traffic on port 990 to 9990
sudo iptables -t nat -A OUTPUT -o lo -p tcp --dport 990 -j REDIRECT --to-port 9990

Make rules persistent:

sudo apt install iptables-persistent
sudo netfilter-persistent save

sudo dnf install iptables-services
sudo service iptables save

sudo iptables-save > /etc/iptables/iptables.rules
sudo systemctl enable iptables

Firewall rules (if using UFW):

sudo ufw allow 3000/tcp  # Bind/detect
sudo ufw allow 3002/tcp  # Bind/detect
sudo ufw allow 2021/udp  # SSDP
sudo ufw allow 8883/tcp  # MQTT
sudo ufw allow 990/tcp   # FTPS
sudo ufw allow 9990/tcp  # FTPS internal
sudo ufw allow 50000:50100/tcp  # FTP passive data

Firewall rules (if using firewalld):

sudo firewall-cmd --permanent --add-port=3000/tcp  # Bind/detect
sudo firewall-cmd --permanent --add-port=3002/tcp  # Bind/detect
sudo firewall-cmd --permanent --add-port=2021/udp  # SSDP
sudo firewall-cmd --permanent --add-port=8883/tcp  # MQTT
sudo firewall-cmd --permanent --add-port=990/tcp   # FTPS
sudo firewall-cmd --permanent --add-port=9990/tcp  # FTPS internal
sudo firewall-cmd --permanent --add-port=50000-50100/tcp  # FTP passive data
sudo firewall-cmd --reload

Docker (Linux)¶

Docker requires host networking for SSDP discovery to work.

docker-compose.yml:

services:
  bambuddy:
    image: ghcr.io/maziggy/bambuddy:latest
    container_name: bambuddy
    network_mode: host  # Required for SSDP discovery
    cap_add:
      - NET_BIND_SERVICE  # Required for virtual printer proxy (port 990)
    volumes:
      - bambuddy_data:/app/data
      - bambuddy_logs:/app/logs
    environment:
      - TZ=Europe/Berlin
    restart: unless-stopped

volumes:
  bambuddy_data:
  bambuddy_logs:

You still need iptables rules on the host (for the FTP 990 → 9990 redirect):

sudo iptables -t nat -A PREROUTING -p tcp --dport 990 -j REDIRECT --to-port 9990
sudo iptables -t nat -A OUTPUT -o lo -p tcp --dport 990 -j REDIRECT --to-port 9990

Make rules persistent (Debian/Ubuntu):

sudo apt install iptables-persistent
sudo netfilter-persistent save

Firewall rules (if using UFW):

sudo ufw allow 3000/tcp  # Bind/detect
sudo ufw allow 3002/tcp  # Bind/detect
sudo ufw allow 2021/udp  # SSDP
sudo ufw allow 8883/tcp  # MQTT
sudo ufw allow 990/tcp   # FTPS
sudo ufw allow 9990/tcp  # FTPS internal
sudo ufw allow 50000:50100/tcp  # FTP passive data

Firewall rules (if using firewalld):

sudo firewall-cmd --permanent --add-port=3000/tcp  # Bind/detect
sudo firewall-cmd --permanent --add-port=3002/tcp  # Bind/detect
sudo firewall-cmd --permanent --add-port=2021/udp  # SSDP
sudo firewall-cmd --permanent --add-port=8883/tcp  # MQTT
sudo firewall-cmd --permanent --add-port=990/tcp   # FTPS
sudo firewall-cmd --permanent --add-port=9990/tcp  # FTPS internal
sudo firewall-cmd --permanent --add-port=50000-50100/tcp  # FTP passive data
sudo firewall-cmd --reload

Docker (macOS / Windows)¶

Use bridge networking with port mapping:

services:
  bambuddy:
    image: ghcr.io/maziggy/bambuddy:latest
    container_name: bambuddy
    cap_add:
      - NET_BIND_SERVICE
    ports:
      - "${PORT:-8000}:8000"           # Web UI
      - "3000:3000"                    # Bind/detect
      - "3002:3002"                    # Bind/detect (alt port)
      - "990:9990"                     # FTPS (host 990 → container 9990)
      - "8883:8883"                    # MQTT
      - "50000-50100:50000-50100"      # FTP passive data
    volumes:
      - bambuddy_data:/app/data
      - bambuddy_logs:/app/logs
    environment:
      - TZ=Europe/Berlin
      # Required for FTP passive mode behind Docker NAT:
      # Set to your Docker host's LAN IP
      #- VIRTUAL_PRINTER_PASV_ADDRESS=192.168.1.100
    restart: unless-stopped

volumes:
  bambuddy_data:
  bambuddy_logs:

Unraid¶

1. Set Network Type to host in container settings

2. Add iptables rules via Unraid terminal:

   iptables -t nat -A PREROUTING -p tcp --dport 990 -j REDIRECT --to-port 9990
   iptables -t nat -A OUTPUT -o lo -p tcp --dport 990 -j REDIRECT --to-port 9990
   

3. Make rules persistent by adding to /boot/config/go:

   echo "iptables -t nat -A PREROUTING -p tcp --dport 990 -j REDIRECT --to-port 9990" >> /boot/config/go
   echo "iptables -t nat -A OUTPUT -o lo -p tcp --dport 990 -j REDIRECT --to-port 9990" >> /boot/config/go
   

Synology NAS¶

1. Use Host Network in Container Manager

2. SSH into your NAS and add iptables rules:

   sudo iptables -t nat -A PREROUTING -p tcp --dport 990 -j REDIRECT --to-port 9990
   

3. Create a scheduled task to restore rules on boot:

4. Control Panel → Task Scheduler → Create → Triggered Task → User-defined script
5. Event: Boot-up
6. Script: iptables -t nat -A PREROUTING -p tcp --dport 990 -j REDIRECT --to-port 9990

TrueNAS SCALE¶

1. Use Host Network when creating the app/container

2. Add iptables rules via shell:

   iptables -t nat -A PREROUTING -p tcp --dport 990 -j REDIRECT --to-port 9990
   iptables -t nat -A OUTPUT -o lo -p tcp --dport 990 -j REDIRECT --to-port 9990
   

Proxmox LXC¶

1. Enable nesting in container options (for iptables support)

2. Inside the LXC:

   apt install iptables
   iptables -t nat -A PREROUTING -p tcp --dport 990 -j REDIRECT --to-port 9990
   iptables -t nat -A OUTPUT -o lo -p tcp --dport 990 -j REDIRECT --to-port 9990
   
   # Make persistent
   apt install iptables-persistent
   netfilter-persistent save
   

Configuration¶

Creating a Virtual Printer¶

1. Complete the platform setup above first
2. Go to Settings in Bambuddy
3. Scroll to the Virtual Printer section
4. Click Add Virtual Printer
5. Set a Name for this virtual printer
6. Choose your Mode: Immediate, Review, Print Queue, or Proxy
7. Choose the Printer Model to emulate
8. Set an Access Code (exactly 8 characters) — not needed for Proxy mode
9. Enter a Bind IP — a dedicated IP address for this virtual printer
10. Click Create, then toggle it to Enabled

You can create multiple virtual printers, each with its own mode, model, and bind IP. They appear as separate printers in your slicer.

Dedicated Bind IP¶

Each virtual printer requires its own dedicated IP address. This IP is used for all services (FTP, MQTT, SSDP, Bind) and must be unique across all enabled virtual printers.

For example, if you want to run 3 virtual printers:

You add these extra IPs as interface aliases (secondary addresses) on your network adapter. The commands below are temporary — see the persistence section for each platform to keep them across reboots.

Adding Interface Aliases¶

ip -br addr show
# Example output: eth0  UP  192.168.1.100/24

sudo ip addr add 192.168.1.101/24 dev eth0
sudo ip addr add 192.168.1.102/24 dev eth0
sudo ip addr add 192.168.1.103/24 dev eth0

ip addr show eth0
# Should show inet 192.168.1.100/24, 192.168.1.101/24, etc.

sudo apt install netplan.io

ls /etc/netplan/
# Usually 01-netcfg.yaml, 01-network-manager-all.yaml, or 50-cloud-init.yaml

network:
  version: 2
  ethernets:
    eth0:
      dhcp4: true
      addresses:
        - 192.168.1.101/24
        - 192.168.1.102/24
        - 192.168.1.103/24

sudo netplan apply

sudo apt install ifupdown

auto eth0:1
iface eth0:1 inet static
    address 192.168.1.101
    netmask 255.255.255.0

auto eth0:2
iface eth0:2 inet static
    address 192.168.1.102
    netmask 255.255.255.0

auto eth0:3
iface eth0:3 inet static
    address 192.168.1.103
    netmask 255.255.255.0

sudo ifup eth0:1
sudo ifup eth0:2
sudo ifup eth0:3

sudo dnf install NetworkManager

sudo pacman -S networkmanager
sudo systemctl enable --now NetworkManager

sudo nmcli con mod "Wired connection 1" +ipv4.addresses "192.168.1.101/24"
sudo nmcli con mod "Wired connection 1" +ipv4.addresses "192.168.1.102/24"
sudo nmcli con mod "Wired connection 1" +ipv4.addresses "192.168.1.103/24"

# Apply (brief reconnect)
sudo nmcli con up "Wired connection 1"

ip addr add 192.168.1.101/24 dev eth0
ip addr add 192.168.1.102/24 dev eth0

echo "ip addr add 192.168.1.101/24 dev eth0" >> /boot/config/go
echo "ip addr add 192.168.1.102/24 dev eth0" >> /boot/config/go

sudo ip addr add 192.168.1.101/24 dev eth0
sudo ip addr add 192.168.1.102/24 dev eth0

apt install iproute2

net0: name=eth0,bridge=vmbr0,ip=192.168.1.100/24,gw=192.168.1.1
net1: name=eth1,bridge=vmbr0,ip=192.168.1.101/24
net2: name=eth2,bridge=vmbr0,ip=192.168.1.102/24

pct set 100 -net1 name=eth1,bridge=vmbr0,ip=192.168.1.101/24
pct set 100 -net2 name=eth2,bridge=vmbr0,ip=192.168.1.102/24

Printer Model Selection¶

Choose which Bambu printer model the virtual printer should emulate:

Network Interface Override¶

Adding to Bambu Studio / OrcaSlicer¶

Automatic Discovery¶

1. Ensure the virtual printer is enabled and running
2. In Bambu Studio/OrcaSlicer, go to Device tab
3. Click Refresh or wait for discovery
4. The virtual printer "Bambuddy" should appear
5. Click to add it, entering the access code when prompted

Manual Addition (Bind with Access Code)¶

If automatic discovery doesn't work (VPN, remote, bridge mode):

1. In Bambu Studio, go to Device → Add Printer
2. Select Add printer by IP (or Bind with access code)
3. Enter the IP address of your Bambuddy server
4. Enter the access code (8 characters)
5. The printer will be added to your device list

Sending Prints to Bambuddy¶

Server Modes (Immediate / Review / Print Queue)¶

1. Slice your model as usual
2. Select "Bambuddy" from the printer dropdown
3. Click the Send button (next to the Print button)
4. The file will be transferred to Bambuddy

What Happens Next:

• Immediate: The file is automatically archived
• Review: The file appears in Pending Uploads for you to review, assign to a project, add notes, or queue for printing
• Print Queue: The file is archived and added to the print queue as an unassigned job

Proxy Mode¶

In Proxy mode, you use the slicer normally — slice, select the printer, and click Print or Send just like you would with a local printer. Bambuddy relays everything to the real printer transparently.

Proxy Mode — Remote Printing¶

What is Proxy Mode?¶

Unlike the server modes that archive files locally, Proxy Mode forwards your print jobs directly to a real Bambu Lab printer. Bambuddy acts as a secure relay between your slicer and your printer.

How It Works¶

1. Select the target printer in Bambuddy settings (must be in LAN mode)
2. For cross-network: select the slicer network interface for SSDP relay
3. Enable the proxy — printer appears in slicer discovery via SSDP
4. Connect using the printer's access code
5. Print as normal — traffic is relayed through Bambuddy

Proxy Mode Ports¶

Key Benefits¶

Feature	Description
TLS-encrypted control channels	MQTT and FTP control fully encrypted; use VPN for data channel
No cloud dependency	Your data never touches third-party servers
Uses printer's credentials	No additional passwords — use your printer's access code
Full protocol support	FTP, MQTT, and bind protocol are all proxied
Connection monitoring	Real-time status showing active connections

Requirements¶

Printer Requirements:

• Bambu Lab printer in LAN Mode (Developer Mode)
• Printer must be accessible from Bambuddy on your local network
• Printer's IP address and access code

Network Requirements:

• Bambuddy server accessible from the slicer (same LAN, VPN, or internet)
• Ports 3000 + 3002 (bind), 990 (FTP), 8883 (MQTT), and 50000-50100 (FTP data) reachable from the slicer
• Static IP or dynamic DNS for your Bambuddy server (if remote)

Supported Network Configurations:

Setting Up Proxy Mode¶

Step 1: Complete Platform Setup¶

Make sure you've completed the Platform Setup for your installation (iptables rules, firewall ports, Docker config).

Step 2: Configure Remote Access (if needed)¶

To access from outside your home network, forward these ports on your router:

Step 3: Enable Proxy Mode in Bambuddy¶

1. Go to Settings → Virtual Printer
2. Select Proxy mode from the mode options
3. Select your Target Printer from the dropdown
4. Click the toggle to Enable Virtual Printer
5. Verify the status shows "Running" with the proxy ports

Step 4: Configure Your Slicer¶

In Bambu Studio or OrcaSlicer:

1. Go to Device → Add Printer → Add printer manually
2. Enter your Bambuddy server's IP or hostname
3. Enter your printer's access code (not a Bambuddy password)
4. The printer should connect and show as online

Step 5: Print!¶

Select a model, slice it, and click Print. The job will be:

1. Sent to Bambuddy (encrypted via TLS)
2. Relayed to your printer on the local network
3. Started on your printer just like a local print

Dual-Homed (Cross-Network) Setup¶

For setups where Bambuddy has interfaces on two networks (e.g., printer on LAN A, slicer on LAN B):

• Enable the virtual printer, then select the slicer-facing interface under Network Interface Override
• Bambuddy will re-broadcast printer SSDP on the slicer's network
• The slicer discovers the printer automatically via SSDP
• Camera streaming requires additional NAT/iptables rules (RTSP port 322)

Proxy Mode vs Server Modes¶

Troubleshooting¶

Slicer Can't Find or Connect to Virtual Printer¶

1. Check virtual printer is enabled and showing "Running" status in Bambuddy Settings
2. Verify bind/detect ports are reachable — the slicer needs port 3000 or 3002 for the handshake:

   # From the slicer machine
   nc -zv BAMBUDDY_IP 3000
   nc -zv BAMBUDDY_IP 3002
   

3. Check iptables rules are active (for FTP):

   sudo iptables -t nat -L -n | grep 990
   

4. Check firewall — ports 3000/tcp, 3002/tcp, 2021/udp, 8883/tcp, 990/tcp, 50000-50100/tcp must be open
5. Same network? — SSDP discovery only works on the same LAN/subnet. Use "bind with access code" for VPN, remote, or Docker bridge setups

FTP Error / Connection Reset¶

1. Verify iptables rules are correctly configured (990 → 9990 redirect)
2. Check permissions on the uploads directory
3. Check no other FTP server is using port 990 or 9990
4. Review logs for specific error messages

"Wrong Printer Model" Error¶

The slicer's selected printer profile must match the virtual printer model in Bambuddy settings.

Permission Denied Errors¶

If you see "Permission denied" in the logs:

# Fix ownership of the virtual printer directory
sudo chown -R $(whoami):$(whoami) /path/to/bambuddy/data/virtual_printer

Authentication Failed¶

1. Verify access code matches in both Bambuddy and slicer
2. Access code must be exactly 8 characters
3. Try removing and re-adding the printer in your slicer

Wrong IP in SSDP / TLS Handshake Fails (Multi-NIC)¶

If Bambuddy has multiple network interfaces (LAN + VPN, Docker bridges, etc.), the auto-detected IP may be on the wrong interface:

1. Go to Settings → Virtual Printer
2. Enable the virtual printer if not already enabled
3. Under Network Interface Override, select the interface your slicer connects through
4. The virtual printer will restart with the correct IP in SSDP broadcasts and TLS certificate

TLS Connection Failed / Error -1¶

This typically means the slicer doesn't trust the virtual printer's certificate:

1. Verify Bambuddy CA is in slicer's certificate file:

   # Check that the Bambuddy CA appears in printer.cer
   grep -c "BEGIN CERTIFICATE" "/path/to/slicer/resources/cert/printer.cer"
   

   The count should be higher than a stock install (stock has 1 certificate).

2. Wrong certificate? If you have multiple Bambuddy hosts or reinstalled, you must update the certificate. See Step 2.

3. Verify certificate fingerprints match:

   # On Bambuddy server (Docker)
   docker exec bambuddy openssl x509 -in /app/data/virtual_printer/certs/bbl_ca.crt -noout -fingerprint -sha1
   
   # On Bambuddy server (native)
   openssl x509 -in virtual_printer/certs/bbl_ca.crt -noout -fingerprint -sha1
   

   Verify this fingerprint appears in one of the certificates in your slicer's printer.cer.

4. Fully restart the slicer — Cmd+Q on macOS, or End Task on Windows. Just closing the window is not enough.

5. Regenerate certificates (last resort):

   # Delete certs and restart Bambuddy
   rm -rf /path/to/virtual_printer/certs/
   # Then disable and re-enable virtual printer in UI
   

   You'll need to remove the old Bambuddy CA from the slicer and append the new one.

Proxy Mode: Printer Shows Offline in Slicer¶

• Verify the target printer is online in Bambuddy
• Check that the printer is in LAN mode
• Restart the proxy by toggling it off and on

Proxy Mode: Connection Drops During Transfer¶

• Large files may timeout on slow connections
• Check your internet upload speed

Technical Details¶

Security¶

• Bind protocol (ports 3000, 3002): Unencrypted TCP — transmits printer identity only, no sensitive data
• MQTT control channel: Fully TLS-encrypted (TLS 1.2)
• FTP control channel: Fully TLS-encrypted (implicit FTPS, TLS 1.2)
• FTP data channel: In proxy mode, encrypted between Bambuddy and printer (depends on printer model). Not encrypted between slicer and Bambuddy due to a Bambu Studio limitation. Use a VPN for end-to-end data encryption.
• Self-signed certificates are auto-generated (shared CA persists, per-instance device cert regenerates per serial)
• Access code authentication required for all connections (8 characters)
• Certificates stored in virtual_printer/certs/ (shared CA) and virtual_printer/certs/{id}/ (per-instance certs)

Limitations¶

• Each virtual printer requires its own dedicated bind IP address
• SSDP discovery requires same LAN — use manual IP entry for VPN, remote, or Docker bridge setups
• Slicer must trust the self-signed certificate (see Certificate Installation)
• FTP data channel unencrypted on slicer side (use VPN for full encryption)