<!DOCTYPE html>
<html lang="en">
<!-- Global site tag (gtag.js) - Google Analytics -->
<script async src="https://www.googletagmanager.com/gtag/js?id=UA-112407000-2"></script>
<script>
    window.dataLayer = window.dataLayer || [];

    function gtag() {
        dataLayer.push(arguments);
    }
    gtag('js', new Date());

    gtag('config', 'UA-112407000-2');
</script>

<!-- Google Tag Manager -->
<script>
    (function (w, d, s, l, i) {
        w[l] = w[l] || [];
        w[l].push({
            'gtm.start': new Date().getTime(),
            event: 'gtm.js'
        });
        var f = d.getElementsByTagName(s)[0],
            j = d.createElement(s),
            dl = l != 'dataLayer' ? '&l=' + l : '';
        j.async = true;
        j.src =
            'https://www.googletagmanager.com/gtm.js?id=' + i + dl;
        f.parentNode.insertBefore(j, f);
    })(window, document, 'script', 'dataLayer', 'GTM-KS8HHSF');
</script>
<!-- End Google Tag Manager -->

<head>
    	<title>Installing Codewind for Eclipse | Codewind</title>
	<meta charset="utf-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
	<meta name="viewport" content="width=device-width, initial-scale=1">
	<meta name="description" content="Installing Codewind for Eclipse">
	<meta name="keywords" content="introducing, introduction, overview, what is, tools, eclipse, getting started, Codewind for Eclipse, work within Eclipse"/>
	<link rel="icon" type="image/png" sizes="16x16" href="images/favicon/favicon-16x16.png">
	<link rel="icon" type="image/png" sizes="32x32" href="images/favicon/favicon-32x32.png">
	<link href="https://fonts.googleapis.com/css?family=IBM+Plex+Sans:300,400,600&display=swap" rel="stylesheet">
	<!-- Bootstrap CSS CDN -->
	<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css"
	integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">
	<link href="https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css" rel="stylesheet" />
	<link rel="stylesheet" href="css/styles.css">
	<link rel="stylesheet" href="css/docs.css">
	<link rel="stylesheet" href="css/blog.css">
	<link rel="stylesheet" href="css/guides.css">
	<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.17.1/themes/prism.min.css">
	

</head>

<body data-spy="scroll" data-target="#toc">
    <!-- Google Tag Manager (noscript) -->
    <noscript><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-KS8HHSF"
        height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
        <!-- End Google Tag Manager (noscript) -->
    <div class="main">
    <!-- Bootstrap NavBar -->
	<nav class="navbar navbar-expand-lg navbar-light cw-banner fixed-top" aria-label="topnav">
    		        <button class="navbar-toggler navbar-toggler-right" type="button" data-toggle="collapse"
            data-target="#navbarNavDropdown" aria-controls="navbarNavDropdown" aria-expanded="false"
            aria-label="Toggle navigation">
            <span class="navbar-toggler-icon"></span>
        </button>
        <a class="navbar-brand" href="/codewind/">
            <img alt="Codewind logo image"  title="Codewind logo image" src="images/header/header-logo.svg" class="cw-header-logo" alt="">
        </a>
        <div class="collapse navbar-collapse justify-content-end cw-navbar-padding" id="navbarNavDropdown">
            <ul class="navbar-nav cw-navbar-nav">
                
                <li class="nav-item cw-navbar-item cw-header-link-docs">
                    <a class="nav-link cw-nav-link cw-header-link-text" href="overview.html">Docs</a>
                </li>
                <li class="nav-item cw-navbar-item cw-header-link-news">
                    <a class="nav-link cw-nav-link cw-header-link-text" href="news.html">News</a>
                </li>
                
                <li class="nav-item cw-navbar-item cw-header-link-blog">
                    <a class="nav-link cw-nav-link cw-header-link-text" href="blog.html">Blog</a>
                </li>
                
                <li class="nav-item cw-navbar-item cw-header-link-guides">
                    <a class="nav-link cw-nav-link cw-header-link-text" href="guides.html">Guides</a>
                </li>

                 <li class="nav-item cw-navbar-item cw-header-link">
                    <a class="nav-link cw-nav-link" href="https://github.com/eclipse/codewind"><img alt="Codewind Github"  class="banner-image"  title="Codewind Github" data-toggle="tooltip" data-placement="top" id="cw_github_stars" title="..." src="images/header/github.svg"/></a>
                </li>
                
                <li class="nav-item cw-navbar-item cw-header-link">
                    <a class="nav-link cw-nav-link" href="https://twitter.com/EclipseCodewind"><img alt="Codewind Twitter"  class="banner-image" title="Codewind Twitter" src="images/header/twitter.png"/></a>
                </li>
                 <li class="nav-item cw-navbar-item cw-header-link">
                    <a class="nav-link cw-nav-link" href="https://mattermost.eclipse.org/eclipse/channels/eclipse-codewind"><img alt="Codewind Mattermost"  class="banner-image"  title="Codewind Mattermost" src="images/header/mattermost.png"/></a>
                </li>
                <li class="nav-item cw-navbar-item cw-header-link">
                    <a class="nav-link cw-nav-link" href="https://www.youtube.com/channel/UCnKCVK6RFDyHFqUmXlAhCHQ"><img alt="Codewind YouTube"  class="banner-image" title="Codewind YouTube" src="images/header/youtube.png"/></a>
                </li>
               
               
                <!-- li class="nav-item cw-navbar-item" id="download-li">
                    <button onClick="window.location.href='https://microclimate.dev/download/codewind';" type="button" class="btn cw-download-button">Download</button>
                    <a href="https://microclimate.dev/download/codewind" class="nav-link cw-nav-link cw-download-link" href="#">Download</a>
                </li>  -->


                
                <!-- Smaller devices menu END -->

            </ul>
        </div>

    	</nav>
    	<!-- End Bootstrap NavBar -->
