Jump to content

Tutorial01: Difference between revisions

From OSgrid Wiki
← Older edit
No edit summary
No edit summary
 
(4 intermediate revisions by the same user not shown)
Line 1: Line 1:
What is OpenSimulator?
What is OpenSimulator?


OpenSimulator is an open source multi-platform, multi-user 3D application server. It can be used to create a virtual environment (or world) which can be accessed through a variety of clients, on multiple protocols.
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 has an optional facility (the Hypergrid) to allow users to visit other OpenSimulator installations across the web from their 'home' OpenSimulator installation.  


OpenSimulator allows virtual world developers to customize their worlds using the technologies they feel work best - the framework is designed to be easily extensible.  
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 is written in C#, running both on Windows over the .NET Framework and on Unix-like machines over the Mono framework. The source code is released under a BSD License,
OpenSimulator empowers virtual world developers to customize their worlds using the technologies they feel work best – the framework is designed for easy extensibility.  
a commercially friendly license to embed OpenSimulator in products. If you want to know about the development history, see History on the opensim wiki. You find their documentation here: http://opensimulator.org/wiki/User_Documentation.  


Out of the box, OpenSimulator can be used to simulate virtual environments similar to Second Life™, given that it supports the core of SL's messaging protocol.  
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.
As such, these virtual worlds can be accessed with the regular SL viewers. However, OpenSimulator does not aim to become a clone of the Second Life server platform.  
For details on its development history, see the History page on the OpenSimulator wiki.
Rather, the project aims to enable innovative feature development for virtual environments and the Metaverse at large.  
The official user documentation is available here: http://opensimulator.org/wiki/User_Documentation


'''Before you can start running your own regions, it is rather handy if you know all the terms and names of the protocols, the software, and have a grasp of what something exactly means. This prevents you from getting real frustrated.  Also what worked for others, might not work for you.  Please find the list of “scary words” below, with a short simple explanation / definition of what it means and can do for you. It’s basic, not very in depth, so also the “less technical” has an idea of what’s meant. You need to however have the basic understanding of these concepts to be able to “operate” a server.  
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.


Do i need a powerful machine to run a region on OSgrid ?
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.


No, the machine you work on now, will likely be capable of hosting a region. A region needs 1 GB of free RAM and 1 CPU core to comfortably run. More is better however, and whilst it will work on less, performance is according.
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?'''


'''Goals for this class''' :
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.


  ♦ Get a basic understanding of the names & abbreviations of all the terms, services and  protocols used running a simulator.
'''Goals for this class''':
  ♦ Understanding what these things do, and why you need them.
  ♦ How is OSgrid setup, and how do you and your simulators fit in that picture
  ♦ Understanding Basic networking.
A lot of the things discussed below are very “broad” and will take at least a year of study to learn all ins and outs, so we keep it basic, and within the scope of our class. If we tell you, you’ll need a IP address, please assume you do. Can always ask questions later. First get the global picture, learn to drive. You can always grow to be a racer or even become a mechanic later.


'''Administrator''' : A user with elevated permissions. ( allowed to do anything on a machine, including installing and starting servers etc. ) .   
  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.


'''Cache''' :  Cache, stores recently used information so that it can be quickly accessed at a later time. Computers incorporate several different types of caching in order to run more efficiently, thereby improving performance. Common types of caches include browser cache, disk cache, memory cache, and processor cache. Also our viewers have a viewer cache.


'''Console''' : Also called Simulator, instance or Shell. It is the “Dos-like” black box screen /shell with the command prompt that appears when you start “OpenSim.exe”. That physically “is” the simulator software. It is the server on which the regions run.  
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').


'''Coordinates''' : This is the x,y designation that determines a region's position within the grid. see https://www.osgrid.org/map.php
'''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.


'''CPU''' : Central processing unit. The unit that calculates all the instructions of your computer. The more “cores” it has available, the faster it can calculate. The data processed by a CPU generally comes from the hard drive, is loaded into the RAM, and queued for processing.  Big processes are cached on the hard drive, whilst the CPU processes the current active data in the RAM memory.  
'''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''' : Computer transactions in which the server fulfills a request made by a client are very common and the client/server model has become one of the central ideas of network computing. Your pc runs a client. In our case it is a viewer. We use it to visit regions, which reside on OpenSimulator software. We call those the servers. A server can typically “serve’ multiple clients simultaneously. (There are also other models, like p2p (peer to peer) in which there are only clients communicating to each other).  
'''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).


