Every now and then, this hits me. I fire up OpenSim (or RealXtend), and it crashes instantly with a “BadImageFormatException” - when you see this, you know you have a compatibility problem with an embedded C/C++ binary. In english, 90% of the time this means you are running under a 64-bit environment with a mix of 64 and 32bit code trying to run together.

OpenSim is 64-bit aware

The reason for this happening is that OpenSim by virtue of the .NET platform is quite 64-bit aware, this means natively it can address 16TB of memory just fine if run on a 64-bit operating system. (nb, under Mono you need to make sure Mono is 64bit to get the same benefits).

However unfortunately, some of the libraries we link against have to be compiled ‘one way’ or the ‘other way’ and not both.  When running a 64-bit application, things such as memory pointer lengths are difference, so there is no way to cleanly pass data between a 32-bit and 64bit application - everything must be one or the other.

So how do you fix this?

There’s two routes, the easy route, and the proper route. The easy route is good for 90% of our users - if you dont need to access more than 4GB of memory and dont mind about the slight slowdown when handling double precision numbers, then just run 32-bit.

How? Instead of launching OpenSim.exe launch OpenSim.32BitLaunch.exe instead - this forces OpenSim to run under a 32bit environment (under windows provided by WoW32).

The more detailed fix

The next option is to strip out the sections that are causing problems. OpenSim is modular - so you can swap bits and pieces with their alternatives. The following are components that are not 64-bit compatible by default (however it is possible to fix this, something I will get to in a moment.)

Incompatible Components List

Physics - most problems come from our Physics Engines, since these tend to be written in high performance C/C++ with ASM littered. The following list of physics engines by default are NOT 64-bit compatible.

• OpenDynamicsEngine - The ODE DLL we provide is compiled for a 32bit operating system, however you can fetch the sources for our custom ODE DLL from (SVN) http://opensimulator.org/svn/opensim-libs/ and build it yourself on your native environment.
• AGEIA PhysX - The AGEIA PhysX support (now Nvidia PhysX) relies on a natively compiled 32-bit DLL. At present there is no fix here.

Compatible Engines

• BasicPhysics - This is purely managed but very simple in operation. Collisions are provided only between the avatar and the ground here. This runs without problems regardless of environment
• POSPhysics - POS physics is a more complicated BasicPhysics engine with bounding box collisions between objects. For some tasks this is sufficient.
• BulletX - Our own custom BulletX library is derived from the BulletXNA project, this is a properly developed fully managed physics engine that does proper collisions (however the friction coefficient can be a little low for some users).

Storage Engines - At least one of our storage engines relies on some hard coded components, it’s listed below

• SQLite - Whaaa? SQLite is broken on 64-bit environments? Afraid it’s true. Unfortunately on Windows systems the only solution is to recompile the entire of Mono (including Mono.SQLite.dll) yourself under a 64-bit flag.

Compatible Engines

• MySQL - The DotNetConnector provided by MySQL is 100% compatible and probably the recommended adapter for production installs.
• MSSQL - Windows-only however MSSQL is also free and the adapter is built into .NET itself so is pretty much guarunteed compatible.

Other incompatible components

Perenially we have problems with the following components in addition to the above, this includes libsecondlife’s OpenJPEG version - this can be fixed by compiling libsecondlife and OpenJpeg (using make) on the target system. This may have been fixed recently however as complaints about this DLL have lessened sharply.

Running

Once you have swapped incompatible components out, or recompiled them appropriately, OpenSim should run under a 64-bit environment natively on Windows. As mentioned above, under Linux/Mono you will need to make sure that Mono has been compiled as a 64bit application for this to take effect.

The differences between the two are mostly marginal, however there are some definitve improvements in certain mathematical loops and stability when using large amounts of memory. In production environments, running 64-bit mode can be an attractive option, however will require constant maintainence to compile the above libraries as new releases occur.

