Build library with windows and double precision #276

daxur-studios · 2025-09-28T14:48:59Z

daxur-studios
Sep 28, 2025

Hello, it took me a couple of days to get this working and didn't find any example, so thought I'd share in case anyone else wants to build the lib in a windows machine with double precision enabled.

build.ps1

# Clean Build directory
Remove-Item -Recurse -Force ./Build -ErrorAction SilentlyContinue

$ErrorActionPreference = "Stop"

$buildType = if ($args.Count -gt 0) { $args[0] } else { "Distribution" }

$numProcs = (Get-CimInstance -ClassName Win32_Processor).NumberOfLogicalProcessors

# Remove dist if exists
Remove-Item -Recurse -Force ./dist -ErrorAction SilentlyContinue
New-Item -ItemType Directory -Path ./dist | Out-Null

if ($buildType -ne "Debug") {
    # Build Debug ST
    emcmake cmake -B Build/Debug/ST -DCMAKE_BUILD_TYPE=Debug -DBUILD_WASM_COMPAT_ONLY=ON
    cmake --build Build/Debug/ST -j $numProcs

    # Build Debug MT
    emcmake cmake -B Build/Debug/MT -DENABLE_MULTI_THREADING=ON -DENABLE_SIMD=ON -DCMAKE_BUILD_TYPE=Debug -DBUILD_WASM_COMPAT_ONLY=ON
    cmake --build Build/Debug/MT -j $numProcs

    # Rename for debug
    if (Test-Path ./dist/jolt-physics.wasm-compat.js) { Move-Item ./dist/jolt-physics.wasm-compat.js ./dist/jolt-physics.debug.wasm-compat.js }
    if (Test-Path ./dist/jolt-physics.multithread.wasm-compat.js) { Move-Item ./dist/jolt-physics.multithread.wasm-compat.js ./dist/jolt-physics.debug.multithread.wasm-compat.js }
}

# Build the specified type ST
$stPath = "Build/$buildType/ST"
$mtPath = "Build/$buildType/MT"
emcmake cmake -B $stPath "-DCMAKE_BUILD_TYPE=$buildType"
cmake --build $stPath -j $numProcs

# Build the specified type MT
emcmake cmake -B $mtPath -DENABLE_MULTI_THREADING=ON -DENABLE_SIMD=ON "-DCMAKE_BUILD_TYPE=$buildType"
cmake --build $mtPath -j $numProcs

if ($buildType -eq "Debug") {
    $debugWasmCompat = "./dist/jolt-physics.debug.wasm-compat.js"
    $debugMtWasmCompat = "./dist/jolt-physics.debug.multithread.wasm-compat.js"
    if (Test-Path ./dist/jolt-physics.wasm-compat.js) { Copy-Item ./dist/jolt-physics.wasm-compat.js $debugWasmCompat }
    if (Test-Path ./dist/jolt-physics.multithread.wasm-compat.js) { Copy-Item ./dist/jolt-physics.multithread.wasm-compat.js $debugMtWasmCompat }
}

# Update worker URL for debug multithread
if (Test-Path ./dist/jolt-physics.debug.multithread.wasm-compat.js) {
    $debugMtContent = Get-Content ./dist/jolt-physics.debug.multithread.wasm-compat.js -Raw
    $debugMtContent = $debugMtContent -replace 'jolt-physics.multithread.wasm-compat.js', 'jolt-physics.debug.multithread.wasm-compat.js'
    $debugMtContent | Set-Content ./dist/jolt-physics.debug.multithread.wasm-compat.js -NoNewline -Encoding utf8
}

# Create d.ts file
$dtsContent = @"
import Jolt from "./types";

export default Jolt;
export * from "./types";
"@
$dtsContent | Out-File ./dist/jolt-physics.d.ts -Encoding utf8

