fix windows support

[candytaco]

Fix: Windows compatibility

Turns out that the issue was simple: the C math libraries are integrated in Windows, so asking for m.lib during opemctm compilation failed on that line in Windows. Added a guard that only asks for m.lib if not Windows.

A few other things to ensure compatibility:

• explicitly enforce the javascript mimetype when opening viewers
• account for Windows locking files when they are opened
• the direct path to the inkscape executable can now be specified; falls back to just calling inkscape
• removed legacy Windows config resolution

[Copilot]

Pull request overview

This PR aims to make Pycortex run more reliably on Windows by removing the hard dependency on the Unix libm during compilation, fixing MIME type serving for WebGL viewers, and addressing Windows file-locking constraints around temporary files and external executables (e.g., Inkscape).

Changes:

• Skip linking against m on Windows when building OpenCTM.
• Force .js to be served with a JavaScript MIME type to avoid browser execution refusal on Windows.
• Update multiple temp-file workflows (and dependency path resolution) to better tolerate Windows file locking and PATH differences.

Reviewed changes

Copilot reviewed 17 out of 17 changed files in this pull request and generated 7 comments.

Show a summary per file

File	Description
setup.py	Avoid linking m on Windows builds.
README.md	Remove Windows “unsupported” note; add build-from-source note.
cortex/webgl/serve.py	Force JavaScript MIME type mapping for .js.
cortex/volume.py	Avoid Windows temp-file locking by closing NamedTemporaryFile and cleaning up explicitly.
cortex/utils.py	Use resolved Inkscape executable path constant for launching.
cortex/tests/test_testing_utils.py	Update mocks to align with new Inkscape path resolution helper.
cortex/tests/test_quickflat.py	Adjust Inkscape detection and temp-file handling for Windows.
cortex/tests/test_dataset.py	Close temp files before reopening via filename (Windows) and update Inkscape detection.
cortex/testing_utils.py	Add config-aware Inkscape path resolution used by tests and runtime.
cortex/svgoverlay.py	Avoid /dev/stdin, build Inkscape command as argv list, and use temp files for Windows.
cortex/options.py	Update user config directory resolution for the new appdirs behavior.
cortex/freesurfer.py	Close temp files before reuse on Windows; explicitly unlink temp outputs.
cortex/defaults.cfg	Document Windows-friendly Inkscape configuration behavior.
cortex/dataset/dataset.py	Write overlay content to a named temp file for Windows compatibility.
cortex/brainctm.py	Adjust OpenCTM temp-file handling for Windows.
cortex/blender/init.py	Replace context-managed temp file usage with explicit close/unlink flow.
cortex/appdirs.py	Remove legacy Windows appauthor-based directory structure; use environment variables directly.

Suppressed comments (5)

cortex/tests/test_dataset.py:40

• This test creates a delete=False HDF temp file but never removes it, so it will accumulate across repeated test runs. Wrap the body in try/finally and os.unlink(tf.name) in the finally block.

This issue also appears in the following locations of the same file:

• line 163
• line 184
• line 197
• line 209

def test_dataset():
    vol = np.random.randn(*volshape)
    stack = (np.ones(volshape[::-1]) * np.linspace(0, 1, volshape[0])).T
    mask = db.get_mask(subj, xfmname, "thick")

    ds = dataset.Dataset(randvol=(vol, subj, xfmname), stack=(stack, subj, xfmname))
    ds.append(thickstack=ds.stack.masked["thick"])
    tf = tempfile.NamedTemporaryFile(suffix = ".hdf", delete = False)
    tf.close()
    ds.save(tf.name)

    ds = dataset.Dataset.from_file(tf.name)
    assert len(ds["thickstack"].data) == mask.sum()
    assert np.allclose(ds["stack"].data[mask], ds["thickstack"].data)

cortex/tests/test_dataset.py:194

• This test creates a delete=False temp file but never deletes it, which can leave behind many *.hdf files. Add a try/finally cleanup to unlink the temp file.

def test_mask_save():
    tf = tempfile.NamedTemporaryFile(suffix = ".hdf", delete = False)
    tf.close()
    ds = cortex.Dataset(test=(np.random.randn(*volshape), subj, xfmname))
    ds.append(masked=ds.test.masked["thin"])
    data = ds.masked.data
    ds.save(tf.name)

    ds = cortex.load(tf.name)
    assert ds.masked.shape == volshape
    assert np.allclose(ds.masked.data, data)

cortex/tests/test_dataset.py:207

• This test creates a delete=False temp file but never deletes it. Use try/finally so the temp file is unlinked even if ds.save() or assertions fail.

def test_overwrite():
    # the handle is closed so that h5py can open the file by name, which
    # Windows forbids while the original handle is still open
    tf = tempfile.NamedTemporaryFile(suffix = ".hdf", delete = False)
    tf.close()
    ds = cortex.Dataset(test=(np.random.randn(*volshape), subj, xfmname))
    ds.save(tf.name)

    ds.save()
    assert ds.test.data.shape == volshape

cortex/tests/test_dataset.py:227

• This test creates a delete=False temp file but never deletes it (and the test is long enough that failures are plausible), so it can leave behind many *.hdf files. Add a try/finally cleanup that unlinks the temp file at the end.

