ParlorNet
Turn-based game server for any computer, old or new
Clients | Protocols | Browsers | Telnet programs | Docs | Source

Internet Othello Server (IOS): client-side protocol research

Status: research notes, 2026-11-21. Every fact carries a source tag like [S3] (list in section i). Anything not backed by a source is marked UNVERIFIED. Nothing here comes from memory.

Method: web search, the Internet Archive (Wayback Machine) copies of the NEC pages, and strings pulled from the Reversi The Eclipse 1.2 binary. No connection to any server was made: external.nj.nec.com no longer resolves (NXDOMAIN, checked 2026-11-21 with host), so there was nothing to probe.

Key findings in brief

  1. IOS is real, documented only indirectly. There is no surviving IOS manual that I could find. The best primary sources are (a) the source of a 1994-95 IOS client written by IOS's own author [S6], (b) the Wayback copy of the author's history page [S3], and (c) strings inside Reversi The Eclipse itself [S9].
  2. IOS was replaced around 1999 by the Generic Game Server (GGS) on the same host and port (5000) [S3][S4][S5]. GGS is the successor, not a sibling, and has a different, well-documented protocol with a "client" mode. Old IOS clients (such as Eclipse 1.2, 1997) speak the IOS protocol, not GGS.
  3. "Reversi The Eclipse" is confirmed: a 1997 Macintosh game (Lars Graulund, Freeverse Software) [S8][S10]. Its binary contains an IOS login dialog, host external.nj.nec.com, port 5000, and <ios> message parsing [S9].
  4. The IOS wire format is human text meant for telnet, parsed by clients by line and column position. The IOS text formats below are recovered from client parsing code, so they are accurate for what that client accepted, but are not a full specification. A real capture or the IOS help text is still needed to close the gaps (section h).

(a) What IOS is, history, is it running

(b) Connection details

ItemValueSource
Hostexternal.nj.nec.com (also ftp.nj.nec.com, IP 138.15.10.2 in 1997/98)[S12][S11][S9]
Port5000[S12][S11], and the Eclipse binary contains "5000" next to the host-name prompt [S9]
Transportplain TCP, "simple telnet"; no telnet option negotiation is performed by the reference client[S6]
Line endingserver lines end in LF; the client strips a CR if present, so CR LF is accepted. Client commands are sent terminated by a single \n.[S6]
EncodingASCII (UNVERIFIED, nothing says otherwise; the client treats bytes as chars)[S6]
Max linethe reference client aborts on a received line over 8192 chars[S6]
Login nameat most 8 characters (client buffers are 9 bytes; Eclipse's dialog text says "Max. 8")[S6][S9]
Promptslogin: and password: arrive with no trailing newline and are matched as exact strings; after login the command prompt looks like <login>% and the client extracts its own login name from text before the %[S6]

Note: the 1994 client's "simple telnet" claim means a raw TCP connection is enough for the reference client. Whether the server ever sent telnet IAC negotiation bytes is not documented (UNVERIFIED).

(c) Login and account flow

(d) Command set a client uses

Verified only where a source is cited. Commands are lines typed to the server (case unclear, UNVERIFIED).

Sent by reference clients:

CommandMeaning / formatSource
wholist users. Client waits for a header line starting login blitz stand. G M idle on for from host[S6]
`match <opponent> <time> <inc> <def> [white\black]`challenge an opponent; the three integers are the client's time settings (see Time). Omitted colour means random[S6] (put_match)
accept <name>accept a challenge from <name>[S6]
decline <name>decline; the client may also send tell <name> <reason>[S6]
tell <name> <text>private message[S6]
PM <sq> <value> <time>play a move. sq is a letter+digit like D3 (client prints column as upper-case A-H, row digit), pass is ps. value is the program's evaluation, printed %+5.2f; time is time spent on the move, %8.2f. Example form: PM D3 +0.00 1.50[S6] (put_move)
quit, resignleave; resign[S9] (strings)
set trust 1tell the server to trust client-reported move times[S9] (strings); the GGS successor documents the same idea as the trust variable [S16]
helpserver help text ("You can get more help from the server by typing help")[S15]
playersthe Java client has a "players" button that lists ready players; its exact wire command is UNVERIFIED (probably who)[S15]

Other commands implied but with no verified syntax (UNVERIFIED): shout/yell, channels, observe, undo, adjourn/continue, rated vs unrated toggle, open/close for challenges. Evidence they exist: the IOS who columns show a registered flag, a playing flag, and open/rated/trust flags [S6]; the author says IOS channels existed and had a limit [S3]; Mac Eclipse strings include told, Talk, stored and unrated fragments [S9]; the successor GGS has all of these [S16].

Matches use a request/accept flow: a challenge is "pending" until the target accepts. The server announces events using lines starting <ios> (next section).

(e) Server output formats

All structured server messages carry a <ios> prefix and are parsed by the clients by position within the line [S6][S9]. Formats below are what the reference client's parser (written by IOS's author) expects.