<!-- Bootstrap row -->
<div class="row" id="body-row">
    <!-- Sidebar -->
    <div id="sidebar-container" class="bg-light"  role="navigation" aria-label="sidebar">
        <!-- Bootstrap List Group -->
        <ul class="list-group sticky-top bg-light cw-sticky-offset">
            
            

				
				<a href="overview.html" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-url="overview.html">
					What is Codewind?
				</a>
				

			

				


				

				<a href="#getting_started" id="#getting_started" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" aria-expanded="false">Getting started<span class="submenu-icon"></span></a>
				<div class="cw-sidebar-div cw-sidebar-submenu collapse" id="getting_started">

					
					
						
							<a href="gettingstarted.html" class="bg-light list-group-item" data-parent="#getting_started" data-url="gettingstarted.html">Overview: Getting started</a>
						
					
					
					
						

							

							<a href="#vs_code" id="#vs_code" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" data-parent="#getting_started" aria-expanded="false">VS Code<span class="submenu-icon"></span></a>

							<div class="cw-sidebar-div cw-sidebar-submenu-submenu collapse" id="vs_code">
								
									
										<a href="vsc-getting-started.html" class="bg-light list-group-item" data-parent="#vs_code" data-url="vsc-getting-started.html">Installing Codewind for VS Code</a>
									
										<a href="vsc-firstproject.html" class="bg-light list-group-item" data-parent="#vs_code" data-url="vsc-firstproject.html">Creating your first Codewind project with Codewind for VS Code</a>
									
										<a href="vsc-codechange.html" class="bg-light list-group-item" data-parent="#vs_code" data-url="vsc-codechange.html">Making a code change with VS Code</a>
									
							</div>
						
					
					
					
						

							

							<a href="#eclipse" id="#eclipse" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" data-parent="#getting_started" aria-expanded="false">Eclipse<span class="submenu-icon"></span></a>

							<div class="cw-sidebar-div cw-sidebar-submenu-submenu collapse" id="eclipse">
								
									
										<a href="eclipse-getting-started.html" class="bg-light list-group-item" data-parent="#eclipse" data-url="eclipse-getting-started.html">Installing Codewind for Eclipse</a>
									
										<a href="eclipse-firstproject.html" class="bg-light list-group-item" data-parent="#eclipse" data-url="eclipse-firstproject.html">Creating your first Codewind project with Codewind for Eclipse</a>
									
										<a href="eclipse-codechange.html" class="bg-light list-group-item" data-parent="#eclipse" data-url="eclipse-codechange.html">Making a code change with Eclipse</a>
									
							</div>
						
					
					
					
						

							

							<a href="#intellij" id="#intellij" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" data-parent="#getting_started" aria-expanded="false">IntelliJ<span class="submenu-icon"></span></a>

							<div class="cw-sidebar-div cw-sidebar-submenu-submenu collapse" id="intellij">
								
									
										<a href="intellij-getting-started.html" class="bg-light list-group-item" data-parent="#intellij" data-url="intellij-getting-started.html">Installing Codewind for IntelliJ</a>
									
										<a href="intellij-firstproject.html" class="bg-light list-group-item" data-parent="#intellij" data-url="intellij-firstproject.html">Creating your first Codewind project with Codewind for IntelliJ</a>
									
										<a href="intellij-codechange.html" class="bg-light list-group-item" data-parent="#intellij" data-url="intellij-codechange.html">Making a code change with IntelliJ</a>
									
							</div>
						
					
					
				</div>
				

			

				


				

				<a href="#using_codewind_as_a_hosted_application_on_the_cloud" id="#using_codewind_as_a_hosted_application_on_the_cloud" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" aria-expanded="false">Using Codewind as a hosted application on the cloud<span class="submenu-icon"></span></a>
				<div class="cw-sidebar-div cw-sidebar-submenu collapse" id="using_codewind_as_a_hosted_application_on_the_cloud">

					
					
						
							<a href="eclipseche-codewind-overview.html" class="bg-light list-group-item" data-parent="#using_codewind_as_a_hosted_application_on_the_cloud" data-url="eclipseche-codewind-overview.html">Overview: Using Codewind as a hosted application on the cloud</a>
						
					
					
					
						

							

							<a href="#eclipse_che" id="#eclipse_che" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" data-parent="#using_codewind_as_a_hosted_application_on_the_cloud" aria-expanded="false">Eclipse Che<span class="submenu-icon"></span></a>

							<div class="cw-sidebar-div cw-sidebar-submenu-submenu collapse" id="eclipse_che">
								
									
										<a href="che-installinfo.html" class="bg-light list-group-item" data-parent="#eclipse_che" data-url="che-installinfo.html">Installing Eclipse Che for Codewind</a>
									
										<a href="che-createcodewindworkspace.html" class="bg-light list-group-item" data-parent="#eclipse_che" data-url="che-createcodewindworkspace.html">Creating a Codewind workspace in Che</a>
									
										<a href="che-setupregistries.html" class="bg-light list-group-item" data-parent="#eclipse_che" data-url="che-setupregistries.html">Adding an image registry in Codewind in Che</a>
									
										<a href="che-codechange.html" class="bg-light list-group-item" data-parent="#eclipse_che" data-url="che-codechange.html">Making a code change with Codewind for Eclipse Che</a>
									
										<a href="che-createfirstproject.html" class="bg-light list-group-item" data-parent="#eclipse_che" data-url="che-createfirstproject.html">Creating your first Codewind project with Codewind for Eclipse Che</a>
									
										<a href="che-tektonpipelines.html" class="bg-light list-group-item" data-parent="#eclipse_che" data-url="che-tektonpipelines.html">Configuring Codewind for Tekton pipelines</a>
									
										<a href="che-odo-support.html" class="bg-light list-group-item" data-parent="#eclipse_che" data-url="che-odo-support.html">OpenShift Do (odo) support in Codewind</a>
									
										<a href="openshiftregistry.html" class="bg-light list-group-item" data-parent="#eclipse_che" data-url="openshiftregistry.html">Adding the OpenShift internal registry with Codewind</a>
									
										<a href="che-uninstall.html" class="bg-light list-group-item" data-parent="#eclipse_che" data-url="che-uninstall.html">Uninstalling Codewind for Eclipse Che</a>
									
							</div>
						
					
					
				</div>
				

			

				
				<a href="remote-deploying-codewind.html" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-url="remote-deploying-codewind.html">
					Deploying Codewind remotely
				</a>
				

			

				


				

				<a href="#using_codewind_remotely" id="#using_codewind_remotely" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" aria-expanded="false">Using Codewind remotely<span class="submenu-icon"></span></a>
				<div class="cw-sidebar-div cw-sidebar-submenu collapse" id="using_codewind_remotely">

					
					
						
							<a href="remote-codewind-overview.html" class="bg-light list-group-item" data-parent="#using_codewind_remotely" data-url="remote-codewind-overview.html">Overview: Using Codewind remotely</a>
						
					
					
					
						

							

							<a href="#connecting_your_ide_to_remote_codewind" id="#connecting_your_ide_to_remote_codewind" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" data-parent="#using_codewind_remotely" aria-expanded="false">Connecting your IDE to remote Codewind<span class="submenu-icon"></span></a>

							<div class="cw-sidebar-div cw-sidebar-submenu-submenu collapse" id="connecting_your_ide_to_remote_codewind">
								
									
										<a href="remotedeploy-vscode.html" class="bg-light list-group-item" data-parent="#connecting_your_ide_to_remote_codewind" data-url="remotedeploy-vscode.html">Connecting VS Code to remote Codewind</a>
									
										<a href="remotedeploy-eclipse.html" class="bg-light list-group-item" data-parent="#connecting_your_ide_to_remote_codewind" data-url="remotedeploy-eclipse.html">Connecting Eclipse to remote Codewind</a>
									
							</div>
						
					
					
					
						
							<a href="remote-setupregistries.html" class="bg-light list-group-item" data-parent="#using_codewind_remotely" data-url="remote-setupregistries.html">Adding an image registry in remote Codewind</a>
						
					
					
					
						
							<a href="remotedeploy-projects-vscode.html" class="bg-light list-group-item" data-parent="#using_codewind_remotely" data-url="remotedeploy-projects-vscode.html">Creating and importing projects</a>
						
					
					
				</div>
				

			

				
				<a href="workingwithtemplates.html" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-url="workingwithtemplates.html">
					Working with templates
				</a>
				

			

				


				

				<a href="#developing_projects" id="#developing_projects" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" aria-expanded="false">Developing projects<span class="submenu-icon"></span></a>
				<div class="cw-sidebar-div cw-sidebar-submenu collapse" id="developing_projects">

					
					
						
							<a href="checkingstatuses.html" class="bg-light list-group-item" data-parent="#developing_projects" data-url="checkingstatuses.html">Understanding application and build statuses</a>
						
					
					
					
						
							<a href="importing-existing-projects.html" class="bg-light list-group-item" data-parent="#developing_projects" data-url="importing-existing-projects.html">Importing existing projects</a>
						
					
					
					
						
							<a href="project-actions.html" class="bg-light list-group-item" data-parent="#developing_projects" data-url="project-actions.html">Project actions</a>
						
					
					
					
						
							<a href="project-settings.html" class="bg-light list-group-item" data-parent="#developing_projects" data-url="project-settings.html">Project settings</a>
						
					
					
					
						
							<a href="referencing-files.html" class="bg-light list-group-item" data-parent="#developing_projects" data-url="referencing-files.html">Referencing files external to a project</a>
						
					
					
					
						
							<a href="private-registries.html" class="bg-light list-group-item" data-parent="#developing_projects" data-url="private-registries.html">Developing with packages from private registries and repositories</a>
						
					
					
					
						
							<a href="offline-codewind.html" class="bg-light list-group-item" data-parent="#developing_projects" data-url="offline-codewind.html">Using Codewind offline</a>
						
					
					
					
						
							<a href="debugging.html" class="bg-light list-group-item" data-parent="#developing_projects" data-url="debugging.html">Debugging in Codewind</a>
						
					
					
				</div>
				

			

				


				

				<a href="#performance_monitoring" id="#performance_monitoring" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" aria-expanded="false">Performance monitoring<span class="submenu-icon"></span></a>
				<div class="cw-sidebar-div cw-sidebar-submenu collapse" id="performance_monitoring">

					
					
						
							<a href="metrics-dashboard.html" class="bg-light list-group-item" data-parent="#performance_monitoring" data-url="metrics-dashboard.html">Understanding the Metrics Dashboard</a>
						
					
					
					
						
							<a href="performance.html" class="bg-light list-group-item" data-parent="#performance_monitoring" data-url="performance.html">Monitoring applications with the Performance Dashboard</a>
						
					
					
				</div>
				

			

				


				

				<a href="#openapi_tools" id="#openapi_tools" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" aria-expanded="false">OpenAPI Tools<span class="submenu-icon"></span></a>
				<div class="cw-sidebar-div cw-sidebar-submenu collapse" id="openapi_tools">

					
					
						
							<a href="open-api-tools-for-vscode.html" class="bg-light list-group-item" data-parent="#openapi_tools" data-url="open-api-tools-for-vscode.html">Codewind OpenAPI Tools for VS Code</a>
						
					
					
					
						
							<a href="open-api-tools-for-eclipse.html" class="bg-light list-group-item" data-parent="#openapi_tools" data-url="open-api-tools-for-eclipse.html">Codewind OpenAPI Tools for Eclipse</a>
						
					
					
				</div>
				

			

				
				<a href="troubleshooting.html" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-url="troubleshooting.html">
					Troubleshooting
				</a>
				

			
            
        </ul>
        <!-- List Group END-->
    </div>
    <!-- sidebar-container END -->
    <!-- MAIN -->
    <div id="content-container">
    		<div class="py-5 px-5">
    		    <div class="cw-docs-spacer"></div>
        		<div role="main"><h1 id="getting-started-with-codewind">Getting Started with Codewind</h1>

