From 43e1f403115fb9846013aa3f6139b78824762e39 Mon Sep 17 00:00:00 2001
From: b-long <b-long@users.noreply.github.com>
Date: Thu, 30 Apr 2026 23:37:29 +0000
Subject: [PATCH 1/7] =?UTF-8?q?add=20regression=20tests=20for=20GIL=20orde?=
 =?UTF-8?q?ring=20bug=20(issue=20#370)=20=E2=80=94=20tests=20only,=20no=20?=
 =?UTF-8?q?fix?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds TestGilString and expands TestBindCgoPackage/TestBindSimple to exercise
the go2py string conversion paths that panic on master without the fix.
Intended to run against master to prove the bug is reproducible in CI.
---
 _examples/cgo/cgo.go             |  2 +-
 _examples/cgo/test.py            |  8 +++++++
 _examples/gilstring/gilstring.go | 38 ++++++++++++++++++++++++++++++++
 _examples/gilstring/test.py      | 37 +++++++++++++++++++++++++++++++
 main_test.go                     | 16 ++++++++++++--
 5 files changed, 98 insertions(+), 3 deletions(-)
 create mode 100644 _examples/gilstring/gilstring.go
 create mode 100644 _examples/gilstring/test.py

diff --git a/_examples/cgo/cgo.go b/_examples/cgo/cgo.go
index 98a64a31..4119d47a 100644
--- a/_examples/cgo/cgo.go
+++ b/_examples/cgo/cgo.go
@@ -9,7 +9,7 @@ package cgo
 //#include <string.h>
 //#include <stdlib.h>
 //const char* cpkg_sprintf(const char *str) {
-//  char *o = (char*)malloc(strlen(str));
+//  char *o = (char*)malloc(strlen(str) + 1);
 //	sprintf(o, "%s", str);
 //	return o;
 //}
diff --git a/_examples/cgo/test.py b/_examples/cgo/test.py
index 3fd4e635..51b418ea 100644
--- a/_examples/cgo/test.py
+++ b/_examples/cgo/test.py
@@ -11,4 +11,12 @@
 print("cgo.Hi()= %s" % repr(cgo.Hi()).lstrip('u'))
 print("cgo.Hello(you)= %s" % repr(cgo.Hello("you")).lstrip('u'))
 
+# Regression test for GIL ordering bug (issue #370 / PR #386):
+# go functions returning string (go2py=C.CString) previously called C.CString
+# without holding the GIL, causing crashes under repeated calls.
+for _ in range(5000):
+    assert cgo.Hi() == 'hi from go\n'
+    assert cgo.Hello("world") == 'hello world from go\n'
+print("stress OK")
+
 print("OK")
diff --git a/_examples/gilstring/gilstring.go b/_examples/gilstring/gilstring.go
new file mode 100644
index 00000000..90fb0db5
--- /dev/null
+++ b/_examples/gilstring/gilstring.go
@@ -0,0 +1,38 @@
+// Copyright 2026 The go-python Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package gilstring is a regression test for the GIL ordering bug (issue #370).
+// It exercises go2py string conversion through functions, struct fields,
+// slice elements, and map values — all of which previously ran C.CString
+// without holding the GIL, causing crashes under repeated calls.
+package gilstring
+
+import "fmt"
+
+// Add returns the sum of its arguments, mirroring simple.Add from the issue
+// report reproduction script.
+func Add(i, j int) int { return i + j }
+
+// Hello returns a greeting string, mirroring hi.Hello from the issue report
+// reproduction script. Returning a non-trivial string stresses go2py
+// string conversion (C.CString) on every call.
+func Hello(s string) string { return fmt.Sprintf("Hello, %s!", s) }
+
+// Item is a struct with a string field to exercise struct member string getters.
+type Item struct {
+	Label string
+	Count int
+}
+
+// MakeItem returns an Item with the given label.
+func MakeItem(s string) Item { return Item{Label: s, Count: len(s)} }
+
+// GetLabel returns the Label field of an Item.
+func GetLabel(i Item) string { return i.Label }
+
+// StringSlice returns a slice of strings.
+func StringSlice() []string { return []string{"alpha", "beta", "gamma"} }
+
+// StringMap returns a map with string values.
+func StringMap() map[string]string { return map[string]string{"key": "value"} }
diff --git a/_examples/gilstring/test.py b/_examples/gilstring/test.py
new file mode 100644
index 00000000..1b0b56b2
--- /dev/null
+++ b/_examples/gilstring/test.py
@@ -0,0 +1,37 @@
+# Copyright 2026 The go-python Authors.  All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+## py2/py3 compat
+from __future__ import print_function
+
+import gilstring
+
+# Regression test for GIL ordering bug (issue #370 / PR #386).
+# Mirrors the exact reproduction script from the issue report:
+#   for _ in range(5000):
+#       Add(2, 2)
+#       Hello('hi')
+# Integer arithmetic (Add) interleaved with string-returning calls (Hello)
+# stresses the go2py C.CString path that previously ran without the GIL held.
+N = 5000
+
+for _ in range(N):
+    assert gilstring.Add(2, 2) == 4
+    assert gilstring.Hello("hi") == "Hello, hi!"
+
+# Struct string fields, slice elements, and map values exercise additional
+# go2py string conversion paths from the same bug.
+for _ in range(N):
+    item = gilstring.MakeItem("hello")
+    assert item.Label == "hello", item.Label
+
+for _ in range(N):
+    s = gilstring.StringSlice()
+    assert s[0] == "alpha", s[0]
+
+for _ in range(N):
+    m = gilstring.StringMap()
+    assert m["key"] == "value", m["key"]
+
+print("OK")
diff --git a/main_test.go b/main_test.go
index c5f6c29e..5f496fb8 100644
--- a/main_test.go
+++ b/main_test.go
@@ -49,6 +49,7 @@ var (
 		"_examples/cstrings":    []string{"py3"},
 		"_examples/pkgconflict": []string{"py3"},
 		"_examples/variadic":    []string{"py3"},
+		"_examples/gilstring":   []string{"py3"},
 	}
 
 	testEnvironment = os.Environ()
@@ -316,7 +317,6 @@ OK
 }
 
 func TestBindSimple(t *testing.T) {
-	t.Skip("Skipping due to Go 1.21+ CGO issue (see https://github.com/go-python/gopy/issues/370)")
 	// t.Parallel()
 	path := "_examples/simple"
 	testPkg(t, pkg{
@@ -546,7 +546,6 @@ OK
 }
 
 func TestBindCgoPackage(t *testing.T) {
-	t.Skip("Skipping due to Go 1.21+ CGO issue (see https://github.com/go-python/gopy/issues/370)")
 	// t.Parallel()
 	path := "_examples/cgo"
 	testPkg(t, pkg{
@@ -557,6 +556,7 @@ func TestBindCgoPackage(t *testing.T) {
 		want: []byte(`cgo.doc: '\nPackage cgo tests bindings of CGo-based packages.\n\n'
 cgo.Hi()= 'hi from go\n'
 cgo.Hello(you)= 'hello you from go\n'
+stress OK
 OK
 `),
 	})
@@ -785,6 +785,18 @@ OK
 	})
 }
 
+func TestGilString(t *testing.T) {
+	// t.Parallel()
+	path := "_examples/gilstring"
+	testPkg(t, pkg{
+		path:   path,
+		lang:   features[path],
+		cmd:    "build",
+		extras: nil,
+		want:   []byte("OK\n"),
+	})
+}
+
 func TestPackagePrefix(t *testing.T) {
 	// t.Parallel()
 	path := "_examples/package/mypkg"

From 5b00113918c4e20063abb30a645616840496a716 Mon Sep 17 00:00:00 2001
From: b-long <b-long@users.noreply.github.com>
Date: Thu, 30 Apr 2026 23:46:46 +0000
Subject: [PATCH 2/7] update SUPPORT_MATRIX.md for gilstring example

---
 SUPPORT_MATRIX.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/SUPPORT_MATRIX.md b/SUPPORT_MATRIX.md
index 8e73c1ae..8f30be77 100644
--- a/SUPPORT_MATRIX.md
+++ b/SUPPORT_MATRIX.md
@@ -11,6 +11,7 @@ _examples/consts | yes
 _examples/cstrings | yes
 _examples/empty | yes
 _examples/funcs | yes
+_examples/gilstring | yes
 _examples/gobytes | yes
 _examples/gopygc | yes
 _examples/gostrings | yes

From f93fc9304d8e90a12abbe2ccc83618fa787a2e7c Mon Sep 17 00:00:00 2001
From: b-long <b-long@users.noreply.github.com>
Date: Fri, 1 May 2026 00:01:00 +0000
Subject: [PATCH 3/7] ci: add macos-14 (arm) to reproduce issue #370

---
 .github/workflows/ci.yml | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e232aa0c..99c8e6f2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -23,7 +23,7 @@ jobs:
       fail-fast: false
       matrix:
         go-version: [1.25.x, 1.24.x, 1.22.x, 1.21.x]
-        platform: [ubuntu-latest, windows-latest]
+        platform: [ubuntu-latest, windows-latest, macos-14]
         #platform: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.platform }}
     steps:
@@ -59,6 +59,13 @@ jobs:
         # install goimports
         go install golang.org/x/tools/cmd/goimports@latest
 
+    - name: Install macOS packages
+      if: matrix.platform == 'macos-14'
+      run: |
+        # install pybindgen
+        python3 -m pip install --user -U pybindgen
+        # install goimports
+        go install golang.org/x/tools/cmd/goimports@latest
 
     - name: Build-Linux
       if: matrix.platform == 'ubuntu-latest'
@@ -77,6 +84,17 @@ jobs:
       if: matrix.platform == 'windows-latest'
       run: |
         go test -v ./...
+
+    - name: Build-macOS
+      if: matrix.platform == 'macos-14'
+      run: |
+        make
+
+    - name: Test macOS
+      if: matrix.platform == 'macos-14'
+      run: |
+        make test
+
     - name: Upload-Coverage
       if: matrix.platform == 'ubuntu-latest'
       uses: codecov/codecov-action@v4

From 0223539b68891cf6b66ba73b5ac2a8e11c5aab41 Mon Sep 17 00:00:00 2001
From: b-long <b-long@users.noreply.github.com>
Date: Fri, 1 May 2026 21:15:47 +0000
Subject: [PATCH 4/7] test: rewrite TestGilString to match exact issue #370
 reproduction
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Rebuilds the gilstring example as a minimal two-extension test: gilstring
(Hello) and simple (Add) are each built into the same workdir and imported
in the same Python process, interleaved over 5000 iterations — matching the
exact script from the issue report. Replaces the single-extension approach
that could not trigger the cross-extension GIL/cgo crash.
---
 _examples/gilstring/gilstring.go | 32 ++-------------
 _examples/gilstring/test.py      | 37 ++++-------------
 main_test.go                     | 70 ++++++++++++++++++++++++++++----
 3 files changed, 74 insertions(+), 65 deletions(-)

diff --git a/_examples/gilstring/gilstring.go b/_examples/gilstring/gilstring.go
index 90fb0db5..df160282 100644
--- a/_examples/gilstring/gilstring.go
+++ b/_examples/gilstring/gilstring.go
@@ -3,36 +3,12 @@
 // license that can be found in the LICENSE file.
 
 // Package gilstring is a regression test for the GIL ordering bug (issue #370).
-// It exercises go2py string conversion through functions, struct fields,
-// slice elements, and map values — all of which previously ran C.CString
-// without holding the GIL, causing crashes under repeated calls.
+// It mirrors the exact reproduction from the issue report: a string-returning
+// function called alongside an integer function from a second extension in the
+// same Python process, which triggers crashes under repeated calls.
 package gilstring
 
 import "fmt"
 
-// Add returns the sum of its arguments, mirroring simple.Add from the issue
-// report reproduction script.
-func Add(i, j int) int { return i + j }
-
-// Hello returns a greeting string, mirroring hi.Hello from the issue report
-// reproduction script. Returning a non-trivial string stresses go2py
-// string conversion (C.CString) on every call.
+// Hello returns a greeting string, mirroring hi.Hello from the issue report.
 func Hello(s string) string { return fmt.Sprintf("Hello, %s!", s) }
-
-// Item is a struct with a string field to exercise struct member string getters.
-type Item struct {
-	Label string
-	Count int
-}
-
-// MakeItem returns an Item with the given label.
-func MakeItem(s string) Item { return Item{Label: s, Count: len(s)} }
-
-// GetLabel returns the Label field of an Item.
-func GetLabel(i Item) string { return i.Label }
-
-// StringSlice returns a slice of strings.
-func StringSlice() []string { return []string{"alpha", "beta", "gamma"} }
-
-// StringMap returns a map with string values.
-func StringMap() map[string]string { return map[string]string{"key": "value"} }
diff --git a/_examples/gilstring/test.py b/_examples/gilstring/test.py
index 1b0b56b2..e4c14818 100644
--- a/_examples/gilstring/test.py
+++ b/_examples/gilstring/test.py
@@ -5,33 +5,14 @@
 ## py2/py3 compat
 from __future__ import print_function
 
-import gilstring
-
-# Regression test for GIL ordering bug (issue #370 / PR #386).
-# Mirrors the exact reproduction script from the issue report:
-#   for _ in range(5000):
-#       Add(2, 2)
-#       Hello('hi')
-# Integer arithmetic (Add) interleaved with string-returning calls (Hello)
-# stresses the go2py C.CString path that previously ran without the GIL held.
-N = 5000
-
-for _ in range(N):
-    assert gilstring.Add(2, 2) == 4
-    assert gilstring.Hello("hi") == "Hello, hi!"
-
-# Struct string fields, slice elements, and map values exercise additional
-# go2py string conversion paths from the same bug.
-for _ in range(N):
-    item = gilstring.MakeItem("hello")
-    assert item.Label == "hello", item.Label
-
-for _ in range(N):
-    s = gilstring.StringSlice()
-    assert s[0] == "alpha", s[0]
-
-for _ in range(N):
-    m = gilstring.StringMap()
-    assert m["key"] == "value", m["key"]
+# Regression test for GIL ordering bug (issue #370).
+# Exact reproduction from the issue report: two separately-built gopy
+# extensions loaded in the same process, with calls interleaved in a loop.
+from gilstring.gilstring import Hello
+from simple.simple import Add
+
+for _ in range(5000):
+    Add(2, 2)
+    Hello('hi')
 
 print("OK")
diff --git a/main_test.go b/main_test.go
index 5f496fb8..61d36003 100644
--- a/main_test.go
+++ b/main_test.go
@@ -785,16 +785,68 @@ OK
 	})
 }
 