Game created and ended [S6]

<ios> [GAME 2 (fly vs. mic) (rated) created
<ios> [GAME 2 (fly vs. mic) (rated) ended

The first name is black and the second white (the client assigns them in that order). rated/unrated appears in the second parenthesis. "ended" is detected by the word in the eighth token; the final score text is not in this line (UNVERIFIED where the score appears).

Match offer [S6]

<ios> MATCH ...        (first line)
      ...              (second line: score range)

Fields recovered from the parser: a rated/unrated/stored marker (column 13 is r for rated, s for stored), then my time, increment, default time, an opponent name, the opponent's time values, and a colour word (white or black, with * at position 5 meaning random colour). Second line: max_win .. min_win draw min_loss .. max_loss - the score range at which the game would be a win, draw or loss for the player (the reference client reads five integers %d .. %d %d %d .. %d). Exact column layout is UNVERIFIED beyond the offsets used by the parser (20 for the first number block, 15 for the second line).

Human-readable board [S6]

<ios> BOARD of GAME   4, (scorpion vs. mic)

followed by a fixed block of lines, which the client reads by line index and column: line 0 header; line 1 holds the colour to move (column 12 is * for black, O for white); lines 2-9 are board rows; column 31+2k is the disc for column k. Discs: * black, O white, - empty. Clock text for the first player sits at fixed columns 11-18 (HH:MM:SS) with a default time at column 20 and increment at column 24; the second player's clock at columns 59-72 [S6]. The last move is at columns 52-58 (move number at 52-53, square letter+digit at 57-58, p for pass), a Y/N at column 0 of the last line says whether it is the client's turn, and the move value at column 70 [S6]. These offsets are copied from parsing code and should be confirmed against a real capture before use (UNVERIFIED as a layout of a whole message).

**Machine-readable board line PB** [S6]

<ios> PB   0 <black> <white> <tb> <tw> <defb> <defw> <incb> <incw> <color> <turn> <moveno> <move> <value> <time> <64 cells>

This is a single-line board used by programs. The parser reads, from column 8: game number, black name, white name, black time, white time, black and white default time, black and white increment, colour to move (* or O), turn flag Y/N (is it my turn), last move number, last move code (negative means pass), evaluation value, elapsed time, and then 64 board characters (*, O, -) starting at column 78, row by row [S6]. Which command or variable switches this form on is not stated in the code (UNVERIFIED; the reference client simply accepts both forms).

Move list [S6]

<ios> MOVES of GAME   2, (mic vs. scorpion)

followed by a grid of 8 board rows where each square shows the move number at which it was played; ( and # mark non-playable squares. The client builds a move-by-move array (up to 60 entries) from it [S6].

Who list [S6]

A header line login blitz stand. G M idle on for from host, then one line per user: name at column 0; blitz rating at column 10; a + at column 15 marks a registered player; the standard (15 minutes or more) rating at column 17; a flag at column 25 (- means not playing); and a flag at column 27 (- closed, otherwise open; r/R rated; R/U trusted). The list ends at the first line without [ at column 9. [S6]

Moves, notation, passes

(f) Rules and options

(g) Reversi The Eclipse and other clients

Reversi The Eclipse 1.2 [S8][S9][S10]

Conclusion: it is a telnet-style IOS client that parses the same <ios> messages as the reference client; it logs in with a handle and optional password and drives play by sending text commands. UNVERIFIED details: exact commands for challenge and accept, how it turns on the PB single-line board, how it handles server prompts. The ground truth would be to decompress the image (Disk Copy "ADC" compression) and read the program's resources, or to run it in an emulator against our adapter and capture the bytes.

Other IOS clients with sources

PC clients: DOS, Windows 3.x and Windows 95/98

Added 2026-11-21 from docs/research/pc-clients.md; tags like [pc S1] are that file's sources. Nothing was run.

(h) Unverified items and open questions

  1. Exact IOS help text and the complete command list (no surviving copy found). The IOS server source was never released as far as I found; the GGS source is GPL, but it is the successor [S3][S18].
  2. Whether who, match and others are case-sensitive; abbreviations.
  3. Complete text of the board block and the final score line, including how the game result is announced.
  4. How the PB single-line board is enabled and whether the server stops sending the human board then.
  5. Pass syntax (ps versus pa) and whether the server auto-passes.
  6. Shouts, channels, observe, undo, adjourn: syntax.
  7. Whether telnet negotiation bytes are sent.
  8. Whether unregistered names need a password.
  9. How Eclipse 1.2 starts and accepts a game (challenge flow as seen in its UI).
  10. Why the host is gone (the NEC lab history is not sourced here).
  11. Whether anyone still runs an IOS-compatible server. Not found; the closest live thing is GGS at skatgame.net:5000 [S2].

Best next step: a capture of Eclipse 1.2 talking to a stub (an emulated Mac under QEMU/Basilisk with our listener on port 5000 and name resolution of external.nj.nec.com pointed at it; that is deployment-layer only). Log the bytes it sends after login, then fill the gaps above from its behaviour. This costs nothing on the project side and settles items 2-9 directly.

Adapter approach recommendation

Suggested mapping: our protocol to IOS and back

Our side from docs/protocol.md and docs/types/reversi-1.md.

OursIOS side
HELO name, then AUTthe IOS login: / password: exchange. The adapter creates the handle from the IOS name (max 8 chars; ours allows 12, so use the IOS name as given and prefix/suffix only if needed). The IOS password answers the server's password question only (docs/accounts.md).
GAMnot needed; IOS has one game. The adapter only exposes reversi/1 standard (size 8).
LSTwho (users) plus <ios> MATCH offers. Our tables are open seats; IOS has users who are "open". Map open table creators to who lines flagged open; map a match <name> to joining that creator's table.
NEW reversi standarda user becoming "open" / sending match. Our JON plus NEW correspond to challenge then accept.
JON tableaccept <name>
LVE tableresign (if running) or decline; quit closes everything
SEE tableobserving (UNVERIFIED syntax)
VUE table G/Mboard text per (e): <ios> BOARD ... block or <ios> PB .... Our rows R y cells and C n0 n1 map to the */O/- rows and the disc counts
MOV table d3PM D3 +0.00 <time> ; our lowercase square maps to uppercase letters; rows already 1..8 from the top, the same as IOS row digits per the parser (row digit at the line start counts down the board)
no PASS verb in ours (server passes)IOS clients may send a pass (ps/pa). The adapter must translate an incoming pass into nothing when the server has already passed, and drop or reject if illegal. Needs capture to confirm
CHT table texttell <name> <text>
EVT ... PUT/FLP/PASS/TURN/ENDan <ios> BOARD/PB refresh after each move (IOS resends the whole board, not deltas), a game-end line `<ios> [GAME n (a vs. b) (ratedunrated) ended. END win seat n0-n1` maps to the score text (format UNVERIFIED)
clock option clock=...match time fields (main, increment, default)
colours: seat 0 and seat 1, not part of contractIOS fixes * black and O white; the adapter maps seat 0 to black because reversi/1 says seat 0 moves first and in Othello black moves first (matches IOS's black-first display in [S6])

What IOS has that we lack: ratings (ELO/Glicko, rating lists; the adapter should show a fixed or unrated value unless we add ratings), rooms/channels and shouts, tells to arbitrary users (we only have table chat), a global who list, observers, rated vs unrated games, adjourned/stored games, trust time reporting, random openings (r), komi/anti variants (GGS). What we have that IOS lacks: typed move events with flips (IOS resends boards), CHK, SEE as a first-class view, WAT polling, multi-game hosting, board sizes other than 8 for IOS.

(i) Sources

This doc on GitHub


 These pages cover every ParlorNet server. | Source code | ParlorNet is free software.