<p>There are three ways of using Codewind - locally, remotely or as a hosted application on the cloud. To get started, <strong>you can try out Codewind by using the local configuration</strong>. In this configuration, you create, develop, build and run your containerised applications on your local machine using your local IDE.</p>

<p>Follow the instructions to get started with using Codewind locally. This will guide you through:</p>

<ol>
  <li>Installing Codewind into your IDE on your local machine</li>
  <li>Creating your first project</li>
  <li>Making a code change to try out the inner loop experience</li>
</ol>

<p>Select your IDE to get started:</p>

<ul>
  <li><a href="./vsc-getting-started.html#installing-codewind-for-vs-code">VS Code</a></li>
  <li><a href="./eclipse-getting-started.html#installing-codewind-for-eclipse">Eclipse</a></li>
  <li><a href="./intellij-getting-started.html#installing-codewind-for-intellij">IntelliJ</a></li>
</ul>

<p><strong>Codewind on Eclipse Che</strong> If you want to go straight to using Codewind as a hosted application in the cloud, follow <a href="./che-installinfo.html">these instructions</a>.</p>

<p><strong>Using Codewind Remotely</strong> If you want to use Codewind remotely, you must first <a href="#installing-codewind-for-vs-code">follow the step to install Codewind locally</a>. By <a href="./remote-codewind-overview.html">using Codewind remotely</a>, Codewind is configured for making code changes on your local IDE but building and running your application in the cloud. Once you have installed Codewind remotely, you can proceed to either:</p>

