Integrated Data Scripting for the Cloud - Get started with MBrace.Core and MBrace.Azure today.

Welcome to MBrace simple scripting of scalable compute and data jobs big data and big compute

MBrace.Core is a simple programming model for scalable cloud data scripting and programming with F# and C#. With MBrace.Azure, you can script Azure for large-scale compute and data processing, directly from Visual Studio.

Getting Started with the MBrace.Azure preview in Visual Studio

  1. If necessary, learn basic F# scripting in Visual Studio
  2. If using F# 3.1 (Visual Studio 2013), follow the step-by-step guide to create your cluster in Azure using Brisk Engine. (If you have special needs, or are using F# 3.0/Visual Studio 2012 or F# 4.0/Visual Studio 2015, then you can provision a bespoke MBrace Azure cloud service)
  3. Download the hands-on tutorial and learn MBrace
  4. Give feedback on github

Training and Support

Consultancy partners including Nessos and Elastacloud contribute to MBrace and provide training, support and consultancy services.

Combining the strength and experience of two consultancies, Nessos and Elastacloud partner to bring you training and support for both MBrace.Core and MBrace.Azure.

MBrace.Core - Cloud Programming Made Simple

Confused by the cloud? Cloud computation and data can be simple, if using the right framework. MBrace.Core helps the cloud empower you, not enslave you.

MBrace.Azure - Included Features

Whether new to Azure or an advanced Azure developer, MBrace.Azure brings Azure storage and compute to your fingertips.

Running LINQ-style queries in the cloud.

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
open MBrace.Core
open MBrace.Flow

let numberOfDuplicates =
    CloudFlow.OfCloudFilesByLine ["container/data0.csv" ; "container/data1.csv"]
    |> CloudFlow.map (fun line -> line.Split(','))
    |> CloudFlow.map (fun tokens -> int tokens.[0], Array.map int tokens.[1 ..])
    |> CloudFlow.groupBy (fun (id,_) -> id)
    |> CloudFlow.filter (fun (_,values) -> Seq.length values > 1)
    |> CloudFlow.length
    |> cluster.Run
val cluster : MBrace.Azure.Client.Runtime

Full name: Snippets-index.cluster
module Unchecked

from Microsoft.FSharp.Core.Operators
val defaultof<'T> : 'T

Full name: Microsoft.FSharp.Core.Operators.Unchecked.defaultof
namespace MBrace
namespace MBrace.Azure
namespace MBrace.Azure.Client
type Runtime =
  private new : clientId:string * config:Configuration -> Runtime
  member AttachClientLogger : logger:ICloudLogger -> unit
  member AttachLocalWorker : ?workerCount:int * ?maxTasks:int -> unit
  member ClearAllProcesses : ?fullClear:bool * ?force:bool -> unit
  member ClearAllProcessesAsync : ?fullClear:bool * ?force:bool -> Async<unit>
  member ClearProcess : pid:string * ?fullClear:bool * ?force:bool -> unit
  member ClearProcessAsync : pid:string * ?fullClear:bool * ?force:bool -> Async<unit>
  member CreateCancellationTokenSource : unit -> ICloudCancellationTokenSource
  member CreateProcess : workflow:Cloud<'T> * ?name:string * ?defaultDirectory:string * ?fileStore:ICloudFileStore * ?defaultAtomContainer:string * ?atomProvider:ICloudAtomProvider * ?defaultChannelContainer:string * ?channelProvider:ICloudChannelProvider * ?dictionaryProvider:ICloudDictionaryProvider * ?cancellationToken:ICloudCancellationToken * ?faultPolicy:FaultPolicy -> Process<'T>
  member CreateProcessAsTask : workflow:Cloud<'T> * ?name:string * ?defaultDirectory:string * ?fileStore:ICloudFileStore * ?defaultAtomContainer:string * ?atomProvider:ICloudAtomProvider * ?defaultChannelContainer:string * ?channelProvider:ICloudChannelProvider * ?dictionaryProvider:ICloudDictionaryProvider * ?cancellationToken:ICloudCancellationToken * ?faultPolicy:FaultPolicy -> Task<Process<'T>>
  ...

Full name: MBrace.Azure.Client.Runtime
namespace MBrace.Core
namespace MBrace.Flow
val numberOfDuplicates : int64

Full name: Snippets-index.numberOfDuplicates
static member CloudFlow.OfCloudFilesByLine : paths:seq<string> * ?encoding:System.Text.Encoding * ?sizeThresholdPerCore:int64 -> CloudFlow<string>
val map : f:('T -> 'R) -> flow:CloudFlow<'T> -> CloudFlow<'R>

Full name: MBrace.Flow.CloudFlow.map
val line : string
System.String.Split(params separator: char []) : string []
System.String.Split(separator: string [], options: System.StringSplitOptions) : string []
System.String.Split(separator: char [], options: System.StringSplitOptions) : string []
System.String.Split(separator: char [], count: int) : string []
System.String.Split(separator: string [], count: int, options: System.StringSplitOptions) : string []
System.String.Split(separator: char [], count: int, options: System.StringSplitOptions) : string []
val tokens : string []
Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

