<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
	$pageTitle 		= "SMILA - Downloads";
	$pageKeywords	= "SMILA, Unified Information Access Architecture, unstructured information management, information logistics, semantic web, framework, platform, eclipse";
	$pageAuthor		= "Igor Novakovic";

	# Paste your HTML content between the EOHTML markers!
	$html = <<<EOHTML

	<div id="midcolumn">
		<h1>Downloads</h1>
		<h2>Releases</h2>
		<h3>0.9</h3>
		<p>
			The release <b>0.9</b> is the latest stable version of SMILA.
			<ul>
				<li>Linux 32 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/0.9/SMILA-incubation-0.9-linux.gtk.x86.zip">SMILA-incubation-0.9-linux.gtk.x86.zip</a></li>
				<li>Linux 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/0.9/SMILA-incubation-0.9-linux.gtk.x86_64.zip">SMILA-incubation-0.9-linux.gtk.x86_64.zip</a></li>
				<li>Mac OS X 64 Bit (Cocoa): <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/0.9/SMILA-incubation-0.9-macosx.cocoa.x86_64.zip">SMILA-incubation-0.9-macosx.cocoa.x86_64.zip</a></li>
				<li>Windows 32 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/0.9/SMILA-incubation-0.9-win32.win32.x86.zip">SMILA-incubation-0.9-win32.win32.x86.zip</a></li>
				<li>Windows 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/0.9/SMILA-incubation-0.9-win32.win32.x86_64.zip">SMILA-incubation-0.9-win32.win32.x86_64.zip</a></li>
				<li>SDK Examples (platform independent): <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/releases/0.9/SMILA-0.9-integrator-examples.zip">SMILA-0.9-integrator-examples.zip</a></li>
			</ul>
		</p>
		<h2>Milestones</h2>
		<h3>0.9 M1</h3>
		<p>
			<ul>
				<li>Linux 32 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/milestones/0.9-M1/SMILA-incubation-0.9-M1-linux.gtk.x86.zip">SMILA-incubation-0.9-M1-linux.gtk.x86.zip</a></li>
				<li>Linux 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/milestones/0.9-M1/SMILA-incubation-0.9-M1-linux.gtk.x86_64.zip">SMILA-incubation-0.9-M1-linux.gtk.x86_64.zip</a></li>
				<li>Mac OS X 64 Bit (Cocoa): <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/milestones/0.9-M1/SMILA-incubation-0.9-M1-macosx.cocoa.x86_64.zip">SMILA-incubation-0.9-M1-macosx.cocoa.x86_64.zip</a></li>
				<li>Windows 32 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/milestones/0.9-M1/SMILA-incubation-0.9-M1-win32.win32.x86.zip">SMILA-incubation-0.9-M1-win32.win32.x86.zip</a></li>
				<li>Windows 64 Bit: <a href="http://www.eclipse.org/downloads/download.php?file=/rt/smila/milestones/0.9-M1/SMILA-incubation-0.9-M1-win32.win32.x86_64.zip">SMILA-incubation-0.9-M1-win32.win32.x86_64.zip</a></li>
			</ul>
		</p>
		
		<h2>Archived releases and milestones</h2>
		<p>
			You can find older SMILA releases and milestones in our 
			<a href="downloads_archive.php">download archive</a>.
		</p>
		<h2>Nightly builds</h2>
		<p>
			The nightly builds are provided for now only for Linux and Windows. Please note that these builds
			have not been tested and that they actually reflect the status of the current development branch.
			<ul>
				<li><a href="http://build.eclipse.org/rt/smila/nightly/">SMILA nightly builds</a></li>
			</ul>
		</p>
		<h2>SMILA extensions for BPEL designer</h2>
		<p>
			Starting from release 0.8 we offer BPEL designer extensions for management of SMILA's workflows. 
			Detailed instructions on how to obtain the BPEL designer and install deploy our extensions int can be found 
			<a href="http://wiki.eclipse.org/SMILA/BPEL_Designer">here</a>.
		</p>
		<h2>Resources</h2>
		<p>
			If you would like to incorporate SMILA logo (e.g. "powered by SMILA") into your application or your website, here 
			are some graphics you can freely use:
			<table border="1" frame="border" >
				<tr>
					<td><img src="logo/SMILA_Icon.jpg" alt="SMILA icon" align="left" width="124" height="124"></td>
				</tr>
				<tr>
					<td><img src="logo/SMILA.gross.png" alt="SMILA with name - large" align="left" width="434" height="96"></td>
				</tr>
				<tr>
					<td><img src="logo/SMILA.Icon.tagline.jpg" alt="SMILA with tagline" align="left" width="124" height="163"></td>
				</tr>
				<tr>
					<td><img src="logo/SMILA_Tagline_Large.jpg" alt="SMILA with tagline - large" align="left" width="420" height="119"></td>
				</tr>
				<tr>
					<td><img src="logo/SMILA.powered.gross.jpg" alt="powered by SMILA - large" align="left" width="320" height="103"></td>
				</tr>
				<tr>
					<td><img src="logo/SMILA_powered_klein.jpg" alt="powered by SMILA" align="left" width="125" height="191"></td>
				</tr>
			</table>
		</p>
		<h2>SMILA Distributions</h2>
		<p>
			Free and Commercial Distributions of SMILA:
			<ul>
				<li>eccenca: <a href="http://www.eccenca.com">Find out more about the different editions of eccenca</a></li>
				<li>eccenca Marketplace: <a href="http://market.eccenca.com">Components to extend the capabilities of your SMILA and eccenca installation</a></li>
			</ul>
		</p>
	</div>

EOHTML;

	include('rightColumn.php');
	$html .= $rightColumn;

	# Generate the web page
	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>