So, I’m sitting here banging my head this morning over two issues. One, why the heck is terrain never deviating from zero height, and secondly why things werent looking quite right - as you could see in the previous posts it was clearly rendering prims but things were ‘missing’ or not quite right. Turns out the answer was both.

First, Terrain.

Yesterday I got the heightfield behaving properly, but couldnt understand why it was never being set when placed onto the live feed coming from the network stack. Answer turned out I was doing something stupid and had typo’d on a variable name for my indexer. Once that was fixed, we were rendering scenes like the one below.

It’s beggining to look a lot prettier, but as you may have noticed, the prims dont appear to line up in any recognisable pattern. While there is definetely a pattern there - something is very off.

Second, Objects - Part A.

Showing this one to Easy [Babcock] in the office, we quickly worked out that infact objects were never being rotated - every object had exactly the same identical zero rotation. After a few minutes debugging, this turns out to be related to the conversion from a Quaternion to a Euler rotation for WPF. Switching from Vector3 to Media.Quaternion internally solved the problem nicely.

Here’s a view of Abbotts aerodrome with the fix inplace.

Much better, although there’s still some clumps missing.

Second, Objects - Part B.

So, it’s looking like we’ve almost got this rendering correctly. At least object shape and rotation is being displayed correctly, although there’s still something lacking. It turns out that most of the bits missing corresponded nicely with camera view - so I’ve fixed this by telling libsl to ‘rove’ the camera position around the sim to download the entire thing. The above screenshot had this fix inplace.

This solved at least terrain loading completely and most objects.

Loading it up on OSGrid in Wright Plaza - everything seems to actually render properly now, at least so far as primitives go - we’re missing sculpties right now which form a large component of Wright Plaza’s design.

Second, Objects - Part C!? Huh?

Panning our Camera around a little, we notice something a little bit … odd. Namely that around 0,0,0 there’s a large congregation of primitives. I’ve been noticing this already and had discarded it as possibly being neighbouring sims in which case, I’ll just knock them out later.

But it turns out, there’s valuable prims being thrown there - it looks to me like maybe the child primitives in link sets having their “Position” being relative to the parent primitive rather than the sim (in OpenSim we have both .Position and .AbsolutePosition to seperate these).

So, I’m going to be working on that for the rest of this afternoon - after which I’m going to play with either texture rendering, or getting Meshmeriser to work so we can discard the dependency on the black-box GPL’d rendering library.

So, I’ve discovered XBAP. It’s a little secret technology that Microsoft developed as a way of running WPF applications in a browser, and I do have to say it’s very useful and handy.

An XBAP is a full blown application running on the .NET platform. It can access everything .NET can access within a security sandbox - including the Direct3D API. The sandbox is a little bit annoying but quite understandable - and most awesomely - it runs under Firefox fine, I’ve been using Firefox to debug.

Why not Silverlight?

When Silverlight was first released - I was quite intriguided. Not only do you get C# and a .NET environment, maybe we could do a version of OpenViewer running in Silverlight? We’ll after careful examination - Silverlight is capable of neither decent network access, nor any hardware 3D rendering capabilities. (I do have to question someone investing all this time in a “Flash Killer” and neglecting to add 3D capabilities. But I digress…). So the idea’s been dormant ever since I discovered this.

A few days ago, after my friend Tish Shute mentioned a MS developer talking about tighter integration between Direct3D and WPF the other day, I dug up in my head this thing I’d heard of once before called an XBAP - it’s basically a WPF Application, but hosted inside your browser, and in the last year since I checked it out, XBAP has improved a lot.

For one, it worked inside my Firefox browser painlessly without me apparently having to install anything (.NET had already put the appropriate plugins in place). It also just-so-happens to support hardware 3D rendering, direct network access (Hi libsecondlife libomv!), and a few other shiny things as long as the application sticks in it’s sandbox.

OpenViewer - meet Lively.

