Community hub
0 subscribers8 pages, 0 posts
Recent from talks
All channels
Be the first to start a discussion here.
Be the first to start a discussion here.
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Welcome to the community hub built to collect knowledge and have discussions related to OpenSimulator.
Nothing was collected or created yet.
OpenSimulator
View on Wikipediafrom Wikipedia
 | This article has multiple issues. Please help improve it or discuss these issues on the talk page. (Learn how and when to remove these messages)
|
| OpenSimulator | |
|---|---|
 | |
| Stable release | 0.9.3.0
/ November 8, 2024[1] |
| Operating system | Cross-platform |
| Type | Server |
| License | BSD |
| Website | opensimulator |
| Inventory Archive | |
|---|---|
| Filename extension |
.iar |
| UTI conformation | application/tar |
| Developed by | OpenSimulator |
| Type of format | File archiver |
| OpenSimulator Archive | |
|---|---|
| Filename extension |
.oar |
| Internet media type |
application/oar |
| UTI conformation | application/tar |
| Developed by | OpenSimulator |
| Type of format | File archiver |
OpenSimulator is an open-source server platform originally launched in 2007 for hosting virtual worlds and metaverse environments. It is largely compatible with the virtual world Second Life but full compatibility is not a design goal.
Features
[edit]OpenSimulator is written in C# and is designed to be easily expanded through the use of plugin modules. OpenSimulator can operate in one of two modes: standalone or grid mode. In standalone mode, a single process handles the entire simulation. In grid mode, various aspects of the simulation are separated among multiple processes, which can exist on different machines.[2]
OpenSimulator uses loadable modules for most of its functionality. These loadable modules can be independently developed to add functionality to the server.[3]
OpenSimulator currently uses a modified Second Life protocol for client to server communication, and requires retrofitting to a suitable virtual world viewer (client) in order to connect. Interoperability with Second Life protocols was initially a design goal.[4] During the OpenSimulator Community Conference 2018, the core developers announced they may not always seek to maintain compatibility with Linden Lab's Second Life Protocols, and may change or add facilities in line with differing aims.[citation needed]
OpenSim has a number of features not available in Second Life. These include virtual world content (OAR) and avatar inventory (IAR) save and load capabilities, extensions to the scripting language that enable saving and retrieval of text data to avatar inventory in notecard format and the creation and management of non-player characters (NPCs).[citation needed]
OpenSim also uses an architecture known as "Hypergrid", which allows users to teleport between multiple OpenSim-based virtual worlds by providing a hyperlinked map which indexes public grids.[5] This allows for public grids to retain teleportation links to each other without having to be on the same grid. The number of hypergrid-enabled OpenSimulator grids fluctuates. As of February 2023, there were just over 400 active hypergrid-enabled services.[citation needed]
See also
[edit]
- Open Wonderland – A Java-based open source 3D toolkit for creating collaborative virtual worlds.
- IBM Virtual Universe Community – One of the largest contributors to the OpenSim project.
- Open Cobalt – A decentralized open source virtual world architecture.
- High Fidelity Inc - A "next-generation" social virtual reality platform.
- JanusVR - Immersive web browsing software support VR and loading worlds via web content
References
[edit]- ^ "Download - Current release". OpenSimulator. 8 November 2024. Retrieved 3 July 2025.
- ^ "Configuration". OpenSimulator. 21 June 2021. Retrieved 2 December 2022.
- ^ "Getting Started with Region Modules". OpenSimulator. 12 March 2012. Retrieved 2 December 2022.
- ^ White, Brian (11 August 2008). "A Bridge between Virtual Worlds: Second Life's new program links virtual environments". Technology Review. MIT. ISSN 1099-274X. Archived from the original on 20 May 2022. Retrieved 2 December 2022.
- ^ "Hypergrid". OpenSimulator. 24 December 2021. Retrieved 2 December 2022.
Further reading
[edit]- Lin, Tsun-Ju; Lan, Yu-Ju (October 2015). "Language Learning in Virtual Reality Environments: Past, Present, and Future". Educational Technology & Society. 18 (4): 486–497. eISSN 1436-4522. ISSN 1176-3647. JSTOR jeductechsoci.18.4.486. S2CID 43324220.
External links
[edit]
Wikimedia Commons has media related to OpenSimulator.
OpenSimulator
View on Grokipediafrom Grokipedia
OpenSimulator is an open-source, multi-platform, multi-user 3D application server that enables the creation of customizable virtual environments, or "worlds," which can be populated with dynamic, user-generated content using free 3D tools.[1] It serves as a flexible platform for hosting virtual worlds, supporting both standalone simulations and large-scale grids with thousands of interconnected regions, and is particularly valued for its use in education, research, and prototyping new 3D applications.[2] Developed under the BSD license and written primarily in C#, OpenSimulator is compatible with a subset of Second Life viewers and other clients, allowing users to interact with these environments through standard protocols.[3]
The project was founded on January 29, 2007, by Darren Guard (known as MW), with the initial goal of creating a proof-of-concept server compatible with the Second Life client to provide an open alternative for virtual world development.[4] Early contributions from developers such as Stefan Andersson (lbsa71), Adam Frisby (AdamZaius), Sean Dague (sdague), and Justin Casey (Justincc) helped evolve it from a basic Second Life emulator into a general-purpose virtual environment platform supporting multiple protocols and clients.[4] By March 2008, the associated OSGrid network had grown to support 1,800 users and 200 simulator regions, marking significant early adoption.[4]
Key features of OpenSimulator include real-time physics simulation, in-world scripting via LSL (Linden Scripting Language) and OSSL (OpenSimulator Scripting Language), and the Hypergrid system, which allows seamless travel between different OpenSimulator installations to form a distributed metaverse.[2] It runs on Windows, Unix-like systems, and .NET/Mono environments, with modular architecture enabling customization through scene plugins and extensions for advanced functionalities like voice chat and terrain editing.[5] As of November 2024, the latest stable release is version 0.9.3.0, which requires .NET 8 for optimal performance, though earlier versions remain available for legacy setups.[6]
OpenSimulator's community-driven development fosters ongoing innovation, with resources like IRC channels, mailing lists, and a bug tracker facilitating contributions from users worldwide.[1] Its emphasis on interoperability and openness has made it a foundational tool for exploring metaverse concepts, virtual collaboration, and immersive simulations without proprietary constraints.[4]
History
Founding and Early Development
OpenSimulator was founded on January 29, 2007, by Darren Guard, known online as MW, who sought to develop an open-source server platform for 3D virtual environments as an alternative to proprietary systems like Second Life's server software.[4] This initiative was spurred by the growing interest in open-source virtual worlds following the release of an open-source version of the Second Life client, aiming to enable decentralized and customizable 3D spaces without reliance on closed ecosystems.[4] Early development began with initial code commits in February 2007, led by a small core team including founder MW, Stefan Andersson (lbsa71), Gareth, and Adam Frisby (AdamZaius), who focused on building a proof-of-concept server compatible with the Second Life client.[4] By April 2007, IBM entered the picture when Sean Dague began evaluating OpenSimulator for potential enterprise applications in the 3D internet space; he joined the project formally in May, securing commit access.[4] This involvement culminated in July 2007 with IBM's commitment to the project, enhancing the platform's accessibility for standalone and grid deployments.[4] Key technical advancements during this period included the Zircon rewrite, which established a robust client stack and API, and the subsequent Sugilite rewrite, introducing layered abstractions such as Scene, Framework, Region, and Grid components to support scalable virtual world operations.[4] In July 2007, Gareth launched OSGrid as the first public grid for OpenSimulator, providing a testing ground for multi-user simulations and later maintained by Charles Krinke (ckrinke) starting that same month.[4] The grid experienced rapid adoption, growing from approximately 250 users and 25 simulators by late October 2007 to 600 users and 75 simulators by December 2007, and further to 1,150 users and 150 simulators by January 2008 and 1,800 users and 200 simulators by March 2008, demonstrating early community interest in open virtual worlds.[4]Major Milestones and Releases
In October 2008, the first version of in-world search was introduced on OSGrid, marking a significant step toward enhanced user navigation and functionality within OpenSimulator environments, and signaling the project's transition to more structured milestones.[4] This feature allowed users to search for content directly in the virtual world, laying groundwork for broader adoption and testing on public grids. A key advancement occurred on December 20, 2008, when the first successful 6-region Hypergrid standalone grid was implemented by Bruce Patton, with assistance from Diva Danzia following November trials; this enabled seamless interoperability between independent OpenSimulator instances, expanding possibilities for distributed virtual worlds.[4] Core development during this period was tracked through Subversion (SVN) revisions, starting from r1 and progressing through early commits like in December 2007 when Justin Casey (justincc) joined as a core committer, with steady advancements continuing into 2009 to refine stability and features.[4] Contributions from the IBM Virtual Universe Community, including core committers like Sean Dague—who introduced SQLite support and hosted test regions—and Dirk Huseman, bolstered early scalability and enterprise-oriented enhancements, such as improved database handling for larger grids.[4] These efforts supported more robust testing and deployment in professional settings. Stable releases evolved progressively, culminating in version 0.9.3.0 ("Nessie") on November 8, 2024, which incorporated ongoing stability improvements like .NET 8 compatibility and refined asset management, building on prior versions to enhance reliability for production use.[7][6] The annual OpenSimulator Community Conference (OSCC), which began in 2013 as a platform for developers and users, has since become a cornerstone event; the 2025 edition (OSCC25), scheduled for December 6–7, 2025, emphasized discussions on emerging features, core development, and interoperability challenges.[8][9] Recent advancements from 2016 onward include the integration of dynamic scalability models, such as hybrid grid expansion and contraction mechanisms, which allow OpenSimulator to adapt region resources based on user load, as detailed in research extending the framework for internet-scale virtual environments.[10] These models prioritize efficient resource allocation without compromising performance, drawing from foundational OSGrid growth as a testing bed for such innovations.Technical Architecture
Core Components and Framework
OpenSimulator is primarily implemented in C#, using the .NET runtime (version 8 required for recent releases) for cross-platform compatibility on Windows, Linux, macOS, and other platforms. This choice enables robust performance in virtual world simulations while facilitating development and deployment on diverse hardware environments. The software is released under the BSD license, which permits free modification, distribution, and commercial use without restrictive copyleft requirements, fostering a vibrant ecosystem of contributors and derivatives.[11][12][13] The framework employs a plugin-based architecture centered on inversion of control principles, where core functionality is extended through modular components without modifying the base codebase. This design utilizes interfaces and connectors to decouple services, allowing developers to implement or swap modules for specific needs, such as custom behaviors or integrations. Key layers include the Scene object, which manages in-region elements like objects and avatars; the Region or Framework layer, responsible for instantiating and simulating individual regions; and the Grid layer, which orchestrates communication and coordination across multiple interconnected regions to form larger virtual worlds.[14][15][16] Default implementations for essential services are replaceable to support flexibility, including the BulletS physics module based on the Bullet Physics Engine for high-performance collision detection and dynamics simulation. Asset storage and retrieval are handled through modular services that integrate with various backends, while database support defaults to SQLite for lightweight standalone setups or MySQL/MariaDB for scalable grid operations, ensuring persistent data management for user inventories, regions, and assets. This modular service approach aligns with OpenSimulator's compatibility with the Second Life protocol, enabling seamless viewer integration.[17][18] OpenSimulator utilizes specialized file formats for archiving and portability: the .oar (OpenSim Archive) format encapsulates entire regions, including terrain, objects, textures, and scripts, in a gzipped tar structure for easy export and import across instances. Complementing this, the .iar (Inventory Archive) format stores user inventory folders and items, preserving all associated assets like notecards and scripts in a self-contained gzipped tar file, facilitating user data migration between grids or backups.[19][20]Supported Platforms and Deployment Modes
OpenSimulator is a cross-platform application server compatible with Windows, Linux, and macOS operating systems. It uses the .NET runtime (version 8 required for versions 0.9.3.0 and later, released starting November 2024, with the latest stable version 0.9.3.1 as of August 2025) for deployments across diverse hardware architectures.[5][21][22] This multi-platform support allows administrators to choose the most suitable host system based on availability and performance needs. The minimum hardware requirements for running OpenSimulator include at least 1 GB of RAM per region for moderately loaded simulations, though 2 GB is recommended for regions with high avatar counts, numerous primitives, or active scripts to prevent performance degradation. A multi-core CPU is essential for handling physics simulations and concurrent tasks, with a general guideline of one core per active region plus an additional core for system overhead. Deployments can scale significantly on clustered server setups, supporting thousands of interconnected regions in large grids without inherent architectural limits, provided sufficient network bandwidth and storage are available.[23] OpenSimulator offers three primary deployment modes to accommodate varying scales and use cases: standalone mode for single-user or small simulations, where all services run in one process via OpenSim.exe; grid mode for multi-region worlds, utilizing a central Robust.exe server to manage shared services across multiple region instances; and hypergrid-enabled configurations, which extend both standalone and grid modes to facilitate interoperability across distributed virtual worlds. Configuration is primarily handled through INI files such as OpenSim.ini for region settings and Robust.ini for grid services, supplemented by XML files like Regions.ini for defining region layouts and database connections. Runtime management is achieved via in-console server commands, allowing dynamic adjustments such as user creation, region restarts, or statistics monitoring without restarting the server.[24][25] For data persistence, OpenSimulator supports multiple database backends tailored to deployment complexity: SQLite for lightweight, standalone setups due to its file-based simplicity and no external server requirement; and MySQL or MariaDB for production grids, offering robust scalability, concurrent access, and reliability in multi-user environments. Database selection is specified in the configuration files via connection strings, with SQLite serving as the default for initial testing and the others recommended for any setup expecting persistent, high-traffic operations.[18]Features
Virtual World Capabilities
OpenSimulator enables the creation and management of immersive 3D virtual environments through a modular region-based architecture. Standard regions are fixed at 256 meters by 256 meters, providing a foundational unit for world-building that aligns with the Second Life protocol for compatibility. The Varregion module extends this capability, allowing administrators to configure larger variable-sized regions, such as 512x512 meters or greater, to support expansive, seamless mega-regions without the deprecated multi-region stitching of earlier versions. This flexibility accommodates diverse scales, from intimate parcels to vast landscapes, while maintaining performance through server-side optimizations.[26][27][28] Real-time physics simulation is a core component, powered by selectable engines that model interactions like collisions, gravity, and motion. The BulletSim module integrates the Bullet Physics library for high-fidelity simulations, including support for complex vehicle dynamics and deformable objects, while ubODE offers an improved iteration of the Open Dynamics Engine (ODE) with enhanced stability for large-scale scenes. These engines process physical properties in real time, enabling realistic environmental responses such as wind effects on foliage or water currents influencing buoyancy. Basicphysics and POS serve as lighter alternatives for less demanding setups.[17][29][30] Multi-user interactions are facilitated within each region, supporting up to 100 concurrent avatars for collaborative experiences. Users can manipulate objects in-world by creating, linking, and editing primitives (prims)—basic geometric building blocks—directly through compatible viewers. Terrain editing tools allow real-time sculpting, texturing, and elevation adjustments to shape landscapes, complemented by environmental effects like dynamic skies, day-night cycles, and particle systems for weather or atmospheric phenomena. Non-player characters (NPCs), implemented as bots via OSSL functions such as osNpcCreate and osNpcSay, integrate as automated agents capable of navigation, dialogue, and scripted actions to enhance population density and interactivity without requiring live users.[31][32][33] Content creation and sharing are bolstered by multi-protocol support for importing and exporting 3D assets. Prims can be built natively or exported to standard formats like OBJ for external editing, while meshes are imported via COLLADA (.dae) files from tools like Blender, enabling detailed models with 4 levels of detail (high, medium, low, and lowest) for optimized rendering, including support for Physically Based Rendering (PBR) materials since version 0.9.3.0. Textures in PNG, JPEG, or TGA formats apply visual details to objects and terrain, with built-in upload mechanisms ensuring compatibility across viewers. These features allow seamless integration of professional-grade assets into the simulation.[34][35][36][37]Scripting and Extensibility
OpenSimulator supports in-world scripting primarily through a compatibility layer with the Linden Scripting Language (LSL), which allows users to program behaviors for objects, avatars, and environments within virtual worlds. This implementation covers a substantial subset of LSL's functionality from Second Life, enabling developers to create interactive elements such as animations, interactions, and dynamic content.[38] Additionally, OpenSimulator extends LSL with the OpenSimulator Scripting Language (OSSL), introducing functions prefixed with "os" that provide enhanced capabilities, such as advanced region manipulation and external integrations not available in the original LSL. These OSSL extensions are configurable via the OpenSim.ini file to control permissions and prevent potential security risks.[39] Scripting in OpenSimulator is event-driven, where scripts respond to triggers like avatar interactions (e.g., touch events via thetouch_start handler), timed intervals (using llSetTimerEvent), or external communications (such as HTTP requests with llHTTPRequest). Events are processed sequentially within a state machine framework, with up to 300 events queued per script to manage performance, configurable through the MaxScriptEventQueue parameter in the server's configuration. This model supports asynchronous operations, allowing scripts to handle complex interactions without blocking the simulation, and is powered by the YEngine since version 0.9.3.0 for improved efficiency in long-running tasks.[38][40]
Extensibility beyond core scripting is achieved through plugin modules, which allow administrators and developers to add custom services and features by implementing interfaces like IRegionModule or using dynamic loading via Mono.Addins. These modules can extend the server with capabilities such as custom networking protocols, data services, or specialized simulations; for instance, voice chat integration has been advanced through community efforts like EchoVoice, a self-hosted alternative to Vivox that leverages open-source VoIP solutions. Plugins are loaded at runtime based on configuration files like OpenSim.ini or Robust.ini, enabling modular enhancements without recompiling the core server.[41][42]
The community contributes to scripting and extensibility through a structured process for feature proposals and patches. Proposals begin with a detailed technical description posted to the opensim-dev mailing list, followed by creation of a wiki page under the Feature_Proposals namespace if interest is shown, using a standardized template to outline implementation and benefits. Patches for code changes or extensions are submitted via the Mantis bug tracker, generated using Git commands like git format-patch to ensure one logical change per submission, and must adhere to coding standards and pass automated tests before review. This process fosters collaborative development, with feedback typically provided within one to two weeks.[43][44]
Interoperability
Viewer Compatibility
OpenSimulator primarily integrates with viewers originally developed for Second Life, such as Firestorm and Singularity, through support for a modified version of the Second Life protocol.[45] These viewers, which are open-source forks of Linden Lab's official client, allow users to connect to OpenSimulator-based grids by entering the grid's login URI, such as "login.osgrid.org" for the OSGrid test environment.[46] This compatibility enables basic functionality like avatar movement, object interaction, and terrain rendering, but advanced Second Life features may not be fully supported without viewer-side modifications.[3] As of September 2025, the official OpenSimulator documentation lists over 30 compatible viewers, including both graphical clients and alternative interfaces like text-based or mobile options.[3] Prominent examples include Firestorm (supporting Linux, macOS, and Windows with features like Physically Based Rendering), Dayturn (optimized for Windows and macOS), Cool VL Viewer (cross-platform with experimental beta support), and Radegast (a lightweight .NET-based client for scripting and automation).[3] Other third-party viewers, such as Scenegate and Mobile Grid Client for Android, provide specialized access for non-desktop environments. Feature parity varies across these viewers; for instance, while core rendering and scripting are widely supported, specialized capabilities like voice chat or inventory management may differ based on the viewer's development focus.[3] OpenSimulator maintains partial compatibility with the Second Life protocol, with core messaging support announced as a foundational goal since the project's inception, though full interoperability has never been guaranteed.[45] In 2018, during the OpenSimulator Community Conference, core developers noted that ongoing alignment with Linden Lab's evolving viewer protocol would not always be prioritized, leading to potential divergences.[47] Specific issues arise with advanced features like Animesh (animated objects) and Bakes on Mesh (server-side texture baking for avatars), which often require updated viewers with experimental patches for proper rendering and functionality.[48] For example, early implementations of Animesh in OpenSimulator releases around 2019 necessitated viewer updates to handle animation blending, while Bakes on Mesh support remains experimental in many clients to avoid compatibility risks on older grids.[48] Due to independent development teams for OpenSimulator and its viewers, with differing timelines and priorities, compatibility is not assured and can break across updates.[3] Users are recommended to test viewers on public grids like OSGrid, the official community testbed, to verify functionality before deployment on private regions.[31] Compatible viewers are essential for features like Hypergrid travel, which relies on client-side protocol handling for seamless cross-grid teleportation.[3]Hypergrid and Cross-Grid Functionality
The Hypergrid is a distributed networking protocol in OpenSimulator that enables seamless connections between independent instances or grids, forming a federated metaverse where users can travel without interruption. It allows region administrators to create hyperlinks on maps or in-world objects pointing to remote locations, using addresses in the formathop://hostname:port/region-name x y, facilitating direct teleportation while preserving the user's appearance, attachments, and access to their home grid's inventory. This protocol, introduced as a proof-of-concept in 2008 by developer Diva Distraction and integrated into the OpenSimulator core by December of that year, marked the first successful demonstration of cross-grid avatar transfer.[25][49]
By 2023, the Hypergrid supported over 400 active grids, enabling a vast, interconnected ecosystem of virtual worlds with shared content and user mobility, though participation requires explicit permissions for asset and inventory sharing to prevent unauthorized exports. As of October 2025, there are 257 tracked OpenSim grids, with around 250 active and many hypergrid-enabled.[50] Users can maintain friend lists across connected grids, enhancing social features in this distributed environment. Content portability is further supported through Open Archive Region (OAR) files for entire regions and Inventory Archive (IAR) files for personal items, allowing builders to transfer creations between grids with minimal reconfiguration.[51][25][24]
Security in the Hypergrid is managed through configurable permission systems, primarily in version 2.0 and later, which include gatekeeper services to control foreign agent access and user-level restrictions on travel to specific grids via whitelists or blacklists. For instance, grid operators can disable foreign logins entirely or limit exports of sensitive assets like scripts, while users at higher permission levels may be allowed broader inter-grid travel. Recent advancements as of 2025 have focused on integrating voice communication across grids, with EchoVoice providing a modernized solution for Hypergrid-enabled regions to support multiple voice protocols without disrupting avatar transfers.[52][53][54]
Hypergrid functionality requires viewers compatible with OpenSimulator's protocol extensions for handling remote asset fetches during travel.[25]