Blue Sky Dreams

You’ve had an idea which gives you that feeling in your tummy, but the road to get there winds into tomorrow? Post it here!

Accounts/Security

User Profiles on USB sticks

Imagine being able to carry around your personal desktop settings, documents etc. on a USB stick.. which you could just stick into any computer, and it’ll allow you to login as.. well.. you.

Obviously there would have to be some security considerations and what rights you have would have to be setup for each PC (unless your rights are network based), otherwise you’d only have the basic minimal rights.

• A notification dialog that offers options for a newly inserted device could offer to install the user’s profile (xfury)
• The USB key could carry a half of a key pair for each computer the profile has been used on. The computer would use it as a login token that unlocked the user’s assigned permissions.

Globally Unique Identifier for Client IDs

Giving each client a Globally Unique Identifier could be usefull for communication & security.
Obviously privacy of users should be kept in mind when using these ids. (logicalerror)

Human Interface

Browser

Build the windows system in such a way that controls can flow like in a browser, this would make applications more flexible and it would be much easier to make a browser.

Comment: You mean, people could write something like this:

<window>
 <button id="button1" align="left">Hello World</button>
 <button id="button2" align="right">Hello again</button>
</window>

Comment: Well i was thinking along simular lines, but i actually ment that the GUI controls themselves would have the ability to flow and have a similar box model as html to simplify making a browser and giving regular applications some browser like capabilities. (logicalerror)

Comment: Sounds more or less exactly like XAML/WPF/.NET 3.0 Unless I’ve missed my guess, that would basically mean this is already on the roadmap. (Aurrin)

GUI

Would it be possible to design a couple of basic (mock-up) interfaces for inter-process communication & graphics / IO drivers, then create an implementation under vanilla .NET and start building a GUI on top of that (under windows/linux)?

So that when the graphics/IO drivers etc. etc. are (nearly) done, it wouldn’t take that much time to get a gui up and running since we’d already have the basis..

Comment: Let’s not do that for drivers, but instead do that for the graphics engine itself. If you want a place to start, the Jeto.Graphics and Jeto.Ui layers are LGPLed and have a significant codebase already. (I know I can’t help but plug it!). Doing that for drivers would require setting up a very complex environment, and I’m not entirely sure it’s possible. (xfury)

Comment: What exactly is your definition of ‘graphics engine’? As for drivers i ment just writing an interface to the ‘driver’ which on a windows implementation would simply map to, for instance, opengl calls.. Jeto -> Interesting. (Logicalerror)

Hardware accelerated GUI

It’s the way of the future, a GUI that’s designed with hardware acceleration from the start would be a lot simpler (with the exception of the graphics driver) and more flexible then one with hardware acceleration jury rigged on top.

Comment: the graphics driver provides the hardware acceleration :) (xfury)

Comment: Well obviously yes, but most GUI’s are designed with software rendering in mind, which can lead to situations where some things don’t map well to (3d) graphics hardware, or that some things that graphics hardware does very well are not supported by the GUI because software does it rather poorly … (logicalerror)

Comment: I think he means write the GUI on top of OpenGL (or whatever you will end up using). Note that this doesn’t mean that you have to build a 3D desktop as OpenGL provides 2D graphics as well. (cam.turn)

Comment: Since we’re writing everything from scratch and we can’t easily use legacy code (because we’re using a different language and OS structure) we can’t really ‘use’ OpenGL.. especially since OpenGL is designed for C, not an OOP programming language such as C#.
So we’ll have to write our own 3d acceleration library (which probably would be as similar as possible to OpenGL).
As for “GUI that’s designed with hardware acceleration” means that, for example, the GUI wouldn’t allow you to ‘plot pixels’ but force you to work with higher level primitives. (because 3d hardware is really good at high level primitives, but extremely poor at ‘plotting pixels’)
So some type of operations are really fast with 3d hardware, some are extremely slow. (logicalerror)

