<!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>OpenShift Do (odo) support in Codewind | 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="OpenShift Do (odo) support in Codewind">
	<meta name="keywords" content="build, develop, deploy, install, installing, installation, Codewind for Eclipse Che, cloud, public cloud, services, command line, cli, command, devops, OpenS..."/>
	<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/learn.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="learn.html">Learn</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">
    <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>
        

        

        


        <!-- must be a valid css selector, or will break collapse function -->
        

        <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-overview.html" class="bg-light list-group-item" data-parent="#_getting_started"
                data-url="gettingstarted-overview.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">1. 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">2. 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">3. 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">1. Installing Codewind for Eclipse</a>
                
                <a href="eclipse-firstproject.html" class="bg-light list-group-item" data-parent="#_eclipse"
                    data-url="eclipse-firstproject.html">2. 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">3. 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">1. Installing Codewind for IntelliJ</a>
                
                <a href="intellij-firstproject.html" class="bg-light list-group-item" data-parent="#_intellij"
                    data-url="intellij-firstproject.html">2. 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">3. Making a code change with IntelliJ</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>
        

        

        


        <!-- must be a valid css selector, or will break collapse function -->
        

        <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">1. Overview: Using Codewind remotely</a>
            

            

            

            

            <a href="#_2_connecting_your_ide_to_remote_codewind" id="#_2_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">2. Connecting your IDE to remote Codewind<span
                    class="submenu-icon"></span></a>

            <div class="cw-sidebar-div cw-sidebar-submenu-submenu collapse" id="_2_connecting_your_ide_to_remote_codewind">

                
                <a href="remotedeploy-vscode.html" class="bg-light list-group-item" data-parent="#_2_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="#_2_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">3. Adding an image registry in remote Codewind</a>
            

            

            

            

            <a href="#_4_creating_and_importing_projects" id="#_4_creating_and_importing_projects"
                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">4. Creating and importing projects<span
                    class="submenu-icon"></span></a>

            <div class="cw-sidebar-div cw-sidebar-submenu-submenu collapse" id="_4_creating_and_importing_projects">

                
                <a href="remotedeploy-projects-vscode.html" class="bg-light list-group-item" data-parent="#_4_creating_and_importing_projects"
                    data-url="remotedeploy-projects-vscode.html">VS Code</a>
                
                <a href="remotedeploy-projects-eclipse.html" class="bg-light list-group-item" data-parent="#_4_creating_and_importing_projects"
                    data-url="remotedeploy-projects-eclipse.html">Eclipse</a>
                
            </div>
            

            
        </div>
        

        

        


        <!-- must be a valid css selector, or will break collapse function -->
        

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

            

            
            <a href="che-installinfo.html" class="bg-light list-group-item" data-parent="#_using_codewind_on_eclipse_che"
                data-url="che-installinfo.html">1. Installing Eclipse Che for Codewind</a>
            

            

            
            <a href="che-setupregistries.html" class="bg-light list-group-item" data-parent="#_using_codewind_on_eclipse_che"
                data-url="che-setupregistries.html">2. Adding an image registry in Codewind on Eclipse Che</a>
            

            

            
            <a href="openshiftregistry.html" class="bg-light list-group-item" data-parent="#_using_codewind_on_eclipse_che"
                data-url="openshiftregistry.html">2a. Adding the OpenShift internal registry with Codewind</a>
            

            

            
            <a href="che-createcodewindworkspace.html" class="bg-light list-group-item" data-parent="#_using_codewind_on_eclipse_che"
                data-url="che-createcodewindworkspace.html">3. Creating a Codewind workspace in Eclipse Che</a>
            

            

            
            <a href="che-createfirstproject.html" class="bg-light list-group-item" data-parent="#_using_codewind_on_eclipse_che"
                data-url="che-createfirstproject.html">4. Creating your first Codewind project with Codewind for Eclipse Che</a>
            

            

            
            <a href="che-codechange.html" class="bg-light list-group-item" data-parent="#_using_codewind_on_eclipse_che"
                data-url="che-codechange.html">5. Making a code change with Codewind for Eclipse Che</a>
            

            

            
            <a href="che-uninstall.html" class="bg-light list-group-item" data-parent="#_using_codewind_on_eclipse_che"
                data-url="che-uninstall.html">6. Uninstalling Codewind for Eclipse Che</a>
            

            
        </div>
        

        

        
        <a href="che-odo-support.html"
            class="bg-light list-group-item list-group-item-action flex-column align-items-start"
            data-url="che-odo-support.html">
            OpenShift Do (odo) support in Codewind
        </a>
        

        

        
        <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>
        

        

        


        <!-- must be a valid css selector, or will break collapse function -->
        

        <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>
        

        

        


        <!-- must be a valid css selector, or will break collapse function -->
        

        <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>
        

        

        


        <!-- must be a valid css selector, or will break collapse function -->
        

        <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="che-tektonpipelines.html"
            class="bg-light list-group-item list-group-item-action flex-column align-items-start"
            data-url="che-tektonpipelines.html">
            Configuring Codewind for Tekton pipelines
        </a>
        

        

        
        <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>
    <!-- MAIN -->
    <div id="content-container">
        <div class="py-5 px-5">
            <div class="cw-docs-spacer"></div>
            <div role="main"><h1 id="openshift-do-odo-support-in-codewind">OpenShift Do (odo) support in Codewind</h1>