# Copy d.ts to various names
$tsFiles = @(
    'jolt-physics.wasm.d.ts',
    'jolt-physics.wasm-compat.d.ts',
    'jolt-physics.debug.wasm-compat.d.ts',
    'jolt-physics.multithread.d.ts',
    'jolt-physics.multithread.wasm.d.ts',
    'jolt-physics.multithread.wasm-compat.d.ts',
    'jolt-physics.debug.multithread.wasm-compat.d.ts'
)
foreach ($file in $tsFiles) {
    Copy-Item ./dist/jolt-physics.d.ts ./dist/${file}
}

# Copy wasm-compat js to Examples/js
Get-ChildItem ./dist -Filter 'jolt-physics*.wasm-compat.js' -ErrorAction SilentlyContinue | ForEach-Object { Copy-Item $_.FullName ./Examples/js/ }

Also updated CMakeLists.txt to improve cross-platform compatibility and streamline the build process.

cmake_minimum_required(VERSION 3.13 FATAL_ERROR)
set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)

FIND_PACKAGE(Python3)
set(PYTHON ${Python3_EXECUTABLE} CACHE STRING "Python path")
set(EMSCRIPTEN_ROOT $ENV{EMSDK}/upstream/emscripten CACHE STRING "Emscripten path")
set(CMAKE_TOOLCHAIN_FILE ${EMSCRIPTEN_ROOT}/cmake/Modules/Platform/Emscripten.cmake)
set(WEBIDL_BINDER_SCRIPT ${EMSCRIPTEN_ROOT}/tools/webidl_binder.py)
set(JOLT_FRONT_MATTER_FILE ${CMAKE_CURRENT_SOURCE_DIR}/front-matter.js)
set(JOLT_HEADER_FILE ${CMAKE_CURRENT_SOURCE_DIR}/JoltJS.h)
set(JOLT_IDL_FILE ${CMAKE_CURRENT_SOURCE_DIR}/JoltJS.idl)
set(OUTPUT_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/dist/)
set(JOLT_TYPING ${OUTPUT_FOLDER}/types.d.ts)

# Option to turn on memory profiling
option(ENABLE_MEMORY_PROFILER "Enable emscriptens memory profiler to help find leaks" OFF)

# Option to turn on double precision
option(DOUBLE_PRECISION "Compile the library in double precision mode" OFF)

# Option to turn multi threading on
option(ENABLE_MULTI_THREADING "Compile the library in multi threading mode (warning: doesn't work in Safari nor with any JS callbacks currently)'" OFF)

# Option to turn on SIMD
option(ENABLE_SIMD "Enable SIMD instructions (warning: last major browser to support this was Safari 16.4 in March 2023)" OFF)

# Option to speed up compilation by only compiling the WASM compat version
option(BUILD_WASM_COMPAT_ONLY "Compile online the WASM compat version of the library (speeds up compilation)" OFF)

# Enable for resizable heap, with some amount of slowness
option(ALLOW_MEMORY_GROWTH "Allow Memory Growth" OFF)

# Default initial memory size is 128*1024*1024 = 128MB
set(INITIAL_MEMORY 134217728 CACHE STRING "Initial Memory")

# Default maximum memory size is 2*1024*1024*1024 = 2GB (only used when ALLOW_MEMORY_GROWTH is true)
set(MAXIMUM_MEMORY 2147483648 CACHE STRING "Maximum Memory")

# The configurations we support
set(CMAKE_CONFIGURATION_TYPES "Debug;Release;Distribution")

# No floating point exception checking
set(FLOATING_POINT_EXCEPTIONS_ENABLED OFF)

# Turn off LTO
set(INTERPROCEDURAL_OPTIMIZATION OFF)

# Override debug symbols
if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
	set(GENERATE_DEBUG_SYMBOLS ON)
	set(JPH_DEBUG_SYMBOL_FORMAT "source-map" CACHE STRING "")
else()
	set(GENERATE_DEBUG_SYMBOLS OFF)
endif()

# Turn off custom allocator
set(DISABLE_CUSTOM_ALLOCATOR ON)