Official GUI Guidelines

It would be a good idea to have official gui guidelines so that all applications that follow these guidelines will have the same look & feel and are consistent in their usage.

Comment: Agreed. If someone wants to go and throw together a set of Human Interface Guidelines, maybe basing the ideas on other HIG documents and make a Human Interface Guidelines wiki page (just make sure to note that the guidelines are “proposed” and not “final”) it would be much appreciated. Of course, because it’s not on the next milestone we should avoid starting the whole community debate and finalization process until later. (xfury)

Comment: Yup that makes sense ;) (logicalerror)

Support for multiple input devices

It could be usefull to support multiple mouses and keyboards on a single system, combined with multi-monitor support, this would make it possible for one person to work behind one monitor with mouse & keyboard, and another on another monitor.

This will effectively make it possible for 2 people to use the same system at once.

With multi-core systems becoming the norm, especially with intel already experimenting with an 80 core processor, performance isn’t really an issue anymore.

This would make it easier for, for example internet cafe’s, to be able to service more people with fewer pcs.

Comment: This is a really cool idea, but how would you get two monitors working together cheaply? I believe that you would need PCI graphics cards, which aren’t generally available any more. And the price goes higher as you add more screens. And even higher when you need a motherboard with 10 USB ports to support all the mice. (cam.turn)

Comment: There are loads of video cards on the market that can support, by itself, two or more monitors (i have one for example).
You’d only need one of these graphics cards and 4 usb ports (2 keyboards, 2 mice).
Besides, a lot of motherboards allow you to use more than 1 pci-express video card, because of NVidia SLI or ATI CrossFire. (logicalerror)

Comment: If you get it right you could get Multi-touch point sensing working. http://cs.nyu.edu/~jhan/ftirtouch/. All you need for MPT to work is the ability to be ‘aware’ of more than one cursor (could even apply properties to cursors, such as size and what-not). (moitoius)

Comment: Actually, this would be excellent for scenarios where you’d like to have multiple people collaborating on something. The ability for it to recognize and distinguish multiple users’ inputs at a time would be excellent. Bonus points for making it possible to make multiple computers act together via network. (Aurrin)

Fundamentals

Paging

If we keep pages containing code readonly, not only will we have a higher level of security, but it would also allow us to page code pages from the executables (when available) instead of paging in/out of the page-file or virtual memory partition.

Comment: Huh? I thought that you were going to interpret CIL code, which has nothing to do with X86 code. (cam.turn)

Comment: The CIL code is compiled into X86 instructions. How else is a processor going to execute CIL code? (logicalerror)

Block Allocation

The current method for block allocation isn’t really viable in the long term. A more formal/efficient system should be implemented. There’s a few options out there and the slab allocation approach seems to be the most used, though implementing it is going to take some planning.

GUI shows when unmountable device isn’t ready to be unmounted

Most operating systems have all kinds of caches at various levels, maybe even in hardware, and when you save a file to, for example, an USB stick there probably is a delay before it’s actually written to the stick.
Windows requires you to click on an icon and unmount an USB stick, and linux has an unmount command.
Both allow you to pull out the stick at any point.. but you might lose some data.
What really would be usefull would be that you could visually see in your GUI at any point in time when an unmountable device is ready to be removed without any loss of data (or when it’s being used).
Since we cannot physically avoid the device from being removed, it’s a good idea to give the user visual cues to let him/her know when it’s safe instead.
(Having some way to ‘force’ caches to be flushed should also be possible obviously)

File system transactions

It would be nice to have functionality in the OS to group several file system actions together in a transaction, like moving x files. This transaction could be reversed when an error occured (all files would be locked during the transaction).
This would allow the OS to optimize the whole transaction, ordering all operations according to where which files are on the harddisk to more efficiently read & write.

Simple directory structure