<p>The Codewind odo extension supports <a href="https://github.com/openshift/odo">OpenShift Do (odo)</a>. You can use the extension to efficiently write, build, and deploy components on an OpenShift or OKD cluster.</p>

<ol>
  <li><a href="#extension-overview">Extension overview</a></li>
  <li><a href="#setting-up-the-extension">Setting up the extension</a></li>
  <li><a href="#current-limitations">Current limitations</a></li>
</ol>

<h2 id="extension-overview">Extension overview</h2>

<ul>
  <li>Compatible with Eclipse Che for Codewind and using Codewind remotely.</li>
  <li>Supports Java, Node.js, Python, and Perl components.</li>
  <li>Provides OpenShift templates to help you create components with different supported languages.</li>
  <li>Imports and enables continued development of your existing components.</li>
</ul>

<h2 id="setting-up-the-extension">Setting up the extension</h2>

<h3 id="prerequisites">Prerequisites</h3>

<ul>
  <li><a href="che-installinfo.html">Install</a> Codewind on Che on an OpenShift cluster.</li>
</ul>

<h3 id="adding-roles-to-support-the-extension">Adding roles to support the extension</h3>

<p>The extension needs additional roles for accessing OpenShift resources. Use the following commands to clone the <a href="https://github.com/eclipse/codewind-odo-extension">codewind-odo-extension</a> repository, create the <code class="highlighter-rouge">ClusterRole</code> with the required permissions, and bind that <code class="highlighter-rouge">ClusterRole</code> to the corresponding Codewind service account.</p>

<h3 id="importing-the-java-image-stream-to-your-openshift-or-okd-cluster">Importing the Java image stream to your OpenShift or OKD cluster</h3>

<p>To create or import a Java component, you must import the Java image stream to your OpenShift or OKD cluster so that odo can build the component image.</p>

<h3 id="adding-the-roles-and-importing-the-java-image-stream">Adding the roles and importing the Java image stream</h3>

<ol>
  <li>Log in to your OpenShift or Origin Community Distribution (OKD) cluster and ensure that the Codewind workspace is created.</li>
  <li>Enter the following commands to go to the correct location, add the roles and import the Java image stream, and perform cleanup:
    <div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>git clone https://github.com/eclipse/codewind-odo-extension &amp;&amp;\
cd ./codewind-odo-extension/setup &amp;&amp;\
./setup.sh
cd - &amp;&amp;\
rm -rf codewind-odo-extension
</code></pre></div>    </div>
  </li>
</ol>

<h2 id="current-limitations">Current limitations</h2>

<ul>
  <li>Supports only Codewind for Eclipse Che on an OpenShift or OKD cluster.</li>
  <li>Does not support project configuration.</li>
  <li>Does not support debug mode.</li>
  <li>Does not have HTTPS protocol support for accessing applications.</li>
</ul>
</div>
        </div>

        <div class="py-5 px-5 text-right">
            Last update: May 27, 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>