'''Database''' : OpenSimulator stores all its data in a Database. This can be SQL-lite (Used by default in OSgrid) or a MySQL, PostGres, or other database program.
'''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).


'''DNS name''' : Since we humans are bad with numbers, we give our IP addresses Names, so they are easier to remember. The internet “phonebook” for translating IP addresses to names is called DNS ( Domain Name System).  
'''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


'''DHCP server''' : Server that dynamically assigns IP addresses to computers that do not have a static IP address. ( A DHCP assigned address is thus “dynamic”).  
'''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.


'''DIVA''' : A very convenient distribution of a 4 region standalone grid, which includes a pre-configured web-interface. Read the /DOC folder ! This is outside the scope of our classes for now.  
'''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''' : Magical organism that uses nicotine and caffeine to produce “code”. These guys & girls “program” OpenSimulator. It’s the crème de la crème of the “nerds”, and your existence in the grid is solitary due and thanks to them. ( Some blame them for anything they can…). However, without developers, no grid. So be nice when you meet one. They deserve it.  
'''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.


'''Estate''' : Hosts can use estates to “group” simulators and grant specific permissions to Estate owners. Estates are controlled on a simulator level.  
'''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'.


'''Firewall''' : hard or software that denies & blocks connections from outside your network to enter your computer. ( Unless you make “access rules”  to allow the traffic / program ).  
'''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).


'''Gateway''' : The Gateway for your network is the address of the device that sends your traffic to  the internet. Typically this is a modem or router, directly connected to the ISP. Any router supports basic NAT. That’s what makes it a router. Routers without NAT are called Modems.  
'''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.


'''Grid''' : A network of OpenSimulator interconnected regions. This can be setup with the OpenSimulator software. A grid has a different architecture than a standalone, or “grid connected” region. A Grid is a community or network of individual simulators using some form of shared database for one or all of its grid services. So it’s a collection of independent OpenSim Instances, Simulators, Sims, Regions, or Megaregions sharing a database or databases which handle assets and inventory for grid members.
'''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.


'''Grid Administrator''' : A user with elevated permissions on the Grid servers. Mind that grid admins have no permissions or special abilities on “your” server. Despite it being connected to the grid, a Grid Admin cannot get elevated permissions on your local server.  
'''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.


'''Host''' : Someone running a Server instance. ( He “hosts” servers / regions in a machine in his/her network. Also, within a network environment any computer or device connected to that network can be referred to a host or client. ( see client / server model ).
'''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.


'''Instance''' : One example of OpenSim running, on a server or PC, in whatever form as outlined below. Usually, but not always, contained inside a single directory on your computer.
'''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.


'''IP address''' : ( Internal / External ) ( Static / Dynamic ) : Your router has 1 unique public IP address (imagine the internet working like the mail, with unique addresses). The router can translate this to multiple “internal” ip addresses. This is why you have to make port forward’s for the simulator (server) software to work.  These IP addresses can be “ static” ( ie always the same) or Dynamic ( you possibly get a new one every time you restart).  
'''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.


'''UUID''' : Universally Unique Identifier. This is a number which is unique in the world. Such numbers are used to store your assets, region names and much more data, of which only 1 can exist. (since its made out of a partial date-timestamp, it can be unique).  
'''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.


'''NPC''' : Non player character. IE a “Bot”. These vary, from simple scripted avatars, to very advanced software controlled ones, running artificial intelligence.  
'''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.


'''OpenSimulator''' : The software used to build grids. It’s a program with a whole lot of modules, which can be switched on / off and configured by editing their .ini files.  
'''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).


'''Simulator''' : See “console”. A simulator is the software that you can install the regions on. The programs forming the Simulator are the contents of your BIN folder. It is One instance of OpenSimulator, running anywhere from one region to hundreds.
'''Map''':
The visual representation of the grid, showing the location and names of registered regions. Also, historically, a tool for navigation.


'''Standalone''' : A machine with a simulator on local assets, that is not connected to any grid.  
'''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.