Windows makes it really easy to turn your harddisk in a garbage belt, there’s only very loose structure. Linux has more structure, to a degree, but it’s not really intuitive to beginners..

Comment: Yes, that’s a very good idea. My idea of a simple directory structure is this: /Programs contains a collection of folders, each containing a single application, for example, /Programs/Notepad/ would be the folder containing the Notepad application. /System would contain the system code. /User/[username]/Desktop would contain a user’s desktop, and /User/[username]/Documents would contain a user’s documents. Simple, huh? (cam.turn)

Comment: Exactly. Also no registery, applications will have to store their settings in an app.config file in their own directory.
(We probably would have to enforce this somehow)
This way deinstalling an application will be as simple as removing a directory. (logicalerror)

Comment: What about securing certain directories. We could build in UCES (User Code Execution Security) and CAS (Code Access Security) into the OS. What that means is that writing to a certain directory would have hard-coded permission requirements (UserAccessAttribute.Require(UserPrivelage.InstallDriverAssembly) for example). At the same time, for users with those privelages we could do something as follows: (moitoius)

[UserAccess(UserPrivelage.InstallDriverAssembly)]
public bool InstallDriverAssembly(Stream file, string name)
{
  if(!CodeAccessAttribute.Inquire(CodePrivelage.WriteASMAssembly))
    return false; // Would pop up a dialog here for the user to grant access.
  using(Stream out = FileStream.Open("/System/Asm86/" + name))
  // Write file to out
  ;
}

... in System.IO.FileStream class.

public Stream Open(string filename)
{
  if(filename.StartsWith("/System/Asm86/"))
    CodeAccessAttribute.Require(CodePrivelage.WriteASMAssembly);
  // Open the file.
}

Comment: If you work this right, it will solve the next two items. Something like have top level directories /System (OS static files) /Programs (Program files) /Configuration for all configuration files, and /Data. Then subdivide /Programs by program name (Not company name, please!) and require single-folder depth for the main program. Under /Configuration, subdivided by program names exactly as in /Programs, with the addition of a /Configuration/System folder, and each of those subdivided by user. Under /Data, have /Data/System and then one folder per user. You can sym-link them access to their own configuration folder per program to avoid duplication. That way, each top-level folder is more or less drop-in, and the OS and programs can even be marked read/exec-only most of the time. (Aurrin)

Seperation of OS files, applications and OS state information

It’s a bit of a waste that when running VM’s that each VM needs a complete copy of the entire OS.
The reason behind this is that all the files of the OS (often taking most of the space on the VM),
the files which make up the state of the OS (user information, rights etc.) and the applications are completely interweaved.
If this is kept seperate, this would make it possible to place applications and state on a different drive than the static OS files.
VM’s could then have a readonly virtual harddisk containing the static files of the OS (which is shared among different VM’s), and another virtual harddisk for all the state & applications.
In fact, this could be taken further by also being able to share application files.

Comment: it would be nice to still being able to update the OS and applications even when they’re shared among VM’s.. any ideas?

An OS designed with packages in mind

Most OSes have the concept of installers and packages implemented at a very late time in development, and it’s usually jury rigged into the OS. An Official package/installer system which is more integrated into the OS would help keep computers clean.

Comment: I suggest a bundle-like system, where the program’s folder acts as the package itself, at least according to the OS. The folder would include an XML definition describing the properties of the package. Jeto makes use of this approach. (xfury)

Comment: Erm, clickonce deployment? (moitoius)

Tags, or .NET Attributes for Files

Any developer would be able to make a kind of tag which it could then be attached to any file,
this tag would be a type of class so type-safe.

Some possibilities:

• A CVS/svn-like program could add information about the file on the file itself.
• An image viewer to catalog images
• Attaching icons to a file.

Issues:

• Portraying these tags/attributes in normal files sent across non-SharpOS environments like the Internet: this issue was what prevented Apple from continuing their use of HFS forks.

