---
layout: post
status: PUBLISHED
published: true
title: Introducing the Haddock template
author:
  display_name: Dave Koelmeyer
  login: davekoelmeyer
  email: dave.koelmeyer@dave.koelmeyer.co.nz
author_login: davekoelmeyer
author_email: dave.koelmeyer@dave.koelmeyer.co.nz
id: e38731cb-64e0-4e07-b4f0-b968107a9a5f
date: '2018-01-13 01:42:40 -0500'
categories:
- General
tags:
- haddock
comments: []
permalink: jspwiki/entry/introducing_the_haddock_template
---
<p>As mentioned in our <a href="https://blogs.apache.org/jspwiki/entry/a_new_blog_home_for" target="_blank" title="JSPWiki's inaugral blog post">inaugural blog post</a>, JSPWiki has a new template named <em><a href="https://jspwiki-wiki.apache.org/Wiki.jsp?page=Haddock%20Template" title="Link to more information on the Haddock template" target="_blank">Haddock</a></em>. It's been refined over the past several developer releases, and we feel it can now serve as the default, production-ready template for your JSPWiki installation. Let's take a look at some highlights.</p>
<h4>A new user interface<br /></h4>
<p>Haddock features a clean, modern look and feel which builds upon the <a href="http://getbootstrap.com/" title="Link to the Bootstrap framework" target="_blank">Bootstrap</a> framework. While our legacy default template has served us well over the years, Haddock is a huge leap forward for JSPWiki's user interface. </p>
<p>JSPWiki's legacy template:</p>
<p> <img src="https://blogs.apache.org/jspwiki/mediaresource/67497430-6080-438d-b68d-2aedf10c925f" alt="JSPWiki's legacy template" width="891" height="529" /></p></p>
<p>The Haddock template:</p>
<p> <img src="https://blogs.apache.org/jspwiki/mediaresource/9ea75fac-165c-4780-a6a5-aaacf59eb20e" alt="The JSPWiki Haddock template" width="891" height="653" /></p></p>
<p>The legacy template and associated skins are still available, but future user interface development will be focused on Haddock.</p>
<h4>A new editing experience</h4>
<p>Haddock ships with a brand-new plain editor, packed with new features. Smart typing pairs, automatic suggestions, and tab completion with snippets hugely accelerate the process of adding wiki content. Search and replace has been moved to a floating window, live content previewing is now available in a split-screen view, and the editor interface has been streamlined to display certain commands only when needed. And for folks who prefer a WYSIWYG experience, Haddock ships with a new WYSIWYG editor as well.</p>
<p>These are only some of Haddock's new editing features, and we'll be highlighting a selection in upcoming blog posts. For now, check out everything Haddock is capable of here: </p>
<ul>
<li><a href="https://jspwiki-wiki.apache.org/Wiki.jsp?page=Haddock%20Template" title="Link to more information on the Haddock template" target="_blank">https://jspwiki-wiki.apache.org/Wiki.jsp?page=Haddock%20Template</a></li>
</ul>
<h4>Under-the-hood changes</h4>
<p>Haddock's improvements don't just run skin-deep. Javascript and CSS files have been modularised for easier maintenance and reduced complexity (enabling for example straightfoward creation of custom dynamic styles). <a href="https://github.com/mishoo/UglifyJS" title="Link to UglifyJS" target="_blank">UglifyJS</a> and <a href="https://github.com/wro4j/wro4j" title="Link to wro4j" target="_blank">wro4j</a> are used to reduce application loading times. Net result? The speediest JSPWiki yet.</p>
<h4>Trying Haddock out <br /></h4>
<p>Using Haddock is <a href="https://jspwiki-wiki.apache.org/Wiki.jsp?page=Haddock%20Template" title="Link to information on enabling Haddock" target="_blank">easy</a>, and a great way to instantly supercharge your existing JSPWiki site. For any problems, support or feedback, let us know on our <a href="https://jspwiki.apache.org/community/mailing_lists.html" title="Link to the JSPWiki mailling lists" target="_blank">mailing lists</a>.</p>
<ul> </ul>
