Tutorial01
What is OpenSimulator?
OpenSimulator is an open-source, multi-platform, multi-user 3D application server. It enables the creation of virtual environments (or worlds) accessible through various clients using multiple protocols.
It also includes an optional feature, the Hypergrid, which allows users to visit other OpenSimulator installations across the web directly from their 'home' OpenSimulator installation.
OpenSimulator empowers virtual world developers to customize their worlds using the technologies they feel work best – the framework is designed for easy extensibility.
OpenSimulator is written in C# and runs on Windows (using the .NET runtime) and Unix-like machines (e.g., Linux, macOS, using the Mono framework or direct .NET runtime installs). The source code is released under a BSD License, a commercially friendly license allowing OpenSimulator to be embedded in other products. For details on its development history, see the History page on the OpenSimulator wiki. The official user documentation is available here: http://opensimulator.org/wiki/User_Documentation
Out of the box, OpenSimulator can simulate virtual environments similar to Second Life™, as it supports the core SL messaging protocol. Consequently, these virtual worlds can often be accessed using standard SL-compatible viewers. However, OpenSimulator does not aim to be merely a clone of the Second Life server platform. Instead, the project's goal is to facilitate innovative feature development for virtual environments and the wider Metaverse.
Before you attempt to run your own regions, it is highly beneficial to familiarize yourself with the key terminology, software components, and protocols involved. Having a clear understanding of what each term means and what each component does will help prevent significant frustration later on. Furthermore, configurations or solutions that work for others may not be directly applicable to your specific setup due to differences in hardware, network configurations, or software versions. The glossary / 'scary words list' below provides brief explanations for many common terms.
These definitions are introductory and not highly technical, aiming to give less technical users a foundational idea. However, a basic understanding of these concepts is necessary to operate an OpenSimulator server effectively.
Do I need a powerful machine to run a region on OSgrid?
No, the computer you currently use to access virtual worlds is likely capable of hosting a region. As a general guideline, a region requires approximately 1 GB of free RAM and 1 dedicated CPU core to run comfortably. More resources generally lead to better performance, and while OpenSimulator might function with less, performance will reflect those limitations.
Goals for this class:
Gain a basic understanding of the names and abbreviations for terms, services, and protocols used when running a simulator. * Understand the function of these components and why they are needed. * Learn the basic structure of OSgrid and how your simulator connects to it. * Understand fundamental networking concepts relevant to hosting.
Many topics discussed below are complex and could take extensive study to master fully. This guide keeps the explanations basic and focused on the essentials for getting started. If the guide states you need an IP address, please assume for now that you do. Focus first on understanding the overall picture and learning the basics ('learning to drive'). You can always delve deeper later to become an expert ('racer') or system maintainer ('mechanic').
Administrator: A user account on a computer system (e.g., Windows Administrator, Linux 'root' user) with elevated permissions. This level of access is typically required to install server software, modify system configurations (like firewall rules), and manage services.
Cache: A temporary storage area holding recently accessed information for faster retrieval later. Computers utilize various caches (processor, memory, disk, browser) to enhance performance. Virtual world viewers also maintain caches (e.g., for textures, inventory) which sometimes need to be cleared manually to resolve display or loading issues.
Client-Server Model: A common network architecture where a 'client' program (e.g., your viewer) requests information or services from a 'server' program (e.g., the OpenSimulator instance hosting a region). The server processes the request and sends a response back to the client. A single server typically handles connections from multiple clients simultaneously. (This contrasts with Peer-to-Peer (P2P) models where clients connect directly to each other).
Console: Also referred to as the Simulator, Instance, or Shell. It is the text-based interface window (often a black window with scrolling text on Windows, or a terminal session on Linux/macOS) that displays messages and accepts commands when you run the OpenSim.exe (or equivalent) program. This window represents the running simulator software process that hosts your region(s).
Coordinates: The X,Y pair of numbers (e.g., 10000, 10000) specifying a region's location on the grid map. Check the current OSgrid map here: https://www.osgrid.org/map.php
CPU (Central Processing Unit): The primary processor chip in your computer responsible for executing program instructions and performing calculations. The number of 'cores' (processing units) generally affects how many tasks can be handled concurrently and the speed of complex operations.
Database: A structured system for storing and retrieving data. OpenSimulator relies on a database to store persistent information like region objects (prims), terrain data, user inventory (if running grid services), and various settings. Common choices include SQLite (a simple file-based database, often the default in distributions like OSgrid's), MySQL/MariaDB (more robust relational databases recommended for multi-region setups), or PostgreSQL.
Developer: (Informal definition!) Magical organism that converts caffeine and nicotine into software 'code'. These individuals program the OpenSimulator platform. They represent the pinnacle of technical expertise ("crème de la crème of the nerds"), and your virtual existence relies solely on their efforts. (Though some users blame them for everything...). However, without developers, there's no grid. So, be appreciative when interacting with them; they likely deserve it.
DHCP (Dynamic Host Configuration Protocol) server: A network service, often built into your router, that automatically assigns temporary IP addresses to devices joining your local network. An IP address assigned via DHCP is considered 'dynamic'.
DIVA (or Diva Distro): A specific, convenient pre-packaged distribution of OpenSimulator created by Diva Canto (Crista Lopes). It often includes multiple regions pre-configured (e.g., a 4-region 'standalone') and may include a web interface, aiming for easier initial setup. Always consult its specific documentation (usually in a /DOC folder).
DNS (Domain Name System) Name: Since humans prefer names over long numbers, DNS acts as the internet's distributed directory service, translating human-readable domain names (like www.osgrid.org) into the numerical IP addresses computers use to locate servers.
Estate: An administrative grouping of one or more regions within OpenSimulator. Allows designated 'Estate Managers' or the 'Estate Owner' specific permissions to manage settings (e.g., region restarts, covenants, access controls, terrain textures) across all regions within that estate. Configuration is handled at the simulator level.
Firewall: Software or hardware acting as a security gatekeeper for network traffic. It inspects data packets and blocks or allows them based on defined security rules, preventing unauthorized access. You typically need to configure your firewall to allow incoming connections on the ports OpenSimulator uses.
Gateway (Default Gateway): The IP address of the device on your local network (usually your router) that acts as the exit point, forwarding traffic destined for the external internet.
Grid: A network of interconnected OpenSimulator simulators (each hosting one or more regions) that usually share central services (like user accounts, assets, inventory) via common databases. OSgrid is a large, public grid. This contrasts with 'Standalone' mode.
Grid Administrator: A user with administrative privileges specifically on the central grid servers responsible for managing grid-wide services (user accounts, central asset/inventory databases, grid map registration, overall grid policy). Importantly, Grid Admins typically have no administrative access or special permissions on the individually hosted simulators/regions connected to the grid.
Host: An individual or entity operating an OpenSimulator server instance, thus 'hosting' regions. In networking terms, any device connected to the network can be called a host.
Instance: A single, running process of the OpenSimulator server software (e.g., OpenSim.exe). One instance is typically contained within its own installation directory and can host one or potentially many regions.
IP address (Internal/External) (Static/Dynamic): Every device connected directly to the internet needs a unique public (External) IP address. Your Internet Service Provider (ISP) usually assigns one to your router. This public IP can be Static (fixed, unchanging) or Dynamic (assigned via DHCP from the ISP and may change over time, e.g., when your router reboots). Your router uses NAT to assign private (Internal) IP addresses (typically in ranges like 192.168.x.x, 10.x.x.x, or 172.16.x.x) to devices within your local home network. Correctly configuring OpenSimulator requires knowing both your internal server IP and your external public IP, and understanding if the public IP is static or dynamic (dynamic IPs require Dynamic DNS services for reliable hosting).
Map: The visual representation of the grid, showing the location and names of registered regions. Also, historically, a tool for navigation.
Mega Region: An older, often problematic method used to make multiple adjacent regions within a single simulator instance behave like one large region without borders. This approach is generally deprecated; VAR Regions are the preferred modern solution.
Modem: A device that MOdulates/DEModulates signals to enable data transmission over a specific communication line (e.g., cable, DSL). Unlike routers, basic modems usually don't perform IP routing or NAT. Routers often incorporate modem functionality.
Module: A distinct software component or plugin that adds specific features or capabilities to the core OpenSimulator server. Examples include modules for voice communication (Vivox, Freeswitch, Murmur/Whisper), different physics engines (BulletSim, ubODE), or optional grid services. Modules are often enabled/disabled and configured in .ini files.
MySQL / MariaDB: Powerful open-source relational database management systems. MariaDB is a popular community-developed fork of MySQL. These are often recommended over SQLite for hosting multiple regions or grids expecting higher load, due to better performance, scalability, and features. They require separate installation and configuration.
NAT (Network Address Translation): The process, typically handled by your router, of mapping multiple private internal IP addresses (used only within your local network) to your single public IP address (used for communication on the internet). This allows multiple devices in your home to share one internet connection.
NAT loopback: A router capability allowing devices on the local network to connect to a local server using the network's public IP address. If a router lacks NAT loopback, attempts from within the local network to connect to a local server via its public IP address might fail (even if external connections work fine), because the router doesn't correctly "loop back" the request internally.
NAT loopback Adapter: A virtual network adapter configured on a Windows system as a software workaround for routers lacking NAT loopback. It intercepts traffic destined for the machine's own public IP address and redirects it locally (to 127.0.0.1), allowing viewer-server communication on the same machine using the public IP setting required for grid registration. This workaround does not enable other devices on the local network to connect via the public IP.
NPC (Non-Player Character): An avatar within the virtual world that is controlled by software (scripts or external programs) rather than a human user. Also commonly called a "Bot." NPCs can range from simple scripted agents to complex AI entities.
.NET (formerly .NET Framework / .NET Core): The software development framework from Microsoft that OpenSimulator is built upon using the C# language. Running OpenSimulator requires the appropriate version of the .NET runtime to be installed on the server machine (Windows, Linux, or macOS). Recent OpenSimulator versions typically require modern .NET runtimes like .NET 6 or .NET 8.
OpenSimulator: The core open-source server software platform used for creating and running 3D multi-user virtual worlds and grids.
OSgrid: The oldest and one of the largest public grids utilizing the OpenSimulator platform. It primarily functions as the official test grid for the latest development versions of OpenSimulator, providing essential large-scale testing and feedback.
OSI model (Open Systems Interconnection): A conceptual model that standardizes network functions into seven logical layers (Physical, Data Link, Network, Transport, Session, Presentation, Application). Useful for understanding network theory and troubleshooting complex issues, not required knowledge for basic OpenSim operation. It does provide a good "base" for understanding how things work. Warriors of the net OSI Demystified .
Parcel: A defined subdivision of land within a region. Parcels can be owned by different users or groups than the region owner and have their own specific settings (name, description, build/script permissions, access lists, media URL, etc.). Minimum size is typically 16sqm (4x4m).
Physics engine: The OpenSimulator module responsible for simulating physical laws like gravity, collisions, friction, and vehicle movement. Different engines (e.g., BulletSim, ubODE) can be chosen via configuration, offering varying performance and realism trade-offs.
Plaza: An OSgrid-specific term for regions owned and operated directly by OSgrid, Inc. on their central servers. These serve specific community functions (LBSA for socializing, Wright for shopping, Hurliman for meetings, Recreation for events, Zaius/Seaprior/Teravus for residential plots). Users hosting their own regions are asked not to include "Plaza" in the region name.
Port (Network Port): A numerical identifier (0-65535) used to distinguish specific services or communication endpoints on a computer within a network. OpenSimulator typically uses UDP port 9000 by default for region communication, but this is configurable. Firewalls and routers need to have the correct TCP and UDP ports opened and forwarded to allow connections.
Port forwarding : A router configuration rule that directs incoming network traffic arriving at the router's public IP on a specific external port number to a specific internal IP address and port number of a device (like your server) on the local network. Essential for allowing external users to reach your hosted region.
RAM (Random Access Memory): The computer's fast, volatile memory used for active data processing by the CPU. More RAM allows OpenSimulator to handle larger regions, more scripts, and more concurrent avatars effectively.
Region : The fundamental unit of space in OpenSimulator, usually visualized as a square island on the map. Standard size is 256x256 meters, but VAR regions can be larger. Each region is managed by a Simulator process. Also called "sims."
Region Overlap : An error condition preventing simulator startup, occurring when the defined coordinates and size of a region you are trying to register on the grid map conflict with the space occupied by an existing, already registered region. Check the grid map (e.g., https://www.osgrid.org/?q=node/17) for available coordinates. Note that map displays might not always accurately show the full extent of large VAR regions.
Router : A device connecting different networks (like your home LAN to the internet WAN) and directing traffic between them using routing tables. Typically performs NAT, DHCP, and firewall functions in home setups. Must be configured correctly (port forwarding, firewall rules) for hosting.
Script : A program, usually written in LSL (Linden Scripting Language) or its OpenSimulator extension OSSL, embedded within an in-world object to make it interactive or autonomous (e.g., move, change appearance, respond to touch/chat, communicate with external web services).
Simulator : See Console. The running OpenSimulator server software instance that hosts and simulates one or more regions.
SQLite (often spelled SQL-lite): A lightweight, serverless, file-based database engine. Often used as the default database for simple standalone OpenSimulator setups or in distribution packages like OSgrid's default download. Generally less suited for high-performance or multi-region setups compared to MySQL/MariaDB.
Standalone : An OpenSimulator configuration where a single instance manages its own regions, users, assets, and inventory locally, without connecting to central grid services. Can optionally enable Hypergrid connections to other grids/standalones.
Thread (of execution): The smallest unit of processing that can be scheduled by an operating system. OpenSimulator uses multiple threads within its process to handle different tasks concurrently, such as network communication, physics simulation, and script execution.
UUID (Universally Unique Identifier): A 128-bit number generated using algorithms designed to ensure practical uniqueness across all systems worldwide. Used extensively in OpenSimulator to identify every unique entity: avatars, objects (prims), inventory items (textures, scripts, sounds, etc.), regions, parcels, groups.
VAR Region : A region configured with a Variable Area Region size, meaning it can be larger than the standard 256x256 meters (e.g., 512x512, 1024x1024) while still being managed as a single region within one simulator instance, providing a seamless, borderless larger landmass. The preferred method over the older Mega Region approach.
Viewer : The client software (e.g., Firestorm, Alchemy) installed on a user's computer to connect to and interact with OpenSimulator or Second Life virtual worlds. It renders the 3D scene, handles user input, and communicates with the simulator server. See https://www.osgrid.org/login_viewers.php for compatible options.
Virus scanner : Security software designed to detect and remove malware from computer systems.
Wireless : Using radio waves (like Wi-Fi) for network connections instead of physical cables (Ethernet). While convenient, wired connections generally offer lower latency and more stable performance, which is preferable for hosting servers.
OSgrid is a grid that runs on the OpenSimulator engine, specifically the very latest development version. When a new version is released by the OpenSimulator developers, OSgrid typically installs it for large-scale testing before any other grid. We test the OpenSimulator engine, so the latest bugfixes, features, modules, and updates are usually packed into the OSgrid download available on our site. You can download this software and run your own server (simulator) on your own PC. The software is modular, allowing you to choose different components (like physics engines or databases) to suit your needs, although the pre-configured default settings are suitable for most users connecting to OSgrid.
- < NEXT>
