Oimo.js

Oimo.js
Name	Oimo.js
Developer	Masashi Katsumata
Initial release	2011
Latest release	2015 (core); community forks ongoing
Programming language	JavaScript, TypeScript (wrappers)
Platform	Web, Node.js, WebAssembly integrations
License	MIT

Oimo.js is a lightweight JavaScript physics engine focused on rigid body dynamics for real-time 3D applications. It targets interactive graphics, games, and simulations in browsers and Node.js environments by providing collision detection, constraints, and basic solvers optimized for JavaScript performance. Designed during the rise of WebGL and HTML5, it competes with contemporaries in the open-source physics ecosystem and has been used in projects integrating real-time rendering libraries and game engines.

History

Oimo.js was created by Masashi Katsumata during the early 2010s when libraries such as WebGL and frameworks like Three.js were driving a surge in browser-based 3D experiences. Its initial releases around 2011 emphasized compactness and speed for rigid body simulation, echoing design choices seen in engines like Bullet (physics engine) and Box2D (for 2D). The project attracted attention from developers working on WebGL demos, Mozilla-driven experiments, and Web game jams; its development intersected with broader movements spearheaded by organizations such as Google and Mozilla Foundation promoting open web technologies. Over time, community forks and integrations extended its lifespan even after the original core saw fewer updates; this mirrors patterns from other projects such as Ammo.js and community-maintained ports of native engines.

Features

Oimo.js provides a set of features tailored to interactive 3D scenes: rigid body dynamics, collision detection, and constraint systems supporting joints and limits. It includes primitive and compound shapes (boxes, spheres, cylinders) suitable for scenes rendered with engines like Three.js, PlayCanvas, and Babylon.js. The engine exposes tunable parameters for damping, restitution, and friction, comparable to options in PhysX and Havok (software), while maintaining a smaller footprint for browser delivery akin to lightweight projects like Cannon.js. Oimo.js emphasizes ease of use for prototyping, with features aimed at typical game patterns such as kinematic bodies, sleep optimization, and simple continuous collision detection options popularized in engines like Unity (game engine).

Architecture and design

The architecture centers on an object-oriented JavaScript core implementing broad-phase and narrow-phase collision stages, a constraint solver, and an integrator. The broad-phase uses simple spatial partitioning strategies suitable for scenes integrated with WebGL render loops, while the narrow-phase computes contact points and normals for primitives. Constraints are implemented as iterative solvers inspired by methods in Project Chrono and classical rigid-body literature. Memory and allocation were consciously minimized to mitigate garbage collection pauses in engines that run alongside frameworks such as React (web framework) or Angular (web framework) when used in hybrid web applications. The design choices reflect trade-offs similar to those made by teams behind Godot Engine and other open-source projects balancing performance, size, and API simplicity.

Usage and API

Developers use Oimo.js by creating a world instance, adding rigid bodies and shapes, and stepping the simulation inside a render loop provided by libraries like Three.js or Babylon.js. The API offers constructors and methods for bodies, shapes, and joints, along with configuration for gravity, timestep, and solver iterations. Typical integration patterns resemble workflows in Unity (game engine) scripting or in browser-based examples from Mozilla Developer Network, where the engine is stepped each frame and state is copied to rendering entities. Bindings and wrappers in TypeScript and adapter projects provide typings similar to those found in ecosystems around TypeScript and DefinitelyTyped, enabling tighter editor integration for developers using editors like Visual Studio Code.

Performance and benchmarks

Oimo.js was benchmarked in the context of browser demos and lightweight games, often compared against engines such as Cannon.js, Ammo.js, and native ports like Bullet (physics engine) compiled via Emscripten. Its strengths are small bundle size and low overhead for simple scenes with many primitive bodies; however, it can trail optimized native or WebAssembly solutions on complex constraint-heavy workloads. Performance profiles frequently cited trade-offs between GC behavior, single-threaded JavaScript execution, and solver iteration counts—issues also discussed in the performance analyses of WebAssembly conversions and native engine bindings. Benchmarks used representative workloads similar to those in demos from Google Chrome performance showcases and academic evaluations of real-time simulation.

Integrations and bindings

Oimo.js integrates with rendering and engine ecosystems through straightforward adapters and example code for Three.js, Babylon.js, and PlayCanvas. Community bindings and wrappers provide TypeScript definitions, convenience utilities for common joint types, and small glue modules for synchronization with scene graphs in engines like A-Frame and projects hosted on platforms such as GitHub. Some integrations convert Oimo.js state to formats compatible with networked multiplayer frameworks influenced by projects like Colyseus and Socket.io to enable synchronized physics across clients.

Development and community

Although core development slowed after mid-2010s, the community maintained forks, issue trackers, and ports reflecting the collaborative patterns seen in open-source ecosystems around GitHub and npm (software) packages. Contributors ranged from independent web developers to teams building demos showcased at conferences like JSConf and meetups organized by local communities. Discussions about feature requests, bug fixes, and performance improvements mirrored conversations happening in repositories for other engines such as Cannon.js and Ammo.js, with some community members proposing WebAssembly rewrites or hybrid approaches to leverage engines like Bullet (physics engine) via compilation. The project remains part of the historical record of browser-based physics engines that enabled a generation of WebGL content.

Category:JavaScript libraries