<ol>
  <li>Deploy Codewind to your cloud if not already done so by you or a sysadmin/DevOps engineer. See tutorial <a href="./remote-deploying-codewind.html">Deploying Codewind Remotely</a>.</li>
  <li>Connect your Codewind extension of your local desktop IDE to Codewind in your cloud by following the tutorial <a href="./remote-codewind-overview.html">Using Codewind Remotely</a>.</li>
</ol>

<p><strong>The different configurations of Codewind</strong> To find out about the different ways of using Codewind - locally, remotely, or as an application hosted on the cloud - see <a href="./overview.html#architecture">Codewind Architecture</a>.</p>

<h3 id="installing-codewind-for-eclipse">Installing Codewind for Eclipse</h3>

<p>Install Codewind for Eclipse to develop your containerized projects from within Eclipse.</p>

<p>To install Codewind for Eclipse, complete the following steps:</p>

<ol>
  <li>Download and install the latest <a href="https://www.eclipse.org/downloads/packages/">Eclipse IDE for Enterprise Java Developers</a> or use an existing installation.
    <ul>
      <li>Install Eclipse IDE Version 2019-09 R (4.13.0) or later to avoid <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=541220">Bug 541220</a>.</li>
      <li><strong>Note:</strong> The earliest supported version of the Eclipse IDE is Version 2019-03 (4.11).</li>
    </ul>
  </li>
  <li>Install <a href="https://docs.docker.com/install/">Docker</a> 17.06 or later. If you use Linux, you must also install <a href="https://docs.docker.com/compose/install/">Docker Compose</a>.</li>
  <li>If you are installing Codewind on Windows, enable your local drive for sharing in Docker. To do this, open the <strong>Docker Settings</strong> window, click the <strong>Shared Drives</strong> tab, and select the drive on which you are installing Codewind.</li>
  <li>Install <a href="https://marketplace.eclipse.org/content/codewind">Codewind from Eclipse Marketplace</a>.
    <ul>
      <li><a href="http://marketplace.eclipse.org/marketplace-client-intro?mpc_install=4638524" title="Drag to your running Eclipse* workspace. *Requires Eclipse Marketplace Client"><img src="https://marketplace.eclipse.org/sites/all/themes/solstice/public/images/marketplace/btn-install.png" alt="Drag to your running Eclipse workspace. " /></a> Drag this install button to your running Eclipse workspace.
        <ul>
          <li><strong>Note:</strong> You must have the Eclipse Marketplace Client.</li>
        </ul>
      </li>
      <li>To install from the Eclipse IDE, complete the following steps:
        <ol>
          <li>Open the Eclipse IDE and navigate to <strong>Help</strong>&gt;<strong>Eclipse Marketplace</strong>.</li>
          <li>Search for <code class="highlighter-rouge">Codewind</code>.</li>
          <li>Click the <strong>Install</strong> button.</li>
          <li>Finish the wizard and accept licenses as needed.</li>
          <li>When the installation is complete, restart Eclipse.</li>
        </ol>
      </li>
    </ul>
  </li>
  <li>Open the Codewind view.
    <ul>
      <li>Navigate to <strong>Window</strong>&gt;<strong>Show View</strong>&gt;<strong>Other…</strong>&gt;<strong>Codewind</strong>&gt;<strong>Codewind Explorer</strong></li>
    </ul>
  </li>
  <li>Codewind requires the installation of additional Docker images to run.  Double-click the <strong>Codewind</strong> item in the Codewind Explorer view to complete the installation. The installation might take a few minutes to complete.</li>