Comment: It should definitely not be something which is required for files to operate properly, but more like usefull meta-data for categorizing and indexing data for whatever purpose.. The ‘tags’ need to be saveable somehow so that they can be stored in zip-files and backups etc. Maybe if there’s a filename bla.jpg then a hidden file named bla.jpg.tags would hold the tags? I’m not sure.. (logicalerror)

Comment: I was at a professional photographer last week where they took digital photo’s from my 2 year old daughter, and afterwards they showed me the pictures on a mac.. they kept track of which photos would be printed out and at which size on a piece of paper, but they also abused some sort of rating setting per picture (i’m not a mac user) to keep track which pictures should be printed out at which size..

When i saw them doing that, i really felt like having the ability to attach notes and comments to arbitrary files would really be usefull in this situation… Maybe it doesn’t have to actually be attached to the files at a filesystem level, but it would really be usefull imho (logicalerror)

Comment: Something which most people (even Windows developers) don’t realize is that Windows’s NTFS contains this sort of metadata. I can’t quite remember the tool to read/write this just now, though. (cam.turn)

Comment: What would be really great is a full blown DB based filesystem i.e. what WinFS was supposed to be. Everything is based around meta data, and meta data is hevily used to allow for some serious indexing and searching capabilities. For instance if done well it means you can easily search for an email that you wrote to your friend XXX on date YYY about subject ZZZ. You can still have drives and directories but in effect these just become another bit of meta data and I’d have thought that people would naturally starting using thier own tags and containers rather than the classic drives and directories. It would be a killer feature if supported from the start, then all applications would keep it in mind when being written. Of course it would be quite a battle to develop it with sucficient performance, the indexing would have to be top notch. (smellyhippy)

Comment: A semantic database might handle this issue. In the ideal case, any data-except binary data-will get stored within it. The real problem is the performance. In case of semantic stores, the data needs to get splitted into knowledge domains.

Applications sleep while not receiving any ’’registered’’ SharpOS events

Most GUIs have a loop where it’s waiting for events, usually getting lots and lots of events that the application doesn’t care about. All these applications taken together waste a lot of processing power doing basically nothing.

But what if we use a different approach:

1. If an application wants to receive events from SharpOS, then it has to register the events. (This could easily be done using delegates / events)

1. This would allow SharpOS to let the gui-thread sleep untill there’s an event that the application actually handles.
2. Since most applications would consist out of a very simple GUI with (radio)buttons etc., most applications would basically not use any processing time, especially if the graphics-output of every window is buffered, untill a window was clicked.
3. People who would make applications for SharpOs could be educated to only register (and later unregister) events while you actually need them.
   (for example; for a drag/drop operation, register ‘onmousemove’ after you press a button, and unregister it after you release the mouse button)

Good side: more performance
Bad side: no longer a single point of entry for events

Comment: Why would there have to be different entry points for different events? Just use the same loop, and the kernel will filter out messages which the program doesn’t want. (cam.turn)

Comment: There would be no need for a loop.. Adding one would just add an extra step and extra overhead.. (logicalerror)

Attaching interfaces (and implementations) to file types

Imagine creating an interface for loading an image, and implementations of that interface could be attached
to the file types that it knows how to load.
Then an image viewer could iterate over all the implementations of that image loading interface,
and it would then have the ability to load all the file formats that have an implementation of that interface.
If a couple of years from now a new file format is created, and someone creates an image loading implementation for it.
That old image viewer would suddenly, magically, know how to load that file.
Obviously newer versions of the interface could be introduced when the old interface lacks certain features..
They could simply exist side by side.

Comment: How is this different from normal plugins? (xfury)

Comment: I suppose not much, just that they’re defined at OS level and that new categories of ‘plugins’ can easily be added by third parties (logicalerror)

Comment: Do you mean attaching the loading mechanism to the file itself? Certainly that could get a little crazy on the data-sizes of many images :) (xfury)