def test_pack():
    tf = tempfile.NamedTemporaryFile(suffix = ".hdf", delete = False)
    tf.close()
    ds = cortex.Dataset(test=(np.random.randn(*volshape), subj, xfmname))
    ds.save(tf.name, pack=True)

    ds = cortex.load(tf.name)
    pts, polys = cortex.db.get_surf(subj, "fiducial", "lh")
    dpts, dpolys = ds.get_surf(subj, "fiducial", "lh")
    assert np.allclose(pts, dpts)

    overlay_db = cortex.db.get_overlay(subj, None, modify_svg_file=False)
    rois_db = overlay_db.rois.labels.elements.keys()
    # keep the temporary file object in memory to avoid the file being deleted
    temp_file = ds.get_overlay(subj, "rois")
    overlay_ds = cortex.db.get_overlay(subj, temp_file.name, modify_svg_file=False)
    rois_ds = overlay_ds.rois.labels.elements.keys()
    assert rois_db == rois_ds

cortex/tests/test_dataset.py:173

• This test creates a delete=False temp file but never deletes it. Add cleanup (preferably try/finally) so the temp file is removed even when assertions fail.

def test_dataset_save():
    tf = tempfile.NamedTemporaryFile(suffix = ".hdf", delete = False)
    tf.close()
    mrand = np.random.randn(2, *volshape)
    rand = np.random.randn(*volshape)
    ds = cortex.Dataset(test=(mrand, subj, xfmname))
    ds.append(twod=cortex.Volume2D(rand, rand, subj, xfmname))
    ds.append(rgb=cortex.VolumeRGB(rand, rand, rand, subj, xfmname))
    ds.append(vert=cortex.Vertex.random(subj))
    ds.save(tf.name)

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.

[kroq-gar78]

What's going on with this commit? e67eb94

[candytaco]

That's one of the file locking fixes. Windows locks a file when a process opens it to prevent multiple threads from writing to it simultaneously. So we have to close the handlers when passing files between processes.

Because of this, we have the tempfiles not be delete immediately after the opening process closes it, and we track filename inside the scope. unlink then deletes it as the tempfile scope exits.

[AbhroneelGhosh]

Thanks for this — tested it thoroughly on native Windows (MSVC build, conda env), including installing Inkscape and running the full test suite plus the example scripts under examples/. With Inkscape configured, pytest cortex/tests (excluding the headless-browser tests) passes cleanly: 71 passed, 4 skipped (playwright/Chromium and FreeSurfer, both legitimately unavailable here), 0 failed. The /dev/stdin → argument-list rewrite in svgoverlay.py works correctly end-to-end.

Found two remaining UnicodeEncodeError gaps, both from the same root cause (open() with no explicit encoding=, so Windows falls back to the locale codepage — cp1252 on this machine — instead of UTF-8). Both are quick, one-line-per-call-site fixes.

1. cortex.webgl.make_static() crashes on Windows — 100% reproducible via your own example

Running examples/webgl/static.py verbatim (cortex.Volume.random → cortex.webgl.make_static(outpath=..., data=volume, recache=True)) crashes every time:

UnicodeEncodeError: 'charmap' codec can't encode character '\ufeff' in position 0: character maps to <undefined>
  File "cortex\webgl\view.py", line 279, in make_static
    htmlembed.embed(html, desthtml, rootdirs)
  File "cortex\webgl\htmlembed.py", line 131, in embed
    htmlfile.write(line)

Root cause: htmlembed.py:122

with open(outfile, "w") as htmlfile:

opens the output file with no encoding=, so it inherits the Windows locale codepage. The html5lib serializer's output isn't guaranteed to be codepage-safe — here it's a leading \ufeff, but any character outside cp1252 would trigger the same crash. This isn't an edge case tied to unusual subject/colormap names — it's unconditional, since html_embed=True (the default) always routes through this exact code path. Static export — one of the most basic ways to share a viewer — is currently broken on Windows out of the box.

The same missing encoding= exists in the sibling code path at webgl/view.py:281 (make_static(..., html_embed=False)):

with open(desthtml, "w") as htmlfile:

Fix (both locations):

with open(outfile, "w", encoding="utf-8") as htmlfile:   # htmlembed.py:122
with open(desthtml, "w", encoding="utf-8") as htmlfile:  # webgl/view.py:281

2. Non-ASCII Windows usernames crash on first import cortex

options.py:20 writes the user's options.cfg the same unencoded way:

with open(usercfg, 'w') as fp:
    config.write(fp)

config.write() embeds the resolved filestore path, which is derived from appdirs.user_data_dir() — i.e. it contains the Windows username. I reproduced the exact failure mode by running this same code (unmodified) against a representative non-Latin-script value, since I can't create a differently-scripted Windows account on this machine to trigger it natively:

>>> c.set('basic', 'filestore', 'C:\\Users\\王伟\\AppData\\Local\\pycortex\\db')
>>> with open(path, 'w') as fp: c.write(fp)
UnicodeEncodeError: 'charmap' codec can't encode characters in position 21-23: character maps to <undefined>

(Note: a simple accented character like café won't reproduce this — é happens to be directly encodable in cp1252. It takes a genuinely non-Western-European script — Chinese, Japanese, Korean, Cyrillic, Arabic — which is a realistic username on any non-US/Western-European Windows install.)

Practical impact: any user whose Windows account name isn't in cp1252's repertoire hits this on the very first import cortex, before they've done anything else.

Fix:

with open(usercfg, 'w', encoding="utf-8") as fp:

---