Fix wbr hang in Local mode by skipping message sends

In Local mode, send_message was adding to the outgoing Eio stream
but nothing consumed from it. After 100 messages (stream capacity),
Eio.Stream.add blocked forever, causing the application to hang.

.beads/issues.jsonl

···
 {"id":"automerge-P8","title":"Phase 8: Conformance testing","description":"Implement full conformance test suite using json-crdt-traces fixtures plus fuzzing/property tests.","status":"open","priority":1,"issue_type":"epic","created_at":"2025-12-26T11:45:05.443231113+01:00","updated_at":"2025-12-26T11:45:05.443231113+01:00","labels":["conformance","epic","phase-8","testing"],"dependencies":[{"issue_id":"automerge-P8","depends_on_id":"automerge-P7","type":"parent-child","created_at":"2025-12-26T13:51:16.084904641+01:00","created_by":"gdiazlo"}]}
 {"id":"crdt-4pq","title":"Fix RGA concurrent insert ordering for json-joy compatibility","description":"The RGA algorithm's tie-breaking for concurrent inserts doesn't match json-joy's implementation. When two replicas insert at the same position concurrently, the resulting order differs.\n\nEvidence from conformance tests:\n- Expected: \"An epic synopsis\"  \n- Got: \"A synepic nopsis\" (the \"n\" from \"An\" appears in wrong position)\n\nNeed to analyze json-joy's RGA implementation and match its ordering rules:\n- Understand how json-joy determines concurrent inserts\n- Match tie-breaking logic for timestamp comparison\n- May need to track causal dependencies to determine concurrency","status":"closed","priority":1,"issue_type":"bug","assignee":"claude","created_at":"2025-12-26T17:19:31.628018647+01:00","updated_at":"2025-12-26T17:45:10.110299973+01:00","closed_at":"2025-12-26T17:45:10.110299973+01:00","labels":["conformance","crdt","json-joy","rga"]}
 {"id":"crdt-4ra","title":"Reduce binary codec output size (currently 4x larger than json-joy)","description":"Binary output is 4.9KB vs json-joy's ~1.2KB for 1K chars.\nInvestigate:\n1. Timestamp encoding efficiency (delta encoding?)\n2. RGA chunk representation\n3. Node type encoding overhead\n4. Compare byte-by-byte with json-joy format","status":"closed","priority":2,"issue_type":"task","created_at":"2025-12-27T00:34:56.319523298+01:00","updated_at":"2025-12-27T09:29:04.871828606+01:00","closed_at":"2025-12-27T09:29:04.871828606+01:00","labels":["binary-codec","optimization","performance","size"],"dependencies":[{"issue_id":"crdt-4ra","depends_on_id":"crdt-icx","type":"blocks","created_at":"2025-12-27T00:34:56.320955254+01:00","created_by":"gdiazlo"}]}
-{"id":"crdt-68q","title":"Fix compact codec failing tests (friendsforever_flat)","description":"","status":"in_progress","priority":0,"issue_type":"bug","created_at":"2026-01-02T12:15:25.878861438+01:00","updated_at":"2026-01-02T12:15:34.21425901+01:00"}
-{"id":"crdt-6rt","title":"Fix remaining test failures after simdjsont migration","description":"","status":"in_progress","priority":0,"issue_type":"bug","assignee":"gdiazlo","created_at":"2026-01-02T11:36:44.354508505+01:00","updated_at":"2026-01-02T11:36:52.177356478+01:00"}
+{"id":"crdt-68q","title":"Fix compact codec failing tests (friendsforever_flat)","description":"","status":"closed","priority":0,"issue_type":"bug","created_at":"2026-01-02T12:15:25.878861438+01:00","updated_at":"2026-01-02T18:42:18.462948762+01:00","closed_at":"2026-01-02T18:42:18.462948762+01:00"}
+{"id":"crdt-6rt","title":"Fix remaining test failures after simdjsont migration","description":"","status":"closed","priority":0,"issue_type":"bug","assignee":"gdiazlo","created_at":"2026-01-02T11:36:44.354508505+01:00","updated_at":"2026-01-02T18:42:13.420876009+01:00","closed_at":"2026-01-02T18:42:13.420876009+01:00"}
 {"id":"crdt-7f0","title":"Optimize RGA sequential insert (O(n²) -\u003e O(n log n))","description":"Sequential insert of 10K chars takes 284ms - this is O(n²) behavior.\nOptions:\n1. Use tree-based structure (AVL, finger tree) instead of list\n2. Add index for fast position lookup\n3. Consider json-joy's B+tree approach\n\nTarget: \u003c 50ms for 10K sequential inserts","status":"closed","priority":1,"issue_type":"task","created_at":"2025-12-27T00:35:00.551809524+01:00","updated_at":"2025-12-27T00:46:27.873263358+01:00","closed_at":"2025-12-27T00:46:27.873263358+01:00","labels":["optimization","performance","rga"],"dependencies":[{"issue_id":"crdt-7f0","depends_on_id":"crdt-icx","type":"blocks","created_at":"2025-12-27T00:35:00.557418209+01:00","created_by":"gdiazlo"}]}
 {"id":"crdt-9h3","title":"Optimize binary encoding performance (currently 3x slower than json-joy)","description":"Binary encoding is ~21K ops/sec vs json-joy's ~108K ops/sec.\nInvestigate:\n1. Buffer allocation strategy\n2. Varint encoding efficiency\n3. CBOR encoding overhead\n4. Consider pre-allocating buffers based on model size","status":"closed","priority":1,"issue_type":"task","created_at":"2025-12-27T00:34:52.454913078+01:00","updated_at":"2025-12-27T00:41:24.590935842+01:00","closed_at":"2025-12-27T00:41:24.590935842+01:00","labels":["binary-codec","optimization","performance"],"dependencies":[{"issue_id":"crdt-9h3","depends_on_id":"crdt-icx","type":"blocks","created_at":"2025-12-27T00:34:52.456412445+01:00","created_by":"gdiazlo"}]}
 {"id":"crdt-9ry","title":"Run final benchmarks and compare with json-joy","description":"After all optimizations:\n1. Run full benchmark suite\n2. Verify all tests pass\n3. Document comparison with json-joy\n4. Target: exceed json-joy performance across all metrics","status":"closed","priority":2,"issue_type":"task","created_at":"2025-12-27T00:35:14.61471182+01:00","updated_at":"2025-12-27T00:46:58.828283923+01:00","closed_at":"2025-12-27T00:46:58.828283923+01:00","labels":["benchmarks","documentation"],"dependencies":[{"issue_id":"crdt-9ry","depends_on_id":"crdt-apw","type":"blocks","created_at":"2025-12-27T00:35:14.620794117+01:00","created_by":"gdiazlo"},{"issue_id":"crdt-9ry","depends_on_id":"crdt-9h3","type":"blocks","created_at":"2025-12-27T00:35:14.621445689+01:00","created_by":"gdiazlo"},{"issue_id":"crdt-9ry","depends_on_id":"crdt-4ra","type":"blocks","created_at":"2025-12-27T00:35:14.621869631+01:00","created_by":"gdiazlo"},{"issue_id":"crdt-9ry","depends_on_id":"crdt-7f0","type":"blocks","created_at":"2025-12-27T00:35:14.622264163+01:00","created_by":"gdiazlo"},{"issue_id":"crdt-9ry","depends_on_id":"crdt-z3n","type":"blocks","created_at":"2025-12-27T00:35:14.622793455+01:00","created_by":"gdiazlo"}]}
 {"id":"crdt-apw","title":"Investigate binary decode performance (35M ops/sec seems wrong)","description":"Binary decode shows 35M ops/sec which is suspiciously fast. Need to verify:\n1. The decode is actually doing work (not returning cached/memoized result)\n2. The decoded model is correct and usable\n3. Add validation that decoded model matches original","status":"closed","priority":1,"issue_type":"task","created_at":"2025-12-27T00:34:47.948086278+01:00","updated_at":"2025-12-27T00:38:53.472587773+01:00","closed_at":"2025-12-27T00:38:53.472587773+01:00","labels":["binary-codec","investigation","performance"],"dependencies":[{"issue_id":"crdt-apw","depends_on_id":"crdt-icx","type":"blocks","created_at":"2025-12-27T00:34:47.954081564+01:00","created_by":"gdiazlo"}]}
-{"id":"crdt-bwe","title":"Fix A decode_timestamp","description":"","status":"open","priority":1,"issue_type":"bug","created_at":"2026-01-02T12:06:12.866717163+01:00","updated_at":"2026-01-02T12:06:12.866717163+01:00"}
+{"id":"crdt-bwe","title":"Fix A decode_timestamp","description":"","status":"closed","priority":1,"issue_type":"bug","created_at":"2026-01-02T12:06:12.866717163+01:00","updated_at":"2026-01-02T18:42:23.50415162+01:00","closed_at":"2026-01-02T18:42:23.50415162+01:00"}
 {"id":"crdt-icx","title":"Investigate and optimize benchmark performance issues","description":"Investigation and optimization of CRDT library performance based on benchmark comparison with json-joy.\n\nKey findings from initial benchmarks:\n1. Binary decode shows suspiciously fast results (35M ops/sec) - needs verification\n2. Binary encoding is 3x slower than json-joy\n3. Binary codec produces 4x larger output than json-joy\n4. RGA sequential insert is O(n²) - 284ms for 10K chars\n\nTarget: Match or exceed json-joy performance given our more capable CPU.","status":"closed","priority":1,"issue_type":"epic","created_at":"2025-12-27T00:34:36.713327259+01:00","updated_at":"2025-12-27T00:47:00.530534521+01:00","closed_at":"2025-12-27T00:47:00.530534521+01:00","labels":["benchmarks","optimization","performance"]}
 {"id":"crdt-z3n","title":"Add benchmark validation to ensure correctness","description":"Add validation steps to benchmarks:\n1. Verify encode/decode round-trip produces identical model\n2. Verify model view matches expected content\n3. Add checksums/hashes to detect corruption","status":"closed","priority":1,"issue_type":"task","created_at":"2025-12-27T00:35:03.801590973+01:00","updated_at":"2025-12-27T00:38:54.776020436+01:00","closed_at":"2025-12-27T00:38:54.776020436+01:00","labels":["benchmarks","testing"],"dependencies":[{"issue_id":"crdt-z3n","depends_on_id":"crdt-icx","type":"blocks","created_at":"2025-12-27T00:35:03.802861658+01:00","created_by":"gdiazlo"}]}