Comment: No that would be crazy ;) (logicalerror)

Comment: I think that what he means is that the kernel would define structures for many common things, like images in this example, and define “factory” functions to load these structures, and people could create libraries to do the actual loading. In this example, there would be libraries named “load-image-bitmap.so”, “load-image-jpeg.so”, “load-image-xpm.so”, etc, and whenever a new format came out, someone could write a library named “load-image-[new image format].so”. Just tell me if you want me to explain it slightly better ;) (cam.turn)

Comment: Something like that. It wouldn’t actually be defined in the kernel itself tough, at least not in a hardcoded way.

Misc

Application snapshots

It would be usefull if it was possible to simply make a snapshot of an application so that you can start the application again on a later date and continue exactly where you where at that point. This could help with debugging, giving presentations etc.

Comment: This would actually be rather simple, a bit like Windows XP’s “hibernate” function, only it would work on a single program rather than all of them. OT: This is probably the best feature of Windblows Windows[logicalerror]! (OT: Hint: to access the hibernate function, hold down some key (ctrl, I think it was) and the stand by button will change to the hibernate button.) (cam.turn)

Comment: Would be especially cool if a UPS+Driver was installed and when the power went off all the apps would ‘freeze’ (grey out or some cool GFX FX). The user could then choose to close or to hibernate that application. Once the applications are closed the OS would then proceed to hibernate.

Virtualization / Compatibility Layers
We should make use of virtualization and/or compatibility layers to allow the system to make use of software written for other platforms.
This allows our design to remain uninfluenced by compatibility with legacy systems. (edited by xfury)

Comment: I think that you should probably not put this in the kernel, but let a user application handle it. The user application would be something like QEMU+WINE put together. (cam.turn)

Comment: The kernel is the only part of the OS which would be allowed to run the type of low level code that would make it possible to do virtualisation, if we would allow other non-kernel applications to create and run x86 code it would undermine the security of the OS.. (logicalerror)

Comment: Always allow the user to undermine the security of the OS if they want. This is one of the biggest pit-falls of Microsuck. We do need some facility for running direct x86 code, but the user would (as per my previous comment) need a UCES right to do that.

Vector math data types converted to vector instructions by the JIT/AOT

Modern processors have extensions like SSE/3DNow which are usefull for things like 2d/3d calculations.
Unfortunatly virtually no compiler out there has language level primitives which easily map to these extensions.
It would really be nice if SharpOS had some math primitives which the compiler would know how to easily map to these processor extensions.
This would really give the SharpOS .NET implementation an edge over normal programming languages since supporting all these different extensions in a normal application is very difficult and time consuming.
They wouldn’t actually have to be language extensions, they could simply be structs that the compiler would recognize.

• We would need to ensure that whatever library provides these structures also provide a software fallback for performing the math in the normal fashion. This means that running this code on a platform that supports vector operations would be faster, but running the code on a processor that does not support such instructions would actually be slightly slower than using normal math operations.

Comment: not if processor specific versions of these structures are implemented for each system..

Comment: I think that these should be kept in a library, say SharpOS.Math.Extensions, rather than being built into the language. Then applications written for SharpOS could also be run on older OSes architectures[moitoius]. (cam.turn)

Comment: Which is exactly the idea in the first place. (logicalerror)

Comment: cam.turn: Need to be careful of that – next you get lazy developers that don’t check before using the faster methods. Here is one way to tackle the problem. You could even make an attribute for an assembly so that when the assembly is probed it first finds the generic one, then the MMX one (this would then be an off-shoot of MSIL in that an assembly can contain a single class/method).

... In Matrix Class.

private static MatrixImplementation impl; // Maybe need to somehow have a 'system-wide' static.

static Matrix()
{
  if(MMX)
    impl = new MMXMatrixImplementation();
}

public static Matrix operator+ (Matrix one, Matrix other)
{
   return impl.Add(one, other);
}