One of the things I really do dig about Google’s lively client is just how seamless it integrates in your browser. It’s not a full blown 3D world no, but I think Google got one thing right: Make it as easy to get instant gratification as humanely possible.

I think this is one lesson that the OpenViewer project might be able to take onboard - and XBAP might be an easy way to get there (at least for Windows clients)

The drawbacks (and there’s some reasonable ones)

Nothings perfect, and unfortunately this isn’t a perfect solution either. There’s some problems that wont be completely easy to solve, and some aren’t solvable in the current form.

First is the security sandbox - unless the user downloads and installs the WPF application (then hosts the installed copy) you get no local storage meaning no cache or access to the local harddisk (including uploads). Big catch.

Second big catch - it’s Windows only. Looks like Vista at that. While it may run on Firefox under Vista, this wont be a foolproof solution for Mac or Linux users, at the moment, Mono lacks a complete WPF implementation which means it might be a while before they get it (and even then it would be in standalone mode rather than in-browser)

Third catch - Performance doesn’t seem highly optimal when rendering complex 3D scenes. This one I think may come largely from the experiments I have been doing using a lot of brute-force methods, I expect this one to be somewhat capable of workarounds.

Toying as a viewer

Right now, I’m in the early early stages of getting a viewer up and running as an XBAP - text-only we can do no problems, getting 3D in adds a degree of complexity since we still cant use libprimrender due to LL licensing issues. I’ll be using the OpenSim Meshmeriser library instead here for the moment, although accurate rendering would be great.

I expect to post some screenshots in the next few days as I get this to a reasonable level - if you are lucky, I might even publish the XBAP file so you can play around with it. Source will be forthcoming after I’m happy enough with it.

It’ll go under a different name to OpenViewer - mainly because of the non-portable problem. I’m using the name internally XBAPViewer right now, but I’ll think of something better before it’s released.

Disclaimer: This is probably a bad idea in motion, I make no claims as to how well this could hold up in the long run or real world - I have some personal concerns about how Amazon is able to scale their S3 service effectively, and the recent downtime should give cause to think first before putting this into production.

If you want to be a cool geek these days, you absolutely have to insert the words ‘cloud computing’ into every other sentence. It’s no suprise then that one of the more adopted and interesting toys in the last year or two has been the Amazon Simple Storage Service (S3 for short).

It’s a “cloud” based storage solution, where you can upload files onto the cloud relatively cheaply. It’s being used in places Akamai used to be used for mirroring and proxying of frequently accessed files. (Even Linden Lab uses it for distrobuting their updates.)

The price is right, and the solution is fully programmable via a convenient web API, so it’s snuck itself into all sorts of places. What I’d like to experiment here is using it as a complete grid asset server, for those who havnt toyed much with the OpenSim asset server under the hood - it’s effectively a webserver with two supported operations: “PUT” and “GET” - funnily enough this overlaps nicely with any network accessible storage system, S3 included.

Building a new asset storage module from scratch

First thing we need to do is go hunting for another asset storage module in OpenSim so we can take a look at the interface we are required to implement. After a quick hunt for “asset_database” (the OpenSim.ini setting) it turns up that we need to create a class that derives from AssetServerBase which in turn derives from IAssetServer.

This looks relatively painless so far, we need to make a class which implements all five of these functions. The next step is to go take a look around and see if there is a decent .NET library for interfacing with S3. Turns out there is - .NET S3. (Post-authoring note: Apparently Amazon have an official library which looks easier to use, for one it doesn’t require the delegate hackery seen in the GetAsset function)

This library, while not fantastically documented does seem to do the job quickly and easily.

Implementing the asset client

Now we are at the point where we can actually write our class, using the above library, I’ve skipped ahead and written the class as presented below:

As you can see, the meat of the function sits in the StoreAsset and GetAsset functions, in this case we’ve overridden them to save to an EC2 Bucket (”directory”). We’ve made the directory a parameter of the constructor, as long as each region on the “grid” uses the same directory, they will act as one giant asset database.

