Projects

OpenSimulator

OpenSimulator is a Second Life-compatible open source region simulator. Its companion project, OpenGridServices, provides the infrastructure for setting up a grid of simulators.

OpenMetaverse

The OpenMetaverse project is a collection of building blocks to construct the next generation of virtual world platforms on. Born out of the libsecondlife project, it contains a reimplementation of the Linden Lab Second Life protocol, and will host future metaverse implementations and enhancements as well as examples and documentation.

OpenViewer

OpenViewer is a Second Life-compatible virtual world client.

METAbolt

METAbolt is like a "messenger type application" with lots of built in virtual world features so that one cannot only carry out communications but also be able to perform most of the important tasks required in a virtual world. METAbolt is light weight and cross grid. With a single ... [More] click, it is possible to run multiple instances. METAbolt is primarily developed for Second Life but it can also be used on any grid based on OpenSIM. [Less]

Radegast

Radegast is a light weight client for connecting to Second Life and Open Simulator virtual worlds.

devobot

DevoBot provides a base framework for writing SecondLife bots that are controlled via commands sent through instant messages. The main goal is to allow extremely rapid development by providing the ability to modify source code without having to recompile or even relog the bot account. SupportIf ... [More] you have a legitimate bug or patch then by all means use the issue tracker but otherwise please do not request assistance here for issues specific to libomv or for IronPython help as there's already a wealth of information available for these online. Here are some starting points: libomv ironpython.info InstallationNote: Mono users will require at least mono 2.4.x Check out the source code Rename config.py.example to config.py Edit config.py and set the owner and login variables Run run.py with IronPython Adding CommandsSimply add function definitions inside commands.py - these functions only have two requirements. Firstly they must be prefixed with the @bot.Command decorator and secondly they must have two required arguments, client and msg eg: @bot.Command() def my_command(client, msg): # do somethingThe @bot.Command decorator simply identifies the function as a command. This allows you to have other functions and variables inside commands.py that aren't accessible as commands. By default a command is only available to the owner specified in config.py - to make a command publicly accessible add the public keyword argument to the @bot.Command decorator, eg: @bot.Command(public=True) def my_command(client, msg): # do somethingThe types for the two required arguments for a command function are respectively the OpenMetaverse.GridClient object that represents the current bot and the OpenMetaverse.InstantMessage object that represents the instant message used to trigger the command. To trigger a command simply send the bot an instant message with the command name, prefixed with "~", so in order to trigger the quit command you'd send an instant message saying ~quit Adding EventsThere are two ways to specify event handlers. The first is similar to the approach for adding commands whereby event handlers are simply defined inside events.py as functions. To define an event handler simply name the function the same as its event in OpenMetaverse, providing the same list of parameters for the relevant event handler in OpenMetaverse along with an extra initial parameter representing the OpenMetaverse.GridClient object. You must also use the @bot.Event decorator to identify the function as an event handler, eg: @bot.Event() def OnChat(client, msg, audible, type, source, name, id, owner, pos): """print chat""" print "[%s/chat] %s: %s" % (client.Self.Name, name, msg)The second way for defining event handlers is to explicitly assign them inside your own code. To assist in applying many modifications to a bot while it is still logged in, a method is provided for specifically setting a master event handler for each event rather than having to deal with adding and removing multiple event handlers per event. To set a master event handler for a particular event, simply set the handler on bot.events eg: import bot # define a command that creates and sets a master event handler @bot.Command() def set_chat_handler(client, msg): def print_chat(client, msg, lvl, type, src_type, from_name, id, owner_id, pos): """print chat""" print "[%s/chat] %s: %s" % (client.Self.Name, name, msg) bot.events.OnChat = print_chatNote that you must still provide the extra initial parameter representing the OpenMetaverse.GridClient object however in this case it's unnecessary to use the @bot.Event decorator since you're explicitly defining the event handler. The key idea here is that you can modify and run the print_chat function over and over as many times as you like and the OnChat event will only ever be triggered once each time. You can still add event handlers in the traditional way libopenmv intends you to however you may find less than desirable results by doing so with a bot that can be modified while it's running. OnInstantMessageThe OnInstantMessage event is treated specially and unavailable for use within the approaches described above for event handlers. This is not due to the handling of commands as described above but due to the large number of concerns that seem to pass through it. Basically the OnInstantMessage event is broken down into a separate event for each type of InstantMessageDialog so using the approaches described above for event handlers you can add specific handlers for things like OnGroupInvitation and OnInventoryOffered. If you need to handle instant messages that aren't valid commands, simply define a command called default inside commands.py which will be called when an instant message is received and a command is not triggered. Scripting BotsViewing the source of run.py shows that it simply performs an import of the bot module, performs a login on all the credentials provided in config.py and then listens for commands typed in the console. This provides a starting point for scripting your own bots. [Less]

slcl

The SLCL will provide an interface library for SecondLifetm with the following goals for developers using the library: Do not have to worry about what specific packets are being created or received Should provide facilities to automatically track items of interest including Parcels, Objects/Prims ... [More] , Avatars, Inventory. All exposed objects will be representational of what the item is, and not solely based on their underlying packet representation All publicly exposed interfaces should use terminology familiar to end-users (players) and not specifically the terminology used within the protocol/message template. It should be noted that this library is not intended to compete with the libsecondlife project, but rather complement it. We fully expect code to be ported between these projects on a regular basis. This project's aim is to simply take the libsecondlife library and tailor specifically to provide a high level abstracted client access to SecondLifetm. Those needing to be 'closer' to the network level should consider making use of libsecondlife directly. [Less]

ghettosl

This program utilizes libopenmetaverse (formerly libsecondlife) for connecting to and performing several basic functions in SecondLife. Please note that this program has not been maintained for some time and may not be considered stable in its present state, although attempts have been made to keep it working with the latest version of libomv.

inventoryviewer

This project uses libOpenMetaverse (formerly libsecondlife) to provide a simple graphical interface for viewing your Second Life inventory.

stickychat

StickyChat is an SLProxy application for Second Life. It initially started out as a small application aimed at making certain attributes of chat 'Sticky', such as Whisper, Shout, and even talking on other channels (and echoing what you say on silent channels back to you so you know what you ... [More] said). By 'Sticky', I mean that the default chat is modified to have different attributes and these attributes stick so long as the features are enabled, basically auto-whisper/shout and such. It has since evolved to incorporate plugins with much more functionality. Plugins:Filters:Filter various things, such as typing sounds/anims, screenshot sounds/anims, insta-sit (sit immediately instead of trying to find your way to seat), automatically accept/decline teleports, inventory, friendship offers. Translate:Translate incoming and outgoing chat. Translation of IM's not yet implemented. Friends:Quick implementation to allow for fooling your client to think all your friends are online (so you can offer them teleports easily and what not), fooling your client to think all your friends are offline, and querying SL about all your friends to fix all their statuses. Future plans here are to monitor your friends list, so you can know when people remove you. [Less]