Comment: The right class (mmx/generic/sse etc.) would actually be chosen at compile time by the AOT/JIT compilers, which would simply check what the capabilities of the current machine are. The user would simply use ‘the matrix class’ and would never have to worry about architecture specific stuff. (logicalerror)

Volatile data

In C++ all data is assumed to be non volatile (it assumes it won’t be changed by another thread, so it can put data in registers instead of re-reading it from memory all the time) and you have to add the “volatile” keyword in front of data if you want the compiler to assume it might be changed by another thread.
On the .net platform it’s different; it’s assumed any data can be modified by another thread at any time, so it doesn’t cache fields in registers because they might be changed.
This is safer, but costs performance.
So what if we let the AOT / JIT compiler determine (so far as this is possible) what data could and couldn’t possibly be volatile?

Comment: This would be incredibly slow for large files. I suggest creating an attribute named “nonvolatile” and putting that in front of any variable that shouldn’t be volatile. (cam.turn)

Comment: It could be an optional optimalisation. The Kernel, for example, is always compiled AOT (Ahead of Time) with full optimalisations enabled. I can also imagine that (some) applications could be AOT compiled when installed (the compiled code would be cached in a secure place).
It could even be a background process, AOT compiling when the computer is idle.. giving you a normal, less optimized, JIT compiled application at first, and a more optimized application later. There are lots of possibilities… (logicalerror)

Comment: There is a ‘volatile’ keyword in C#, or am I missing something? (moitoius)

Named threads

Wouldn’t it be nice that when you debug a multi-threaded application, the threads would actually be named (and easily recognizable)?
Since all threads in SharpOs could be implementations of a thread class, the threads could be named with an attribute for easy debugging..

Comment: yeah, that’s useful. I can’t believe .NET doesn’t provide that?? I like the attribute part (xfury)

Comment: Java provides this, go over and take a look at it. (cam.turn)

Comment: Java doesn’t has attributes.. I noticed that .NET actually has a Name property for it’s thread class, but it’s kind of strange that you can only set it after you’ve created the thread.. Also, all of the ‘standard’ .NET threads don’t have their names set (logicalerror)

Comment: Well windows doesn’t currently support named threads (although Vista was supposed to, I haven’t checked if it got in the final feature list) so naming of threads in .Net is handled by the runtime, in the sameway that logical threads and physical threads don’t necessarily have a direct mapping. Thats why you have to set the name after creation. (smellyhippy)

Support for Intelligent Agents

• lightweight inter process communication
• being able to stop a process, save it to disk and restarting it later.. or even transferring it to another computer
• secure design

