<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>

<head>
<title>Epsilon</title>
<link rel="stylesheet" href="book.css" charset="utf-8" type="text/css">
</head>

<body>
	<div id="contents">
		<a href="https://www.eclipse.org/epsilon/"><img class="logo"
			src="epsilon-logo.svg"></img></a> <i>(Note: please manually open in a
			new tab of your web browser any hyperlink not opening as expected)</i>
		<h1>What is Epsilon?</h1>
		<p>
			<a href="https://www.eclipse.org/epsilon/">Epsilon</a> is a family of
			Java-based scripting languages for automating common model-based
			software engineering tasks, such as code generation, model-to-model
			transformation and model validation, that work out of the box with
			EMF (including Xtext and Sirius), UML, Simulink, XML and other types
			of models. Epsilon also includes Eclipse-based editors and debuggers,
			convenient reflective tools for textual modelling and model
			visualisation, and Apache Ant tasks.
		</p>

		<h1>Documentation</h1>
		<p>
			Epsilon's documentation is maintaned on its own external website. The
			<a href="https://www.eclipse.org/epsilon/doc/">overview</a> section
			of this website is the best place to look for documentation,
			examples, tutorials, screencasts and lectures.
		</p>

		<h1>Getting help</h1>
		<p>
			If you have a question that is not answered in the <a
				href="https://www.eclipse.org/epsilon/doc/">documentation</a> or in
			the <a href="https://www.eclipse.org/epsilon/faq/">frequently
				asqued questions</a> section, please send a message to the <a
				href="https://www.eclipse.org/forums/index.php/f/22/">Epsilon
				forum</a>.
		</p>

		<h1>Reporting bugs</h1>
		<p>
			If you believe you've found a bug in Epsilon, please consider <a
				href="https://bugs.eclipse.org/bugs/enter_bug.cgi?product=epsilon">submitting
				a bug report</a> to the Eclipse Bugzilla and we'll try to fix it as soon
			as possible.
		</p>
	</div>
</body>
</html>
