TailTalk revives AppleTalk as a dependency-free userspace Rust stack for modern OSes

TailTalk, an open-source project written in Rust on top of the Tokio async runtime, implements the complete AppleTalk protocol suite entirely in userspace. According to the project's GitHub page, which surfaced on the Hacker News front page, the toolkit runs on Linux, macOS and Windows and connects to classic Macs and Apple printers over EtherTalk or LocalTalk. It was built from scratch with no dependency on Netatalk or any kernel drivers — a raw network socket, or a TashTalk-compatible device for LocalTalk, is all the hardware it needs.

A complete stack with no kernel footprint

The implementation includes parsers and fully asynchronous APIs for the major AppleTalk protocols: the AppleTalk Address Resolution Protocol (AARP), Datagram Delivery Protocol (DDP), Name Binding Protocol (NBP), AppleTalk Transaction Protocol (ATP), Printer Access Protocol (PAP), AppleTalk Session Protocol (ASP), AppleTalk Filing Protocol (AFP) and the AppleTalk Data Stream Protocol. Multiple independent copies of the stack can run on the same machine simultaneously, and each component is designed to be as close to zero-configuration as possible, echoing the plug-it-in-and-it-works behaviour of era-appropriate Mac hardware.

The author started the project to move files to and from old Macs, print to LaserWriters, ImageWriters and networked StyleWriters, and to write modern async software that communicates with them. One caveat: TailTalk currently only works in routerless setups. Support for gracefully joining networks that have routers is in progress but has not landed in the mainline code, and the README warns that the whole thing is an early prototype, with bugs and missing functionality to be expected.

GUI, AFP server and printer bridging

The user-facing program is the TailTalk GUI, aimed at TashTalk USB hardware. It includes an AFP server intended to work with nearly every Mac that shipped with a LocalTalk port. It can import StuffIt archives and floppy disk images into the shared path while preserving resource forks, making their contents available to remote clients.

Printer support runs in both directions: LocalTalk-capable LaserWriters, ImageWriters and StyleWriters can be exposed to modern networks as AirPrint/IPP printers, and modern printers can be shared back to classic Macs.

The README lists four demo programs used to verify the stack as it was developed: aep-echo, which sends an echo request and prints the response time; afp-server, an AFP 1.0, 1.1 and 2.0 compatible server supporting basic directory browsing and file operations on classic Mac systems; nbp-lookup, which performs NBP lookups; and pap-print, which sends PostScript files to PAP printers and has so far only been tested against the author's LaserWriter 4/600 PS. They sit alongside the tailtalkd daemon and the tailtalk-gui application.

A daemon for shared access

The AARP/DDP underlay runs in-process by default, but can instead live in tailtalkd, a shared daemon that owns the physical interfaces and serves DDP sockets, addressing and routing rules to multiple clients over a protobuf protocol on Unix or UDP sockets. Clients can be other TailTalk programs, via the TalkStack builder API, or plain C code.

Platform and hardware details

Building requires Rust 1.90 or newer, with cargo-packager producing AppImages on Linux, app bundles on macOS and NSIS installers on Windows. EtherTalk support is compiled into the GUI by default on macOS, where libpcap ships with the operating system; on Linux and Windows it is an opt-in feature that needs libpcap or the npcap SDK. Raw-socket transports require root or setcap on Linux, and the ChModBPF package on macOS — unless the setup is TashTalk-only, in which case no elevated privileges are needed.

TashTalk USB devices use a Silicon Labs CP210x USB-to-UART bridge. macOS 11 and later recognises the CP2102N chip out of the box, while older macOS releases need the vendor driver, and Linux users need a udev rule to access the device without root.

The author reports testing against real hardware, including a PowerBook G3 running Mac OS 9.2 over Ethernet, a Macintosh SE/30 on System 7.1, a Macintosh Classic on System 6.0.8, plus a LaserWriter 4/600 PS, a Color StyleWriter 2200 and an ImageWriter II. One documented quirk involves the AsanteTalk adapter, which chooses its EtherTalk phase at power-on and defaults to Phase 1 if it sees no Phase 2 traffic. TailTalk handles Phase 1 for LaserWriters, NBP and basic operations, but AFP fails in that mode because the responses appear to be dropped.

Why it matters

Keeping vintage Macs and Apple printers usable has usually meant running period-correct servers or wrestling with Netatalk configurations. TailTalk reframes the problem: because the entire stack is an async Rust library in userspace, new software can embed AFP, PAP or NBP directly — an AirPrint bridge for an ImageWriter, or a scriptable file transfer tool for a System 6 machine — without kernel modules or legacy server setups. Resource-fork-preserving imports of StuffIt archives and floppy images also target a genuine data-preservation need. The project is still a prototype and router support is missing, but its cross-platform reach, multi-client daemon design and toolkit approach give retrocomputing a modern foundation to build on, and the author is openly inviting contributions.