Add MANIFOLD_NO_IOSTREAM build-time option

Wraps iostream-using overloads in the public headers (manifold.h,
manifoldc.h) and their impls (src/impl.cpp, bindings/c/manifoldc.cpp)
with `#ifndef MANIFOLD_NO_IOSTREAM`. Adds an
`option(MANIFOLD_NO_IOSTREAM)` (default OFF) that propagates the macro
as a PUBLIC compile definition on the manifold target so consumers'
own includes of manifold's headers also strip the iostream-using
overloads. Default behavior unchanged when off.

The bundled Clipper2 (when MANIFOLD_USE_BUILTIN_CLIPPER2=ON) carries
a corresponding patch that adds `CLIPPER2_NO_IOSTREAM` macro guards
to its public headers — tracking AngusJohnson/Clipper2#1094, drops
once that PR lands and the SHA pin moves past it. When
MANIFOLD_NO_IOSTREAM=ON, manifold sets CLIPPER2_NO_IOSTREAM=ON for
the bundled Clipper2 build.

CMake-level conflict guards: MANIFOLD_NO_IOSTREAM=ON is incompatible
with MANIFOLD_DEBUG / MANIFOLD_TIMING (those use std::cout for
diagnostic output), and currently requires MANIFOLD_TEST=OFF (test
fixtures use <filesystem>/<fstream>; restriction will be lifted by a
follow-up MANIFOLD_NO_FILESYSTEM option).

Build-time check: src/no_iostream_check.cpp + a manifold_no_iostream_check
OBJECT target compile manifold/manifold.h with MANIFOLD_NO_IOSTREAM
defined. Always-on; fails the build if iostream usage creeps into
the public header outside the macro guards.

CI: new build_no_iostream cell on Ubuntu/clang exercising
MANIFOLD_NO_IOSTREAM=ON + MANIFOLD_USE_BUILTIN_CLIPPER2=ON (the
patch-application path).

Motivation + the broader consumer cocktail this enables:
elalish#1046 (comment)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: zmerlynn

.github/workflows/manifold.yml

@@ -175,6 +175,46 @@ jobs:
         sudo cmake --install build
         ./scripts/test-cmake.sh
 
+  build_no_iostream:
+    name: NO_IOSTREAM (clang)
+    timeout-minutes: 20
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v6
+    - name: Install apt packages
+      uses: awalsh128/cache-apt-pkgs-action@v1.6.0
+      with:
+        packages: cmake clang
+    - name: Configure + build with MANIFOLD_NO_IOSTREAM=ON
+      run: |
+        cmake \
+          -DCMAKE_BUILD_TYPE=Release \
+          -DCMAKE_C_COMPILER=clang \
+          -DCMAKE_CXX_COMPILER=clang++ \
+          -DMANIFOLD_NO_IOSTREAM=ON \
+          -DMANIFOLD_USE_BUILTIN_CLIPPER2=ON \
+          -DMANIFOLD_STRICT=ON \
+          -DMANIFOLD_TEST=OFF \
+          -DMANIFOLD_PYBIND=OFF \
+          . -B build
+        cmake --build build
+    - name: Verify conflict guards fire (NO_IOSTREAM + DEBUG)
+      run: |
+        if cmake -DMANIFOLD_NO_IOSTREAM=ON -DMANIFOLD_DEBUG=ON \
+                 -DMANIFOLD_USE_BUILTIN_CLIPPER2=ON \
+                 . -B /tmp/conflict-debug 2>&1; then
+          echo "FAIL: configure should have failed for NO_IOSTREAM + DEBUG"
+          exit 1
+        fi
+    - name: Verify conflict guards fire (NO_IOSTREAM + TEST)
+      run: |
+        if cmake -DMANIFOLD_NO_IOSTREAM=ON -DMANIFOLD_TEST=ON \
+                 -DMANIFOLD_USE_BUILTIN_CLIPPER2=ON \
+                 . -B /tmp/conflict-test 2>&1; then
+          echo "FAIL: configure should have failed for NO_IOSTREAM + TEST"
+          exit 1
+        fi
+
   build_gcc_codecov:
     name: code coverage
     timeout-minutes: 45

CMakeLists.txt

@@ -42,6 +42,11 @@ option(MANIFOLD_DEBUG "Enable debug tracing/timing" OFF)
 option(MANIFOLD_ASSERT "Enable assertions - requires MANIFOLD_DEBUG" OFF)
 option(MANIFOLD_TIMING "Enable Boolean3 phase timing without debug overhead" OFF)
 option(MANIFOLD_STRICT "Treat compile warnings as fatal build errors" OFF)