</ol>

<p><img src="images/eclipseinstall1.png" alt="image of Codewind once installed" width="800px" /></p>

<p>7. After the installation completes, you have a running local connection in the Codewind Explorer view.</p>

<p><img src="images/eclipseinstall2.png" alt="image of Codewind once installed" width="800px" /></p>

<h3 id="after-installation">After installation</h3>

<p><strong>Getting started with Codewind - next steps</strong> Continue to instructions for <a href="./eclipse-firstproject.html">creating your first Eclipse Codewind Project</a>.</p>

<p><strong>Installing Codewind for remote use</strong> If you intend to use Codewind <a href="./remote-codewind-overview.html">remotely</a>, you have now completed the pre-requisite step of installing Codewind on your local machine and can proceed to:</p>

<ol>
  <li>Deploy Codewind to your cloud if not already done so by you or a sysadmin/DevOps engineer. See tutorial <a href="./remote-deploying-codewind.html">Deploying Codewind Remotely</a>.</li>
  <li>Connect your Codewind extension of your local desktop IDE to Codewind in your cloud by following the tutorial <a href="./remote-codewind-overview.html">Using Codewind Remotely</a>.</li>
</ol>
</div>
        </div>
        
        <div class="py-5 px-5 text-right">
        Last update: May 08, 2020
        </div>
        
    </div>
    