# Turn off ObjectStream
set(ENABLE_OBJECT_STREAM OFF)

# Use 32-bit object layers to support more bits in ObjectLayerPairFilterMask
set(OBJECT_LAYER_BITS 32)

# Enable multi threading
if (ENABLE_MULTI_THREADING)
	set(MULTI_THREADED_FLAG
		-pthread
		--post-js ${CMAKE_CURRENT_SOURCE_DIR}/multi-threaded.js
		-s SHARED_MEMORY)
	set(ENVIRONMENT_FLAG
		"-s ENVIRONMENT='web,node,worker'"
		"-s PTHREAD_POOL_SIZE=16")
	set(CMAKE_CXX_FLAGS "-pthread -s SHARED_MEMORY")
	set(OUTPUT_BASE_NAME "${OUTPUT_FOLDER}jolt-physics.multithread")
	set(REMOVE_THREAD_LOCAL "")
else()
	set(MULTI_THREADED_FLAG "")
	set(ENVIRONMENT_FLAG "-s ENVIRONMENT='web,node'")
	set(OUTPUT_BASE_NAME "${OUTPUT_FOLDER}jolt-physics")
	# Tried to keep this multi-platform since windows/mac/linux all treat -i different,
	# though this creates extra backup file in a non-tracked folder.
	# Removing 'thread_local' from the generated binding code fixes a small 'residual' allocation
	# in the proper_cleanup.html demo and it is not needed when in single threaded mode.
	# See: https://github.com/jrouwe/JoltPhysics.js/discussions/222#discussioncomment-11381106
	set(REMOVE_THREAD_LOCAL ${CMAKE_COMMAND} -E echo "Thread local removal skipped on Windows")
endif()

# Replace 'replace_by_import' by 'import' in the generated JS code to workaround a bug in emscripten
# See: https://github.com/jrouwe/JoltPhysics.js/issues/245
set(REPLACE_IMPORT ${CMAKE_COMMAND} -E echo "Import replacement skipped on Windows")

# Enable SIMD flags
if (ENABLE_SIMD)
	set(ENABLE_SIMD_FLAG
		-msimd128
		-msse4.2)
	set(USE_WASM_SIMD ON)
else()
	set(ENABLE_SIMD_FLAG "")
	set(USE_WASM_SIMD OFF)
endif()

# Include Jolt
include(FetchContent)
FetchContent_Declare(
        JoltPhysics
        GIT_REPOSITORY "https://github.com/jrouwe/JoltPhysics"
        GIT_TAG "475e564ae87c1ff8cbeaca6a5659b110a1b29143"
		SOURCE_SUBDIR "Build"
)
FetchContent_MakeAvailable(JoltPhysics)

# Enable resizable heap, with some amount of slowness. Default is 128*1024*1024 = 128MB
if (ALLOW_MEMORY_GROWTH)
	set(MEMORY_GROWTH_FLAG
		-s ALLOW_MEMORY_GROWTH=1
		-s MAXIMUM_MEMORY=${MAXIMUM_MEMORY})
else()
	set(MEMORY_GROWTH_FLAG "")
endif()

# Enable memory profiler
if (ENABLE_MEMORY_PROFILER)
	set(MEMORY_PROFILER_FLAG "--memoryprofiler")
	set(INCLUDE_DEMANGLE_ALL_FLAG "-s DEFAULT_LIBRARY_FUNCS_TO_INCLUDE='$demangleAll'")
	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MEMORY_PROFILER_FLAG}")
else()
	set(MEMORY_PROFILER_FLAG "")
	set(INCLUDE_DEMANGLE_ALL_FLAG "")
endif()

