<html><head>
<link rel="stylesheet" href="../../default_style.css">
<title>Eclipse Foundation</title></head>
<body text="#000000" bgcolor="#ffffff" link="#0000ee" vlink="#551a8b" alink="#ff0000">
<table border=0 cellspacing=5 cellpadding=2 width="100%" >
  <tr> 
    <td align=left width="72%"> <font class=indextop> Business Information and<br>
      Reporting Tools</font><br>
      <font class=indexsub>&nbsp; </font></td>
    <td width="28%"><img src="../../images/Idea.jpg" height=86 width=120></td>
  </tr>
</table>
<table border=0 cellspacing=5 cellpadding=2 width="100%" >
  <tr> 
    <td align="left" valign="top" bgcolor="#0080C0"><b><font color="#FFFFFF" face="Arial,Helvetica">Press release</font></b></td>
  </tr>
  <tr> 
    <td> <br>
      <h1 ALIGN="CENTER"><b><span style='font-size:16.0pt;font-family:Arial;"Times New Roman"'><b> 
        Eclipse Foundation and Actuate Announce Approval of <br>
        Business Intelligence and Reporting Tools Project </b></span></b></h1>
      <ul>
        <li>Industry Analysts Applaud Actuate's Bold Move in Open Source</li>
      </ul>
      <P>South San Francisco, Calif. - October 6, 2004 - Actuate Corporation (NASDAQ: 
        ACTU), the world leader in Enterprise Reporting Applications, and the 
        Eclipse Foundation, a community committed to the implementation of a universal 
        platform for tools integration, today announced that the Eclipse Foundation 
        has officially approved the Business Intelligence and Reporting Tools 
        (BIRT) Project. Thirty days after posting the BIRT proposal on the Eclipse 
        website, there has been a positive response from Open Source developers 
        who have given feedback to the first Eclipse-backed BI project.</p>
      <P> &quot;The Eclipse community and our board members are pleased to accept 
        BIRT as a top level project,&quot; said Mike Milinkovich, executive director 
        of the Eclipse Foundation, Inc. &quot;The volume of positive feedback 
        received in response to the BIRT proposal clearly demonstrates the need 
        for a Business Intelligence and reporting tool as part of the Eclipse 
        technology portfolio.&quot;</p>
      <P>Now that the BIRT project has been officially approved by Eclipse, Actuate 
        will begin the task of stewarding development of BIRT, which is expected 
        to culminate in the industry's first open Business Intelligence and Reporting 
        platform by early 2005. Industry analysts agree that BIRT will benefit 
        developers and Actuate by expanding the visibility of business intelligence 
        and reporting to a wide audience of developers. These developers require 
        easy to use tools, such as BIRT, to decrease development costs associated 
        with the core application functions of reporting and analysis. <br>
      </p>
      <P><b>Industry Analysts Embrace Actuate's Decision to Support BI Open Source 
        Development</b></p>
      <P><b>Forrester Research</b><br>
        &quot;Actuate is being aggressive in an area where most of its competitors 
        choose not to be: open-source,&quot; noted Keith Gile, senior analyst, 
        Forrester Research. In his September 2004 report, Actuate Pioneers Open 
        Source Business Intelligence And Reporting, he adds that &quot;BI vendors 
        that have avoided participation in an open-source initiative need to rethink 
        this approach, and ideally get involved, as open-source will be an issue 
        that must be addressed sooner than later.&quot;</p>
      <P><b>Gartner</b><br>
        On 26 August 2004 Bill Hostmann, research director, Gartner Research and 
        Mark Driver, vice president and research director, Gartner Research co-authored 
        an article entitled &quot;Actuate Brings BI Technology to Open Source 
        Group.&quot; The full text of their analysis is available at: http://www.actuate.com/download/actuate_brings_.pdf<br>
      </p>
      <P><b>IDC</b><br>
        &quot;Actuate could realize strong pull-through revenue from its involvement 
        in the Eclipse community,&quot; said Dan Vesset, research director, IDC. 
        &quot;Should demand for an open source reporting standard exist, Actuate's 
        active participation in Eclipse is a positive strategic move that could 
        give it first-mover advantage in this open source community.&quot;</p>
      <P><b>META Group</b><br>
        &quot;Actuate will be building BIRT from the ground up (i.e. no Actuate 
        iServer code will be used). However, application developers without a 
        core BI and reporting standard will be able to use a free open source 
        tool to embed with the applications they develop,&quot; said Kurt Schlegel, 
        senior program director, META Group.</p>
      <P><b>Ventana Research</b><br>
        &quot;The Eclipse Foundation's Java IDE technology reaches thousands if 
        not millions of Java developers. Adding BIRT to the Eclipse project portfolio 
        means these developers now gain similar access to business intelligence 
        technology,&quot; said Eric Rogge, vice president and research director, 
        Ventana Research. &quot;BIRT will benefit from Actuate's experience and 
        competence in enterprise reporting. Actuate will benefit by expanding 
        their visibility in a community where the need for reporting technology 
        is growing.&quot;</p>
      <P><b>Actuate to Steward BIRT Development Roadmap</b> <br>
        &quot;Actuate is honored to have the opportunity to collaborate with the 
        Eclipse community to build a strong Open Source foundation for Business 
        Intelligence and reporting,&quot; said Mark Coggins, senior vice president 
        of engineering at Actuate Corporation. &quot;Our goal is to provide cooperative 
        leadership in the quest to bring developers an easy-to-use tool that will 
        help decrease Business Intelligence and reporting development costs and 
        increase innovation in this area. Now that BIRT is approved, the next 
        order of business is to post a set of project milestones for the technology.&quot; 
      </p>
      <P>The BIRT Project will leverage the Eclipse platform to provide infrastructure 
        and tools for designing, deploying, generating and viewing reports. BIRT 
        will be an easy-to-use platform to quickly and effectively create and 
        deploy reports without the high development cost associated with having 
        the developer hand-code the reports components. </p>
      <P><b>To Find Out More</b><br>
        To become involved in the development of BIRT please visit <a href="http://www.eclipse.org/proposals/eclipse-birt/index.html" target="_top">www.eclipse.org/proposals/eclipse-birt/index.html</a>. 
        More information is available at: <a href="http://www.actuate.com/corporate/corporateresources.asp?ArticleId=7256" target="_blank">www.actuate.com/corporate/corporateresources.asp?ArticleId=7256</a>. 
        <br>
      </p>
      </td>
  </tr>
  </table>