</div>
<!-- footer row -->
<footer>

<div id="footer-div-mobile">
        
        <div class="row">
	        <div class="col-sm-12 text-center">
		        <span>Useful Links:</span>
		        <br/><br/>
		        <a class="cw-footer-links" href="http://www.eclipse.org">Eclipse Foundation</a><br/>
		        <a class="cw-footer-links" href="http://www.eclipse.org/legal/privacy.php">Privacy Policy</a><br/>
		        <a class="cw-footer-links" href="http://www.eclipse.org/legal/termsofuse.php">Website Terms of Use</a><br/>
		        <a class="cw-footer-links" href="http://www.eclipse.org/legal/copyright.php">Copyright Agent</a><br/>
		        <a class="cw-footer-links" href="http://www.eclipse.org/legal">Legal</a><br/>
		    </div>
        </div>
        <div class="cw_footer_display_flex cw-footer-same-height cw-footer-center">
        
        <div class="cw_footer_display_icons row">
    		<div class="cw-footer-col text-center col-md-3 col-sm-6 col-xs-12">
            <div>
                <div>
                    <a href="mailto:codewind-dev@eclipse.org"><img alt="Send us an email"  title="Send us an email" src="images/footer/email-icon.svg" class="cw-logo" /></a>
                </div>
            </div>
        </div>
        <div class="cw-footer-col text-center col-md-3 col-sm-6 col-xs-12">
            <div>
                <div>
                    <a href="https://twitter.com/EclipseCodewind"><img alt="Codewind Twitter"  title="Codewind Twitter" src="images/footer/twitter-logo.svg" class="cw-logo" /></a>
                </div>
            </div>
        </div>
        
        <div class="cw-footer-col text-center col-md-3 col-sm-6 col-xs-12">
            <div>
                <div>
                    <a href="https://github.com/eclipse/codewind"><img alt="Codewind Github"  title="Codewind Github" src="images/footer/github-logo.svg"
                            class="cw-logo" /></a>
                </div>
            </div>
        </div>
        

        <div class=" cw-footer-col text-center col-md-3 col-sm-6 col-xs-12">
            <div>
                <div>
                    <a href="https://mattermost.eclipse.org/eclipse/channels/eclipse-codewind"><img alt="Codewind Mattermost"  title="Codewind Mattermost" src="images/footer/mattermost-logo.png" class="cw-logo-mm" /></a>
                </div>
            </div>
        </div>
        <div class="cw-footer-col text-center col-md-3 col-sm-6 col-xs-12">
            <div>
                <div>
                    <a href="https://www.youtube.com/channel/UCnKCVK6RFDyHFqUmXlAhCHQ"><img alt="Codewind YouTube"  title="Codewind YouTube" src="images/footer/youtube-logo-dark.svg"
                            class="cw-logo" /></a>
                </div>
            </div>
        </div>
        <div class="cw-footer-col text-center col-md-3 col-sm-6 col-xs-12">
            <div>
                <div>
                    
                    <a href="http://www.eclipse.org"><img class="cw-logo-eclipse-mobile" alt="Eclipse"  title="Eclipse" src="images/footer/eclipse.svg"/></a>
                </div>
            </div>
        </div>
        </div>
        
		</div>
		
    </div>
    
    
    <div class="row cw-footer-desktop" id="footer-div">
        <div class="cw-footer-left">
        		<div class="px-5 cw-font-12>
	        <span class="cw-font-14">Useful Links:</span>
	        <br/><br/>
	        <a class="cw-footer-links" href="http://www.eclipse.org">Eclipse Foundation</a><br/>
	        <a class="cw-footer-links" href="http://www.eclipse.org/legal/privacy.php">Privacy Policy</a><br/>
	        <a class="cw-footer-links" href="http://www.eclipse.org/legal/termsofuse.php">Website Terms of Use</a><br/>
	        <a class="cw-footer-links" href="http://www.eclipse.org/legal/copyright.php">Copyright Agent</a><br/>
	        <a class="cw-footer-links" href="http://www.eclipse.org/legal">Legal</a><br/>
	        </div>
	        
        </div>
        <div class="cw-footer-border-right"></div>
        <div class="cw_footer_display_flex cw-footer-same-height cw-footer-center">
        <div class="cw_footer_display_icons">
    		<div class="cw-footer-col text-center">
            <div>
                <div>
                    <a href="mailto:codewind-dev@eclipse.org"><img alt="Send us an email"  title="Send us an email" src="images/footer/email-icon.svg" class="cw-logo" /></a>
                </div>
            </div>
        </div>
        <div class="cw-footer-col text-center">
            <div>
                <div>
                    <a href="https://twitter.com/EclipseCodewind"><img alt="Codewind Twitter"  title="Codewind Twitter" src="images/footer/twitter-logo.svg" class="cw-logo" /></a>
                </div>
            </div>
        </div>
        
        <div class="cw-footer-col text-center">
            <div>
                <div>
                    <a href="https://github.com/eclipse/codewind"><img alt="Codewind Github"  title="Codewind Github" src="images/footer/github-logo.svg"
                            class="cw-logo" /></a>
                </div>
            </div>
        </div>
        

        <div class=" cw-footer-col text-center">
            <div class="cw-logo-mm" >
                <div class="cw-logo-mm" >
                    <a href="https://mattermost.eclipse.org/eclipse/channels/eclipse-codewind"><img alt="Codewind Mattermost"  title="Codewind Mattermost" src="images/footer/mattermost-logo.png" class="cw-logo-mm" /></a>
                </div>
            </div>
        </div>
        <div class="cw-footer-col text-center">
            <div>
                <div>
                    <a href="https://www.youtube.com/channel/UCnKCVK6RFDyHFqUmXlAhCHQ"><img alt="Codewind YouTube"   title="Codewind YouTube" src="images/footer/youtube-logo-dark.svg"
                            class="cw-logo" /></a>
                </div>
            </div>
        </div>
        
        </div>
        
		</div>
		<div class="cw-footer-border-right"></div>
		<div class="cw-footer-right cw-footer-same-height cw-footer-vcenter">
		<div class="cw-footer-eclipse-img cw-footer-same-height px-5 ">
	        
		<a href="http://www.eclipse.org">
		<img alt="Eclipse"  title="Eclipse" src="images/footer/eclipse.svg"/>
		</a>
	        </div>
		</div>
    </div>