set(EMCC_ARGS
  -fno-rtti
  -fno-exceptions
  --extern-pre-js ${JOLT_FRONT_MATTER_FILE}
  --post-js glue.js
  --closure=1
  --closure-args="--dynamic_import_alias=replace_by_import"
  --closure-args="--externs"
  --closure-args="${CMAKE_CURRENT_SOURCE_DIR}/extern-import.js"
  ${MULTI_THREADED_FLAG}
  --post-js ${CMAKE_CURRENT_SOURCE_DIR}/helpers.js
  ${MEMORY_GROWTH_FLAG}
  -s ALLOW_TABLE_GROWTH=1
  -s WASM_BIGINT=0
  ${ENVIRONMENT_FLAG}
  -s EXPORT_ES6=1
  -s EXPORT_NAME="Jolt"
  -s MODULARIZE=1
  -s NO_EXIT_RUNTIME=1
  -s NO_FILESYSTEM=1
  -s STACK_SIZE=1048576
  -s INITIAL_MEMORY=${INITIAL_MEMORY}
  -s EXPORTED_RUNTIME_METHODS=HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64
  ${MEMORY_PROFILER_FLAG}
  ${INCLUDE_DEMANGLE_ALL_FLAG}
  ${ENABLE_SIMD_FLAG})

if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
	set(EMCC_ARGS
		${EMCC_ARGS}
		-g${JPH_DEBUG_SYMBOL_FORMAT}
		-s ASSERTIONS)
else()
	set(EMCC_ARGS
		${EMCC_ARGS}
		-O3)
endif()

set(EMCC_JS_ARGS ${EMCC_ARGS}
  -s AGGRESSIVE_VARIABLE_ELIMINATION=1
  -s ELIMINATE_DUPLICATE_FUNCTIONS=1
  -s SINGLE_FILE=1
  -s LEGACY_VM_SUPPORT=1
  -s WASM=0)

set(EMCC_WASM_ARGS ${EMCC_ARGS}
  -s BINARYEN_IGNORE_IMPLICIT_TRAPS=1
  -s WASM=1)

set(EMCC_WASM_COMPAT_ARGS ${EMCC_WASM_ARGS}
  -s SINGLE_FILE=1)

set(EMCC_GLUE_ARGS
  -c
  -I${JoltPhysics_SOURCE_DIR}/..
  -Wall
  -std=c++17
  -fno-rtti
  -fno-exceptions
  ${MULTI_THREADED_FLAG}
  -DJPH_OBJECT_LAYER_BITS=32
  -DJPH_DISABLE_CUSTOM_ALLOCATOR
  -include ${JOLT_HEADER_FILE}
  ${MEMORY_PROFILER_FLAG}
  ${ENABLE_SIMD_FLAG})

# Can't find a way to automatically inherit settings set by target_compile_definitions, so hardcoding defines here
if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
	set(JOLT_IDL_FILE ${JOLT_IDL_FILE} ${CMAKE_CURRENT_SOURCE_DIR}/JoltJS-DebugRenderer.idl )
	set(EMCC_GLUE_ARGS
		${EMCC_GLUE_ARGS}
		-DJPH_DEBUG_RENDERER -DJPH_PROFILE_ENABLED -D_DEBUG)
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "Release")
	set(JOLT_IDL_FILE ${JOLT_IDL_FILE} ${CMAKE_CURRENT_SOURCE_DIR}/JoltJS-DebugRenderer.idl )
	set(EMCC_GLUE_ARGS
		${EMCC_GLUE_ARGS}
		-DJPH_DEBUG_RENDERER -DJPH_PROFILE_ENABLED -DNDEBUG)
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "Distribution")
	set(EMCC_GLUE_ARGS
		${EMCC_GLUE_ARGS}
		-DNDEBUG)