Comment: a SIP is very much what a Intelligent Agent is. I guess SIPs are already based on this idea. Serialisation should be able for all System.Object`s.

POGO

I’m sure most of you know what POGO is. It was, in-fact, scheduled to be in the CLR. In terms of C++ it basically profiles a running program. That profiling data is then used to recompile the program: you get ridiculous performance gains. The CLR was supposed to do this real-time, but Microsuck seemed to forget about it: perhaps a feature for SharpOS? (moitoius)

Cluster Computing

If I understand things correctly (and I often don’t) inter-process communication will be performed through some controlled channel. I would expect such a controlled channel would lend itself to being serialized so that it could be sent over a network to a process on another machine – this is cool. But what about the computer’s other resources and I’m thinking here particularly about the file system, would it be possible to share them across a network. I would imagine something like a P2P network where the file system is shared. The point of participating in the P2P network would not be to download the whole file system, but instead just the chunks of it that are important to you right now and enough of the rest to introduce a healthy redundancy. Having this kind of functionality at the core of the operating system and open to all applications would be impressive.

Console Input

It would be pretty nice to have a more semantic way of using the console. Therefore some coding standards will be a requirement. The commands should therefore match the syntax used for powershell cmdlets. The syntax to call a function should be very consistent like <commandname> [ -<parametername> <value>* ]*. Using -- or / instead of the - is optionally possible, but not recommended for ease of use.

Semantic Input Pattern

Semantic input means, that the meaning and (optionally) also the datatype of an input is given. An example is the pseudocode calc -add 1.4^^float 4^int. Another possibility for expressing the same might be calc -add 1.4^^float -add 4^int. As you might notice, this syntax is inspired by LISP and therefore very powerful.

Internally, the first command creates a new calc object and calls a property called add of this object and passes the values. If you would code that by hand it might look like calc.Add ( (float)1.4, (int)4 );. The later example will call the property Add two times: calc.Add( (float)1.4 ); calc.Add( (int)4 ). After the object got created, the OS calls a run() or execute() named method of the object calc.

Another example program called add would be called using another syntax, which might look like add 1.4^^float 4^^int. In this example, the OS would create a object directly by calling its constructor like in add.add( (float)1.4, (int)4 );.

Getting help

Getting help should work in another way. The help program should not call a special function which prints the help. Instead, the help can get implemented using reflection. Help about a given command parameter is therefore implemented as annotation of a property in the source code. This allows for a more consistent print of the help. Also, the user would have the possibility to get help only for specific parameters. In example, the command help <command> will print the general help of a command, help -parameters <commandname> lists the available parameters, help <commandname> <parametername> will output the help only for a specific parameter, and so on.

Unicode handling

Instead of ASCII, handling Unicode might be preferable in any code segment. This will enable the support other languages without the need of doing code switching. Even the input from the keyboard should be mapped to a unicode character rather than an ASCII code.

Network code

To make SharpOS useable asap, the network code is more important than the UI code. If you have a operational HTTP server, you can implement the user interface as html pages and run it from any computer. This means that the network code should have priority over graphical user interfaces. On the server side, a console will be enought for the beginning.

• ARP/RARP
• IPv4/IPv6
• Telnet and HTTP

To improve the portability for existing drivers, the interface for programming drivers should be similar or even compatible with that of Linux. Anyway, linux drivers are often written in C-code, which makes the need for a rewrite very probable.

Comment: I concur that bringing up basic network support should be a priority but IMHO vga support probably takes priority over any kind of application (Telnet, HTTP server, etc). It’s important that the kernel team supply the building blocks so that other developers can write the applications that will run on this OS.

Contracts

Because the SharpOS AOT is restricted to Standard-C# its not possible to write Contracts for inter process (SIP) communication using the contract, message, in, and out keywords. A similar effect might get archived by using Metadata-Tags on interfaces:

Example 1: contract
Bartok

1 contract MyContract {
2    in message InputMethod(...);
3    out message OutputMethod(...);
4 }

C#

1 [Contract] 
2 public interface MyContract {
3    [in] public abstract Message InputMethod(...);
4    [out] public abstract Message OutputMethod(...);
5 }

Example 2: reproduceable type
Bartok

1 rep struct Name {
2    string FirstName;
3    string LastName;
4 }

C#

1 [rep] public struct Name {
2    string FirstName;
3    string LastName;
4 }

The compiler than can create the contract and reproduceable types.

See also: Language Support for Fast and Reliable Message-based Communication in Singularity OS

Comment: The Bartok compiler can also handle states directly using state. How can we present that?
Comment: How to represent expose, delete and receive keywords?

PASH integration

PASH:http://sourceforge.net/projects/pash is a open source implementation for the PowerShell that is licensed under BSD and GPL license.

CUDA/GLSL/ARB Support

Graphics cards have a lot of processing power, and are excellent at multitasking and asymmetric processing. In a normal desktop, unless there is a game running, all that power goes to waste rendering a 2D desktop. If sharpOS supported compiling/changing CIL blocks into, for example, GLSL, normal programs could benefit from the power of GPUs. I don’t know if this is even possible, but I think it is neat, and it might even prove useful. (tecywiz121)