Final Steps: Hooking it up

If we head back to OpenSimBase.cs where we first went looking for “m_assetStorage” originally, on line 412 we see:

Below this, let’s add a new statement

Now, if we change the ini setting to read “s3″ our brand spanking new S3 client should fire up.

In Conclusion

I need to make some notes here, first hard coding classes like the above is a bad idea. We shouldnt be doing it for the grid asset server (and instead should be loading a class via reflection). Second we shouldnt be hard-coding the login keys - moving that up to an ini setting is preffered (and not too difficult to do properly). Third this is a untested bit of code, use it at your own risk, this was done as an experiment in approximately 45 minutes.

However, for all the above warts - this shows off the power of OpenSim for rapid prototyping, one of the great features of OpenSim is just how flexible it can be, and how little work is needed to do something completely crazy with it quickly and relatively easily.

As a contributor and member of the body which is developing the Open Grid Protocol, I’m expected to keep up to date, read chat logs, mailing lists, attend meetings and otherwise spend a lot of my day looking at information, ideas and opinions coming from the various bodies surrounding the AWG.

You’d be surprised how much there is. There’s six reasonably important meetings a week I try read or attend, each produces potentially a 10,000 word transcript. Ignoring mailing lists, and other forms of discussion, that alone is a good healthy paperback each and every week, of course there’s at least now three active mailing lists on top of that and discussions on IRC, Group Chats and elsewhere.

It’s absolutely no suprise then when people get daunted when approaching this, there’s simply too much to keep track of without turning it into a fulltime job.

Signal to Noise Ratio

That is why I’d like to ask everyone who’s contributing, not to stop - but to try help keep the discussions focused. Most of these meetings have a defined spectrum of what is and isnt the topic of the day, and some forums are better than others for specific discussions. (No, I’m not just talking about Permissions here)

That’s not to say what’s being said isnt important - just that when the topic is the value of one specific serialisation format over another please only comment if you have something to say relating to serialisation formats, as mixing and matching topics all over the place is partly one of the reasons that keeping track of comments is so difficult - they are imbued everywhere.

So, here’s a bit of an overview of whats generally discussed where

The Weekly Meetings

• Mark (”Zero Linden”) office hours - The Tuesday office hours tend to be a fairly wide-topic discussion, with the agenda announced at least the week beforehand. You can see what’s going to be discussed on his wiki profile page. The Thursday morning ones tend to be very specific to individual technical items on the specifications themselves.
• OpenSim Office Hours (Tuesday, 1900 UTC, Wright Plaza on OSGrid) - These don’t concern the OGP protocols directly, however the topic of how to add OGP support is often championed here, and Linden Lab maintains a small but regular presence. This is more applicable if you are interested in the OpenSim side of OGP affairs.
• Which Linden office hours - These have recently shifted to people involved in the early beta of the OGP prototyping, SysAdmins and other individuals who will be directly running regions compatible with the OGP spec. If you are interested in being involved in this, this is the meeting to read and attend.
• AWGroupies - If it’s not in the above, the AWGroupies tend to be the best forum. Policy, direction and others are the kinds of discussions most appropriate here. While the other meetings tend to have a very strong technical influence (given it’s related to designing the languages that computers speak to each other with), the AWGroupies has a more social issues and ethics bias.

There’s also several others which are often worth reading and attending.

The Mailing Lists

• SLDev - This is generally focused towards the viewer itself and the features it supports, initially it started as a technical list, but over the course of the last year it has become a more broad spectrum forum open to a larger number of discussions on everything from intellectual property rights (something I have posted about with a suprising degree of frequency lately) to how to compile the viewer on Dead Badger Linux.

• OpenSim-Dev - This is geared towards the OpenSim developers, although topics do spring up here as to the best policies towards default systems, best practices on being a flexible framework that anyone can use. If you are interested in the nitty gritty behind OpenSim there’s a lot of good solid discussion going on here.