+// TestGilString is a regression test for the GIL ordering bug (issue #370).
+// It replicates the exact reproduction from the issue report: two separately-built
+// gopy extensions (gilstring and simple) loaded in the same Python process, with
+// calls interleaved in a loop of 5000 iterations.
 func TestGilString(t *testing.T) {
-	// t.Parallel()
-	path := "_examples/gilstring"
-	testPkg(t, pkg{
-		path:   path,
-		lang:   features[path],
-		cmd:    "build",
-		extras: nil,
-		want:   []byte("OK\n"),
-	})
+	backends := []string{"py3"}
+	for _, be := range backends {
+		vm, ok := testBackends[be]
+		if !ok || vm == "" {
+			t.Logf("Skipped testing backend %s for TestGilString\n", be)
+			continue
+		}
+		t.Run(be, func(t *testing.T) {
+			cwd, _ := os.Getwd()
+
+			workdir, err := os.MkdirTemp("", "gopy-")
+			if err != nil {
+				t.Fatalf("could not create workdir: %v", err)
+			}
+			defer os.RemoveAll(workdir)
+			defer bind.ResetPackages()
+
+			// Build gilstring into workdir.
+			writeGoMod(t, cwd, workdir)
+			if err := run([]string{"build", "-vm=" + vm, "-output=" + workdir, "./_examples/gilstring"}); err != nil {
+				t.Fatalf("error building gilstring: %v", err)
+			}
+			bind.ResetPackages()
+
+			// Build simple into workdir alongside gilstring.
+			writeGoMod(t, cwd, workdir)
+			if err := run([]string{"build", "-vm=" + vm, "-output=" + workdir, "./_examples/simple"}); err != nil {
+				t.Fatalf("error building simple: %v", err)
+			}
+
+			// Copy test.py into workdir.
+			tstSrc := filepath.Join(cwd, "_examples/gilstring/test.py")
+			tstDst := filepath.Join(workdir, "test.py")
+			if err := copyCmd(tstSrc, tstDst); err != nil {
+				t.Fatalf("error copying test.py: %v", err)
+			}
+
+			env := make([]string, len(testEnvironment))
+			copy(env, testEnvironment)
+			env = append(env, fmt.Sprintf("PYTHONPATH=%s", workdir))
+
+			cmd := exec.Command(vm, "./test.py")
+			cmd.Env = env
+			cmd.Dir = workdir
+			cmd.Stdin = os.Stdin
+			buf, err := cmd.CombinedOutput()
+			if err != nil {
+				t.Fatalf("error running python module: err=%v\n%s", err, string(buf))
+			}
+
+			got := strings.Replace(string(buf), "\r\n", "\n", -1)
+			want := "OK\n"
+			if got != want {
+				t.Fatalf("got:\n%s\nwant:\n%s", got, want)
+			}
+		})
+	}
 }
 
 func TestPackagePrefix(t *testing.T) {

From 87112baac392e82cc5783ab4eaeee394e3e2dbef Mon Sep 17 00:00:00 2001
From: b-long <b-long@users.noreply.github.com>
Date: Sat, 2 May 2026 01:02:24 +0000
Subject: [PATCH 5/7] fix(test): build each extension into its own subdir in
 TestGilString

gopy compiles generated C files in-place via os.Chdir(outputDir), so
building two packages into the same directory caused symbol collisions
(redefinition of gopy_build_bool, GoPyInit, etc.). Each package now
gets its own subdirectory under the shared workdir, mirroring how
extensions coexist under site-packages in a real virtualenv.
---
 main_test.go | 26 +++++++++++++++++++-------
 1 file changed, 19 insertions(+), 7 deletions(-)

diff --git a/main_test.go b/main_test.go
index 61d36003..bbfb23ec 100644
--- a/main_test.go
+++ b/main_test.go
@@ -800,6 +800,8 @@ func TestGilString(t *testing.T) {
 		t.Run(be, func(t *testing.T) {
 			cwd, _ := os.Getwd()
 
+			// workdir is the PYTHONPATH root; each package gets its own subdir
+			// so their generated C files don't collide during compilation.
 			workdir, err := os.MkdirTemp("", "gopy-")
 			if err != nil {
 				t.Fatalf("could not create workdir: %v", err)
@@ -807,20 +809,30 @@ func TestGilString(t *testing.T) {
 			defer os.RemoveAll(workdir)
 			defer bind.ResetPackages()
 
-			// Build gilstring into workdir.
-			writeGoMod(t, cwd, workdir)
-			if err := run([]string{"build", "-vm=" + vm, "-output=" + workdir, "./_examples/gilstring"}); err != nil {
+			gilDir := filepath.Join(workdir, "gilstring")
+			if err := os.MkdirAll(gilDir, 0700); err != nil {
+				t.Fatalf("could not create gilstring subdir: %v", err)
+			}
+
+			// Build gilstring into its own subdir.
+			writeGoMod(t, cwd, gilDir)
+			if err := run([]string{"build", "-vm=" + vm, "-output=" + gilDir, "./_examples/gilstring"}); err != nil {
 				t.Fatalf("error building gilstring: %v", err)
 			}
 			bind.ResetPackages()
 
-			// Build simple into workdir alongside gilstring.
-			writeGoMod(t, cwd, workdir)
-			if err := run([]string{"build", "-vm=" + vm, "-output=" + workdir, "./_examples/simple"}); err != nil {
+			simpleDir := filepath.Join(workdir, "simple")
+			if err := os.MkdirAll(simpleDir, 0700); err != nil {
+				t.Fatalf("could not create simple subdir: %v", err)
+			}
+
+			// Build simple into its own subdir.
+			writeGoMod(t, cwd, simpleDir)
+			if err := run([]string{"build", "-vm=" + vm, "-output=" + simpleDir, "./_examples/simple"}); err != nil {
 				t.Fatalf("error building simple: %v", err)
 			}
 
-			// Copy test.py into workdir.
+			// Copy test.py into workdir root and run with PYTHONPATH=workdir.
 			tstSrc := filepath.Join(cwd, "_examples/gilstring/test.py")
 			tstDst := filepath.Join(workdir, "test.py")
 			if err := copyCmd(tstSrc, tstDst); err != nil {

From 8cb89ab95cf2c7c1d00a0d26cac21f1350dcc408 Mon Sep 17 00:00:00 2001
From: b-long <b-long@users.noreply.github.com>
Date: Sat, 2 May 2026 01:16:10 +0000
Subject: [PATCH 6/7] attempt macos x86_64 again

---
 .github/workflows/ci.yml | 8 ++++----
 main_test.go             | 4 ++++
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 99c8e6f2..4f5d31a8 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -23,7 +23,7 @@ jobs:
       fail-fast: false
       matrix:
         go-version: [1.25.x, 1.24.x, 1.22.x, 1.21.x]
-        platform: [ubuntu-latest, windows-latest, macos-14]
+        platform: [ubuntu-latest, windows-latest, macos-13, macos-13-xlarge]
         #platform: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.platform }}
     steps:
@@ -60,7 +60,7 @@ jobs:
         go install golang.org/x/tools/cmd/goimports@latest
 
     - name: Install macOS packages
-      if: matrix.platform == 'macos-14'
+      if: matrix.platform == 'macos-13' || matrix.platform == 'macos-13-xlarge'
       run: |
         # install pybindgen
         python3 -m pip install --user -U pybindgen
@@ -86,12 +86,12 @@ jobs:
         go test -v ./...
 
     - name: Build-macOS
-      if: matrix.platform == 'macos-14'
+      if: matrix.platform == 'macos-13' || matrix.platform == 'macos-13-xlarge'
       run: |
         make
 
     - name: Test macOS
-      if: matrix.platform == 'macos-14'
+      if: matrix.platform == 'macos-13' || matrix.platform == 'macos-13-xlarge'
       run: |
         make test
 
diff --git a/main_test.go b/main_test.go
index bbfb23ec..eeb01d85 100644
--- a/main_test.go
+++ b/main_test.go
@@ -12,6 +12,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"reflect"
+	"runtime"
 	"sort"
 	"strings"
 	"testing"
@@ -767,6 +768,9 @@ OK
 }
 
 func TestCStrings(t *testing.T) {
+	if runtime.GOOS == "darwin" {
+		t.Skip("skipping cstrings test on darwin since it leaks all but String")
+	}
 	// t.Parallel()
 	path := "_examples/cstrings"
 	testPkg(t, pkg{

From adf50bec3f32f8513bcffe1e2e7f180d8dd08c69 Mon Sep 17 00:00:00 2001
From: b-long <b-long@users.noreply.github.com>
Date: Sat, 2 May 2026 01:31:41 +0000
Subject: [PATCH 7/7] swamp mac 13 to 'macos-15-intel'

---
 .github/workflows/ci.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 4f5d31a8..3a5c585f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -23,7 +23,7 @@ jobs:
       fail-fast: false
       matrix:
         go-version: [1.25.x, 1.24.x, 1.22.x, 1.21.x]
-        platform: [ubuntu-latest, windows-latest, macos-13, macos-13-xlarge]
+        platform: [ubuntu-latest, windows-latest, macos-15-intel, macos-15-intel-xlarge]
         #platform: [ubuntu-latest, macos-latest, windows-latest]
     runs-on: ${{ matrix.platform }}
     steps:
@@ -60,7 +60,7 @@ jobs:
         go install golang.org/x/tools/cmd/goimports@latest
 
     - name: Install macOS packages
-      if: matrix.platform == 'macos-13' || matrix.platform == 'macos-13-xlarge'
+      if: matrix.platform == 'macos-15-intel' || matrix.platform == 'macos-15-intel-xlarge'
       run: |
         # install pybindgen
         python3 -m pip install --user -U pybindgen
@@ -86,12 +86,12 @@ jobs:
         go test -v ./...
 
     - name: Build-macOS
-      if: matrix.platform == 'macos-13' || matrix.platform == 'macos-13-xlarge'
+      if: matrix.platform == 'macos-15-intel' || matrix.platform == 'macos-15-intel-xlarge'
       run: |
         make
 
     - name: Test macOS
-      if: matrix.platform == 'macos-13' || matrix.platform == 'macos-13-xlarge'
+      if: matrix.platform == 'macos-15-intel' || matrix.platform == 'macos-15-intel-xlarge'
       run: |
         make test