<html xmlns="http://www.w3.org/1999/xhtml" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:v="urn:schemas-microsoft-com:vml" lang="en"><head>
    <title>Eclipse Foundation Member Newsletter – June-July 2023</title>
    <meta property="og:title" content="Eclipse Foundation Member Newsletter – June-July 2023">
    <meta name="twitter:title" content="Eclipse Foundation Member Newsletter – June-July 2023">
    
    
    
<meta name="x-apple-disable-message-reformatting">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<meta http-equiv="X-UA-Compatible" content="IE=edge">

<meta name="viewport" content="width=device-width, initial-scale=1.0">


    <!--[if gte mso 9]>
  <xml>
      <o:OfficeDocumentSettings>
      <o:AllowPNG/>
      <o:PixelsPerInch>96</o:PixelsPerInch>
      </o:OfficeDocumentSettings>
  </xml>
  
  <style>
    ul > li {
      text-indent: -1em;
    }
  </style>
<![endif]-->
<!--[if mso]>
<style type="text/css">
 body, td {font-family: Arial, Helvetica, sans-serif;}
 .hse-body-wrapper-table {background-color: #f2f2f2;padding: 20px 0 !important}
</style>
<![endif]-->


    






      








    


  <meta name="generator" content="HubSpot"><meta property="og:url" content="http://eclipse-5413615.hs-sites.com/eclipse-foundation-member-newsletter-june-july-2023"><meta name="robots" content="noindex,follow"><!--[if !((mso)|(IE))]><!-- --><style type="text/css">.moz-text-html .hse-column-container{max-width:600px !important;width:600px !important}
.moz-text-html .hse-column{display:table-cell;vertical-align:top}.moz-text-html .hse-section .hse-size-3{max-width:150px !important;width:150px !important}
.moz-text-html .hse-section .hse-size-6{max-width:300px !important;width:300px !important}
.moz-text-html .hse-section .hse-size-9{max-width:450px !important;width:450px !important}
.moz-text-html .hse-section .hse-size-12{max-width:600px !important;width:600px !important}
@media only screen and (min-width:640px){.hse-column-container{max-width:600px !important;width:600px !important}
.hse-column{display:table-cell;vertical-align:top}.hse-section .hse-size-3{max-width:150px !important;width:150px !important}
.hse-section .hse-size-6{max-width:300px !important;width:300px !important}.hse-section .hse-size-9{max-width:450px !important;width:450px !important}
.hse-section .hse-size-12{max-width:600px !important;width:600px !important}}@media only screen and (max-width:639px){img.stretch-on-mobile,.hs_rss_email_entries_table img,.hs-stretch-cta .hs-cta-img{height:auto !important;width:100% !important}
.display_block_on_small_screens{display:block}.hs_padded{padding-left:20px !important;padding-right:20px !important}
ul,blockquote{margin:0;padding:1em 40px}}@media screen and (max-width:639px){.social-network-cell{display:inline-block}
}</style><!--<![endif]--><style type="text/css">a[x-apple-data-detectors]{color:inherit !important;text-decoration:none !important;font-size:inherit !important;font-family:inherit !important;font-weight:inherit !important;line-height:inherit !important}
a{text-decoration:underline}p{margin:0}body{-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%;-webkit-font-smoothing:antialiased;moz-osx-font-smoothing:grayscale}</style></head>
  <body bgcolor="#f2f2f2" style="margin:0 !important; padding:0 !important; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word"><style type="text/css" hs-compress-css-scope="body">.olm-fragment-custom img.stretch-on-mobile,.olm-fragment-custom .hs_rss_email_entries_table img{height:auto !important;width:100% !important}
.olm-fragment-custom .hs_padded{padding-left:20px !important;padding-right:20px !important}</style>
    


<div id="preview_text" style="display:none;font-size:1px;color:#f2f2f2;line-height:1px;max-height:0px;max-width:0px;opacity:0;overflow:hidden;">We want to keep you informed! Here's a list of our new members and a breakdown of all the recent activity at the Eclipse Foundation.  </div>


    
<!--[if gte mso 9]>
<v:background xmlns:v="urn:schemas-microsoft-com:vml" fill="t">
    <v:fill type="tile" size="100%,100%" color="#ffffff"/>
</v:background>
<![endif]-->

    <div class="hse-body-background" style="background-color:#f2f2f2" bgcolor="#f2f2f2">
      <table role="presentation" class="hse-body-wrapper-table" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; margin:0; padding:0; width:100% !important; min-width:320px !important; height:100% !important" width="100%" height="100%">
        <tbody><tr>
          <td class="hse-body-wrapper-td" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding-top:20px">
            <div id="hs_cos_wrapper_main" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_dnd_area" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="dnd_area">  <div id="section_1647523498602" class="hse-section hse-section-first" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;" cellpadding="0" cellspacing="0" role="presentation">
      <tr>
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_1647523498602_0" class="hse-column hse-size-12">
  <div id="hs_cos_wrapper_module_164752349858541" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<div style="overflow:hidden">
<table role="presentation" class="hse-pre-header hse-secondary" width="100%" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; text-align:right; font-family:Arial, sans-serif; font-size:12px; line-height:135%; color:#23496d; margin-bottom:0; padding:0" align="right">
    <tbody>
        <tr>
            
            <td align="right" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; color:#444444; word-break:break-word; text-align:right; font-family:Arial, sans-serif; font-size:12px; padding:10px 0; margin-bottom:0; line-height:135%">
                <a href="http://eclipse-5413615.hs-sites.com/eclipse-foundation-member-newsletter-june-july-2023?ecid=&amp;utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" style="mso-line-height-rule:exactly; color:#F79422; font-weight:normal; text-decoration:underline; font-style:normal" data-hs-link-id="0" target="_blank">View in browser</a>
            </td>
            
        </tr>
    </tbody>
</table>
</div></div>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_2" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border hse-border-top" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; border-top:1px solid #cccccc; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc;border-top:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border hse-border-top" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_2_0" class="hse-column hse-size-12">
  <div id="hs_cos_wrapper_module_16273954429038" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><table class="hse-image-wrapper" role="presentation" width="100%" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt">
  <tbody>
    <tr>
      <td align="center" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; color:#444444; word-break:break-word; text-align:center; padding:10px 20px; font-size:0px">
        <img alt="Member newsletteer header (2)" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Member%20newsletteer%20header%20(2).gif?upscale=true&amp;width=1116&amp;upscale=true&amp;name=Member%20newsletteer%20header%20(2).gif" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; max-width:100%; font-size:16px" width="558" align="middle" srcset="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Member%20newsletteer%20header%20(2).gif?upscale=true&amp;width=1116&amp;upscale=true&amp;name=Member%20newsletteer%20header%20(2).gif 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Member%20newsletteer%20header%20(2).gif?upscale=true&amp;width=2232&amp;upscale=true&amp;name=Member%20newsletteer%20header%20(2).gif 1116w" sizes="(max-width: 558px) 100vw, 558px">
      </td>
    </tr>
  </tbody>
</table></div>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1586291145041102" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1586291145041102_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<ul style="mso-line-height-rule:exactly; line-height:175%">
<li style="mso-line-height-rule:exactly"><span style="color: #3d3935;">Thank you for Attending July's General Assembly Meeting&nbsp;</span></li>
<li style="mso-line-height-rule:exactly"><span style="color: #3d3935;">Reminder of Fee Changes for Existing Members Coming in 2024&nbsp;</span></li>
<li style="mso-line-height-rule:exactly"><span style="color: #3d3935;">EclipseCon: Early-bird registration, Community Day &amp; Last Chance to Sponsor</span></li>
<li style="mso-line-height-rule:exactly"><span style="color: #3d3935;">Join the SDV Hackathon at Accenture Munich&nbsp;</span></li>
<li style="mso-line-height-rule:exactly"><span style="color: #3d3935;">Theiacon 2023 - Call for Presentations is Open</span></li>
<li style="mso-line-height-rule:exactly"><span style="color: #3d3935;">OSPO Alliance News</span></li>
<li style="mso-line-height-rule:exactly"><span style="color: #3d3935;">Eclipse Foundation Publishes Results of Equinox p2 Security Audit</span></li>
<li style="mso-line-height-rule:exactly"><span style="color: #3d3935;">Featured Community: Eclipse OpenVSX</span></li>
<li style="mso-line-height-rule:exactly"><span style="color: #3d3935;">New Members and Industry Collaborations</span></li>
<li style="mso-line-height-rule:exactly">Upcoming Events</li>
</ul></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="module_1673968334569" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#FFFFFF" bgcolor="#FFFFFF">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#FFFFFF">
      <tr style="background-color:#FFFFFF;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="module_1673968334569_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_16762741173248" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<div style="line-height: 0; font-size: 0px">
  <v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
    <v:fill type="tile"/>
    <v:textbox inset="0,0,0,0">

      <div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
  <tbody><tr>
    
    
    
    <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:2pt solid #000000; border-bottom-width:1px"><!--[if mso 16]>&nbsp;<![endif]--></td>
    
    
  </tr>
</tbody></table>


<!--[if gte mso 9]></div></v:textbox></v:rect></div><![endif]--></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16841436614163" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16841436614163_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h2 style="margin:0; mso-line-height-rule:exactly; font-size:22px; text-align:center; line-height:150%" align="center">&nbsp;Thank you for Attending July's General Assembly Meeting&nbsp;</h2></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16739683345244" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16739683345244_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%">An Extraordinary General Assembly (EGA) of the Eclipse Foundation AISBL was held on <span style="font-weight: bold;">July 26, 2023</span>. At the meeting, the Foundation’s auditor presented his report to the members. The general assembly <span style="font-weight: bold;">approved the</span> <span style="font-weight: bold;">annual accounts</span> of the previous financial year, <span style="font-weight: bold;">voted on the discharge of the directors</span> and the <span style="font-weight: bold;">statutory auditor(s)</span>, and <span style="font-weight: bold;">approved the revised 2023 budget</span> as submitted by the Board of Directors.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">We thank all our member representatives who either participated directly in the meeting or provided their input in advance.&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center">&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><em>The General Assembly as set forth in Section V.1. of the Eclipse Foundation AISBL Bylaws is the supreme body of the Eclipse Foundation. It supervises the Board and ensures the achievement of the Purpose of the Eclipse Foundation.</em></p></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_16841436538052" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<div style="line-height: 0; font-size: 0px">
  <v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
    <v:fill type="tile"/>
    <v:textbox inset="0,0,0,0">

      <div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
  <tbody><tr>
    
    
    
    <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:2pt solid #000000; border-bottom-width:1px"><!--[if mso 16]>&nbsp;<![endif]--></td>
    
    
  </tr>
</tbody></table>


<!--[if gte mso 9]></div></v:textbox></v:rect></div><![endif]--></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16878668239923" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16878668239923_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h2 style="margin:0; mso-line-height-rule:exactly; font-size:22px; text-align:center; line-height:150%" align="center">&nbsp;Reminder of Fee Changes for Existing Members Coming in 2024</h2></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16878668785334" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16878668785334_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%">As we have been doing throughout the year, we want to remind all members that last year the board of directors <span style="font-weight: bold;">approved a change in the annual membership fees</span> for all <span style="font-weight: bold;">Strategic, Contributing and Associate members</span>. After careful consideration and analysis of various factors, inflation has been identified as the primary cause of the fee increase. The Board based this difficult decision to adjust the fees, due primarily to inflationary pressures, in order to maintain the high level of service and support that our members have come to expect. We understand that the increase may be an inconvenience for some members, but we believe it is <span style="font-weight: bold;">necessary to ensure the long-term sustainability and growth of the organization. </span>The new fees take effect for existing members upon each Member’s renewal date in 2024, so there are no changes to your renewal fees for 2023.&nbsp;<br>Members are reminded to include the new fees in their 2024 budget planning.&nbsp;<br>You can check the <a href="https://www.eclipse.org/membership/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I#tab-fees" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">updated fees on our website</a>.&nbsp;<br>For more information, please contact <span style="font-weight: bold; color: #f88d2b;"><a href="mailto:membership.coordination@eclipse-foundation.org" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">membership.coordination@eclipse-foundation.org</a>.</span></p></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_16878668193882" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<div style="line-height: 0; font-size: 0px">
  <v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
    <v:fill type="tile"/>
    <v:textbox inset="0,0,0,0">

      <div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
  <tbody><tr>
    
    
    
    <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:2pt solid #000000; border-bottom-width:1px"><!--[if mso 16]>&nbsp;<![endif]--></td>
    
    
  </tr>
</tbody></table>


<!--[if gte mso 9]></div></v:textbox></v:rect></div><![endif]--></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_1684254304234" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#100f0f" bgcolor="#100f0f">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#100f0f">
      <tr style="background-color:#100f0f;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_1684254304234_0" class="hse-column hse-size-12">
  <div id="hs_cos_wrapper_module_16762722393274" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><table class="hse-image-wrapper" role="presentation" width="100%" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt">
  <tbody>
    <tr>
      <td align="center" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; color:#444444; word-break:break-word; text-align:center; padding:5px 20px 15px; font-size:0px">
        <a href="https://www.eclipsecon.org/2023?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" target="_blank" style="color:#00a4bd; mso-line-height-rule:exactly" data-hs-link-id="0">
        <img alt="Canva Design DAFnBMMcnr4" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Canva%20images/Canva%20Design%20DAFnBMMcnr4.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=Canva%20Design%20DAFnBMMcnr4.png" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; max-width:100%; font-size:16px" width="558" align="middle" srcset="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Canva%20images/Canva%20Design%20DAFnBMMcnr4.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=Canva%20Design%20DAFnBMMcnr4.png 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Canva%20images/Canva%20Design%20DAFnBMMcnr4.png?upscale=true&amp;width=2232&amp;upscale=true&amp;name=Canva%20Design%20DAFnBMMcnr4.png 1116w" sizes="(max-width: 558px) 100vw, 558px">
        </a>
      </td>
    </tr>
  </tbody>
</table></div>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16762741173246" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16762741173246_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h2 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-size:22px; text-align:center" align="center"><span style="color: #ffffff;">Register before the price increases</span></h2></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16762741173247" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16762741173247_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://www.eclipsecon.org/2023/registration?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Registration</a> <span style="color: #ffffff;">is open, and the</span> <a href="https://www.eclipsecon.org/2023/schedule/2023-10-17?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">schedule</a> <span style="color: #ffffff;">is now online for EclipseCon 2023, happening October 16 - 19 in Ludwigsburg, Germany. Don’t miss out the chance to get your ticket at the <span style="font-weight: bold;">early-bird price</span>.&nbsp;</span></p></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16921834330733" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16921834330733_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h2 style="margin:0; mso-line-height-rule:exactly; font-size:22px; text-align:center; line-height:150%" align="center"><span style="color: #ffffff;">Sign up for Community Day</span></h2></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16921834394114" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16921834394114_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #ffffff;">Make sure to visit the</span> <a href="https://www.eclipsecon.org/2023/community-day?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Community Day page</a> <span style="color: #ffffff;">and see what the</span> <span style="color: #ffffff;">various projects and industry collaboration groups are planning for Monday, October 16.</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #ffffff;">Adding Community Day to your registration allows you to join sessions and learn more about a diverse array of topics, such as <span style="font-weight: bold;">Java development, IoT, IDEs, cloud-based tools, the software-defined vehicle</span> and other automotive initiatives, and much more.</span></p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:175%"><span style="font-size: 15px;"><span style="color: #000000;">&nbsp;</span></span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #ffffff;">Get your</span> <a href="https://eclipsecon.regfox.com/eclipsecon-2023?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Community Day Pass</a> <span style="color: #ffffff;">for only <span style="font-weight: bold; color: #f88d2b;">€40</span></span><span style="font-weight: bold; color: #f88d2b;">&nbsp;</span></p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:175%">&nbsp;</p></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16921832534851" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16921832534851_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h2 style="margin:0; mso-line-height-rule:exactly; font-size:22px; text-align:center; line-height:150%" align="center"><span style="color: #ffffff;">Book your Hotel Room</span></h2></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16814717679432" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16814717679432_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #ffffff;">If you plan to stay at the Nestor Hotel, we recommend that you</span> <a href="https://www.eclipsecon.org/2023/hotel?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">book your room</a><span style="font-weight: bold;"> <span style="color: #ff9902;">by </span></span><span style="color: #ffffff;"><span style="font-weight: bold; color: #ff9902;">August 31 for the lowest rate</span> and best availability. After that date, nights may be sold out, and the room rate is no longer guaranteed.</span></p></div></div></td></tr></tbody></table>
<div id="hs_cos_wrapper_module_16841429746561" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><table class="hse-image-wrapper" role="presentation" width="100%" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt">
  <tbody>
    <tr>
      <td align="center" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; color:#444444; word-break:break-word; text-align:center; padding:5px 20px 15px; font-size:0px">
        <a href="https://www.eclipsecon.org/2023/prospectus?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" target="_blank" style="color:#00a4bd; mso-line-height-rule:exactly" data-hs-link-id="0">
        <img alt="Untitled design (3)-2" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Untitled%20design%20(3)-2.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=Untitled%20design%20(3)-2.png" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; max-width:100%; font-size:16px" width="558" align="middle" srcset="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Untitled%20design%20(3)-2.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=Untitled%20design%20(3)-2.png 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Untitled%20design%20(3)-2.png?upscale=true&amp;width=2232&amp;upscale=true&amp;name=Untitled%20design%20(3)-2.png 1116w" sizes="(max-width: 558px) 100vw, 558px">
        </a>
      </td>
    </tr>
  </tbody>
</table></div>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16814717629511" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16814717629511_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h2 style="margin:0; mso-line-height-rule:exactly; font-size:22px; text-align:center; line-height:150%" align="center"><span style="color: #ffffff;">Become an EclipseCon Sponsor</span></h2></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16921832730162" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16921832730162_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; font-size:15px; line-height:175%"><span style="color: #ffffff;">Don't miss out on your last opportunity to sponsor EclipseCon 2023 in Ludwigsburg and connect with the open-source community in person. Limited booth spaces are available, so reserve your spot now by checking our sponsorship prospectus page. Email us at <a href="mailto:sponsors@eclipsecon.org" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank"><span style="color: #f88d2b;">sponsors@eclipsecon.org</span></a> for any inquiries. </span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #ffffff;">Join us from October 16-19, 2023! </span><span style="font-size: 15px;"><a href="https://www.eclipsecon.org/2023/prospectus?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">Learn more</a><span style="color: #000000;">.</span></span></p></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_169218625681012" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<div style="line-height: 0; font-size: 0px">
  <v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
    <v:fill type="tile"/>
    <v:textbox inset="0,0,0,0">

      <div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
  <tbody><tr>
    
    
    
    <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #FFFFFF; mso-border-bottom-alt:2pt solid #FFFFFF; border-bottom-width:1px"><!--[if mso 16]>&nbsp;<![endif]--></td>
    
    
  </tr>
</tbody></table>


<!--[if gte mso 9]></div></v:textbox></v:rect></div><![endif]--></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_1688989283574" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_1688989283574_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16921856123396" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16921856123396_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h2 style="margin:0; mso-line-height-rule:exactly; font-size:22px; text-align:center; line-height:150%" align="center">Join Eclipse SDV Hackathon Challenge</h2></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16819142890342" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16819142890342_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%">Join us at the<span style="font-weight: bold;"> SDV Hackathon on November 28-30, 2023</span>. “<span style="font-weight: bold;">Build the car of the future - use current Eclipse SDV projects to solve real automotive challenges</span>!” &nbsp;The event is being held at Accenture’s facilities in Munich, Germany.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">Be among the first to participate in a solely automotive software hack challenge that will revolutionize the future software-connected vehicle. If you have coding skills and you are passionate about cars and mobility,<span style="font-weight: bold;"> this is your chance to showcase your creativity and skills</span>.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">This event will provide an opportunity for tech enthusiasts and innovative minds to showcase their skills and creativity in Eclipse SDV projects and compete in a team.&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:justify" align="justify">You will be led through the two-and-a-half day coding marathon by our mentors from major OEMs, Tier 1 and automotive technology companies including <span style="font-weight: bold;">Mercedes-Benz Tech Innovation, Bosch, ETAS, Continental, Microsoft, and more</span>. Our experienced Hack Coaches will be guiding you through the two tracks: SDV Tooling and SDV Blueprints and help you bring to life innovative use cases and features built on top of existing real-life automotive software projects.&nbsp;</p></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_169218623960111" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">



  

























  <table align="center" border="0" cellpadding="0" cellspacing="0" role="presentation" style="border-spacing:0 !important; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:separate!important">
    <tbody><tr>
        <!--[if mso]>
      <td align="center" valign="middle" bgcolor="#F88D2B" valign="middle" style="border-radius:8px;cursor:auto;background-color:#F88D2B;padding:12px 18px;">
    <![endif]-->
    <!--[if !mso]><!-- -->
      <td align="center" valign="middle" bgcolor="#F88D2B" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; border-radius:8px; cursor:auto; background-color:#F88D2B">
   <!--<![endif]-->
        <a href="https://forms.gle/t5NXKw2PmtVsBhAY7?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" target="_blank" style="color:#00a4bd; mso-line-height-rule:exactly; font-size:16px; font-family:arial, helvetica, sans-serif; Margin:0; text-transform:none; text-decoration:none; padding:12px 18px; display:block" data-hs-link-id="0">
          <strong style="color:#ffffff;font-weight:normal;text-decoration:none;font-style:normal;">Register</strong>
        </a>
      </td>
    </tr>
  </tbody></table>
</div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_169218627571713" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<div style="line-height: 0; font-size: 0px">
  <v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
    <v:fill type="tile"/>
    <v:textbox inset="0,0,0,0">

      <div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
  <tbody><tr>
    
    
    
    <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #3D3935; mso-border-bottom-alt:2pt solid #3D3935; border-bottom-width:1px"><!--[if mso 16]>&nbsp;<![endif]--></td>
    
    
  </tr>
</tbody></table>


<!--[if gte mso 9]></div></v:textbox></v:rect></div><![endif]--></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16921861146569" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16921861146569_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h2 style="margin:0; mso-line-height-rule:exactly; font-size:22px; text-align:center; line-height:150%" align="center">Theiacon 2023 - Call for Presentations is Open</h2></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_169218611809110" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_169218611809110_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%">Join <a href="https://events.eclipse.org/2023/theiacon/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">TheiaCon 2023</a>, the annual virtual conference focused on the Eclipse Theia IDE ecosystem. Connect with developers, adopters, and contributors from various backgrounds. The conference will feature full-length talks, expert panel discussions, and lightning talks. Share your expertise, insights, and contributions by <a href="https://docs.google.com/forms/d/e/1FAIpQLScj5BE1K_Yo6spy7eZKUEePluqFuF8QgLMnj57zmyBhH8-L-g/viewform?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">submitting a presentation proposal</a>.</p>
<p style="mso-line-height-rule:exactly; line-height:175%; font-weight:bold">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; font-weight:bold"><span style="color: #f88d2b;">Important Dates:</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #3d3935;"><span style="font-weight: bold;">Presentation Submission Deadline</span>: October 2, 2023</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="font-weight: bold; color: #3d3935;">Conference Dates</span>: November 15-16, 2023</p></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16921857328948" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">



  

























  <table align="center" border="0" cellpadding="0" cellspacing="0" role="presentation" style="border-spacing:0 !important; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:separate!important">
    <tbody><tr>
        <!--[if mso]>
      <td align="center" valign="middle" bgcolor="#F88D2B" valign="middle" style="border-radius:8px;cursor:auto;background-color:#F88D2B;padding:12px 18px;">
    <![endif]-->
    <!--[if !mso]><!-- -->
      <td align="center" valign="middle" bgcolor="#F88D2B" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; border-radius:8px; cursor:auto; background-color:#F88D2B">
   <!--<![endif]-->
        <a href="https://docs.google.com/forms/d/e/1FAIpQLScj5BE1K_Yo6spy7eZKUEePluqFuF8QgLMnj57zmyBhH8-L-g/viewform?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" target="_blank" style="color:#00a4bd; mso-line-height-rule:exactly; font-size:16px; font-family:arial, helvetica, sans-serif; Margin:0; text-transform:none; text-decoration:none; padding:12px 18px; display:block" data-hs-link-id="1">
          <strong style="color:#ffffff;font-weight:normal;text-decoration:none;font-style:normal;">Submit your proposal</strong>
        </a>
      </td>
    </tr>
  </tbody></table>
</div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_16819142998653" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<div style="line-height: 0; font-size: 0px">
  <v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
    <v:fill type="tile"/>
    <v:textbox inset="0,0,0,0">

      <div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
  <tbody><tr>
    
    
    
    <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #3D3935; mso-border-bottom-alt:2pt solid #3D3935; border-bottom-width:1px"><!--[if mso 16]>&nbsp;<![endif]--></td>
    
    
  </tr>
</tbody></table>


<!--[if gte mso 9]></div></v:textbox></v:rect></div><![endif]--></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="module_1666373212442" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="module_1666373212442_0" class="hse-column hse-size-12">
  <div id="hs_cos_wrapper_module_16878703821805" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><table class="hse-image-wrapper" role="presentation" width="100%" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt">
  <tbody>
    <tr>
      <td align="center" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; color:#444444; word-break:break-word; text-align:center; padding:10px 20px; font-size:0px">
        <img alt="Canva Design DAFnBAuS9g4" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Canva%20images/Canva%20Design%20DAFnBAuS9g4.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=Canva%20Design%20DAFnBAuS9g4.png" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; max-width:100%; font-size:16px" width="558" align="middle" srcset="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Canva%20images/Canva%20Design%20DAFnBAuS9g4.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=Canva%20Design%20DAFnBAuS9g4.png 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Canva%20images/Canva%20Design%20DAFnBAuS9g4.png?upscale=true&amp;width=2232&amp;upscale=true&amp;name=Canva%20Design%20DAFnBAuS9g4.png 1116w" sizes="(max-width: 558px) 100vw, 558px">
      </td>
    </tr>
  </tbody>
</table></div>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16819142809531" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16819142809531_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h2 style="margin:0; mso-line-height-rule:exactly; font-size:22px; text-align:center; line-height:150%" align="center">What's the OSPO Alliance?</h2></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16921856323047" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16921856323047_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%">An <span style="font-weight: bold;">Open Source Program Office</span> can be seen as the connection between your organisation and the larger Open Source ecosystem. In 2021, the Eclipse Foundation co-created the OSPO Alliance, together with a group of other<a href="https://ospo-alliance.org/membership/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank"> European organisations</a>. Eclipse Foundation members willing to take their Open Source awareness and skills to the next level will find a whole range of curated resources to help them. Whether it's about <span style="font-weight: bold;">starting an Open Source Program Office </span>from scratch with the <a href="https://ospo-alliance.org/ggi/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank"><strong>Good Governance Initiative</strong> </a>or benefiting from the experience of your peers who regularly come to give feedback during<a href="https://ospo-alliance.org/onramp/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank"> <strong>OnRamp sessions</strong></a>.These initiatives are practical solutions to professionalize the management of open source software, inbound and outbound, making engaging with open source software less risky and more predictable. These are great and valuable complementary resources to those you can find on the Eclipse Foundation's website.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">Our resources are designed to make participation as easy as possible: <span style="font-weight: bold;">there is no financial commitment or formal membership associated with supporting the OSPO</span> Alliance. <a href="https://ospo-alliance.org/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Learn more</a>&nbsp;</p></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_16473587215094" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<div style="line-height: 0; font-size: 0px">
  <v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
    <v:fill type="tile"/>
    <v:textbox inset="0,0,0,0">

      <div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
  <tbody><tr>
    
    
    
    <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:2pt solid #000000; border-bottom-width:1px"><!--[if mso 16]>&nbsp;<![endif]--></td>
    
    
  </tr>
</tbody></table>


<!--[if gte mso 9]></div></v:textbox></v:rect></div><![endif]--></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16889892896143" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16889892896143_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h2 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-size:22px">Eclipse Foundation Publishes Results of Equinox p2 Security Audit</h2>
<p style="mso-line-height-rule:exactly; line-height:175%">Securing the open source software supply chain is one of the Eclipse Foundation’s top priorities, and our recent security audit for Equinox p2 is an important part of this effort. As the provisioning component of the Eclipse IDE, Equinox p2 was a logical choice for our first security audit. Identifying and addressing vulnerabilities of any provisioning system is a critically important aspect of supply chain security, as fixing the vulnerabilities discovered in the audit lowers the risk of developers installing malware when obtaining extensions from the internet.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">If you are interested in an audit of your Eclipse project or in joining the <span style="font-weight: bold;">Eclipse Cyber Risk Initiative</span>, feel free to reach out to our security team <a href="mailto:security@eclipse-foundation.org" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">security@eclipse-foundation.org</a>. &nbsp;<a href="https://blogs.eclipse.org/post/mika%C3%ABl-barbero/eclipse-foundation-publishes-results-equinox-p2-security-audit?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Learn more</a></p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_1645020379900" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_1645020379900_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_16921855540195" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<div style="line-height: 0; font-size: 0px">
  <v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
    <v:fill type="tile"/>
    <v:textbox inset="0,0,0,0">

      <div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
  <tbody><tr>
    
    
    
    <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:2pt solid #000000; border-bottom-width:1px"><!--[if mso 16]>&nbsp;<![endif]--></td>
    
    
  </tr>
</tbody></table>


<!--[if gte mso 9]></div></v:textbox></v:rect></div><![endif]--></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="module_1673949977244" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="module_1673949977244_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16473590477546" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16473590477546_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h2 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-size:22px; text-align:center" align="center">Featured Community: OpenVSX</h2></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_1679067798590" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:149px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="149" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:149px">
<![endif]-->
<div id="column_1681908236222_0" class="hse-column hse-size-3">
  <div id="hs_cos_wrapper_module_167040758352012" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><table class="hse-image-wrapper" role="presentation" width="100%" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt">
  <tbody>
    <tr>
      <td align="center" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; color:#444444; word-break:break-word; text-align:center; padding:46px 20px 10px; font-size:0px">
        <img alt="openvsx-registry" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/openvsx-registry.webp?upscale=true&amp;width=218&amp;upscale=true&amp;name=openvsx-registry.webp" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; max-width:100%; font-size:16px" width="109" align="middle" srcset="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/openvsx-registry.webp?upscale=true&amp;width=218&amp;upscale=true&amp;name=openvsx-registry.webp 109w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/openvsx-registry.webp?upscale=true&amp;width=436&amp;upscale=true&amp;name=openvsx-registry.webp 218w" sizes="(max-width: 109px) 100vw, 109px">
      </td>
    </tr>
  </tbody>
</table></div>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->

<!--[if (mso)|(IE)]>
  <td valign="top" style="width:448px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="448" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:448px">
<![endif]-->
<div id="column_1679067798590_0" class="hse-column hse-size-9">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16819082731042" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16819082731042_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%">Open VSX is an Eclipse open source project and alternative to the Visual Studio Marketplace.&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://open-vsx.org/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Learn more</a>&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_1679067812964" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_1679067812965_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16790677576451" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16790677576451_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%"><strong>Get Featured</strong></p>
<p style="mso-line-height-rule:exactly; line-height:175%">Each issue of the member newsletter will feature different working groups. Leaders of working groups wishing to be featured during a particular month should contact <a href="mailto:marketing@eclipse.org" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">marketing@eclipse.org</a>.</p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_8" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#f79422" bgcolor="#f79422">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#f79422">
      <tr style="background-color:#f79422;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_8_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1586443203069146" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1586443203069146_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center"><span style="color: #ffffff; font-size: 24px;"><strong>Upcoming Events</strong></span></p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_9" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_9_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1586443203069148" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1586443203069148_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%"><a href="https://www.crowdcast.io/c/jakartatechtalk-09062023?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Jakarta Tech Talk</a> | September 6, 2023</div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%">
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #3d3935;"><span style="color: #000000;"><a href="https://www.crowdcast.io/e/vecm-14092023?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Eclipse IDE Webinar 2023-09</a> | September 14, 2023</span></span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #3d3935;"><span style="color: #000000;"><a href="https://ghc.anitab.org/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Open Source Day for Grace Hopper 2023</a> | September 22-23, 2023</span></span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #3d3935;"><span style="color: #000000;"><a href="https://foss-security-campus.de/trainings/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I#shop" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">FOSS Security Campus Trainings</a> | September 26-27, 2023</span></span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #3d3935;"><span style="color: #000000;"><a href="https://www.bitkom.org/EN/bfoss23?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Bitkom Forum Open Source</a> | September 27, 2023</span></span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #3d3935;"><span style="color: #000000;"><a href="https://www.etas.com/en/company/etas-connections-2023.php?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">SDV Developer Day at ETAS Connections</a> | September 28, 2024</span></span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://www.eclipsecon.org/2023?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">EclipseCon</a><span style="color: #000000;"> | October 16-19, 2023</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #000000;"><a href="https://events.eclipse.org/2023/esaam2023/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">ESAAM 2023</a> | October 17, 2023</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #000000;"><a href="https://www.jasa.or.jp/expo/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">EdgeTech+ 2023</a> | November 15-16, 2023<br><a href="https://events.eclipse.org/2023/theiacon/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">TheiaCon</a> | November 15-16, 2023</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #000000;"><a href="https://wardsauto.informa.com/autotech-europe/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Autotech Europe</a> | November 14-16, 2023</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #000000;"><a href="https://www.crowdcast.io/c/jakartane-05122023?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Jakartaone Livestream 2023 </a>| December 5-6, 2023</span></p>
</div></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_10" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#f79422" bgcolor="#f79422">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#f79422">
      <tr style="background-color:#f79422;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_10_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1573062770099374" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1573062770099374_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center"><span style="font-size: 24px;"><strong><span style="color: #ffffff;">New Members and Industry Collaborations</span></strong></span></p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="module_1662745371169" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="module_1662745371169_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px 0px"><div id="hs_cos_wrapper_module_16627453711395" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16627453711395_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center">For the month of July 2023</p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_1670408034911" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:299px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="299" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:299px">
<![endif]-->
<div id="column_1670408034911_0" class="hse-column hse-size-6">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_167040805346514" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_167040805346514_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h2 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-size:22px">Contributing Members</h2>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://www.polito.it/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Politecnico di Torino</a></p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->

<!--[if (mso)|(IE)]>
  <td valign="top" style="width:299px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="299" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:299px">
<![endif]-->
<div id="column_1670408034911_2" class="hse-column hse-size-6">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_167040847416916" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_167040847416916_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h2 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-size:22px">Industry Collaborations</h2>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><strong>OpenVSX</strong></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://engineering.salesforce.com/open-source/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">SalesForce</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #3d3935;"><strong>Models for Privacy Engineering</strong></span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #f88d2b;"><a href="https://datainmotion.com/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" style="mso-line-height-rule:exactly; color:#f88d2b" rel="noopener" data-hs-link-id="0" target="_blank"><span style="font-size: 15px;">Data in Motion</span></a></span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #3d3935;"><strong>openMobility</strong></span><strong><span style="color: #000000;"><br></span></strong><span style="color: #f88d2b;"><a href="https://www.vector.com/int/en/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" style="mso-line-height-rule:exactly; color:#f88d2b" rel="noopener" data-hs-link-id="0" target="_blank">Vector Informatik<strong> GmbH</strong></a></span></p>
<ul style="mso-line-height-rule:exactly; line-height:175%"></ul></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_13" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_13_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1591621523496211" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">

<table role="presentation" align="center" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; width:auto; text-align:center" class="hs_cos_wrapper_type_social_module" width="auto">
  <tbody>
    <tr align="center">
      

      
        
      

      <td class="social-network-cell" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">
        <table role="presentation" align="center" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; width:auto; text-align:center" class="hs_cos_wrapper_type_social_module_single" width="auto">
          <tbody>
            <tr align="center">
              
              <td class="display_block_on_small_screens" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:8px 5px; line-height:1; vertical-align:middle" valign="middle">
                <a href="http://www.facebook.com/share.php?u=&amp;utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" style="color:#00a4bd; mso-line-height-rule:exactly; text-decoration:none !important" data-hs-link-id="0" target="_blank">
                  
                  
                  <img src="https://hs-5413615.f.hubspotemail.net/hs/hsstatic/TemplateAssets/static-1.114/img/hs_default_template_images/modules/Follow+Me+-+Email/facebook_square_color.png" alt="Facebook" height="25" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; width:auto!important; height:25px!important; vertical-align:middle" valign="middle">
                  
                </a>
              </td>
              
              
            </tr>
          </tbody>
        </table>
      </td>
      

      
        
      

      <td class="social-network-cell" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">
        <table role="presentation" align="center" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; width:auto; text-align:center" class="hs_cos_wrapper_type_social_module_single" width="auto">
          <tbody>
            <tr align="center">
              
              <td class="display_block_on_small_screens" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:8px 5px; line-height:1; vertical-align:middle" valign="middle">
                <a href="http://www.linkedin.com/shareArticle?mini=true&amp;url=&amp;utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" style="color:#00a4bd; mso-line-height-rule:exactly; text-decoration:none !important" data-hs-link-id="0" target="_blank">
                  
                  
                  <img src="https://hs-5413615.f.hubspotemail.net/hs/hsstatic/TemplateAssets/static-1.114/img/hs_default_template_images/modules/Follow+Me+-+Email/linkedin_square_color.png" alt="LinkedIn" height="25" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; width:auto!important; height:25px!important; vertical-align:middle" valign="middle">
                  
                </a>
              </td>
              
              
            </tr>
          </tbody>
        </table>
      </td>
      

      
        
      

      <td class="social-network-cell" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">
        <table role="presentation" align="center" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; width:auto; text-align:center" class="hs_cos_wrapper_type_social_module_single" width="auto">
          <tbody>
            <tr align="center">
              
              <td class="display_block_on_small_screens" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:8px 5px; line-height:1; vertical-align:middle" valign="middle">
                <a href="https://twitter.com/intent/tweet?original_referer=&amp;url=&amp;source=tweetbutton&amp;text=&amp;utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" style="color:#00a4bd; mso-line-height-rule:exactly; text-decoration:none !important" data-hs-link-id="0" target="_blank">
                  
                  
                  <img src="https://hs-5413615.f.hubspotemail.net/hs/hsstatic/TemplateAssets/static-1.114/img/hs_default_template_images/modules/Follow+Me+-+Email/twitter_square_color.png" alt="Twitter" height="25" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; width:auto!important; height:25px!important; vertical-align:middle" valign="middle">
                  
                </a>
              </td>
              
              
            </tr>
          </tbody>
        </table>
      </td>
      

      
        
      

      <td class="social-network-cell" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">
        <table role="presentation" align="center" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; width:auto; text-align:center" class="hs_cos_wrapper_type_social_module_single" width="auto">
          <tbody>
            <tr align="center">
              
              <td class="display_block_on_small_screens" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:8px 5px; line-height:1; vertical-align:middle" valign="middle">
                <a href="http://pinterest.com/pin/create/button/?url=&amp;media=&amp;utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--GZjmZ2BIB7yPzOJQZH6PJpz9Zrj53K5j5fjLRFjeRUv9IE8tSyfFJb4O0iYRmsaFsyb5I" style="color:#00a4bd; mso-line-height-rule:exactly; text-decoration:none !important" data-hs-link-id="0" target="_blank">
                  
                  
                  <img src="https://hs-5413615.f.hubspotemail.net/hs/hsstatic/TemplateAssets/static-1.114/img/hs_default_template_images/modules/Follow+Me+-+Email/pinterest_square_color.png" alt="Pinterest" height="25" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; width:auto!important; height:25px!important; vertical-align:middle" valign="middle">
                  
                </a>
              </td>
              
              
            </tr>
          </tbody>
        </table>
      </td>
      

      
        
      

      <td class="social-network-cell" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">
        <table role="presentation" align="center" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; width:auto; text-align:center" class="hs_cos_wrapper_type_social_module_single" width="auto">
          <tbody>
            <tr align="center">
              
              <td class="display_block_on_small_screens" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:8px 5px; line-height:1; vertical-align:middle" valign="middle">
                <a href="mailto:?subject=Check%20out%20%20&amp;body=Check%20out" style="color:#00a4bd; mso-line-height-rule:exactly; text-decoration:none !important" data-hs-link-id="0" target="_blank">
                  
                  
                  <img src="https://hs-5413615.f.hubspotemail.net/hs/hsstatic/TemplateAssets/static-1.114/img/hs_default_template_images/modules/Follow+Me+-+Email/mail_square_color.png" alt="Email" height="25" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; width:auto!important; height:25px!important; vertical-align:middle" valign="middle">
                  
                </a>
              </td>
              
              
            </tr>
          </tbody>
        </table>
      </td>
      
    </tr>
  </tbody>
</table>

</div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_14" class="hse-section" style="padding-left:10px; padding-right:10px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container hse-border-bottom hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; border-bottom:1px solid #cccccc; background-color:#ffffff" bgcolor="#ffffff">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-bottom:1px solid #cccccc;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border-bottom hse-border" width="600" bgcolor="#ffffff">
      <tr style="background-color:#ffffff;">
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_14_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1519309286486146" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1519309286486146_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h4 style="font-size:15px; margin:0; mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center"><span style="color: #646c7a;">Copyright © 2023 Eclipse Foundation. All rights reserved.</span></h4></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>

  <div id="section_15" class="hse-section hse-section-last" style="padding-left:10px; padding-right:10px; padding-bottom:20px">

    
    
    <!--[if !((mso)|(IE))]><!-- -->
      <div class="hse-column-container" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; padding-bottom:10px; padding-top:10px">
    <!--<![endif]-->
    
    <!--[if (mso)|(IE)]>
      <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
      <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;" cellpadding="0" cellspacing="0" role="presentation">
      <tr>
    <![endif]-->

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;padding-bottom:10px; padding-top:10px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_15_0" class="hse-column hse-size-12">
  <div id="hs_cos_wrapper_module_1477051461677107532" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">








  



  
  
  
  
  
  


















<table role="presentation" class="hse-footer hse-secondary" width="100%" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; font-family:Arial, sans-serif; font-size:12px; line-height:135%; color:#23496d; margin-bottom:0; padding:0">
    <tbody>
        <tr>
            <td align="center" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; text-align:center; margin-bottom:0; line-height:135%; padding:10px 20px">
                
                <p style="mso-line-height-rule:exactly; font-family:arial, helvetica, sans-serif; font-size:12px; font-weight:normal; text-decoration:none; font-style:normal; color:#23496d; direction:lrt" dir="lrt">
                  Eclipse Foundation, Rond Point Robert Schuman, Brussels, Belgium 1040
                </p>
                <p style="mso-line-height-rule:exactly">
                  
                  <a data-unsubscribe="true" href="#" style="mso-line-height-rule:exactly; font-family:helvetica; font-size:12px; color:#F79422; font-weight:normal; text-decoration:underline; font-style:normal" data-hs-link-id="0" target="_blank">Unsubscribe</a>
                  
                  <a data-unsubscribe="true" href="#" style="mso-line-height-rule:exactly; font-family:helvetica; font-size:12px; color:#F79422; font-weight:normal; text-decoration:underline; font-style:normal" data-hs-link-id="0" target="_blank">Manage preferences</a>
                  
                </p>
                
            </td>
        </tr>
    </tbody>
</table></div>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


    <!--[if (mso)|(IE)]></tr></table><![endif]-->

    </div>
   
  </div>
</div>
          </td>
        </tr>
      </tbody></table>
    </div>
  
</body></html>