• Gridnauts - This is a new mailing list which complements Which’s office hours (listed above) for people who are in the beta and testing the initial region-crossing support on the Linden Beta grid.

At the moment there’s no policies mailing list - which might be something that someone should consider setting up as a legitimate forum for these discussions is clearly needed.

A plea to those involved

Please be relatively concise where possible - brevity always makes it easier to read your (and everyone elses) opinions.

Post your opinions in the right forum at the right time - suddenly changing the topic away while issues are still outstanding on the current topic is somewhat poor form.

Condensed transcripts and summaries help a lot - I personally would appreciate if someone would take up the mantle of providing a summary of each of the meetings above (and possibly mailing lists too) with links into the chat transcripts where appropriate.

I had a very interesting discussion with David Levine (SL: Zha Ewry) last night at the Metaverse Meetup, several luminaries were present, including Prokofy Neva, Tish Shute, and others. We had a varied discussion ranging from the possible future of Virtual Worlds to an informative discussion on the feasibility of copy protection in open standards and worlds.

Reuters has some interesting coverage over here, however I do feel the need to make some corrections on a few points made. While Eric has got lot of interesting points covered, some of them are a bit more nuanced than first appear and I’d like to cover a few of them.

In OpenSim, by default, no copy protection will exist at all. “You cannot know what a foreign piece of software will do with a piece of digital content once it receives it,” Levine said. To insert a digital rights management tool into OpenSim is to invite criminal hackers to find ways to circumvent it and undermine the credibility of the software, he argued.

This isn’t quite true - at least some of it anyway. While he’s spot on with David’s comment that you cant tell what a foreign system will do with a piece of data. OpenSim does support permissions by default - the nuance here is that permissions do not equal copy protection. Copy protection (also known as DRM) I’ve covered in more detail previously.

By default OpenSim - right now, supports your standard SL-flavoured permissions as the default permission module, it’s there today - yes you can swap one permission module with one that doesnt respect those, and yes you could remove it entirely.

Unfortunately as I’ve stated before, there’s no rule of computer science that stops someone from modifying something. Good or bad it is always possible, even if you need to go down to the level where you have a soldering iron installing a “mod chip”. With open source software this is admittedly easier - but any professionally schooled programmer will have all the grounding needed to defeat a copy protection system.

This is why both myself and David Levine believe that the solution is to engineer something that involves assisting and speeding up legal systems. Modern societies decide to respect copyright laws, and therefor they built institutions such as courts to handle disputes, however Prokofy does raise the point that lawyers tend to be expensive, and if the only way to sell content is to have a professional lawyer, then we’re back to old media conglomerates.

As I have stated before, I’m not entirely sure this will be the case, there’s a number of reasons for that, first - something being broken is somewhat black and white - if there is any way to get content under terms not licensed to you, then you can do it. It doesnt really matter that suddenly there is an additional method for doing so, because it was already possible.

The presence of the Open Grid Protocols allows one more potential avenue of attack, but to a malicious individual, this is more difficult than just grabbing the asset from the local cache, or using a tool such as GL Intercept, because it requires connecting in additional servers and dealing with a lot more than you absolutely have to.

Returning to my point - I think we will find that actually people want to be legitimate, purchase content from legitimate providers - and hosting companies (who are actually powering the systems running the World) will have big financial incentives to obey the law and not have copyright infringing content on their systems (since it makes them liable, and corporate lawyers really don’t like that.)

The solutions I’ve mentioned before still hold, first - you can keep on keeping on, in all probability sales will increase rather than decrease because you will be dealing with a much much wider audience. Second - hosting providers will want to be allowed to receive content from top creators, and that means signing contracts which indicate they will enforce permission models wanted by creators (and moderated by consumer demands).

I think for us, the developers the key is to make it possible for people to say “Well, I want my content handled in these five ways.” and be able to host a world that interoperates obeying those laws. Likewise we need to make the inverse easy too so that people who want to share content themselves can, and do so easily. This part comes down to tools - which is in the domain of the technical, however if someone violates that contract, then that’s the moment that social systems need to be employed.