bin/debug_model_codec.ml

···
-open Crdt
-
-let read_file path =
-  if Sys.file_exists path then begin
-    let ic = open_in_bin path in
-    let len = in_channel_length ic in
-    let data = Bytes.create len in
-    really_input ic data 0 len;
-    close_in ic;
-    Some (Bytes.to_string data)
-  end
-  else None
-
-let[@warning "-32"] test_compact dir =
-  let compact_path = dir ^ "/model.compact.json" in
-  let view_path = dir ^ "/view.json" in
-  match (read_file compact_path, read_file view_path) with
-  | Some compact_json, Some view_json -> (
-      Printf.printf "Testing: %s\n" dir;
-      match Model_codec.Compact.decode_string compact_json with
-      | None -> print_endline "  FAIL: decode failed"
-      | Some model -> (
-          (* Debug: show raw str content if it's a string *)
-          (match model.root with
-          | Node.Node_val { val_ref = Some ref_id; _ } -> (
-              match Model.get_node model ref_id with
-              | Some (Node.Node_str { str_rga; _ }) ->
-                  let text = Rga.view_string str_rga in
-                  Printf.printf "  Raw str (first 100): %s\n"
-                    (String.sub text 0 (min 100 (String.length text)))
-              | _ -> ())
-          | _ -> ());
-          let model_view = Model.view model in
-          match Value_codec.decode view_json with
-          | Error e -> Printf.printf "  FAIL: view parse error: %s\n" e
-          | Ok expected_view ->
-              if Value.equal model_view expected_view then
-                print_endline "  PASS: views match"
-              else begin
-                print_endline "  FAIL: view mismatch";
-                print_endline "  Model view (first 500 chars):";
-                let view_str = Value.to_string model_view in
-                print_endline
-                  (String.sub view_str 0 (min 500 (String.length view_str)));
-                print_endline "  Expected view (first 500 chars):";
-                let expected_str = Value.to_string expected_view in
-                print_endline
-                  (String.sub expected_str 0
-                     (min 500 (String.length expected_str)))
-              end))
-  | _ -> Printf.printf "Skipping %s (files not found)\n" dir
-
-let test_verbose dir =
-  let verbose_path = dir ^ "/model.verbose.json" in
-  let view_path = dir ^ "/view.json" in
-  match (read_file verbose_path, read_file view_path) with
-  | Some verbose_json, Some view_json -> (
-      Printf.printf "Testing verbose: %s\n" dir;
-      match Model_codec.Verbose.decode_string verbose_json with
-      | None -> print_endline "  FAIL: decode failed"
-      | Some model -> (
-          (* Debug: show raw str content if it's a string *)
-          (match model.root with
-          | Node.Node_val { val_ref = Some ref_id; _ } -> (
-              match Model.get_node model ref_id with
-              | Some (Node.Node_str { str_rga; _ }) ->
-                  let text = Rga.view_string str_rga in
-                  Printf.printf "  Raw str (first 100): %s\n"
-                    (String.sub text 0 (min 100 (String.length text)))
-              | _ -> ())
-          | _ -> ());
-          let model_view = Model.view model in
-          match Value_codec.decode view_json with
-          | Error e -> Printf.printf "  FAIL: view parse error: %s\n" e
-          | Ok expected_view ->
-              if Value.equal model_view expected_view then
-                print_endline "  PASS: views match"
-              else begin
-                print_endline "  FAIL: view mismatch"
-              end))
-  | _ -> Printf.printf "Skipping %s (files not found)\n" dir
-
-let test_roundtrip dir =
-  let verbose_path = dir ^ "/model.verbose.json" in
-  match read_file verbose_path with
-  | Some verbose_json -> (
-      Printf.printf "Testing roundtrip: %s\n" dir;
-      match Model_codec.Verbose.decode_string verbose_json with
-      | None -> print_endline "  FAIL: verbose decode failed"
-      | Some model -> (
-          (* Encode to compact then decode back *)
-          let compact_encoded = Model_codec.Compact.encode_string model in
-          match Model_codec.Compact.decode_string compact_encoded with
-          | None -> print_endline "  FAIL: compact decode failed"
-          | Some model2 ->
-              let view1 = Model.view model in
-              let view2 = Model.view model2 in
-              if Value.equal view1 view2 then
-                print_endline "  PASS: roundtrip works"
-              else begin
-                print_endline "  FAIL: roundtrip mismatch";
-                Printf.printf "  View1 (first 100): %s\n"
-                  (String.sub (Value.to_string view1) 0
-                     (min 100 (String.length (Value.to_string view1))));
-                Printf.printf "  View2 (first 100): %s\n"
-                  (String.sub (Value.to_string view2) 0
-                     (min 100 (String.length (Value.to_string view2))))
-              end))
-  | None -> Printf.printf "Skipping %s\n" dir
-
-let test_binary_roundtrip dir =
-  let verbose_path = dir ^ "/model.verbose.json" in
-  match read_file verbose_path with
-  | Some verbose_json -> (
-      Printf.printf "Testing binary roundtrip: %s\n" dir;
-      match Model_codec.Verbose.decode_string verbose_json with
-      | None -> print_endline "  FAIL: verbose decode failed"
-      | Some model -> (
-          (* Encode to binary *)
-          let binary = Model_codec.Binary.encode model in
-          Printf.printf "  Binary size: %d bytes\n" (Bytes.length binary);
-          (* Decode back *)
-          match Model_codec.Binary.decode binary with
-          | None -> print_endline "  FAIL: binary decode failed"
-          | Some decoded_model ->
-              let original_view = Model.view model in
-              let decoded_view = Model.view decoded_model in
-              if Value.equal original_view decoded_view then
-                print_endline "  PASS: roundtrip works"
-              else begin
-                print_endline "  FAIL: roundtrip mismatch";
-                Printf.printf "  Original (first 100): %s\n"
-                  (String.sub
-                     (Value.to_string original_view)
-                     0
-                     (min 100 (String.length (Value.to_string original_view))));
-                Printf.printf "  Decoded (first 100): %s\n"
-                  (String.sub
-                     (Value.to_string decoded_view)
-                     0
-                     (min 100 (String.length (Value.to_string decoded_view))))
-              end))
-  | None -> Printf.printf "Skipping %s\n" dir
-
-let test_compact_direct dir =
-  let compact_path = dir ^ "/model.compact.json" in
-  let view_path = dir ^ "/view.json" in
-  match (read_file compact_path, read_file view_path) with
-  | Some compact_json, Some view_json -> (
-      Printf.printf "Testing compact direct: %s\n" dir;
-      match Model_codec.Compact.decode_string compact_json with
-      | None -> print_endline "  FAIL: decode failed"
-      | Some model -> (
-          let model_view = Model.view model in
-          match Value_codec.decode view_json with
-          | Error e -> Printf.printf "  FAIL: view parse error: %s\n" e
-          | Ok expected_view ->
-              if Value.equal model_view expected_view then
-                print_endline "  PASS: views match"
-              else begin
-                print_endline "  FAIL: view mismatch";
-                Printf.printf "  Got (first 200): %s\n"
-                  (String.sub
-                     (Value.to_string model_view)
-                     0
-                     (min 200 (String.length (Value.to_string model_view))));
-                Printf.printf "  Expected (first 200): %s\n"
-                  (String.sub
-                     (Value.to_string expected_view)
-                     0
-                     (min 200 (String.length (Value.to_string expected_view))))
-              end))
-  | _ -> Printf.printf "Skipping %s (files not found)\n" dir
-
-let test_binary_direct dir =
-  let binary_path = dir ^ "/model.bin" in
-  let view_path = dir ^ "/view.json" in
-  match (read_file binary_path, read_file view_path) with
-  | Some binary_data, Some view_json -> (
-      Printf.printf "Testing binary direct: %s\n" dir;
-      match Model_codec.Binary.decode (Bytes.of_string binary_data) with
-      | None -> print_endline "  FAIL: decode failed"
-      | Some model -> (
-          let model_view = Model.view model in
-          match Value_codec.decode view_json with
-          | Error e -> Printf.printf "  FAIL: view parse error: %s\n" e
-          | Ok expected_view ->
-              if Value.equal model_view expected_view then
-                print_endline "  PASS: views match"
-              else begin
-                print_endline "  FAIL: view mismatch";
-                Printf.printf "  Got (first 200): %s\n"
-                  (String.sub
-                     (Value.to_string model_view)
-                     0
-                     (min 200 (String.length (Value.to_string model_view))));
-                Printf.printf "  Expected (first 200): %s\n"
-                  (String.sub
-                     (Value.to_string expected_view)
-                     0
-                     (min 200 (String.length (Value.to_string expected_view))))
-              end))
-  | _ -> Printf.printf "Skipping %s (files not found)\n" dir
-
-let () =
-  let dirs =
-    [
-      "test/fixtures/traces/text/sequential/friendsforever_flat";
-      "test/fixtures/traces/text/sequential/automerge-paper";
-      "test/fixtures/traces/fuzzer/processed/short";
-      "test/fixtures/traces/fuzzer/processed/str-only";
-      "test/fixtures/traces/fuzzer/processed/low-concurrency";
-      "test/fixtures/traces/fuzzer/processed/trace-1";
-    ]
-  in
-  print_endline "=== Testing Verbose ===";
-  List.iter test_verbose dirs;
-  print_endline "";
-  print_endline "=== Testing Compact Direct ===";
-  List.iter test_compact_direct dirs;
-  print_endline "";
-  print_endline "=== Testing Binary Direct ===";
-  List.iter test_binary_direct dirs;
-  print_endline "";
-  print_endline "=== Testing Compact Roundtrip ===";
-  List.iter test_roundtrip dirs;
-  print_endline "";
-  print_endline "=== Testing Binary Roundtrip ===";
-  List.iter test_binary_roundtrip dirs

bin/rga_debug.ml

···
-open Crdt
-
-let project_root =
-  let candidates = [ "."; ".."; "../.."; "../../.." ] in
-  let rec find = function
-    | [] -> "."
-    | dir :: rest ->
-        if Sys.file_exists (dir ^ "/dune-project") then dir else find rest
-  in
-  find candidates
-
-let read_file path =
-  let ic = open_in_bin path in
-  let len = in_channel_length ic in
-  let data = Bytes.create len in
-  really_input ic data 0 len;
-  close_in ic;
-  Bytes.to_string data
-
-let print_op (op_id : Clock.timestamp) op =
-  Printf.printf "    op_id=(%d,%d) %s" op_id.Clock.sid op_id.Clock.time
-    (Op.op_name op);
-  match op with
-  | Op.Op_ins_str { ins_str_obj; ins_str_after; ins_str_value } ->
-      Printf.printf " obj=(%d,%d) after=(%d,%d) value=%S\n" ins_str_obj.sid
-        ins_str_obj.time ins_str_after.sid ins_str_after.time ins_str_value
-  | Op.Op_new_str -> Printf.printf "\n"
-  | Op.Op_ins_val { ins_val_obj; ins_val_value } ->
-      Printf.printf " obj=(%d,%d) value=(%d,%d)\n" ins_val_obj.sid
-        ins_val_obj.time ins_val_value.sid ins_val_value.time
-  | Op.Op_del { del_obj; del_what } ->
-      Printf.printf " obj=(%d,%d) spans=[" del_obj.sid del_obj.time;
-      List.iter
-        (fun (span : Clock.timespan) ->
-          Printf.printf "(%d,%d,%d)" span.sid span.time span.span)
-        del_what;
-      Printf.printf "]\n"
-  | _ -> Printf.printf "\n"
-
-let () =
-  (* Simple test: apply just the first 3 patches step by step *)
-  let trace_dir =
-    project_root ^ "/test/fixtures/traces/text/sequential/friendsforever_flat"
-  in
-  let bin_file = trace_dir ^ "/patches.bin" in
-
-  let bin_data = read_file bin_file in
-  let patches =
-    match Patch_codec_binary.decode_batch (Bytes.of_string bin_data) with
-    | Ok p -> p
-    | Error e -> failwith e
-  in
-
-  Printf.printf "Total patches: %d\n\n" (List.length patches);
-
-  let model = Model.create 0 in
-
-  (* Apply patch 1 *)
-  Printf.printf "=== Patch 1 ===\n";
-  let p1 = List.nth patches 0 in
-  Patch.iter_with_id print_op p1;
-  Model.apply model p1;
-  Printf.printf "Result: %S\n\n"
-    (match Model.view model with Value.String s -> s | _ -> "(none)");
-
-  (* Apply patch 2 *)
-  Printf.printf "=== Patch 2 ===\n";
-  let p2 = List.nth patches 1 in
-  Patch.iter_with_id print_op p2;
-  Model.apply model p2;
-  let v2 = match Model.view model with Value.String s -> s | _ -> "(none)" in
-  Printf.printf "Result: %S\n" v2;
-  Printf.printf "Length: %d\n\n" (String.length v2);
-
-  (* Now apply patch 3 operation by operation *)
-  Printf.printf "=== Patch 3 (step by step) ===\n";
-  let p3 = List.nth patches 2 in
-  let ops = ref [] in
-  Patch.iter_with_id (fun id op -> ops := (id, op) :: !ops) p3;
-  let ops = List.rev !ops in
-
-  (* Get the string node to inspect its RGA *)
-  let str_node =
-    match Model.get_node model { Clock.sid = 1000000; time = 1 } with
-    | Some n -> n
-    | None -> failwith "no str node"
-  in
-
-  let print_chunks () =
-    match str_node with
-    | Node.Node_str { str_rga; _ } ->
-        Printf.printf "  Chunks: ";
-        List.iter
-          (fun (c : string Rga.chunk) ->
-            Printf.printf "[id=%d,sp=%d,%S%s] " c.id.time c.span
-              (if String.length c.data > 8 then String.sub c.data 0 8 ^ ".."
-               else c.data)
-              (if c.deleted then "(D)" else ""))
-          (Rga.to_list str_rga);
-        Printf.printf "\n"
-    | _ -> ()
-  in
-
-  Printf.printf "Before patch 3:\n";
-  print_chunks ();
-  Printf.printf "\n";
-
-  List.iter
-    (fun (op_id, op) ->
-      Printf.printf "Applying: ";
-      print_op op_id op;
-      Model.apply_op model op_id op;
-      print_chunks ();
-      let view =
-        match Model.view model with Value.String s -> s | _ -> "(none)"
-      in
-      Printf.printf "  Result: %S\n\n"
-        (if String.length view > 60 then String.sub view 0 60 ^ "..." else view))
-    ops

bin/wbr/dune

···
+(executable
+ (name wbr)
+ (libraries crdt eio eio_main raylib simdjsont))

bin/wbr/wbr.ml

···
+(** Collaborative Whiteboard Demo
+
+    A real-time collaborative whiteboard with:
+    - Drawing with multiple colors and brush sizes
+    - Real-time cursor presence
+    - Chat functionality
+    - Multi-user networking via Eio
+
+    Usage: ./whiteboard --name "Alice" --host # Start as server ./whiteboard
+    --name "Bob" --connect 192.168.1.1 # Connect to server ./whiteboard --name
+    "Carol" # Local-only mode *)
+
+[@@@warning "-69-32-27-26"]
+
+open Raylib
+module J = Simdjsont.Json
+
+(* ============================================================================
+   Configuration & Scaling
+   ============================================================================ *)
+
+let base_width = 1200
+let base_height = 800
+let default_port = 9999
+let max_chat_messages = 50
+let presence_timeout = 10.0 (* Time before cursor fades *)
+let user_timeout = 30.0 (* Time before user is removed from list *)
+
+let sync_interval =
+  0.5 (* Presence update interval - reduced to avoid flooding *)
+
+(* Mutable layout values that update on resize *)
+let window_width = ref base_width
+let window_height = ref base_height
+
+(* DPI scale - set once at startup based on display, doesn't change on resize *)
+let dpi_scale = ref 1.0
+
+(* Scale for DPI only (not window size) *)
+let scale x = int_of_float (float_of_int x *. !dpi_scale)
+let scalef x = x *. !dpi_scale
+
+(* Get mouse position *)
+let get_mouse_pos () =
+  let mx = float_of_int (get_mouse_x ()) in
+  let my = float_of_int (get_mouse_y ()) in
+  (mx, my)
+
+(* Fixed UI element sizes (scaled for DPI only) *)
+let margin () = scale 10
+let sidebar_width () = scale 280
+let palette_height () = scale 50
+let chat_height () = scale 280
+
+(* Layout calculations - canvas grows/shrinks with window, other elements stay fixed *)
+let canvas_x () = margin ()
+let canvas_y () = margin ()
+
+let canvas_width () =
+  !window_width - canvas_x () - sidebar_width () - (margin () * 2)
+
+let canvas_height () = !window_height - (margin () * 2) - palette_height ()
+let sidebar_x () = !window_width - sidebar_width () - margin ()
+let chat_y () = !window_height - chat_height () - margin ()
+let presence_y () = canvas_y ()
+let presence_height () = chat_y () - presence_y () - margin ()
+
+(* ============================================================================
+   Types
+   ============================================================================ *)
+
+type point = { x : float; y : float }
+
+type stroke = {
+  stroke_id : string;
+  color : int; (* Store as int for serialization *)
+  thickness : float;
+  points : point list;
+}
+
+type user_presence = {
+  user_id : string;
+  user_name : string;
+  cursor_x : float;
+  cursor_y : float;
+  user_color : int;
+  last_seen : float;
+}
+
+type chat_message = {
+  msg_id : string;
+  sender : string;
+  text : string;
+  timestamp : float;
+}
+
+type app_mode = Local | Server | Client of string
+
+type drawing_segment = {
+  draw_user_id : string;
+  draw_color : int;
+  draw_thickness : float;
+  draw_from : point;
+  draw_to : point;
+}
+
+type net_message =
+  | MsgStroke of stroke
+  | MsgDrawing of drawing_segment
+  | MsgPresence of user_presence
+  | MsgChat of chat_message
+  | MsgSync of {
+      strokes : stroke list;
+      messages : chat_message list;
+      users : user_presence list;
+    }
+  | MsgJoin of { user_id : string; user_name : string; user_color : int }
+  | MsgLeave of { user_id : string }
+
+type app_state = {
+  mutable mode : app_mode;
+  mutable my_id : string;
+  mutable my_name : string;
+  mutable my_color : int;
+  mutable is_drawing : bool;
+  mutable current_stroke : point list;
+  mutable strokes : stroke list;
+  mutable brush_color : int;
+  mutable brush_size : float;
+  mutable palette_index : int;
+  users : (string, user_presence) Hashtbl.t; (* user_id -> presence *)
+  mutable messages : chat_message list;
+  mutable chat_input : string;
+  mutable chat_focused : bool;
+  mutable connected : bool;
+  mutable last_presence_sync : float;
+  mutable name_input : string;
+  mutable entering_name : bool;
+  (* Remote drawings: segments from other users currently being drawn *)
+  mutable remote_drawings : drawing_segment list;
+  (* Eio streams for message passing *)
+  incoming : net_message Eio.Stream.t;
+  outgoing : net_message Eio.Stream.t;
+}
+
+(* ============================================================================
+   Colors
+   ============================================================================ *)
+
+(* Multiple palettes - each has black, white, and 8 colors *)
+(* Palette 0: Pastel light *)
+let palette_pastel_light =
+  [|
+    0x000000ff;
+    0xffffffff;
+    0xffb3baff;
+    0xffdfbaff;
+    0xffffbaff;
+    0xbaffc9ff;
+    0xbae1ffff;
+    0xbac8ffff;
+    0xe0baffff;
+    0xffbaffff;
+  |]
+
+(* Palette 1: Pastel medium *)
+let palette_pastel_medium =
+  [|
+    0x000000ff;
+    0xffffffff;
+    0xf8a5a5ff;
+    0xf8cba5ff;
+    0xf8f8a5ff;
+    0xa5f8b8ff;
+    0xa5d8f8ff;
+    0xa5a5f8ff;
+    0xd8a5f8ff;
+    0xf8a5d8ff;
+  |]
+
+(* Palette 2: Pastel muted *)
+let palette_pastel_muted =
+  [|
+    0x000000ff;
+    0xffffffff;
+    0xd4a5a5ff;
+    0xd4bfa5ff;
+    0xd4d4a5ff;
+    0xa5d4b0ff;
+    0xa5c4d4ff;
+    0xa5a5d4ff;
+    0xc4a5d4ff;
+    0xd4a5c4ff;
+  |]
+
+(* Palette 3: Soft warm *)
+let palette_soft_warm =
+  [|
+    0x000000ff;
+    0xffffffff;
+    0xe8998dff;
+    0xeab69fff;
+    0xead89fff;
+    0xb5deadff;
+    0x9fd5e8ff;
+    0x9fb5e8ff;
+    0xc49fe8ff;
+    0xe89fc4ff;
+  |]
+
+(* Palette 4: Soft cool *)
+let palette_soft_cool =
+  [|
+    0x000000ff;
+    0xffffffff;
+    0x9db5c4ff;
+    0x9dc4b5ff;
+    0xb5c49dff;
+    0xc4b59dff;
+    0xc49db5ff;
+    0xb59dc4ff;
+    0x9dc5c4ff;
+    0xa5c4c4ff;
+  |]
+
+(* Palette 5: Vibrant *)
+let palette_vibrant =
+  [|
+    0x000000ff;
+    0xffffffff;
+    0xff6b6bff;
+    0xffa94dff;
+    0xffd93dff;
+    0x6bcb77ff;
+    0x4d96ffff;
+    0x6b5bffff;
+    0xc56bffff;
+    0xff6bb5ff;
+  |]
+
+(* Palette 6: Earth tones *)
+let palette_earth =
+  [|
+    0x000000ff;
+    0xffffffff;
+    0xc9a87cff;
+    0xa8c97cff;
+    0x7cc9a8ff;
+    0x7ca8c9ff;
+    0xa87cc9ff;
+    0xc97ca8ff;
+    0xb5a88fff;
+    0x8fb5a8ff;
+  |]
+
+(* Palette 7: Classic *)
+let palette_classic =
+  [|
+    0x000000ff;
+    0xffffffff;
+    0xff0000ff;
+    0xff8000ff;
+    0xffff00ff;
+    0x00ff00ff;
+    0x00ffffff;
+    0x0000ffff;
+    0x8000ffff;
+    0xff00ffff;
+  |]
+
+let all_palettes =
+  [|
+    palette_pastel_light;
+    palette_pastel_medium;
+    palette_pastel_muted;
+    palette_soft_warm;
+    palette_soft_cool;
+    palette_vibrant;
+    palette_earth;
+    palette_classic;
+  |]
+
+let num_palettes = Array.length all_palettes
+
+(* Get current palette colors *)
+let get_palette idx = all_palettes.(idx mod num_palettes)
+
+let user_colors =
+  [|
+    0xe74c3cff;
+    0x2ecc71ff;
+    0x3498dbff;
+    0x9b59b6ff;
+    0xf1c40fff;
+    0xe67e22ff;
+    0x1abc9cff;
+    0x34495eff;
+  |]
+
+let color_of_int n =
+  Color.create
+    ((n lsr 24) land 0xff)
+    ((n lsr 16) land 0xff)
+    ((n lsr 8) land 0xff)
+    (n land 0xff)
+
+let get_user_color idx = user_colors.(abs idx mod Array.length user_colors)
+
+(* ============================================================================
+   Utilities
+   ============================================================================ *)
+
+let generate_id () =
+  Random.self_init ();
+  String.init 8 (fun _ ->
+      let n = Random.int 36 in
+      if n < 10 then Char.chr (48 + n) else Char.chr (97 + n - 10))
+
+let current_time () = Unix.gettimeofday ()
+let clamp v lo hi = max lo (min hi v)
+
+let point_in_rect x y rx ry rw rh =
+  x >= float_of_int rx
+  && x <= float_of_int (rx + rw)
+  && y >= float_of_int ry
+  && y <= float_of_int (ry + rh)
+
+(* ============================================================================
+   JSON Serialization using Simdjsont
+   ============================================================================ *)
+
+(* Helper to build JSON objects *)
+let obj members = J.Object members
+let arr items = J.Array items
+let str s = J.String s
+let num f = J.Float f
+let int_num i = J.Float (Float.of_int i)
+let mem k v = (k, v)
+
+(* Encode to JSON string - MUST be minified (no newlines) for line-based protocol *)
+let json_to_string json = J.to_string json
+
+(* Build JSON for point *)
+let point_to_json p = arr [ num p.x; num p.y ]
+
+(* Build JSON for stroke (with or without type tag) *)
+let stroke_to_json_obj ~with_type s =
+  let base =
+    [
+      mem "i" (str s.stroke_id);
+      mem "c" (int_num s.color);
+      mem "k" (num s.thickness);
+      mem "p" (arr (List.map point_to_json s.points));
+    ]
+  in
+  obj (if with_type then mem "t" (str "s") :: base else base)
+
+(* Build JSON for user/presence (with or without type tag) *)
+let user_to_json_obj ~with_type p =
+  let base =
+    [
+      mem "i" (str p.user_id);
+      mem "n" (str p.user_name);
+      mem "x" (num p.cursor_x);
+      mem "y" (num p.cursor_y);
+      mem "c" (int_num p.user_color);
+      mem "s" (num p.last_seen);
+    ]
+  in
+  obj (if with_type then mem "t" (str "p") :: base else base)
+
+(* Build JSON for chat message (with or without type tag) *)
+let chat_to_json_obj ~with_type m =
+  let base =
+    [
+      mem "i" (str m.msg_id);
+      mem "n" (str m.sender);
+      mem "x" (str m.text);
+      mem "s" (num m.timestamp);
+    ]
+  in
+  obj (if with_type then mem "t" (str "m") :: base else base)
+
+(* Build JSON for join message *)
+let join_to_json_obj user_id user_name user_color =
+  obj
+    [
+      mem "t" (str "j");
+      mem "i" (str user_id);
+      mem "n" (str user_name);
+      mem "c" (int_num user_color);
+    ]
+
+(* Build JSON for leave message *)
+let leave_to_json_obj user_id = obj [ mem "t" (str "l"); mem "i" (str user_id) ]
+
+(* Build JSON for sync message *)
+let sync_to_json_obj strokes messages users =
+  obj
+    [
+      mem "t" (str "y");
+      mem "s" (arr (List.map (stroke_to_json_obj ~with_type:false) strokes));
+      mem "m" (arr (List.map (chat_to_json_obj ~with_type:false) messages));
+      mem "u" (arr (List.map (user_to_json_obj ~with_type:false) users));
+    ]
+
+(* Build JSON for drawing segment (real-time line) *)
+let drawing_to_json_obj d =
+  obj
+    [
+      mem "t" (str "d");
+      mem "i" (str d.draw_user_id);
+      mem "c" (int_num d.draw_color);
+      mem "k" (num d.draw_thickness);
+      mem "f" (point_to_json d.draw_from);
+      mem "o" (point_to_json d.draw_to);
+    ]
+
+(* Convert message to JSON string *)
+let message_to_json = function
+  | MsgStroke s -> json_to_string (stroke_to_json_obj ~with_type:true s)
+  | MsgDrawing d -> json_to_string (drawing_to_json_obj d)
+  | MsgPresence p -> json_to_string (user_to_json_obj ~with_type:true p)
+  | MsgChat m -> json_to_string (chat_to_json_obj ~with_type:true m)
+  | MsgJoin { user_id; user_name; user_color } ->
+      json_to_string (join_to_json_obj user_id user_name user_color)
+  | MsgLeave { user_id } -> json_to_string (leave_to_json_obj user_id)
+  | MsgSync { strokes; messages; users } ->
+      json_to_string (sync_to_json_obj strokes messages users)
+
+(* JSON parsing helpers *)
+let get_string_field obj key =
+  List.find_map
+    (fun (k, v) ->
+      if k = key then match v with J.String s -> Some s | _ -> None else None)
+    obj
+
+let get_int_field obj key =
+  List.find_map
+    (fun (k, v) ->
+      if k = key then
+        match v with
+        | J.Float f -> Some (Float.to_int f)
+        | J.Int i -> Some (Int64.to_int i)
+        | _ -> None
+      else None)
+    obj
+
+let get_float_field obj key =
+  List.find_map
+    (fun (k, v) ->
+      if k = key then
+        match v with
+        | J.Float f -> Some f
+        | J.Int i -> Some (Int64.to_float i)
+        | _ -> None
+      else None)
+    obj
+
+let get_array_field obj key =
+  List.find_map
+    (fun (k, v) ->
+      if k = key then match v with J.Array items -> Some items | _ -> None
+      else None)
+    obj
+
+(* Parse point from JSON *)
+let parse_point_json = function
+  | J.Array [ J.Float x; J.Float y ] -> Some { x; y }
+  | J.Array [ J.Int x; J.Int y ] ->
+      Some { x = Int64.to_float x; y = Int64.to_float y }
+  | J.Array [ J.Float x; J.Int y ] -> Some { x; y = Int64.to_float y }
+  | J.Array [ J.Int x; J.Float y ] -> Some { x = Int64.to_float x; y }
+  | _ -> None
+
+(* Parse stroke from JSON object members *)
+let parse_stroke_json obj =
+  let stroke_id =
+    Option.value (get_string_field obj "i") ~default:(generate_id ())
+  in
+  let color = Option.value (get_int_field obj "c") ~default:0x000000ff in
+  let thickness = Option.value (get_float_field obj "k") ~default:3.0 in
+  let points =
+    match get_array_field obj "p" with
+    | Some items -> List.filter_map parse_point_json items
+    | None -> []
+  in
+  { stroke_id; color; thickness; points }
+
+(* Parse presence/user from JSON object members *)
+let parse_presence_json obj =
+  let user_id = Option.value (get_string_field obj "i") ~default:"" in
+  let user_name = Option.value (get_string_field obj "n") ~default:"?" in
+  let cursor_x = Option.value (get_float_field obj "x") ~default:0.0 in
+  let cursor_y = Option.value (get_float_field obj "y") ~default:0.0 in
+  let user_color = Option.value (get_int_field obj "c") ~default:0x808080ff in
+  let last_seen =
+    Option.value (get_float_field obj "s") ~default:(current_time ())
+  in
+  { user_id; user_name; cursor_x; cursor_y; user_color; last_seen }
+
+(* Parse chat from JSON object members *)
+let parse_chat_json obj =
+  let msg_id =
+    Option.value (get_string_field obj "i") ~default:(generate_id ())
+  in
+  let sender = Option.value (get_string_field obj "n") ~default:"?" in
+  let text = Option.value (get_string_field obj "x") ~default:"" in
+  let timestamp =
+    Option.value (get_float_field obj "s") ~default:(current_time ())
+  in
+  { msg_id; sender; text; timestamp }
+
+(* Parse array of objects *)
+let parse_array_json items parse_fn =
+  List.filter_map
+    (function J.Object obj -> Some (parse_fn obj) | _ -> None)
+    items
+
+(* Parse drawing segment from JSON object members *)
+let parse_drawing_json obj =
+  let user_id = Option.value (get_string_field obj "i") ~default:"" in
+  let color = Option.value (get_int_field obj "c") ~default:0x000000ff in
+  let thickness = Option.value (get_float_field obj "k") ~default:3.0 in
+  let from_point =
+    match get_array_field obj "f" with
+    | Some items -> (
+        match parse_point_json (J.Array items) with
+        | Some p -> p
+        | None -> { x = 0.; y = 0. })
+    | None -> { x = 0.; y = 0. }
+  in
+  let to_point =
+    match get_array_field obj "o" with
+    | Some items -> (
+        match parse_point_json (J.Array items) with
+        | Some p -> p
+        | None -> { x = 0.; y = 0. })
+    | None -> { x = 0.; y = 0. }
+  in
+  {
+    draw_user_id = user_id;
+    draw_color = color;
+    draw_thickness = thickness;
+    draw_from = from_point;
+    draw_to = to_point;
+  }
+
+(* Parse a network message from JSON string *)
+let parse_message json_str =
+  match Simdjsont.Decode.decode_string Simdjsont.Decode.value json_str with
+  | Error _ -> None
+  | Ok (J.Object obj) -> (
+      match get_string_field obj "t" with
+      | Some "s" -> Some (MsgStroke (parse_stroke_json obj))
+      | Some "d" -> Some (MsgDrawing (parse_drawing_json obj))
+      | Some "p" -> Some (MsgPresence (parse_presence_json obj))
+      | Some "m" -> Some (MsgChat (parse_chat_json obj))
+      | Some "j" ->
+          let user_id = Option.value (get_string_field obj "i") ~default:"" in
+          let user_name =
+            Option.value (get_string_field obj "n") ~default:"?"
+          in
+          let user_color =
+            Option.value (get_int_field obj "c") ~default:0x808080ff
+          in
+          Some (MsgJoin { user_id; user_name; user_color })
+      | Some "l" ->
+          let user_id = Option.value (get_string_field obj "i") ~default:"" in
+          Some (MsgLeave { user_id })
+      | Some "y" ->
+          let strokes =
+            match get_array_field obj "s" with
+            | Some items -> parse_array_json items parse_stroke_json
+            | None -> []
+          in
+          let messages =
+            match get_array_field obj "m" with
+            | Some items -> parse_array_json items parse_chat_json
+            | None -> []
+          in
+          let users =
+            match get_array_field obj "u" with
+            | Some items -> parse_array_json items parse_presence_json
+            | None -> []
+          in
+          Some (MsgSync { strokes; messages; users })
+      | _ -> None)
+  | Ok _ -> None
+
+(* ============================================================================
+   State Management
+   ============================================================================ *)
+
+let create_state ~incoming ~outgoing mode name =
+  Random.self_init ();
+  let my_id = generate_id () in
+  let my_color = get_user_color (Hashtbl.hash my_id) in
+  {
+    mode;
+    my_id;
+    my_name = name;
+    my_color;
+    is_drawing = false;
+    current_stroke = [];
+    strokes = [];
+    brush_color = 0x000000ff;
+    brush_size = 3.0;
+    palette_index = 0;
+    users = Hashtbl.create 32;
+    messages = [];
+    chat_input = "";
+    chat_focused = false;
+    connected = false;
+    last_presence_sync = 0.0;
+    name_input = name;
+    entering_name = name = "";
+    remote_drawings = [];
+    incoming;
+    outgoing;
+  }
+
+let send_message state msg =
+  match state.mode with
+  | Local -> ()
+  | Server | Client _ -> Eio.Stream.add state.outgoing msg
+
+let add_stroke state stroke ~broadcast =
+  if not (List.exists (fun s -> s.stroke_id = stroke.stroke_id) state.strokes)
+  then begin
+    state.strokes <- state.strokes @ [ stroke ];
+    if broadcast then send_message state (MsgStroke stroke)
+  end
+
+let add_chat state msg ~broadcast =
+  if not (List.exists (fun m -> m.msg_id = msg.msg_id) state.messages) then begin
+    state.messages <- state.messages @ [ msg ];
+    if List.length state.messages > max_chat_messages then
+      state.messages <-
+        List.filteri
+          (fun i _ -> i >= List.length state.messages - max_chat_messages)
+          state.messages;
+    if broadcast then send_message state (MsgChat msg)
+  end
+
+let update_user state user ~broadcast =
+  Hashtbl.replace state.users user.user_id user;
+  if broadcast then send_message state (MsgPresence user)
+
+let process_incoming state =
+  (* Non-blocking take from stream *)
+  let rec drain () =
+    match Eio.Stream.take_nonblocking state.incoming with
+    | None -> ()
+    | Some msg ->
+        (match msg with
+        | MsgStroke s -> add_stroke state s ~broadcast:false
+        | MsgDrawing d when d.draw_user_id <> state.my_id ->
+            (* Add to remote drawings for rendering *)
+            state.remote_drawings <- d :: state.remote_drawings;
+            (* Limit to last 100 segments to prevent memory issues *)
+            if List.length state.remote_drawings > 100 then
+              state.remote_drawings <-
+                List.filteri (fun i _ -> i < 100) state.remote_drawings
+        | MsgDrawing _ -> ()
+        | MsgPresence p when p.user_id <> state.my_id ->
+            update_user state p ~broadcast:false
+        | MsgPresence _ -> ()
+        | MsgChat m -> add_chat state m ~broadcast:false
+        | MsgJoin { user_id; user_name; user_color }
+          when user_id <> state.my_id && user_id <> "" ->
+            let p =
+              {
+                user_id;
+                user_name;
+                cursor_x = 0.;
+                cursor_y = 0.;
+                user_color;
+                last_seen = current_time ();
+              }
+            in
+            update_user state p ~broadcast:false;
+            add_chat state
+              {
+                msg_id = generate_id ();
+                sender = "System";
+                text = user_name ^ " joined";
+                timestamp = current_time ();
+              }
+              ~broadcast:false
+        | MsgJoin _ -> ()
+        | MsgLeave { user_id } -> (
+            let user = Hashtbl.find_opt state.users user_id in
+            Hashtbl.remove state.users user_id;
+            (* Clear remote drawings from this user *)
+            state.remote_drawings <-
+              List.filter
+                (fun d -> d.draw_user_id <> user_id)
+                state.remote_drawings;
+            match user with
+            | Some u ->
+                add_chat state
+                  {
+                    msg_id = generate_id ();
+                    sender = "System";
+                    text = u.user_name ^ " left";
+                    timestamp = current_time ();
+                  }
+                  ~broadcast:false
+            | None -> ())
+        | MsgSync { strokes; messages; users } ->
+            List.iter (fun s -> add_stroke state s ~broadcast:false) strokes;
+            List.iter (fun m -> add_chat state m ~broadcast:false) messages;
+            List.iter
+              (fun u ->
+                if u.user_id <> state.my_id then
+                  update_user state u ~broadcast:false)
+              users);
+        drain ()
+  in
+  drain ()
+
+let cleanup_users state =
+  let now = current_time () in
+  let to_remove =
+    Hashtbl.fold
+      (fun user_id u acc ->
+        if user_id <> state.my_id && now -. u.last_seen >= user_timeout then
+          user_id :: acc
+        else acc)
+      state.users []
+  in
+  List.iter (Hashtbl.remove state.users) to_remove
+
+(* ============================================================================
+   Networking with Eio
+   ============================================================================ *)
+
+(* Set TCP_NODELAY on a socket to disable Nagle's algorithm for low latency *)
+let set_tcp_nodelay flow =
+  match Eio_unix.Resource.fd_opt flow with
+  | Some fd ->
+      Eio_unix.Fd.use_exn "setsockopt" fd (fun unix_fd ->
+          Unix.setsockopt unix_fd Unix.TCP_NODELAY true)
+  | None -> ()
+
+(* Read a line from an Eio flow *)
+let read_line flow buf_reader =
+  let buf = Buffer.create 256 in
+  let rec loop () =
+    match Eio.Buf_read.any_char buf_reader with
+    | '\n' -> Some (Buffer.contents buf)
+    | c ->
+        Buffer.add_char buf c;
+        loop ()
+  in
+  try loop () with End_of_file -> None
+
+(* Write a line to an Eio flow *)
+let write_line flow line = Eio.Flow.copy_string (line ^ "\n") flow
+
+(* Client info tracked by server - using polymorphic type for flow *)
+type 'a client_info = {
+  client_flow : 'a;
+  mutable client_user_id : string option;
+}
+
+(* Handle a single client connection (server-side) *)
+let handle_client ~sw ~state ~clients ~clients_mutex client_info =
+  let flow = client_info.client_flow in
+  set_tcp_nodelay flow;
+  let buf_reader = Eio.Buf_read.of_flow ~max_size:65536 flow in
+
+  (* Send sync to new client *)
+  let my_presence =
+    {
+      user_id = state.my_id;
+      user_name = state.my_name;
+      cursor_x = 0.;
+      cursor_y = 0.;
+      user_color = state.my_color;
+      last_seen = current_time ();
+    }
+  in
+  let all_users =
+    my_presence :: Hashtbl.fold (fun _ u acc -> u :: acc) state.users []
+  in
+  let sync =
+    MsgSync
+      { strokes = state.strokes; messages = state.messages; users = all_users }
+  in
+  (try write_line flow (message_to_json sync) with _ -> ());
+
+  (* Read messages from client *)
+  let rec read_loop () =
+    match read_line flow buf_reader with
+    | None -> () (* Client disconnected *)
+    | Some line -> (
+        match parse_message line with
+        | Some msg ->
+            (* Track user_id from join message *)
+            (match msg with
+            | MsgJoin { user_id; _ } ->
+                client_info.client_user_id <- Some user_id
+            | _ -> ());
+            (* Send to main via stream *)
+            Eio.Stream.add state.incoming msg;
+            (* Broadcast to other clients *)
+            Eio.Mutex.use_rw ~protect:true clients_mutex (fun () ->
+                List.iter
+                  (fun ci ->
+                    if ci.client_flow != flow then
+                      try write_line ci.client_flow (message_to_json msg)
+                      with _ -> ())
+                  !clients);
+            (* If join, send server info back *)
+            (match msg with
+            | MsgJoin _ -> (
+                let server_join =
+                  MsgJoin
+                    {
+                      user_id = state.my_id;
+                      user_name = state.my_name;
+                      user_color = state.my_color;
+                    }
+                in
+                try write_line flow (message_to_json server_join) with _ -> ())
+            | _ -> ());
+            read_loop ()
+        | None -> read_loop ())
+  in
+  Fun.protect
+    ~finally:(fun () ->
+      (* Send leave message when client disconnects *)
+      (match client_info.client_user_id with
+      | Some user_id ->
+          let leave_msg = MsgLeave { user_id } in
+          (* Notify server's main loop *)
+          Eio.Stream.add state.incoming leave_msg;
+          (* Broadcast to other clients *)
+          Eio.Mutex.use_rw ~protect:true clients_mutex (fun () ->
+              List.iter
+                (fun ci ->
+                  if ci.client_flow != flow then
+                    try write_line ci.client_flow (message_to_json leave_msg)
+                    with _ -> ())
+                !clients)
+      | None -> ());
+      (* Remove from client list *)
+      Eio.Mutex.use_rw ~protect:true clients_mutex (fun () ->
+          clients := List.filter (fun ci -> ci.client_flow != flow) !clients))
+    read_loop
+
+(* Server: accept connections and broadcast outgoing messages *)
+let run_server ~sw ~net ~state ~clock port =
+  let addr = `Tcp (Eio.Net.Ipaddr.V4.any, port) in
+  let socket = Eio.Net.listen ~sw ~backlog:16 ~reuse_addr:true net addr in
+  let clients = ref [] in
+  let clients_mutex = Eio.Mutex.create () in
+
+  Printf.printf "Server listening on port %d\n%!" port;
+  state.connected <- true;
+
+  (* Fiber to broadcast outgoing messages from main *)
+  Eio.Fiber.fork ~sw (fun () ->
+      while true do
+        let msg = Eio.Stream.take state.outgoing in
+        let json = message_to_json msg in
+        Eio.Mutex.use_rw ~protect:true clients_mutex (fun () ->
+            clients :=
+              List.filter
+                (fun ci ->
+                  try
+                    write_line ci.client_flow json;
+                    true
+                  with _ -> false)
+                !clients)
+      done);
+
+  (* Accept connections *)
+  while true do
+    Eio.Net.accept_fork ~sw socket
+      ~on_error:(fun _ -> ())
+      (fun flow addr ->
+        Printf.printf "Client connected\n%!";
+        let client_info = { client_flow = flow; client_user_id = None } in
+        Eio.Mutex.use_rw ~protect:true clients_mutex (fun () ->
+            clients := client_info :: !clients);
+        handle_client ~sw ~state ~clients ~clients_mutex client_info)
+  done
+
+(* Client: connect and relay messages *)
+let run_client ~sw ~net ~state ~clock host port =
+  (* Parse IP address from dotted decimal string using Unix *)
+  let inet_addr = Unix.inet_addr_of_string host in
+  let ip_bytes =
+    (* inet_addr is abstract, but we can get the string representation and parse it *)
+    let s = Unix.string_of_inet_addr inet_addr in
+    (* For IPv4, convert "a.b.c.d" to 4 bytes *)
+    let parts = String.split_on_char '.' s in
+    String.init 4 (fun i -> Char.chr (int_of_string (List.nth parts i)))
+  in
+  let ip = Eio.Net.Ipaddr.of_raw ip_bytes in
+  let addr = `Tcp (ip, port) in
+  let flow = Eio.Net.connect ~sw net addr in
+  set_tcp_nodelay flow;
+  let buf_reader = Eio.Buf_read.of_flow ~max_size:65536 flow in
+
+  Printf.printf "Connected to server\n%!";
+  state.connected <- true;
+
+  (* Send join *)
+  let join =
+    MsgJoin
+      {
+        user_id = state.my_id;
+        user_name = state.my_name;
+        user_color = state.my_color;
+      }
+  in
+  write_line flow (message_to_json join);
+
+  (* Fiber to send outgoing messages *)
+  Eio.Fiber.fork ~sw (fun () ->
+      try
+        while true do
+          let msg = Eio.Stream.take state.outgoing in
+          write_line flow (message_to_json msg)
+        done
+      with _ -> ());
+
+  (* Read from server *)
+  let rec read_loop () =
+    match read_line flow buf_reader with
+    | None -> ()
+    | Some line -> (
+        match parse_message line with
+        | Some msg ->
+            Eio.Stream.add state.incoming msg;
+            read_loop ()
+        | None -> read_loop ())
+  in
+  read_loop ()
+
+(* ============================================================================
+   Input Handling
+   ============================================================================ *)
+
+let handle_name_input state ~start_network =
+  if not state.entering_name then ()
+  else begin
+    let rec get_chars () =
+      let key = get_char_pressed () in
+      let code = Uchar.to_int key in
+      if code >= 32 && code < 127 && String.length state.name_input < 20 then begin
+        state.name_input <- state.name_input ^ String.make 1 (Char.chr code);
+        get_chars ()
+      end
+    in
+    get_chars ();
+
+    if is_key_pressed Key.Backspace && String.length state.name_input > 0 then
+      state.name_input <-
+        String.sub state.name_input 0 (String.length state.name_input - 1);
+
+    if is_key_pressed Key.Enter && String.length state.name_input > 0 then begin
+      state.my_name <- state.name_input;
+      state.entering_name <- false;
+      start_network ()
+    end
+  end
+
+let handle_drawing state =
+  if state.entering_name then ()
+  else
+    let mx, my = get_mouse_pos () in
+    let in_canvas =
+      point_in_rect mx my (canvas_x ()) (canvas_y ()) (canvas_width ())
+        (canvas_height ())
+    in
+
+    if in_canvas && not state.chat_focused then begin
+      if is_mouse_button_pressed MouseButton.Left then begin
+        state.is_drawing <- true;
+        state.current_stroke <- [ { x = mx; y = my } ]
+      end
+      else if is_mouse_button_down MouseButton.Left && state.is_drawing then begin
+        match state.current_stroke with
+        | p :: _ when ((mx -. p.x) ** 2.) +. ((my -. p.y) ** 2.) > 9. ->
+            let new_point = { x = mx; y = my } in
+            state.current_stroke <- new_point :: state.current_stroke;
+            (* Send real-time drawing update *)
+            send_message state
+              (MsgDrawing
+                 {
+                   draw_user_id = state.my_id;
+                   draw_color = state.brush_color;
+                   draw_thickness = state.brush_size;
+                   draw_from = p;
+                   draw_to = new_point;
+                 })
+        | _ -> ()
+      end
+      else if is_mouse_button_released MouseButton.Left && state.is_drawing then begin
+        state.is_drawing <- false;
+        if List.length state.current_stroke > 1 then begin
+          let stroke =
+            {
+              stroke_id = generate_id ();
+              color = state.brush_color;
+              thickness = state.brush_size;
+              points = List.rev state.current_stroke;
+            }
+          in
+          add_stroke state stroke ~broadcast:true
+        end;
+        state.current_stroke <- []
+      end
+    end
+    else if is_mouse_button_released MouseButton.Left then begin
+      state.is_drawing <- false;
+      state.current_stroke <- []
+    end
+
+let handle_palette state =
+  if state.entering_name then ()
+  else
+    let palette_y = canvas_y () + canvas_height () + scale 10 in
+    let swatch = scale 30 in
+    let mx, my = get_mouse_pos () in
+
+    if is_mouse_button_pressed MouseButton.Left then
+      let palette = get_palette state.palette_index in
+      Array.iteri
+        (fun i c ->
+          let sx = canvas_x () + scale 70 + (i * (swatch + scale 5)) in
+          if point_in_rect mx my sx palette_y swatch swatch then
+            state.brush_color <- c)
+        palette
+
+let handle_brush_size_and_palette state =
+  if state.entering_name || state.chat_focused then ()
+  else
+    let wheel = get_mouse_wheel_move () in
+    if wheel <> 0. then begin
+      if is_key_down Key.Left_shift || is_key_down Key.Right_shift then begin
+        (* Shift + Wheel: cycle palette *)
+        let delta = if wheel > 0. then 1 else -1 in
+        state.palette_index <-
+          (state.palette_index + delta + num_palettes) mod num_palettes
+      end
+      else
+        (* Wheel alone: change brush size *)
+        state.brush_size <- clamp (state.brush_size +. (wheel *. 2.)) 1. 30.
+    end
+
+let handle_chat state =
+  if state.entering_name then ()
+  else
+    let mx, my = get_mouse_pos () in
+    let input_y = chat_y () + chat_height () - scale 35 in
+
+    if is_mouse_button_pressed MouseButton.Left then
+      state.chat_focused <-
+        point_in_rect mx my (sidebar_x ()) input_y (sidebar_width ()) (scale 30);
+
+    if state.chat_focused then begin
+      let rec get_chars () =
+        let key = get_char_pressed () in
+        let code = Uchar.to_int key in
+        if code >= 32 && code < 127 then begin
+          state.chat_input <- state.chat_input ^ String.make 1 (Char.chr code);
+          get_chars ()
+        end
+      in
+      get_chars ();
+
+      if is_key_pressed Key.Backspace && String.length state.chat_input > 0 then
+        state.chat_input <-
+          String.sub state.chat_input 0 (String.length state.chat_input - 1);
+
+      if is_key_pressed Key.Enter && String.length state.chat_input > 0 then begin
+        let msg =
+          {
+            msg_id = generate_id ();
+            sender = state.my_name;
+            text = state.chat_input;
+            timestamp = current_time ();
+          }
+        in
+        add_chat state msg ~broadcast:true;
+        state.chat_input <- ""
+      end;
+
+      if is_key_pressed Key.Escape then state.chat_focused <- false
+    end
+
+let handle_shortcuts state =
+  if state.entering_name || state.chat_focused then ()
+  else if is_key_pressed Key.C then state.strokes <- []
+
+let handle_resize () =
+  (* Update window dimensions - DPI scale stays constant *)
+  let w = get_screen_width () in
+  let h = get_screen_height () in
+  if w <> !window_width || h <> !window_height then begin
+    window_width := w;
+    window_height := h
+  end
+
+let handle_input state ~start_network =
+  handle_resize ();
+  handle_name_input state ~start_network;
+  handle_drawing state;
+  handle_palette state;
+  handle_brush_size_and_palette state;
+  handle_chat state;
+  handle_shortcuts state
+
+(* ============================================================================
+   Rendering
+   ============================================================================ *)
+
+let draw_name_dialog state =
+  let dw = scale 500 in
+  let dh = scale 180 in
+  let dx = (!window_width - dw) / 2 in
+  let dy = (!window_height - dh) / 2 in
+
+  draw_rectangle 0 0 !window_width !window_height (Color.create 0 0 0 180);
+  draw_rectangle dx dy dw dh Color.raywhite;
+  draw_rectangle_lines dx dy dw dh Color.darkgray;
+
+  draw_text "Enter Your Name"
+    (dx + scale 140)
+    (dy + scale 25)
+    (scale 28) Color.darkgray;
+
+  let ix = dx + scale 50 in
+  let iy = dy + scale 70 in
+  let iw = dw - scale 100 in
+  draw_rectangle ix iy iw (scale 50) Color.white;
+  draw_rectangle_lines ix iy iw (scale 50) Color.blue;
+  draw_text (state.name_input ^ "_")
+    (ix + scale 15)
+    (iy + scale 12)
+    (scale 26) Color.black;
+
+  draw_text "Press ENTER to continue"
+    (dx + scale 140)
+    (dy + scale 140)
+    (scale 18) Color.gray
+
+let draw_stroke stroke =
+  match stroke.points with
+  | [] | [ _ ] -> ()
+  | points ->
+      let color = color_of_int stroke.color in
+      let rec draw = function
+        | [] | [ _ ] -> ()
+        | p1 :: p2 :: rest ->
+            draw_line_ex (Vector2.create p1.x p1.y) (Vector2.create p2.x p2.y)
+              stroke.thickness color;
+            draw (p2 :: rest)
+      in
+      draw points
+
+let draw_current_stroke state =
+  if state.is_drawing && List.length state.current_stroke > 1 then begin
+    let color = color_of_int state.brush_color in
+    let points = List.rev state.current_stroke in
+    let rec draw = function
+      | [] | [ _ ] -> ()
+      | p1 :: p2 :: rest ->
+          draw_line_ex (Vector2.create p1.x p1.y) (Vector2.create p2.x p2.y)
+            state.brush_size color;
+          draw (p2 :: rest)
+    in
+    draw points
+  end
+
+let draw_remote_drawings state =
+  List.iter
+    (fun d ->
+      let color = color_of_int d.draw_color in
+      draw_line_ex
+        (Vector2.create d.draw_from.x d.draw_from.y)
+        (Vector2.create d.draw_to.x d.draw_to.y)
+        d.draw_thickness color)
+    state.remote_drawings
+
+let draw_canvas state =
+  let cx, cy, cw, ch =
+    (canvas_x (), canvas_y (), canvas_width (), canvas_height ())
+  in
+  draw_rectangle cx cy cw ch Color.white;
+  draw_rectangle_lines cx cy cw ch Color.lightgray;
+
+  begin_scissor_mode cx cy cw ch;
+  List.iter draw_stroke state.strokes;
+  draw_remote_drawings state;
+  draw_current_stroke state;
+
+  (* Other users' cursors - skip if outside canvas (cursor at -1,-1) *)
+  let now = current_time () in
+  Hashtbl.iter
+    (fun _ u ->
+      if
+        u.user_id <> state.my_id
+        && now -. u.last_seen < presence_timeout
+        && u.cursor_x >= 0. && u.cursor_y >= 0.
+      then begin
+        let color = color_of_int u.user_color in
+        draw_circle (int_of_float u.cursor_x) (int_of_float u.cursor_y)
+          (scalef 6.) color;
+        draw_circle_lines (int_of_float u.cursor_x) (int_of_float u.cursor_y)
+          (scalef 7.) Color.black;
+        draw_text u.user_name
+          (int_of_float u.cursor_x + scale 12)
+          (int_of_float u.cursor_y - scale 6)
+          (scale 14) color
+      end)
+    state.users;
+  end_scissor_mode ()
+
+let draw_palette state =
+  let py = canvas_y () + canvas_height () + scale 10 in
+  let swatch = scale 30 in
+  let palette = get_palette state.palette_index in
+
+  draw_text "Color:" (canvas_x ()) (py + scale 5) (scale 18) Color.darkgray;
+
+  Array.iteri
+    (fun i c ->
+      let sx = canvas_x () + scale 70 + (i * (swatch + scale 5)) in
+      draw_rectangle sx py swatch swatch (color_of_int c);
+      if c = state.brush_color then
+        draw_rectangle_lines (sx - 2) (py - 2) (swatch + 4) (swatch + 4)
+          Color.gold
+      else draw_rectangle_lines sx py swatch swatch Color.darkgray)
+    palette;
+
+  let size_x =
+    canvas_x () + scale 70
+    + (Array.length palette * (swatch + scale 5))
+    + scale 30
+  in
+  draw_text
+    (Printf.sprintf "Size: %.0f" state.brush_size)
+    size_x
+    (py + scale 5)
+    (scale 18) Color.darkgray;
+  draw_circle
+    (size_x + scale 100)
+    (py + scale 15)
+    state.brush_size
+    (color_of_int state.brush_color)
+
+let draw_users state =
+  let sx, sy, sw, sh =
+    (sidebar_x (), presence_y (), sidebar_width (), presence_height ())
+  in
+  draw_rectangle sx sy sw sh Color.raywhite;
+  draw_rectangle_lines sx sy sw sh Color.lightgray;
+
+  draw_text "Users Online"
+    (sx + scale 10)
+    (sy + scale 10)
+    (scale 22) Color.darkgray;
+
+  let status, color =
+    match state.mode with
+    | Local -> ("Local Mode", Color.gray)
+    | Server ->
+        ( (if state.connected then "Hosting" else "Starting..."),
+          if state.connected then Color.green else Color.orange )
+    | Client _ ->
+        ( (if state.connected then "Connected" else "Connecting..."),
+          if state.connected then Color.green else Color.orange )
+  in
+  draw_text status (sx + scale 10) (sy + scale 40) (scale 16) color;
+
+  let y = ref (sy + scale 70) in
+  draw_circle
+    (sx + scale 20)
+    (!y + scale 10)
+    (scalef 8.)
+    (color_of_int state.my_color);
+  draw_text (state.my_name ^ " (you)") (sx + scale 40) !y (scale 16) Color.black;
+  y := !y + scale 30;
+
+  let now = current_time () in
+  (* Sort users by user_id for stable ordering *)
+  let sorted_users =
+    Hashtbl.fold (fun _ u acc -> u :: acc) state.users []
+    |> List.sort (fun a b -> String.compare a.user_id b.user_id)
+  in
+  List.iter
+    (fun u ->
+      if u.user_id <> state.my_id then begin
+        let alpha =
+          if now -. u.last_seen < presence_timeout then 255 else 100
+        in
+        let c = color_of_int u.user_color in
+        let c = Color.create (Color.r c) (Color.g c) (Color.b c) alpha in
+        draw_circle (sx + scale 20) (!y + scale 10) (scalef 8.) c;
+        draw_text u.user_name
+          (sx + scale 40)
+          !y (scale 16)
+          (if alpha = 255 then Color.black else Color.gray);
+        y := !y + scale 30
+      end)
+    sorted_users
+
+let draw_chat state =
+  let sx, cy, sw, ch =
+    (sidebar_x (), chat_y (), sidebar_width (), chat_height ())
+  in
+  draw_rectangle sx cy sw ch Color.raywhite;
+  draw_rectangle_lines sx cy sw ch Color.lightgray;
+
+  draw_text "Chat" (sx + scale 10) (cy + scale 10) (scale 22) Color.darkgray;
+
+  let msg_y = ref (cy + scale 40) in
+  let msg_h = ch - scale 80 in
+  let line_h = scale 22 in
+  let max_visible = msg_h / line_h in
+  let visible =
+    let total = List.length state.messages in
+    if total > max_visible then
+      List.filteri (fun i _ -> i >= total - max_visible) state.messages
+    else state.messages
+  in
+
+  begin_scissor_mode sx (cy + scale 40) sw msg_h;
+  List.iter
+    (fun m ->
+      let text = Printf.sprintf "%s: %s" m.sender m.text in
+      let max_chars = sw / scale 8 in
+      let display =
+        if String.length text > max_chars then
+          String.sub text 0 (max_chars - 3) ^ "..."
+        else text
+      in
+      let color = if m.sender = "System" then Color.blue else Color.black in
+      draw_text display (sx + scale 10) !msg_y (scale 16) color;
+      msg_y := !msg_y + line_h)
+    visible;
+  end_scissor_mode ();
+
+  let iy = cy + ch - scale 35 in
+  let input_bg = if state.chat_focused then Color.white else Color.lightgray in
+  draw_rectangle (sx + scale 5) iy (sw - scale 10) (scale 30) input_bg;
+  draw_rectangle_lines
+    (sx + scale 5)
+    iy
+    (sw - scale 10)
+    (scale 30)
+    (if state.chat_focused then Color.blue else Color.gray);
+
+  let display =
+    if state.chat_input = "" && not state.chat_focused then "Type to chat..."
+    else state.chat_input ^ if state.chat_focused then "_" else ""
+  in
+  draw_text display
+    (sx + scale 12)
+    (iy + scale 6)
+    (scale 16)
+    (if state.chat_input = "" && not state.chat_focused then Color.gray
+     else Color.black)
+
+let draw_help state =
+  let py = canvas_y () + canvas_height () + palette_height () + scale 5 in
+  draw_text
+    (Printf.sprintf
+       "LMB: Draw | Wheel: Size | Shift+Wheel: Palette (%d/%d) | C: Clear"
+       (state.palette_index + 1) num_palettes)
+    (canvas_x ()) py (scale 14) Color.gray
+
+let render state =
+  begin_drawing ();
+  clear_background (Color.create 240 240 240 255);
+
+  draw_canvas state;
+  draw_palette state;
+  draw_users state;
+  draw_chat state;
+  draw_help state;
+
+  if state.entering_name then draw_name_dialog state;
+  end_drawing ()
+
+(* ============================================================================
+   Update
+   ============================================================================ *)
+
+let update_presence state =
+  if state.entering_name then ()
+  else
+    let now = current_time () in
+    if now -. state.last_presence_sync > sync_interval then begin
+      state.last_presence_sync <- now;
+      let mx, my = get_mouse_pos () in
+      (* Always send presence to keep connection alive, use -1,-1 when outside canvas *)
+      let in_canvas =
+        point_in_rect mx my (canvas_x ()) (canvas_y ()) (canvas_width ())
+          (canvas_height ())
+      in
+      let cursor_x, cursor_y = if in_canvas then (mx, my) else (-1., -1.) in
+      let p =
+        {
+          user_id = state.my_id;
+          user_name = state.my_name;
+          cursor_x;
+          cursor_y;
+          user_color = state.my_color;
+          last_seen = now;
+        }
+      in
+      update_user state p ~broadcast:true
+    end
+
+let update state ~start_network =
+  handle_input state ~start_network;
+  process_incoming state;
+  update_presence state;
+  cleanup_users state
+
+(* ============================================================================
+   Main
+   ============================================================================ *)
+
+let parse_args () =
+  let mode = ref Local in
+  let name = ref "" in
+  let i = ref 1 in
+  while !i < Array.length Sys.argv do
+    (match Sys.argv.(!i) with
+    | "--host" | "-h" -> mode := Server
+    | ("--connect" | "-c") when !i + 1 < Array.length Sys.argv ->
+        incr i;
+        mode := Client Sys.argv.(!i)
+    | ("--name" | "-n") when !i + 1 < Array.length Sys.argv ->
+        incr i;
+        name := Sys.argv.(!i)
+    | s when String.length s > 0 && s.[0] <> '-' && !mode = Local ->
+        mode := Client s
+    | _ -> ());
+    incr i
+  done;
+  (!mode, !name)
+
+let () =
+  let mode, name = parse_args () in
+
+  Eio_main.run @@ fun env ->
+  Eio.Switch.run @@ fun sw ->
+  let net = Eio.Stdenv.net env in
+  let clock = Eio.Stdenv.clock env in
+
+  (* Create message streams *)
+  let incoming = Eio.Stream.create 100 in
+  let outgoing = Eio.Stream.create 100 in
+  let state = create_state ~incoming ~outgoing mode name in
+
+  (* Track if networking has been started *)
+  let network_started = ref false in
+
+  (* Function to start networking (called when name is entered) *)
+  let start_network () =
+    if not !network_started then begin
+      network_started := true;
+      match state.mode with
+      | Local -> ()
+      | Server ->
+          Eio.Fiber.fork ~sw (fun () ->
+              run_server ~sw ~net ~state ~clock default_port)
+      | Client host ->
+          Eio.Fiber.fork ~sw (fun () ->
+              run_client ~sw ~net ~state ~clock host default_port)
+    end
+  in
+
+  (match mode with
+  | Local -> Printf.printf "Local mode\n%!"
+  | Server -> Printf.printf "Server mode on port %d\n%!" default_port
+  | Client h -> Printf.printf "Connecting to %s:%d\n%!" h default_port);
+
+  (* Start networking if name provided *)
+  if name <> "" then start_network ();
+
+  set_config_flags [ ConfigFlags.Msaa_4x_hint; ConfigFlags.Window_resizable ];
+  init_window base_width base_height "CRDT Whiteboard";
+  set_window_min_size 800 600;
+  (* Don't use Raylib's FPS limiter - it blocks and prevents Eio fibers from running *)
+  set_target_fps 0;
+
+  (* Initial dimensions *)
+  window_width := get_screen_width ();
+  window_height := get_screen_height ();
+
+  (* Get DPI scale from system - this detects HiDPI displays *)
+  let dpi_vec = get_window_scale_dpi () in
+  let detected_dpi = max (Vector2.x dpi_vec) (Vector2.y dpi_vec) in
+  (* Use DPI scale if > 1, otherwise use 1.0 *)
+  dpi_scale := if detected_dpi > 1.0 then detected_dpi else 1.0;
+  Printf.printf "DPI scale: %.2f (detected: %.2f x %.2f)\n%!" !dpi_scale
+    (Vector2.x dpi_vec) (Vector2.y dpi_vec);
+
+  let frame_time = 1.0 /. 60.0 in
+  (* Target 60 FPS *)
+  let last_frame = ref (Eio.Time.now clock) in
+
+  while not (window_should_close ()) do
+    update state ~start_network;
+    render state;
+
+    (* Use Eio sleep for frame timing - this allows network fibers to run *)
+    let now = Eio.Time.now clock in
+    let elapsed = now -. !last_frame in
+    let sleep_time = frame_time -. elapsed in
+    if sleep_time > 0.001 then Eio.Time.sleep clock sleep_time;
+    last_frame := Eio.Time.now clock
+  done;
+
+  if state.connected then
+    send_message state (MsgLeave { user_id = state.my_id });
+
+  close_window ();
+  Printf.printf "Goodbye!\n%!"