Get Started Now

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

Welcome to MBrace simple scripting of scalable compute and data jobs programming model independent of cloud vendor 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 your favourite editor.

Simple Cloud Programming

MBrace.Core is a cloud programming model simple enough to be explained on a single slide.

Azure Support

MBrace.Azure implements MBrace.Core on the Azure cloud platform.

Simple Provisioning

Simple cluster provisioning for Azure.

Scripting for Compute and Data

Integrate cloud-scale compute and data processing directly into your F#/C# scripting.

Big Data, Big Compute

Scale your data scripts across tens to thousands of machines with seamless access to cloud storage.

Direct from your editor

With MBrace.Azure, use your Azure storage and compute assets, at your fingertips in your favourite editor.

Getting Started with MBrace.Core

  1. Learn basic F# scripting in your favourite editor
  2. Create and use a simulated cluster and storage on your local machine

Contribute to MBrace.AWS

  1. Work is underway to map the MBrace.Core programming model to Amazon Web Services too!
  2. Follow and contribute to this work on github.

Training and Support

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

Combining the strength and experience of two consultancies, Nessos and Compositional IT 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.

Run scalable, distributed data parallel workflows 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.Runtime

Full name: Snippets-index.cluster
module Unchecked

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

Full name: FSharp.Core.Operators.Unchecked.defaultof
namespace MBrace.Core
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.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: FSharp.Core.Operators.int

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

Full name: FSharp.Core.int

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

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

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

Full name: 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 FSharp.Collections
val length : source:seq<'T> -> int

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

Full name: MBrace.Flow.CloudFlow.length

Videos and Articles

MBrace: REPL-driven scalable computation Eirik Tsarpalis

NYC F#

Crunching through big data with MBrace, Azure and F# Mathias Brandewinder

MVP Summit 2015

MBrace: harnessing the cloud with .NET Nick Palladinos

Skillsmatter, London

F# and MBrace with Lena Dzenisenka Channel 9

.NET Fringe, Portland

The F# Path to Data Scripting Nirvana Tomas Petricek, Isaac Abraham, Don Syme

dotnetConf

BigDeedle - MBrace and Deedle for very large time series and data frames. Tomas Petricek

GitHub

MBrace.Azure brings Azure scalability direct to your favourite editor

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 your favourite editor 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 your favourite editor! 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. 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.

MBrace on GitHub

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 Azure Expert, Compositional IT

F# MVP, Azure consultant, director of Compositional IT and author of Learn F#.

Yan Cui MBrace.AWS

F# Developer and AWS Specialist.

Don Syme F# Language Designer (advisor)

F# Language Designer, MBrace Design Advisor.