<table width="100%" cellspacing=0 cellpadding=3 align=center>
		<tr bgcolor="#999999">
		
    <td align="left" valign="top" bgcolor="#0080C0"><b><font color="#FFFFFF" face="Arial,Helvetica">About 
      Eclipse</font></b></td>
		</TR>
		<TR>
		<td align=left>
		<TABLE  width="100%" CELLSPACING=0 CELLPADDING=3>
		<tr>
		  <td> 
            <P> The Eclipse Foundation is a not-for-profit, member-supported corporation 
              that hosts community based open-source projects. Eclipse creates 
              royalty-free technology and a universal platform for development 
              tools integration, modeling, testing and functionally-rich application 
              construction. Eclipse based offerings give developers freedom of 
              choice in a multi-language, multi-platform, multi-vendor supported 
              environment. Eclipse delivers a dynamic plug-in based framework 
              that makes it easier to create and integrate technology, saving 
              time and money. By collaborating and sharing core integration technology, 
              technology providers can concentrate and focus on areas of expertise 
              and differentiation. The Eclipse Platform is written in the Java 
              language and comes with extensive plug-in construction toolkits 
              and examples. It has already been deployed on a range of development 
              workstations including Linux, QNX, Mac OS X and Windows-based systems. 
              Full details of the Eclipse Foundation and white papers documenting 
              the design of the Eclipse Platform are available at <a href="http://www.eclipse.org" target="_top">www.eclipse.org</a>.</p>
            </td>
		</tr>
        </table></table>&nbsp;
<table width="100%" cellspacing=0 cellpadding=3 align=center>
		<tr bgcolor="#999999">
		
    <td align="left" valign="top" bgcolor="#0080C0"><b><font color="#FFFFFF" face="Arial,Helvetica">About 
      Actuate Corporation</font></b></td>
		</TR>
		<TR>
		<td align=left>
		<TABLE  width="100%" CELLSPACING=0 CELLPADDING=3>
		<tr>
		  <td> 
            <P> Actuate Corporation is the world leader in Enterprise Reporting 
              Applications that ensure 100% adoption by users. Actuate's Enterprise 
              Reporting Application Platform is the foundation on which Global 
              9000 organizations (companies with annual revenues greater than 
              $1 billion) and packaged application software vendors develop intuitive, 
              Web portal-like reporting and analytic applications that empower 
              100% of users with decision-making information. These applications 
              are deployed inside and outside the firewall to improve corporate 
              performance across a range of business functions including financial 
              management, sales, human resource management, and customer self-service. 
              When tested against other business intelligence products, Actuate's 
              Enterprise Reporting Application Platform has been proven to offer 
              industry-leading scalability and the lowest Total Cost of Ownership. 
              Actuate has 2,900 customers globally in a range of industries including 
              financial services, pharmaceuticals, insurance, and distribution 
              services, as well as the government sector. <br>
              <br>
              Founded in 1993, Actuate has headquarters in South San Francisco, 
              Calif., and has offices worldwide. Actuate is listed on the NASDAQ 
              exchange under the symbol ACTU. For more information on Actuate, 
              visit the company's web site at <a href="http://www.actuate.com" target="_blank">www.actuate.com</a>.<br>
            </p>
            </td>
		</tr>
        </table></table>&nbsp;
	<table width="100%" cellspacing=0 cellpadding=3 align=center>
		<tr bgcolor="#999999">
    <td align="left" valign="top" bgcolor="#0080C0"><b><font color="#FFFFFF" face="Arial,Helvetica">Media 
      contact</font></b></td>
		</TR>
		</table>
		
<table width="100%" border="0" cellspacing="5">
  <tr>
    <td width="50%"> 
      <div align="center">Madge Miller <br>
        Reichert Communications for Actuate Corporation <br>
        madge@reichertcom.com <br>
        415.296.5131 </div>
    </td>
    <td width="50%"> 
      <div align="center">Barbara Stewart <br>
        Patterson & Associates for Eclipse Foundation <br>
        barbara@patterson.com <br>
        480.488.6909 </div>
    </td>
  </tr>
</table>
		<TABLE  width="100%" CELLSPACING=0 CELLPADDING=3>
		<tr>
		  <td> 
            <hr width="85%">
      <P>Copyright&copy; 2004 Actuate Corporation. All rights reserved. Actuate 
        and the Actuate logo are registered trademarks of Actuate Corporation 
        and/or its affiliates in the U.S. and certain other countries. All other 
        brands, names or trademarks mentioned may be trademarks of their respective 
        owners. </P>
      <P>Brand or product names are registered trademarks or trademarks of their 
        respective holders. Java and all Java-based trademarks are trademarks 
        or registered trademarks of Sun Microsystems, Inc. in the United States 
        and other countries.<br>
      </P>
<hr width="85%">
    </td>
		</tr>
        </table>&nbsp;        
&nbsp;
</body></html>