'''OSgrid''' : The test grid for OpenSimulator. OSgrid runs the very latest “cutting edge” releases issued by the developers of OpenSimulator. It’s large user base provides feedback for improvement, bug tracking etc.  
'''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.


'''Parcel''' : An area of land owned by a single user or group, which is at least 16m² and at maximum the entire region, all within one region.
'''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.


'''Plaza''' : All regions maintained by and running on servers of OSgrid are called Plaza. It’s why one of the very few rules for naming regions is kindly not to use Plaza….
'''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.


'''Port''': Programs connect via the internet through ports. 80 is used for internet traffic, 25 for mail, 21 for FTP, etc. Ports 1-1024 are reserved. (Don’t use these, as that might fuck up things severely). OSgrid uses 9000 by default. There are TCP and UDP ports. Simulators run on TCP, and regions use an UDP port to send traffic.
'''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.


'''Port forwarding''' : Tells a router that if traffic comes in on a certain port, it needs to be sent to a certain internal IP address. ( So if you run a region on port 9000, we need to tell the router that any traffic coming in on the public IP address with port 9000, needs to be sent to your PC, which is running the OSgrid software).  You can “map” 65536 TCP and 65536 UDP ports on 1 single IP address.  Mind a port can only be used once per IP public address.  A program generally can run on any port you assign to it.  
'''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.


'''Physics engine''': Determines what physics system is used. (impacts things like gravity etc).  
'''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.


'''RAM''' : The memory of your computer. ( not to be mistaken with your hard drive, that stores data). The more Ram you have the more prims, scripts, and visitors you can stuff into your regions.  
'''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.


'''Script''' : A mini-program that can communicate with the OpenSim software, making an in-world object “do” things. (Make it spin, change color, move, or whatever).
'''.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.


'''Thread''' : In computer science, a thread of execution is the smallest sequence of programmed instructions that can be managed independently by a scheduler, which is typically a part of the operating system. The implementation of threads and processes differs between operating systems, but in most cases a thread is a component of a process. Multiple threads can exist within one process, executing concurrently (one starting before others finish) and share resources such as memory, while different processes do not share these resources. In particular, the threads of a process share its instructions (executable code) and its context (the values of its variables at any given time).
'''OpenSimulator''':
The core open-source server software platform used for creating and running 3D multi-user virtual worlds and grids.


