Skip to content

Free, open-source 3D sculpting for Linux, macOS and Windows: dense meshes, remeshing, painting, built-in AI (image/text to 3D), Send to Unreal, game-ready LODs, Gaussian splats and OpenUSD.

Unified-memory machines can be Workstation: 64 GB+ RAM with the same measured thresholds

islandmed159df8ad6dbc
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8bfbabf2..d3664a49 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,8 +11,9 @@ All notable changes to SculptForge are listed here. The format follows
the version changes, SculptForge spends about a second or two (under a small overlay; Esc skips) measuring
triangle throughput, upload bandwidth, brush speed and memory bandwidth, and probes the GPU (OpenGL strings,
video memory through GL_NVX_gpu_memory_info, GL_ATI_meminfo, GLX_MESA_query_renderer, amdgpu sysfs, DXGI or
- CGL), RAM, threads, SIMD and OS. The result picks a profile: **Laptop / Budget**, **Workstation** (16 GB+
- discrete GPU, 64 GB+ RAM) or a **Software** safe mode for llvmpipe, with a render triangle budget, motion proxy
+ CGL), RAM, threads, SIMD and OS. The result picks a profile: **Laptop / Budget**, **Workstation** (64 GB+ RAM
+ with a 16 GB+ discrete GPU, or Apple Silicon Max / Ultra and big APUs, that measure fast) or a **Software** safe
+ mode for llvmpipe, with a render triangle budget, motion proxy
threshold, GPU memory and upload budgets, texture, subdivision and micro-triangle limits and the thread count.
Cached in the settings folder; no network use. A one-line status bar message says what was found.
- Preferences > Performance shows what was detected and measured ("Detected <GPU>, <memory> -> Workstation"),
diff --git a/docs/guide/performance.md b/docs/guide/performance.md
index ec271751..ac08dfac 100644
--- a/docs/guide/performance.md
+++ b/docs/guide/performance.md
@@ -54,11 +54,11 @@ There are two main profiles and a safe mode:
| Profile | For | What changes |
|---|---|---|
-| **Laptop / Budget** | laptops and most desktops: 8-16 GB of memory, a 2-4 GB graphics card, Apple Silicon | a moderate number of triangles drawn while the view moves; brushes update shading when you lift the pen (draft brushes) |
-| **Workstation** | 64 GB of memory or more and a graphics card with 16 GB or more | more triangles drawn per frame, larger textures and subdivision limits, shading updated with every dab |
+| **Laptop / Budget** | laptops and most desktops: 8-32 GB of memory, a 2-8 GB graphics card, most Apple Silicon Macs | a moderate number of triangles drawn while the view moves; brushes update shading when you lift the pen (draft brushes) |
+| **Workstation** | 64 GB of memory or more, and a graphics card with 16 GB or more or an Apple Silicon Max / Ultra (or another chip whose graphics share the memory) that measures as fast | more triangles drawn per frame, larger textures and subdivision limits, shading updated with every dab |
| **Software** (safe mode) | no graphics driver, so the drawing happens on the processor (llvmpipe) | the lightest settings, no antialiasing |
-On a laptop running on battery, SculptForge switches to draft brushes, sends less data to the graphics card per
+On a laptop running on battery, whatever its profile, SculptForge switches to draft brushes, sends less data to the graphics card per
frame and aims for 60 frames a second, and the status bar says so; plugged in again, it goes back.
At the top of **Preferences > Performance**:
diff --git a/docs/performance.md b/docs/performance.md
index 8ffd4f20..6f88bf75 100644
--- a/docs/performance.md
+++ b/docs/performance.md
@@ -63,10 +63,11 @@ app `calibrate` measures the GPU too.
Two main tiers and a safe mode:
-- **Workstation**: a discrete GPU with 16 GB or more (15 GB reported), 64 GB or more of RAM (60 GB reported),
- at least 1000M triangles/s, dabs under 3 ms, memory over 4 GB/s.
-- **Laptop / Budget**: everything else, including Apple Silicon and other unified memory machines (8-16 GB RAM,
- 2-4 GB GPUs, thermal and battery limits).
+- **Workstation**: 64 GB or more of RAM (60 GB reported) and either a discrete GPU with 16 GB or more (15 GB
+ reported) or a GPU sharing the system memory (Apple Silicon Max / Ultra, big APUs), whose pool counts as two
+ thirds of the RAM; and in both cases at least 1000M triangles/s, dabs under 3 ms, memory over 4 GB/s.
+- **Laptop / Budget**: everything else (8-32 GB RAM, 2-8 GB GPUs, Apple Silicon with less than 64 GB, thermal and
+ battery limits).
- **Software** (safe mode): a software renderer, or under 60M triangles/s.
A re-calibration of the same GPU keeps the previous tier while the new triangle throughput is within 15% of the
@@ -98,10 +99,11 @@ changes when it does):
| `activeTriangleBudget` | 0.5M | 2M | 8M+ (half the render budget, at most 64M) |
| `uploadBudgetMBPerFrame` | the profile's | the profile's | the profile's |
| `draftBrushMode` (normals and cavity at pen release) | on | on | off (continuous) |
-| `zeroCopyUMA` | the GPU shares system memory: unified or integrated | | |
+| `zeroCopyUMA` | the GPU shares system memory: unified or integrated, in any tier (a 64 GB+ Apple Silicon Workstation too) | | |
| `targetHz` | 60 | 60 / 120 / 144 from the display | 60 / 120 / 144 from the display |
-The app reads the power source with `SDL_GetPowerInfo` at start and every 5 seconds. On battery: draft brushes,
+The app reads the power source with `SDL_GetPowerInfo` at start and every 5 seconds. On battery, whatever the tier
+(an Apple Silicon Workstation is a laptop too): draft brushes,
half the upload budget and 60 Hz (unless set by hand), and the status bar says so. The `draft_brush` override
(on / off) wins over both. `draftBrushMode` is a flag for the brush engine; the brushes don't read it yet.
@@ -142,8 +144,8 @@ cores), so the CPU numbers here are low (memory bandwidth measured 23 GB/s on a
"gl_renderer": "Apple M1 Pro (G13S C0)", "gl_version": "4.6 (Core Profile) Mesa 26.1.8", "gpu_kind": "unified",
"vram_mb": 31667 (GL_NVX_gpu_memory_info: all of the RAM), "timer_query": true, "cpu_threads": 10, "simd": ["neon"]
measurements: 1358M triangles/s (GPU timer), upload 12.8 GB/s, dab 0.37 ms (2.5k vertices), memory 5.9 GB/s, 607 ms
-profile: Laptop ("Detected Apple M1 Pro (G13S C0), 20.6 GB unified -> Laptop (1358M triangles/s, Laptop / Budget:
- no discrete GPU (unified))")
+profile: Laptop (32 GB of RAM is under the 64 GB Workstation needs; this run predates the unified-memory rule, so its
+ reason read "no discrete GPU"; it now reads "30.9 GB RAM")
settings: render budget 11.3M, motion proxy from 11.3M, GPU memory 20.6 GB, uploads 50 MB/frame, textures 8192,
subdivision 120M, micro-triangles 256M, 10 threads, 60 fps
tier_config: cache 4 GB, active 2M, uploads 25 MB/frame (battery), draft brushes, zero-copy UMA, 60 Hz, on battery
diff --git a/src/core/HardwareProfile.cpp b/src/core/HardwareProfile.cpp
index 87f3cbb9..550237d1 100644
--- a/src/core/HardwareProfile.cpp
+++ b/src/core/HardwareProfile.cpp
@@ -408,11 +408,13 @@ ProfileTier tierFromMeasurements(const HardwareInfo& hw, const Calibration& c, c
why += ", safe mode";
return ProfileTier::Software;
}
- // Workstation needs the memory (a 16 GB+ discrete GPU, 64 GB+ RAM) and the measured speed. Everything else,
- // including Apple Silicon and other unified-memory machines, is Laptop / Budget.
- const uint64_t gpu = usableGpuMemoryMB(hw);
+ // Workstation needs the memory and the measured speed: a 16 GB+ discrete GPU, or a GPU sharing the system memory
+ // (Apple Silicon Max / Ultra, big APUs), whose pool is two thirds of the RAM; and 64 GB+ RAM either way.
+ // Everything else is Laptop / Budget.
+ const bool sharedMemory = hw.gpuKind == GpuKind::Unified || hw.gpuKind == GpuKind::Integrated;
+ const uint64_t gpu = sharedMemory ? (hw.ramMB ? hw.ramMB * 2 / 3 : hw.vramMB) : usableGpuMemoryMB(hw);
std::string missing;
- if (hw.gpuKind != GpuKind::Discrete) missing = std::string("no discrete GPU (") + gpuKindName(hw.gpuKind) + ")";
+ if (hw.gpuKind != GpuKind::Discrete && !sharedMemory) missing = std::string("GPU type ") + gpuKindName(hw.gpuKind);
else if (gpu < kWorkstationVramMB) missing = formatMegabytes(gpu) + " of video memory";
if (missing.empty() && hw.ramMB && hw.ramMB < kWorkstationRamMB) missing = formatMegabytes(hw.ramMB) + " RAM";
if (missing.empty() && c.dabMs > 3.0) missing = "slow brushes";
diff --git a/src/core/HardwareProfile.h b/src/core/HardwareProfile.h
index 7b3e746b..828c9e51 100644
--- a/src/core/HardwareProfile.h
+++ b/src/core/HardwareProfile.h
@@ -5,9 +5,10 @@
//
// What the computer is (HardwareInfo: the GPU's OpenGL strings and memory, system RAM, CPU threads, SIMD, OS)
// and how fast it measured (Calibration: triangle throughput, buffer upload bandwidth, brush dab cost, memory
-// bandwidth) map to a profile tier with concrete settings. Two main tiers: Laptop / Budget (8-16 GB RAM, a 2-4 GB
-// GPU or Apple Silicon's unified memory, thermal and battery limits) and Workstation (64 GB+ RAM and a 16 GB+
-// discrete GPU that measures fast), plus a Software safe mode for llvmpipe and friends. core/TierConfig.h turns the
+// bandwidth) map to a profile tier with concrete settings. Two main tiers: Laptop / Budget (8-32 GB RAM, a 2-8 GB
+// GPU or smaller Apple Silicon, thermal and battery limits) and Workstation (64 GB+ RAM with a 16 GB+ discrete GPU,
+// or with a GPU sharing that memory, e.g. Apple Silicon Max / Ultra or a big APU, whose pool counts as two thirds of
+// the RAM; and fast measurements either way), plus a Software safe mode for llvmpipe and friends. core/TierConfig.h turns the
// profile, the power source and the display into the knobs the renderer and brushes read. Settings:
// (PerformanceSettings: render triangle budget, motion proxy threshold, VRAM budget, ...). The mapping uses
// the measurements and memory sizes, never GPU names: names only tell unified from discrete memory and spot a
diff --git a/tests/test_hardware_profile.cpp b/tests/test_hardware_profile.cpp
index 17d4a75f..d75e340d 100644
--- a/tests/test_hardware_profile.cpp
+++ b/tests/test_hardware_profile.cpp
@@ -182,15 +182,28 @@ TEST(hw_profile_mapping) {
CHECK(p.tier == ProfileTier::Laptop);
CHECK(p.settings.maxTextureSize <= 8192);
}
- // Unified memory (Apple Silicon): two thirds of the RAM for the GPU, even when the driver reports all of it;
- // Laptop / Budget however fast it measures.
+ // Unified memory (Apple Silicon): two thirds of the RAM for the GPU, even when the driver reports all of it.
+ // With 32 GB it is Laptop / Budget however fast it measures; with 64 GB+ and the same measured thresholds as a
+ // discrete GPU, Workstation (Max / Ultra).
{
const HardwareProfile p = mapProfile(machine("Mesa", "Apple M1 Pro (G13S C0)", 31667, 31667, 10), measured(2000.0));
CHECK(p.hardware.gpuKind == GpuKind::Unified);
CHECK(p.settings.vramBudgetMB == 31667 * 2 / 3);
CHECK(p.tier == ProfileTier::Laptop);
+ CHECK(p.reason.find("RAM") != std::string::npos);
const HardwareProfile big = mapProfile(machine("Apple", "Apple M2 Ultra", 0, 196608, 24), measured(6000.0));
- CHECK(big.tier == ProfileTier::Laptop);
+ CHECK(big.tier == ProfileTier::Workstation);
+ CHECK(big.settings.vramBudgetMB == 196608 * 2 / 3);
+ const HardwareProfile max = mapProfile(machine("Apple", "Apple M3 Max", 0, 65536, 16), measured(3000.0));
+ CHECK(max.tier == ProfileTier::Workstation);
+ // ... but not when it measures slowly, or its brushes or memory are slow.
+ CHECK(mapProfile(machine("Apple", "Apple M3 Max", 0, 65536, 16), measured(700.0)).tier == ProfileTier::Laptop);
+ CHECK(mapProfile(machine("Apple", "Apple M3 Max", 0, 65536, 16), measured(3000.0, 10.0, 4.0)).tier == ProfileTier::Laptop);
+ CHECK(mapProfile(machine("Apple", "Apple M3 Max", 0, 65536, 16), measured(3000.0, 10.0, 0.5, 3.0)).tier == ProfileTier::Laptop);
+ // A big APU (shared memory) the same way.
+ const HardwareProfile apu = mapProfile(machine("AMD", "AMD Radeon 8060S Graphics (radeonsi, gfx1151)", 0, 131072, 32), measured(2500.0));
+ CHECK(apu.hardware.gpuKind == GpuKind::Integrated);
+ CHECK(apu.tier == ProfileTier::Workstation);
}
// Measurements decide, not names: an unknown GPU that measures like software is safe mode.
CHECK(mapProfile(machine("Weird", "Mystery GPU", 4096, 16384), measured(20.0)).tier == ProfileTier::Software);
@@ -701,9 +714,15 @@ TEST(hw_tier_config) {
CHECK(!forced.draftBrushMode);
CHECK(forced.targetHz == 120);
// Apple Silicon: unified memory, zero-copy.
+ // A 64 GB Apple Silicon Workstation: zero-copy, continuous brushes plugged in, draft on battery.
const HardwareProfile mac = mapProfile(machine("Apple", "Apple M3 Max", 0, 65536, 16), measured(3000.0));
+ CHECK(mac.tier == ProfileTier::Workstation);
CHECK(tierConfigFor(mac, PowerSource::AC, 120).zeroCopyUMA);
CHECK(tierConfigFor(mac, PowerSource::AC, 120).targetHz == 120);
+ CHECK(!tierConfigFor(mac, PowerSource::AC, 120).draftBrushMode);
+ CHECK(tierConfigFor(mac, PowerSource::Battery, 120).draftBrushMode);
+ CHECK(tierConfigFor(mac, PowerSource::Battery, 120).zeroCopyUMA);
+ CHECK(tierConfigFor(mac, PowerSource::Battery, 120).targetHz == 60);
// Software: safe mode at 60 Hz at most.
const HardwareProfile sw = mapProfile(machine("Mesa", "llvmpipe (LLVM 19.1.0, 256 bits)", 0, 16384), measured(40.0));
CHECK(tierConfigFor(sw, PowerSource::AC, 144).targetHz == 60);