---
title: "reference-book/4-dataflows/Instantiate"
source: reference-book
version: genesis-0-1-0
id: reference-book/4-dataflows/Instantiate
canonical: /docs/reference-book/4-dataflows/Instantiate
---


We have reached one of the most special operators of Simorg, instantiate operator $$$KeywordSnippet keyword=#$$$.

This operator can be seen as equivalent to <<<import>>> statements of CPLs but, just like other operators, the similarity is only on the surface.

As the name <<<Instantiate>>> suggests, it is used to create new instances. These instances represent new shells which are generated from code.
So this operator is actually doing compilation of simorg's code at runtime. The most powerful usage of it is when it is being used alongside <<<Logos>>>, simorg's package manager.

Simorg sees <<<Logos>>> as the repository of blueprints. Actually, when you use $$$KeywordSnippet keyword=#$$$, a series of words are converted into entities or beings. More about *blueprints* and *logos* in future chapters.

Instantiate operator is playing a major role in simorg's ontology by creating the shells (which are the units of being in simorg)
out of simorg words (code).

Let's see three different usages of this operator.

## Compiling Simorg Code

$$$AlertBox type=WARNING title=To Be Available Soon... message=This behavior will be supported in futue releases and is not available in PoC version.$$$

Let's see our <<<Hello World!>>> example, but this time using <<<Instantiate>>> operator:

```
 "'Hello World!'?" #myCode
```

 The code <<<"Hello World!":?>>> is simply logging out <<<Hello World!>>> but now we are using it as a string value and pushing it into instantiate operator.

As soon as instantiate operator receives its vibration, it compiles the code and executes it in the current location.

The result will be a series of shells created and added to the current location.

So we will have our <<<Hello World!>>> visible in the terminal.

### Logos Blueprints

As we touched briefly, Simorg has a package manager called <<<Logos>>>, the repository of blueprints of creation. They can be instantiated inside your application.

We will discuss more details in *Blueprints* chapter. For now, let's just celebrate this amazing moment by bringing a delay plugin blueprint into our code and create 3 seconds of delay.

```
"@simorg/time0.1.0" #delay 
"Waiting for 3 Seconds..." ? 3 delay.sec  "Done!" ?
```

By running this code, you will have two subsequent logs appear in console with a delay of <<<3>>> seconds.
Actually, <<<delay.sec>>> is receiving a number representing delay amount in seconds, then it vibrates back the same value out and it vibrates the value literal next to it and finally the logger will receive it.

You got access to a piece of functionality that is created and published freely on Logos.

### Local Blueprints

$$$AlertBox type=WARNING title=To Be Available Soon... message=This behavior will be supported in futue releases and is not available in PoC version.$$$

The final use-case is to instantiate a local blueprint which is represented by a local file.

This approach is usually used to modularize the code in order to have a scalable structure.
Let's see this using an example:

Create a file beside the <<<main.art>>> and let's call it <<<local.art>>>.
Add the following code inside <<<local.art>>>:

```
"Hello from local.art"?
```

Inside <<<main.art>>> we will use the following code,

```
"./local.art" #local
```

Running <<<main.art>>>,

"""
sim main.sim
"""
Hello from local.art
!!!!

So we will have <<<local.art>>> instantiated and executed, making our message appear in the console.


$$$AlertBox type=INFO title=Instantiation Behavior message=Each time we instantiate, new sets of shells are created out of nothingness.$$$ 

$$$AlertBox type=INFO title=Identifier Is Required message=Using => itself is not enough to instantiate. Only when the vibration reaches a Declaration Reference, it will complete the instantiation process.$$$