--------------------
type int = int32

Full name: Microsoft.FSharp.Core.int

--------------------
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>
module Array

from Microsoft.FSharp.Collections
val map : mapping:('T -> 'U) -> array:'T [] -> 'U []

Full name: Microsoft.FSharp.Collections.Array.map
val groupBy : projection:('T -> 'Key) -> source:CloudFlow<'T> -> CloudFlow<'Key * seq<'T>> (requires equality)

Full name: MBrace.Flow.CloudFlow.groupBy
val id : int
val filter : predicate:('T -> bool) -> flow:CloudFlow<'T> -> CloudFlow<'T>

Full name: MBrace.Flow.CloudFlow.filter
val values : seq<int * int []>
module Seq

from Microsoft.FSharp.Collections
val length : source:seq<'T> -> int

Full name: Microsoft.FSharp.Collections.Seq.length
val length : flow:CloudFlow<'T> -> Cloud<int64>

Full name: MBrace.Flow.CloudFlow.length
member MBrace.Azure.Client.Runtime.Run : workflow:Cloud<'T> * ?cancellationToken:ICloudCancellationToken * ?faultPolicy:FaultPolicy -> 'T

MBrace.Azure brings Azure scalability directly into Visual Studio

MBrace.Azure integrates Azure storage and compute VMs as a kind of co-processor to your F# Interactive scripting sessions or your F#/C# applications. It brings Azure scalability directly into Visual Studio using an intuitive and powerful data scripting model. Combining MBrace.Azure with F# gives a powerful and scalable cloud data scripting solution. Don Syme, F# Language Designer

Scaling out Legacy Software

MBrace proved to be one of the most valuable tools we 've ever used; it managed to scale our flagship application ThermoS (a FORTRAN based legacy application) to the cloud, orchestrating a multitude of parametric executions and gathering all of the data produced, without altering a single line of code in ThermoS! The combination of Azure and MBrace coupled with ThermoS provided us with the necessary capacity for our clients' growing needs while keeping the costs at an absolute minimum.

Panos Theodossopoulos, CEO Propulsion Analytics

Distributing Machine Learning Tasks

I was amazed by the simplicity of MBrace and how quickly we could go from starting out for the first time to running compute tasks on a cluster of 150 instances, all from with Visual Studio! Machine learning tasks often require cleaning up the dataset before being able to run any training on them. These clean up tasks could take a lot of time. In our case it was finding and removing duplicate images irrespective of their scale, resolution or crop. By using MBrace's easy compute distribution we could quickly try out our ideas and get results

Indeera, Machine Learning Software Developer

Intense Big Data Processing

I am using MBrace with great pleasure for distributed data science and analysis tasks, possible to run even in exploratory way as an interactive scripts directly from FSI. It is awesome to use for large input data sets, big data processing and any intense algorithms that can be distributed. MBrace managed to build a super friendly infrastructure with absolutely simple and fast cloud provisioning using Azure and Brisk. One of the most valuable advantages of MBrace is the ability to define algorithmic patterns of distribution on the library level instead of internal runtime ecosystem. MBrace respects the efforts and helps to maximize productivity.

Alena Dzenisenka, Software Architect, Member of FSSF Board Of Trustees

Work with legacy code, easier parallelism

The combination of F# and MBrace provides great simplicity in programming the distributed cloud environment. I have a lot of code performing program analysis originally written in C# and I used Azure virtual machine and worker roles to do the parallelism. Now I started to use MBrace and am quite happy about it: (1) it is very easy to include my C# code along with many dependencies in the MBrace framework; (2) the parallelism is so much easier to control and change. (3) the scripting-style MBrace environment provides instant feedback on the parallel jobs, this greatly increases my productivity in data exploration.

Yi Wei, Research Engineer, Microsoft Research Cambridge

Scalable biological computation modelling

MBrace substantially reduces the effort of running our large-scale numeric and symbolic computations on flexible infrastructure. With the documented examples and only a few hours effort, I adapted one of our molecular computing tools from our 10+ year codebase (F#, C#, C++) to having a working sample on MBrace and Azure. MBrace has allowed us to easily move our command-line tools from fixed compute clusters to Azure allowing us to scale on demand. Even better, it lets us specify the experiments dynamically from F# interactive.

Colin Gravill, Software Developer, Biological Computation, Microsoft Research

Contribute to MBrace!

MBrace.Core and MBrace.Azure are both fully open source under an Apache 2.0 license. You can contribute to them today.

Join the MBrace team. See our roadmap and development guide for ways to contribute.

Become an MBrace Contributor Today!

Eirik Tsarpalis Core team

Eirik is F# developer and mathematician at Nessos.

Nick Palladinos Core team

Nick is lead software designer and researcher at Nessos.

Kostas Rontogiannis Core team

Kostas is F# Developer and Azure specialist at Nessos.

Isaac Abraham Elastacloud Brisk team

F# MVP, experienced C# consultant, user of Azure, guitar shredder and mad Tottenham fan.

Don Syme F# Language Designer (advisor)

F# Language Designer, MBrace Design Advisor.