Social solutions do not necessarily mean legal systems - it’s possible that it’s as simple as “Well, you violated our contract, therefor we’re never sharing any more content with you”. Legal contracts will likely be the mainstay at the higher levels (as they always are), but there is nothing stopping the establishment of guilds or other groups which represent groups of content creators to enforce en-masse.

Certainly commercial pressures will cause people doing hosting services to enforce these, because if they do not, their customers will be denied access to new content which will hurt business.

It’s also possible for people to consider alternative models of distribution, including the possibility of say subscriptions to content providers, for instance paying a regular fee to be allowed access to the content creators library of content (done either per user, or per region, I can see plenty of use for this).

For those of you interested in hearing more, and exactly what myself and David discussed, a video of the presentation has gone online - you can hear our exact words and all the nuances therein (and unfortunately with a topic this complex, there’s a lot.).

It’s a simple enough question - often when I see a company or group get involved in OpenSim, the first thing that springs to their mind is “Well, we must launch our own grid!”, with each grid having it’s own isolated set of users, inventory, assets and regions the question must be asked: “Why?”.

But in most cases, this often isn’t the best of ideas, and short of internal uses it’s often counterproductive duplicating effort others have undertaken already. Running a grid properly takes a lot of work - especially if you are doing frequent updates, if your intent is on making it a popular destination for random visitors, then you have extra work publicizing and convincing people to create an account and login.

All in all, it’s a lot of work for relatively little benefit.

Alternatives to starting your own grid

Attach your region[s] to an existing grid - I personally like recommending OSGrid.org - one of the downsides to this approach is that you are relying on the grid provider for your infrastructure - if they either neglect to update frequently you may run into problems, likewise if they have downtime or stability problems, you are tethered to them good and bad.

So, why do it then?

The short answer is to do it for your users, if you require users to register an account on your grid to come view your trinket, you have effectively annihilated any chance of instant gratification so to speak. The difference between opening a map on a popular grid, and logging out then relogging onto your grid is huge. It requires a good deal of effort to to so.

The longer answer lies in pooling resources - in this case users, users may log in to view your trinket, but after they are done with it, go visit someone elses trinket nearby, the key here is that people who come for other peoples shinies may end up visiting yours too - there’s no zero-sum game here, and offering a multitude of attractions is more powerful a drawcard than yours alone.

When you should make your own grid?

There’s plenty of reasons to run your own grid however - the biggest one is privacy and wanting to run something entirely behind a single corporate firewall. Protecting intellectual property and trade secrets requires making reasonable protections when possible, and public grids are not well suited for this.

Another reason is when you want to run something solely independently - such as say a specific concert or event, where you know that your demands require customisations on the grid software itself. In these cases unless you are able to make an arrangement with the grid operator you may run into problems and hosting oneself is a good idea.

So which grids allow outside regions to connect?

OSGrid.org is the best for this since the entire grid is hosted externally - making sure this works smoothly is a goal of the osgrid admins. Connecting a region is free and there are no real terms of service at the moment to speak of, other than “don’t break the law.”

DeepGrid has allowed regions to connect since the beggining - although the grid server software is updated less frequently than the OSGrid ones. A common terms of service do apply for this and region spaces need to be reserved via the website first before connecting (rather than first-come-first-served, price is still free).

CentralGrid offer region connections too however connecting a region invokes a large fee that isnt charged anywhere else, for as far as I can see no advantage. I’m not impressed, but you may be.

There’s a very fundamental problem facing many content creators in Virtual Worlds these days (such as Second Life™, IMVU™ and others), and that is the problem of Piracy - where one unscrupulous individual takes content from a designer or developer, and then attempts to resell it as their own.