'''Region''' : Part of a Simulator, the main unit of a sim. Currently 256 x 256 meters, but other sizes are possible, which will make it a VAR Region. Some people refer to regions as Islands. (as that’s how they appear on the map).  
'''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.


'''Router''' : Networking device that translates 1 or more public IP addresses to internal IP addresses by maintaining a “Routing Table” and a “Connections cache”. This translating of IP addresses Is called NAT. You have to tell it where traffic needs to be sent to ( by making “port forward’s” ).
'''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. [https://www.youtube.com/watch?v=PBWhzz_Gn10 Warriors of the net] [https://www.youtube.com/watch?v=HEEnLZV2wGI OSI Demystified] .  


'''Region Overlap''' : This occurs (and gives an error / crash at startup) when you have chosen coordinates that are in use or your intended region size overlaps with an already existing region. Please use the grid map at https://www.osgrid.org/?q=node/17 to find coordinates that are open and have room for your region(s). Mind that VAR regions are not displayed properly, so if you get an error, try different coordinates.  
'''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).
'''NAT''' : Network Address Translation. The translating of a public IP address (range) to an internal address range. Internal ranges are defined to always use  192.168.x.x 10.x.x.x or 172.16.x.x as ranges. Meaning if your IP starts with any other number, it  is a public “no-nat” address.


'''NAT loopback''' : A router / network expects you to use public addresses for connecting to servers outside your network. However, if a server is in your “own” local network, traffic has to be sent out the gateway, and “looped back in”, as the destination for the server is inside your network. Some routers do not have this feature. They would expect you to use an internal address, when the destination is in the same network as you are. This generates a problem where anyone can login to the sim, apart from the people in the same network that’s “running it”.   (needs diagram)
'''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.


'''NAT loopback Adapter''' : Tricks the PC by making the network adapter send any traffic destined for its own public address to “localhost”. This enables a user to install a viewer and server on 1 machine, and still visit his region, despite having no loopback in the router. (the traffic never actually gets sent to the router/gateway). No other machines from within the same network will be able to access it though.  This is because the packets need to come in via the router, and also for them, loopback fails.
'''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.


'''.NET Framework''' : NET is a developer platform made up of tools, programming languages, and libraries for building many different types of applications. There are various implementations of .NET. Each implementation allows .NET code to execute in different places—Linux, macOS, Windows, iOS, Android, and many more. Current opensim versions require .NET 6 and .NET 8 to operate.  
'''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.


'''Map''' : Tool used since the stone age to find routes, empty space, or places….
'''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.


'''Modem''' : device that MODulates and DEModulates traffic. This does not NAT. It just switches the bits & bytes into transmissible network packets on a medium, typically a wire.  
'''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.


'''Module''' : Piece of software that “Controls” a function. Vivox for instance is a module which can be enabled to have voice on your region. Its optional. It are extensions or plugins that expand possibilities on the default configuration.  
'''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."


'''Mega  Region''' : a group of contiguous regions in one instance of OpenSim without any restraints caused by borders. In effect, a group of anywhere from 2 to hundreds of regions configured to act as one single region. This used to be a “Hack”(and buggy), so we prefer you to use a VAR instead.
'''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.
'''VAR Region''' : Part of a Simulator, the main unit of a sim, but with “Variable Size”. You can create regions bigger than 256x256, without borders, as long as you choose coordinates that allow for the area you need. Such a “big sim” is called a VAR Region. Do not mistake a VAR with a Mega region !


'''Virus scanner''' : Detects and prevents malicious code from entering your computer. (even if the firewall allows the traffic).  
'''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.


'''Wireless''' : Transmitting your bits and bytes through ether ( thin air ) rather than wire. We prefer the latter wherever possible.  
'''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).


'''Viewer''' : Browser for 3d worlds. There are many different ones. Some more stable and less “buggy” than others. Some of the popular OpenSim compatible viewers are available here: https://www.osgrid.org/login_viewers.php
'''Simulator''' : See '''Console'''. The running OpenSimulator server software instance that hosts and simulates one or more regions.
Notice. If you use Lumiya (mobile viewer) use this login URL instead of the standard one:  http://lumiya.osgrid.org:80/


'''OSI model''' : The OSI model (open systems interconnection) is a reference model for how applications  can communicate over a network. (It for instance explains how linux and windows can talk to each other).  This is not something you need to know by heart to run an OpenSimulator server, but it helps you understand how the internet “works”, and knowing it by heart is helpful in identifying where technical problems exist.  
'''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.


https://www.youtube.com/watch?v=HEEnLZV2wGI OSI Demystified
'''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.


https://www.youtube.com/watch?v=PBWhzz_Gn10  Networking general.
'''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.


Now Osgrid is a grid that runs on the opensimulator engine. The very latest version of it. When a new version is released by the developers, OSgrid will install it into operational levels before any other grid. We test the opensimulator engine. So the latest bugfixes, features, modules, updates all are packed in the OSgrid download. You can download this, and run your own server (simulator). It is just software you can download and install, so you can run a simulator on your own pc. The software is 'modulair' meaning you can choose from different components to run your simulator. The pre-configured default is good for most people, but you can for example consider running a different physics engine, or more powerful database for your regions, depending on your needs.
'''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''' :
*- [[Tutorial02|< NEXT>]]
A region configured with a '''V'''ariable '''A'''rea '''R'''egion 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.
 
--------------
- [[Tutorial02|< NEXT>]]
--------------

Latest revision as of 10:04, 21 April 2025

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>

Retrieved from "http://wiki.osgrid.org/index.php?title=Tutorial01&oldid=1035"