</footer>
<!-- footer row END -->
<!-- Main Col END -->
 <!-- Jquery -->
<script
  src="https://code.jquery.com/jquery-3.4.1.min.js"
  integrity="sha256-CSXorXvZcTkaix6Yvo6HppcZGetbYMGWSFlBw8HfCJo="
  crossorigin="anonymous"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.7/umd/popper.min.js"
    integrity="sha384-UO2eT0CpHqdSJQ6hJty5KVphtPhzWj9WO1clHTMGa3JDZwrnQq4sF86dIHNDz0W1" crossorigin="anonymous">
</script>



<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js"
    integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM" crossorigin="anonymous">
</script>


<!-- Font Awesome JS -->
<script defer src="https://use.fontawesome.com/releases/v5.0.13/js/solid.js"
    integrity="sha384-tzzSw1/Vo+0N5UhStP3bvwWPq+uvzCMfrN1fEFe+xBmv1C/AtVX5K0uZtmcHitFZ" crossorigin="anonymous">
</script>
<script defer src="https://use.fontawesome.com/releases/v5.0.13/js/fontawesome.js"
    integrity="sha384-6OIrr52G08NpOFSZdxxz1xdNSndlD4vdcf/q2myIUVO0VsqaGHJsB0RaBE01VTOY" crossorigin="anonymous">
</script>

<script src="js/jquery.matchHeight-min.js"></script>
<script src="js/index.js"></script>
<script src="js/docs.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.17.1/prism.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.17.1/components/prism-docker.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.17.1/components/prism-json.min.js"></script>

</div>
</body>

</html>
 
 
 
 <script src="https://cdnjs.cloudflare.com/ajax/libs/anchor-js/4.2.0/anchor.min.js"></script>
 <script>
$(document).ready(function(){
	
    anchors.options.placement = 'left';
    anchors.add('h1');
    anchors.add('h2');
    anchors.add('h3');
    anchors.add('h4');
});
</script>
 