<!--
▄▄▄       ██▓███   ▄▄▄       ▄████▄   ██░ ██ ▓█████     ██▓  ▄████  ███▄    █  ██▓▄▄▄█████▓▓█████
▒████▄    ▓██░  ██▒▒████▄    ▒██▀ ▀█  ▓██░ ██▒▓█   ▀    ▓██▒ ██▒ ▀█▒ ██ ▀█   █ ▓██▒▓  ██▒ ▓▒▓█   ▀
▒██  ▀█▄  ▓██░ ██▓▒▒██  ▀█▄  ▒▓█    ▄ ▒██▀▀██░▒███      ▒██▒▒██░▄▄▄░▓██  ▀█ ██▒▒██▒▒ ▓██░ ▒░▒███
░██▄▄▄▄██ ▒██▄█▓▒ ▒░██▄▄▄▄██ ▒▓▓▄ ▄██▒░▓█ ░██ ▒▓█  ▄    ░██░░▓█  ██▓▓██▒  ▐▌██▒░██░░ ▓██▓ ░ ▒▓█  ▄
▓█   ▓██▒▒██▒ ░  ░ ▓█   ▓██▒▒ ▓███▀ ░░▓█▒░██▓░▒████▒   ░██░░▒▓███▀▒▒██░   ▓██░░██░  ▒██▒ ░ ░▒████▒
▒▒   ▓▒█░▒▓▒░ ░  ░ ▒▒   ▓▒█░░ ░▒ ▒  ░ ▒ ░░▒░▒░░ ▒░ ░   ░▓   ░▒   ▒ ░ ▒░   ▒ ▒ ░▓    ▒ ░░   ░░ ▒░ ░
 ▒   ▒▒ ░░▒ ░       ▒   ▒▒ ░  ░  ▒    ▒ ░▒░ ░ ░ ░  ░    ▒ ░  ░   ░ ░ ░░   ░ ▒░ ▒ ░    ░     ░ ░  ░
 ░   ▒   ░░         ░   ▒   ░         ░  ░░ ░   ░       ▒ ░░ ░   ░    ░   ░ ░  ▒ ░  ░         ░
     ░  ░               ░  ░░ ░       ░  ░  ░   ░  ░    ░        ░          ░  ░              ░  ░
-->

<!--
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-->

<!DOCTYPE html>
<html lang="en">
<head>
    <link rel="canonical" href="https://ignite.apache.org/in-memory-computing.html"/>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="Cache-Control" content="no-cache, no-store, must-revalidate"/>
    <meta http-equiv="Pragma" content="no-cache"/>
    <meta http-equiv="Expires" content="0"/>

    <title>In-Memory Computing - Apache Ignite</title>

    <meta name="description"
          content="In-memory computing is a type of software and data-processing technique that allows to store data sets
            in memory, across a cluster of inter-connected nodes, and process that data in parallel 100-1000x faster in
            comparison to disk-based systems."/>

    <!--#include virtual="/includes/styles.html" -->

    <!--#include virtual="/includes/sh.html" -->
</head>
<body>

<!--#include virtual="/includes/header.html" -->
<article>
    <header>
        <div class="container">
            <h1><strong>In-Memory Computing</strong> With Apache Ignite</h1>
        </div>
    </header>
    <div class="container">
        <p>
            In-memory computing is a software and data-processing technique that stores data sets in memory across a
            cluster of interconnected nodes. The data is processed in parallel to deliver performance that is 100-1000x
            faster than disk-based systems. In-memory computing software includes a distributed in-memory store with
            APIs and libraries optimized for high-performance data processing. Each cluster node (physical or virtual
            machine) contributes its available memory space with CPU cores to the total capacity of the cluster.
            An application interacts with the cluster as a single unit letting the in-memory computing software shield
            and manage all the internals related to inter-node communications, data distribution, and queries processing.
            The cluster scales linearly and horizontally to meet the data volume and throughput goals
            of the applications.
        </p>
        <p>
            Apache Ignite® is a horizontally scalable, fault-tolerant, distributed in-memory computing platform.
            You can use Ignite to build real-time applications processing terabytes of data at in-memory speeds.
            The Ignite distributed, multi-tier storage scales up and out across available memory and disk resources.
            Ignite can be configured to function as an in-memory cache, in-memory data grid, or in-memory database.
            The Ignite compute and data processing APIs are capable of handling large data sets with minimal or no
            network utilization by applying affinity co-location techniques for data and compute logic.
        </p>

        <div class="jumbotron jumbotron-fluid">
            <div class="container">
                <div class="title display-6">Learn More</div>
                <hr class="my-4">
                <div class="row">
                    <div class="col-sm-6">
                        <ul>
                            <li>
                                <p><a href="/use-cases/datagrid.html">
                                    Ignite as an In-Memory Data Grid <i class="fa fa-angle-double-right"></i>
                                </a></p>
                            </li>
                            <li>
                                <p><a href="/use-cases/in-memory-database.html">
                                    Ignite as an In-Memory Database <i class="fa fa-angle-double-right"></i></a>
                                </p>
                            </li>
                        </ul>
                    </div>
                    <div class="col-sm-6">
                        <ul>
                            <li>
                                <p><a href="/use-cases/in-memory-cache.html">
                                    Ignite as an In-Memory Cache <i class="fa fa-angle-double-right"></i>
                                </a></p>
                            </li>
                            <li><a href="/use-cases/hpc.html">High Performance Computing with Apache Ignite <i
                                    class="fa fa-angle-double-right"></i></a></li>
                        </ul>
                    </div>
                </div>
            </div>
        </div>

    </div>

</article>

<!--#include virtual="/includes/footer.html" -->

<!--#include virtual="/includes/scripts.html" -->
</body>
</html>