+option(
+  MANIFOLD_NO_IOSTREAM
+  "Strip iostream- and filesystem-using bits from the public API and tests; useful for freestanding/embedded builds. When ON, defines both MANIFOLD_NO_IOSTREAM and MANIFOLD_NO_FILESYSTEM."
+  OFF
+)
 option(
   MANIFOLD_DOWNLOADS
   "Allow Manifold build to download missing dependencies"
@@ -100,6 +105,28 @@ mark_as_advanced(TRACY_MEMORY_USAGE)
 mark_as_advanced(MANIFOLD_FUZZ)
 mark_as_advanced(ASSIMP_ENABLE)
 
+# MANIFOLD_NO_IOSTREAM strips iostream- and filesystem-using bits
+# from the public API. It's incompatible with options that *use*
+# iostream/filesystem for their diagnostic or test output:
+#   * MANIFOLD_DEBUG / MANIFOLD_TIMING: debug/timing output via
+#     std::cout.
+#   * MANIFOLD_TEST: most test files (polygon_test, manifold_test,
+#     polygon_fuzz, manifoldc_test) call iostream-using API or open
+#     fstreams directly outside the wrapped test_main.cpp fixtures.
+if(MANIFOLD_NO_IOSTREAM)
+  if(MANIFOLD_DEBUG OR MANIFOLD_TIMING)
+    message(FATAL_ERROR
+      "MANIFOLD_NO_IOSTREAM is incompatible with MANIFOLD_DEBUG / MANIFOLD_TIMING "
+      "(those options use std::cout for diagnostic output).")
+  endif()
+  if(MANIFOLD_TEST)
+    message(FATAL_ERROR
+      "MANIFOLD_NO_IOSTREAM=ON requires MANIFOLD_TEST=OFF "
+      "(several test files call iostream-using API or open fstreams "
+      "directly; only test_main.cpp's fixtures are wrapped).")
+  endif()
+endif()
+
 # Always build position independent code for relocatability
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 

README.md

@@ -124,6 +124,12 @@ CMake flags (usage e.g. `-DMANIFOLD_DEBUG=ON`):
   See profiling section below.
 - `ASSIMP_ENABLE=[<OFF>, ON]`: Enable integration with assimp, which is needed for some of the utilities in `extras`.
 - `MANIFOLD_STRICT=[<OFF>, ON]`: Treat compile warnings as fatal build errors.
+- `MANIFOLD_NO_IOSTREAM=[<OFF>, ON]`: Strip iostream- and filesystem-using
+  bits from the public API and tests; useful for freestanding/embedded
+  builds (e.g., `wasm32-unknown-unknown`). Defines both
+  `MANIFOLD_NO_IOSTREAM` and `MANIFOLD_NO_FILESYSTEM` as PUBLIC compile
+  definitions. Incompatible with `MANIFOLD_DEBUG` / `MANIFOLD_TIMING` /
+  `MANIFOLD_TEST`.
 
 Dependency version override:
 - `MANIFOLD_USE_BUILTIN_TBB=[<OFF>, ON]`: Use builtin version of tbb.

bindings/c/CMakeLists.txt

@@ -43,3 +43,14 @@ install(
   FILES include/manifold/manifoldc.h include/manifold/types.h
   DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/manifold
 )
+
+# Always-on build-time check: compiles manifold/manifoldc.h with
+# MANIFOLD_NO_IOSTREAM defined. Mirrors src/no_iostream_check.cpp's
+# role for the C++ public header.
+add_library(manifoldc_no_iostream_check OBJECT no_iostream_check.cpp)
+target_link_libraries(manifoldc_no_iostream_check PRIVATE manifoldc)
+if(NOT MANIFOLD_NO_IOSTREAM)
+  target_compile_definitions(
+    manifoldc_no_iostream_check PRIVATE MANIFOLD_NO_IOSTREAM
+  )
+endif()

bindings/c/include/manifold/manifoldc.h

@@ -542,6 +542,7 @@ void manifold_delete_rect(ManifoldRect* b);
 void manifold_delete_triangulation(ManifoldTriangulation* m);
 void manifold_delete_execution_context(ManifoldExecutionContext* ctx);
 
+#ifndef MANIFOLD_NO_IOSTREAM
 // MeshIO / Export
 
 // Import a manifold from a Wavefront obj file.
@@ -570,6 +571,7 @@ void manifold_write_obj(ManifoldManifold* manifold,
 //    passing additional data into the callback.
 void manifold_meshgl64_write_obj(ManifoldMeshGL64* mesh,
                                  void (*callback)(char*, void*), void* args);
+#endif  // !MANIFOLD_NO_IOSTREAM
 #ifdef __cplusplus
 }
 #endif

bindings/c/manifoldc.cpp

@@ -14,7 +14,9 @@
 
 #include "manifold/manifoldc.h"
 
+#ifndef MANIFOLD_NO_IOSTREAM
 #include <sstream>
+#endif
 #include <vector>
 
 #include "conv.h"
@@ -1048,6 +1050,7 @@ void manifold_destruct_execution_context(ManifoldExecutionContext* ctx) {
 
 // IO
 
+#ifndef MANIFOLD_NO_IOSTREAM
 ManifoldManifold* manifold_read_obj(void* mem, char* obj_file) {
   std::istringstream iss(obj_file);
   Manifold m = Manifold::ReadOBJ(iss);
@@ -1075,6 +1078,7 @@ void manifold_meshgl64_write_obj(ManifoldMeshGL64* mesh,
   WriteOBJ(ss, *m);
   callback(ss.str().data(), args);
 }
+#endif  // !MANIFOLD_NO_IOSTREAM
 
 #ifdef __cplusplus
 }

bindings/c/no_iostream_check.cpp

@@ -0,0 +1,19 @@
+// Copyright 2026 The Manifold Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Build-time check: compiles manifold/manifoldc.h with MANIFOLD_NO_IOSTREAM
+// defined. Fails the build if iostream usage creeps into the C-API
+// header outside the macro guards.
+
+#include "manifold/manifoldc.h"

cmake/manifoldDeps.cmake

@@ -119,6 +119,22 @@ if(MANIFOLD_CROSS_SECTION)
       CACHE BOOL
       "Preempt cache default of USINGZ (we only use 2d)"
     )
+    # When manifold is built with MANIFOLD_NO_IOSTREAM, also strip
+    # iostream from the bundled Clipper2 — manifold doesn't call any
+    # of Clipper2's stream operators internally, so passing this
+    # through is safe regardless. The CLIPPER2_NO_IOSTREAM macro is
+    # added by the carry-patch below; once Clipper2#1094 lands and
+    # the SHA pin moves past it, the patch drops and the option is
+    # honored natively.
+    if(MANIFOLD_NO_IOSTREAM)
+      set(
+        CLIPPER2_NO_IOSTREAM
+        ON
+        CACHE BOOL
+        "Strip iostream-using overloads from Clipper2 (set by manifold when MANIFOLD_NO_IOSTREAM=ON)"
+        FORCE
+      )
+    endif()
     FetchContent_Declare(
       Clipper2
       GIT_REPOSITORY https://github.com/AngusJohnson/Clipper2.git
@@ -127,6 +143,13 @@ if(MANIFOLD_CROSS_SECTION)
       GIT_PROGRESS TRUE
       SOURCE_SUBDIR
       CPP
+      # Carry-patch: tracks AngusJohnson/Clipper2#1094 (CLIPPER2_NO_IOSTREAM
+      # macro guards). Drops once that PR lands and the SHA pin moves past it.
+      PATCH_COMMAND
+      git
+      apply
+      --ignore-whitespace
+      ${CMAKE_SOURCE_DIR}/cmake/patches/0001-clipper2-no-iostream.patch
     )
     FetchContent_MakeAvailable(Clipper2)
     set_property(

cmake/patches/0001-clipper2-no-iostream.patch

@@ -0,0 +1,122 @@
+Carry-patch: add CLIPPER2_NO_IOSTREAM macro guards to Clipper2's
+public headers so manifold can build Clipper2 without iostream when
+MANIFOLD_NO_IOSTREAM is set (e.g., for wasm32-unknown-unknown
+consumers via the wasm-cxx-shim integration).
+
+Tracks AngusJohnson/Clipper2#1094 — once that lands and manifold's
+Clipper2 SHA pin moves past it, this patch drops.
+
+Generated against Clipper2 SHA 46f639177fe418f9689e8ddb74f08a870c71f5b4
+(the SHA manifoldDeps.cmake currently pins). The headers at this SHA
+are byte-identical to upstream main, so the patch tracks #1094's diff
+exactly.
+
+Apply with: git apply -p1 0001-clipper2-no-iostream.patch
+
+diff --git a/CPP/Clipper2Lib/include/clipper2/clipper.core.h b/CPP/Clipper2Lib/include/clipper2/clipper.core.h
+index 99a5205..d3af0a0 100644
+--- a/CPP/Clipper2Lib/include/clipper2/clipper.core.h
++++ b/CPP/Clipper2Lib/include/clipper2/clipper.core.h
+@@ -14,7 +14,9 @@
+ #include <cstdint>
+ #include <vector>
+ #include <string>
++#ifndef CLIPPER2_NO_IOSTREAM
+ #include <iostream>
++#endif
+ #include <algorithm>
+ #include <numeric>
+ #include <cmath>
+@@ -166,11 +168,13 @@ namespace Clipper2Lib
+ 
+     void SetZ(const z_type z_value) { z = z_value; }
+ 
++#ifndef CLIPPER2_NO_IOSTREAM
+     friend std::ostream& operator<<(std::ostream& os, const Point& point)
+     {
+       os << point.x << "," << point.y << "," << point.z;
+       return os;
+     }
++#endif
+ 
+ #else
+ 
+@@ -203,11 +207,13 @@ namespace Clipper2Lib
+       return Point(x * scale, y * scale);
+     }
+ 
++#ifndef CLIPPER2_NO_IOSTREAM
+     friend std::ostream& operator<<(std::ostream& os, const Point& point)
+     {
+       os << point.x << "," << point.y;
+       return os;
+     }
++#endif
+ #endif
+ 
+     friend bool operator==(const Point& a, const Point& b)
+@@ -396,10 +402,12 @@ namespace Clipper2Lib
+       return result;
+     }
+ 
++#ifndef CLIPPER2_NO_IOSTREAM
+     friend std::ostream& operator<<(std::ostream& os, const Rect<T>& rect) {
+       os << "(" << rect.left << "," << rect.top << "," << rect.right << "," << rect.bottom << ") ";
+       return os;
+     }
++#endif
+   };
+ 
+   template <typename T1, typename T2>
+@@ -498,6 +506,7 @@ namespace Clipper2Lib
+     return Rect<T>(xmin, ymin, xmax, ymax);
+   }
+ 
++#ifndef CLIPPER2_NO_IOSTREAM
+   template <typename T>
+   std::ostream& operator << (std::ostream& outstream, const Path<T>& path)
+   {
+@@ -518,6 +527,7 @@ namespace Clipper2Lib
+       outstream << p;
+     return outstream;
+   }
++#endif
+ 
+ 
+   template <typename T1, typename T2>
+diff --git a/CPP/Clipper2Lib/include/clipper2/clipper.h b/CPP/Clipper2Lib/include/clipper2/clipper.h
+index fe1e299..deb1f7b 100644
+--- a/CPP/Clipper2Lib/include/clipper2/clipper.h
++++ b/CPP/Clipper2Lib/include/clipper2/clipper.h
+@@ -309,6 +309,7 @@ namespace Clipper2Lib {
+       return true;
+     }
+ 
++#ifndef CLIPPER2_NO_IOSTREAM
+     static void OutlinePolyPath(std::ostream& os,
+       size_t idx, bool isHole, size_t count, const std::string& preamble)
+     {
+@@ -338,6 +339,7 @@ namespace Clipper2Lib {
+         if (pp.Child(i)->Count())
+           details::OutlinePolyPathD(os, *pp.Child(i), i, preamble + "  ");
+     }
++#endif
+ 
+     template<typename T, typename U>
+     inline constexpr void MakePathGeneric(const T an_array,
+@@ -377,6 +379,7 @@ namespace Clipper2Lib {
+ 
+   } // end details namespace
+ 
++#ifndef CLIPPER2_NO_IOSTREAM
+   inline std::ostream& operator<< (std::ostream& os, const PolyTree64& pp)
+   {
+     std::string plural = (pp.Count() == 1) ? " polygon." : " polygons.";
+@@ -399,6 +402,7 @@ namespace Clipper2Lib {
+     if (!pp.Level()) os << std::endl;
+     return os;
+   }
++#endif
+ 
+   inline Paths64 PolyTreeToPaths64(const PolyTree64& polytree)
+   {

include/manifold/manifold.h

@@ -273,8 +273,10 @@ using MeshGL = MeshGLP<float>;
  */
 using MeshGL64 = MeshGLP<double, uint64_t>;
 
+#ifndef MANIFOLD_NO_IOSTREAM
 MeshGL64 ReadOBJ(std::istream& stream);
 bool WriteOBJ(std::ostream& stream, const MeshGL64& mesh);
+#endif
 
 /**
  * @brief This library's internal representation of an oriented, 2-manifold,
@@ -517,8 +519,10 @@ class Manifold {
    * ofile.close();
    * @endcode
    */
+#ifndef MANIFOLD_NO_IOSTREAM
   static Manifold ReadOBJ(std::istream& stream);
   bool WriteOBJ(std::ostream& stream) const;
+#endif
 
   /** @name Testing Hooks
    *  These are just for internal testing.