---
layout: default
---

<div class="header-container jumbotron">
    <div class="container">
    <h1>Nemo</h1>
        <p>A Data Processing System for Flexible Employment With Different Deployment Characteristics.</p>
        <p><a class="btn btn-primary btn-lg" href="{{ "/docs/home/" | prepend: site.baseurl }}" role="button">Learn more</a></p>
    </div>
</div>


<div class="container">

    <div class="row">
        <div class="col-md-6">
            <h2 class="header-light regular-pad">What is Nemo? <small>[ˈnemoʊ]</small></h2>
            <blockquote>
                <p>
                    Nemo is a data processing system for flexible employment with different execution scenarios for various deployment characteristics on clusters.
                    They include processing data on specific resource environments, like on transient resources, and running jobs with specific attributes, like skewed data.
                    Nemo decouples the logical notion of data processing applications from runtime behaviors and express them on separate layers using Nemo Intermediate Representation (IR).
                    Specifically, through a set of high-level graph pass interfaces, Nemo exposes runtime behaviors to be flexibly configured and modified at both compile-time and runtime, and the Nemo Runtime executes the Nemo IR with its modular and extensible design.
                </p>
              <!--<p>Jekyll is a simple, blog-aware, static site generator. It takes a template-->
              <!--directory containing raw text files in various formats, runs it through-->
              <!--a converter (like <a href="https://daringfireball.net/projects/markdown/">Markdown</a>)-->
              <!--and our <a href="https://github.com/Shopify/liquid/wiki">Liquid</a> renderer, and-->
              <!--spits out a complete, ready-to-publish static website suitable-->
              <!--for serving with your favorite web server. Jekyll also happens to be the engine-->
              <!--behind <a href="https://pages.github.com">GitHub Pages</a>, which means you can use Jekyll-->
              <!--to host your project’s page, blog, or website from GitHub’s servers <strong>for-->
              <!--free</strong>.</p>-->
            </blockquote>
        </div>
        <div class="col-md-6 text-center">
            <img src="img/nemo-logo.png" alt="" class="img-responsive">
            <!--<img width="512" alt="Nemo reef 98" src="https://upload.wikimedia.org/wikipedia/commons/thumb/6/60/Nemo_reef_98.jpg/512px-Nemo_reef_98.jpg"/>-->
        </div>
    </div>

    <hr>

    <div class="row">
        <div class="col-sm-4">
            <h1 class="text-center"><i class="fa fa-pencil" aria-hidden="true"></i></h1>
            <h3 class="text-center">Flexible</h3>
            <p>
                Nemo offers flexible adaptation to your desired execution environment.
                Examples of such execution environments include using transient resources, disaggregation of different computing resources, and handling skewed data.
            </p>
        </div>
        <div class="col-sm-4">
            <h1 class="text-center"><i class="fa fa-cogs" aria-hidden="true"></i></h1>
            <h3 class="text-center">Modular and Extensible</h3>
            <p>
                Nemo is designed to be modular and extensible for even more variety of execution scenarios and deployment characteristics.
                Users with specific needs can plug in and out the required components and execute their jobs accordingly.
            </p>
        </div>
        <div class="col-sm-4">
            <h1 class="text-center"><i class="fa fa-arrows-alt" aria-hidden="true"></i></h1>
            <h3 class="text-center">Runs Everywhere</h3>
            <p>
                Nemo is able to run Apache Beam™ programs using our runtime, and Apache Spark™ programs in the near future.
                Moreover, by using Apache REEF™, Nemo enables data processing possible on different resource managers including Apache Hadoop™ YARN or Apache Mesos™.
            </p>
        </div>
    </div>


</div>