It’s a problem - no-one can deny that, but the solution to the problem is not ‘deep’ DRM. There are a few reasons for this, especially when it comes to content (scripts and backend programming are another matter entirely and something I will get to in a moment)

Three reasons why this wont work for visual content

First, the obvious one - content must be displayed on the users screen. This means it must be presented to the video card in an unencrypted form. I’ve heard a few silly ideas to prevent this one, such as encrypting the texture and using a shader to decrypt it on the video card (just run the shader in a virtual machine).

At a very fundamental level, the laws of mathematics do not allow you to say “This number cannot be copied.”, computers which are based on very high level mathematics are still subject to these immutable laws. There’s a parallel law here which states that you can always modify something - sure you can make it a house of cards that breaks if you make a change, but someone can always employ superglue to prevent that.

It’s technical, but it’s worth reading the examination of the Skype binary (PDF) done by a security analysis team, the Skype developers know their stuff, exactly how to use cryptography properly, how to try prevent debuggers from being run, etc. Every single one of their protections has been examined and detailed specifically in that document - no matter how clever you think you are, there are cleverer people out there and not all of them have good motivations.

Second reason why this wont work - You hand the legitimate user both the content and the key to decrypt it to display it - there’s no way to avoid this without disallowing the user to view the item (which defeats the purpose of content). There’s nothing stopping them from making a copy of both parts, and once the schema is broken, there’s no going back - it’s out there. You cant revise the encryption scheme after it’s been broken, your content is now available unencrypted.

This has been a big problem with things like DVD encryption, because to release a new encryption scheme you need to get every user to update, and titles released under the old scheme are still broken. DRM used in popular products tends to have a life somewhere between a week and three months - assuming point #1 doesn’t hold, this still means you have to assume all your content more than at most 3 months old is piratable - how many content producers produce enough content every month to make their old lines completely redundant from a sales perspective?

Third reason - DRM tends to annoy customers. Consider the possibility where you want to teleport your avatar around a hypothetical super-grid the size of the internet. You enter a sim which hasnt been authorised (and I’d say in the long term, most will fall into this class - similar to only how a small % of sites have SSL certificates), and bam, your avatar vanishes.

Well, what can you do? Not much - but you arent likely to buy avatars from this user again that’s for certain. There is likely going to be a commercial incentive towards content which after you buy is free to do what you want with. (With copyright law enforcing violators and pirates).

So - how the hell do you protect your revenue/sales in an environment where anything goes?

This question is the real question that should be asked, the answer hasnt yet been determined (market forces will likely be the ones to figure out which models work, and which dont)

• Custom Content - in a world where everything is mass produced and cloned, unique content that has been hand crafted for what you want is a drawcard. It’s unique, it’s yours, it’s $50.00/hour design fees.
• Keep on keeping on - The current model is unlikely to collapse, brands seem to matter and people like being able to say they have legitimate content. Systems will likely appear that allow you to verify whether someone has paid for a piece of content or not. Piracy goes on in virtual worlds today, but sellers seem to keep making sales (I’d like to know more from specific sellers how their sales have gone when a piece of content has been pirated significantly).
• Mark your intent - Tying in with the above point is the idea that you can mark your intent - this is ’shallow’ DRM - it’s nothing that cannot be removed, but it does signify what the creator wanted you to do with this content and has licensed you to do. If someone violates these terms, you can deal with them the same way copyright infringement is handled in the real world, courts. For all the complaints that go on about the DMCA, the act does provide a relatively sane way to deal with IP infringement from a content creator perspective (however beware, filing a false DMCA claim IS perjury).

So what about scripts?

Well, if your script is going to be transmitted from host to host - you have the same problems that commercial web scripts have - and all of the above applies. With sufficient bandwidth and processor time however, it is possible to run scripts on your servers for other peoples (the “hosted” model). OpenSim supports this hosted model via the ScriptEngine that can be run as a grid server - hopefully these kinds of things will become easier to setup and maintain, and perhaps a giant such as Akamai will take to the role for other people.