else()
	message("Unknown CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
endif()

# Add double precision define
if (DOUBLE_PRECISION)
	set(EMCC_GLUE_ARGS ${EMCC_GLUE_ARGS} -DJPH_DOUBLE_PRECISION)
endif()

project("JoltPhysics.js")

add_custom_command(
	OUTPUT ${JOLT_TYPING}
	COMMAND npx webidl-dts-gen -e -d -i jolt.idl -o ${JOLT_TYPING} -n Jolt
	DEPENDS jolt.idl
	COMMENT "Generating JoltPhysics.js typing"
	VERBATIM)

add_custom_command(
	OUTPUT glue.cpp glue.js jolt.idl
	BYPRODUCTS parser.out WebIDLGrammar.pkl
	COMMAND ${CMAKE_COMMAND} -E cat ${JOLT_IDL_FILE} > jolt.idl
	COMMAND ${PYTHON} ${WEBIDL_BINDER_SCRIPT} jolt.idl glue
	COMMAND ${CMAKE_COMMAND} -E echo "Removing thread_local..."
	DEPENDS ${JOLT_IDL_FILE}
	COMMENT "Generating JoltPhysics.js bindings"
	VERBATIM)

add_custom_command(
	OUTPUT glue.o
	COMMAND emcc glue.cpp ${EMCC_GLUE_ARGS} -o glue.o
	DEPENDS glue.cpp ${JOLT_HEADER_FILE}
	COMMENT "Building JoltPhysics.js bindings"
	VERBATIM)
add_custom_target(jolt-bindings ALL DEPENDS glue.js glue.o ${JOLT_TYPING})

if (NOT BUILD_WASM_COMPAT_ONLY)
	if (NOT ENABLE_MULTI_THREADING # Not compatible with multi threading due to error: 'void wasm::I64ToI32Lowering::visitStore(Store *): Assertion `!curr->isAtomic && "atomic store not implemented"' failed.'
		AND NOT ENABLE_SIMD) # Not compatible with SIMD due to error: 'unhandled unaligned load'
		add_custom_command(
			OUTPUT ${OUTPUT_BASE_NAME}.js
			COMMAND emcc glue.o $<TARGET_FILE:Jolt> ${EMCC_JS_ARGS} -o ${OUTPUT_BASE_NAME}.js
			DEPENDS jolt-bindings ${JOLT_FRONT_MATTER_FILE} ${JOLT_TARGETS} ${JOLT_IDL_FILE} ${JOLT_HEADER_FILE}
			COMMENT "Building JoltPhysics.js javascript"
			VERBATIM)
		add_custom_target(jolt-javascript ALL DEPENDS ${OUTPUT_BASE_NAME}.js)
	endif()

	add_custom_command(
		OUTPUT ${OUTPUT_BASE_NAME}.wasm.js ${OUTPUT_BASE_NAME}.wasm.wasm
		COMMAND emcc glue.o $<TARGET_FILE:Jolt> ${EMCC_WASM_ARGS} -o ${OUTPUT_BASE_NAME}.wasm.js
		COMMAND ${REPLACE_IMPORT} ${OUTPUT_BASE_NAME}.wasm.js
		DEPENDS jolt-bindings ${JOLT_FRONT_MATTER_FILE} ${JOLT_TARGETS} ${JOLT_IDL_FILE} ${JOLT_HEADER_FILE}
		COMMENT "Building JoltPhysics.js webassembly"
		VERBATIM)
	add_custom_target(jolt-wasm ALL DEPENDS ${OUTPUT_BASE_NAME}.wasm.js ${OUTPUT_BASE_NAME}.wasm.wasm)
endif()

add_custom_command(
	OUTPUT ${OUTPUT_BASE_NAME}.wasm-compat.js
	COMMAND emcc glue.o $<TARGET_FILE:Jolt> ${EMCC_WASM_COMPAT_ARGS} -o ${OUTPUT_BASE_NAME}.wasm-compat.js
	COMMAND ${REPLACE_IMPORT} ${OUTPUT_BASE_NAME}.wasm-compat.js
	DEPENDS jolt-bindings ${JOLT_FRONT_MATTER_FILE} ${JOLT_TARGETS} ${JOLT_IDL_FILE} ${JOLT_HEADER_FILE}
	COMMENT "Building JoltPhysics.js compat webassembly"
	VERBATIM)
add_custom_target(jolt-wasm-compat ALL DEPENDS ${OUTPUT_BASE_NAME}.wasm-compat.js)

I've put together a readme about my findings to build with windows here:

Building JoltPhysics.js

This document provides comprehensive instructions for building JoltPhysics.js from source, including Windows-specific setup and troubleshooting.

Prerequisites

Required Tools

Emscripten SDK (emsdk)
- Download and install from: https://emscripten.org/docs/getting_started/downloads.html
- Or use the bundled version (recommended for Windows)
CMake (3.13 or higher)
- Download from: https://cmake.org/download/
Python 3
- Required for WebIDL processing
- Version 3.6 or higher recommended
Ninja Build System
- Faster than Make on Windows
- Can be installed via emsdk or separately
Git
- For cloning repositories and submodules

Windows-Specific Setup

On Windows, additional setup is required:

1. Install Visual Studio Build Tools

Install Visual Studio 2022 with:

Desktop development with C++
Windows 10/11 SDK
CMake tools (optional, as we'll use standalone CMake)

2. Install Dependencies via Chocolatey (Recommended)

choco install cmake python git ninja

3. Environment Variables

Add to your PATH:

C:\Program Files\CMake\bin
C:\Python39\ (or your Python installation path)
C:\Program Files\Git\bin

Quick Start (Windows)

Using the Bundled emsdk

Activate Emscripten:

cd emsdk
python emsdk.py install latest
python emsdk.py activate latest
python emsdk.py activate ninja-git-release-64bit

Set up environment and build:
```
.\emsdk\emsdk_env.ps1
.\build.ps1
```

Manual emsdk Installation

Download and install emsdk:

git clone https://github.com/emscripten-core/emsdk.git
cd emsdk
python emsdk.py install latest
python emsdk.py activate latest
python emsdk.py install ninja-git-release-64bit
python emsdk.py activate ninja-git-release-64bit

Build the library:

# In the JoltPhysics.js root directory
.\emsdk\emsdk_env.ps1
.\build.ps1

Build Process Details

What Gets Built

The build process creates multiple variants:

Single-threaded builds:
- jolt-physics.wasm-compat.js - WASM with embedded binary
- jolt-physics.wasm.js - WASM with separate binary file
- jolt-physics.js - asm.js version
Multi-threaded builds:
- jolt-physics.multithread.wasm-compat.js
- jolt-physics.multithread.wasm.js
Debug builds:
- jolt-physics.debug.wasm-compat.js
- jolt-physics.debug.multithread.wasm-compat.js
TypeScript definitions:
- types.d.ts - Main type definitions
- Various .d.ts files for each variant

Build Configuration Options

You can customize the build by passing options to the build scripts:

# Build only debug version
.\build.ps1 Debug

# Build with memory profiler
emcmake cmake -B Build/Distribution/ST -DCMAKE_BUILD_TYPE=Distribution -DENABLE_MEMORY_PROFILER=ON

# Build with double precision
emcmake cmake -B Build/Distribution/ST -DCMAKE_BUILD_TYPE=Distribution -DDOUBLE_PRECISION=ON

# Build with SIMD support
emcmake cmake -B Build/Distribution/MT -DCMAKE_BUILD_TYPE=Distribution -DENABLE_SIMD=ON

# Build only WASM-compat version (faster)
emcmake cmake -B Build/Distribution/ST -DCMAKE_BUILD_TYPE=Distribution -DBUILD_WASM_COMPAT_ONLY=ON

Linux/macOS Build

# Install prerequisites
sudo apt-get install cmake python3 ninja-build  # Ubuntu/Debian
# or
brew install cmake ninja python3                  # macOS

# Build
./build.sh          # Distribution build
./build.sh Debug    # Debug build only

Windows-Specific Fixes Applied

The build system includes several Windows compatibility fixes:

1. CMake Command Fixes

Replaced cat with ${CMAKE_COMMAND} -E cat for cross-platform file concatenation
Updated sed commands to use CMake's cross-platform alternatives

2. PowerShell Variable Expansion

Fixed variable expansion issues in build.ps1:

# Before (broken):
emcmake cmake -B "Build/${buildType}/ST" -DCMAKE_BUILD_TYPE=${buildType}

# After (fixed):
$stPath = "Build/$buildType/ST"
emcmake cmake -B $stPath "-DCMAKE_BUILD_TYPE=$buildType"

3. Environment Variable Quoting

Fixed environment variable handling for multi-threaded builds:

# Before:
set(ENVIRONMENT_FLAG "-s ENVIRONMENT='web,node,worker'")

# After:
set(ENVIRONMENT_FLAG "-s ENVIRONMENT='web,node,worker'" "-s PTHREAD_POOL_SIZE=16")

Troubleshooting

Common Issues

1. "emcc: command not found"

Solution: Ensure emsdk environment is activated:

.\emsdk\emsdk_env.ps1

2. "cmake: no compatible generator found"

Solution: Install Ninja build system:

python emsdk.py install ninja-git-release-64bit
python emsdk.py activate ninja-git-release-64bit

3. "Python command not found"

Solution: Ensure Python is in PATH or use full path:

# Check Python installation
python --version
# or
C:\Python39\python.exe --version

4. Build Fails with "sed: command not found"

Solution: This is handled automatically by the Windows build fixes, but ensure you're using the provided build scripts.

5. Memory Issues During Build

Solution: Increase Node.js memory limit:

node --max-old-space-size=8192 ./node_modules/.bin/webpack

Debug Builds

For debugging C++ code in the browser:

Use debug builds (jolt-physics.debug.*.js)
Enable source maps in your browser
See Chrome WASM debugging guide

Performance Optimization

Use -DBUILD_WASM_COMPAT_ONLY=ON for faster builds during development
Enable SIMD with -DENABLE_SIMD=ON for better performance (limited browser support)
Use multi-threaded builds for CPU-intensive applications

Package Creation

After building, create an npm package:

# Create tarball
npm pack

# This creates: jolt-physics-x.y.z.tgz

# Install in another project
cd /path/to/other/project
npm install /path/to/jolt-physics-x.y.z.tgz

Development Workflow

Make changes to source files
Rebuild using .\build.ps1
Test with examples: npm run examples
Create package with npm pack
Install locally in test projects

Examples

See the Examples/ directory for usage examples:

falling_shapes.html - Basic physics simulation
proper_cleanup.html - Memory management example
character_virtual_controller.html - Character controller demo

Contributing

When contributing to the build system:

Test on both Windows and Linux/macOS
Update this documentation for any new requirements
Ensure all build variants work correctly
Add troubleshooting information for common issues

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Build library with windows and double precision #276

Uh oh!

{{title}}

Uh oh!

Replies: 1 comment

Uh oh!

{{title}}

Uh oh!

Select a reply

Uh oh!

Build library with windows and double precision #276

Uh oh!

daxur-studios Sep 28, 2025

Building JoltPhysics.js

Prerequisites

Required Tools

Windows-Specific Setup

1. Install Visual Studio Build Tools

2. Install Dependencies via Chocolatey (Recommended)

3. Environment Variables

Quick Start (Windows)

Using the Bundled emsdk

Manual emsdk Installation

Build Process Details

What Gets Built

Build Configuration Options

Linux/macOS Build

Windows-Specific Fixes Applied

1. CMake Command Fixes

2. PowerShell Variable Expansion

3. Environment Variable Quoting

Troubleshooting

Common Issues

1. "emcc: command not found"

2. "cmake: no compatible generator found"

3. "Python command not found"

4. Build Fails with "sed: command not found"

5. Memory Issues During Build

Debug Builds

Performance Optimization

Package Creation

Development Workflow

Examples

Contributing

Related Documentation

Replies: 1 comment

Uh oh!

daxur-studios Sep 28, 2025 Author

daxur-studios
Sep 28, 2025

daxur-studios
Sep 28, 2025
Author