public class IndexOfMethod implements TemplateMethodModel {

     public TemplateModel exec(List args) throws TemplateModelException {
         if (args.size() != 2) {
             throw new TemplateModelException("Wrong arguments");
         }
         return new SimpleNumber(
             ((String) args.get(1)).indexOf((String) args.get(0)));
     }
 }

root.put("indexOf", new IndexOfMethod());

 <#assign x = "something">
 ${indexOf("met", x)}
 ${indexOf("foo", x)}

 2
 -1

 foo
 <@upper>
   bar
   <#-- All kind of FTL is allowed here -->
   <#list ["red", "green", "blue"] as color>
     ${color}
   </#list>
   baaz
 </@upper>
 wombat

 foo
   BAR
     RED
     GREEN
     BLUE
   BAAZ
 wombat

 package com.example;
 import java.io.IOException;
 import java.io.Writer;
 import java.util.Map;

 import freemarker.core.Environment;
 import freemarker.template.TemplateDirectiveBody;
 import freemarker.template.TemplateDirectiveModel;
 import freemarker.template.TemplateException;
 import freemarker.template.TemplateModel;
 import freemarker.template.TemplateModelException;

 /**
  *  FreeMarker user-defined directive that progressively transforms
  *  the output of its nested content to upper-case.
  *
  *
  *  <p><b>Directive info</b></p>
  *
  *  <p>Directive parameters: None
  *  <p>Loop variables: None
  *  <p>Directive nested content: Yes
  */
 public class UpperDirective implements TemplateDirectiveModel {

     public void execute(Environment env,
             Map params, TemplateModel[] loopVars,
             TemplateDirectiveBody body)
             throws TemplateException, IOException {
         // Check if no parameters were given:
         if (!params.isEmpty()) {
             throw new TemplateModelException(
                     "This directive doesn't allow parameters.");
         }
         if (loopVars.length != 0) {
                 throw new TemplateModelException(
                     "This directive doesn't allow loop variables.");
         }

         // If there is non-empty nested content:
         if (body != null) {
             // Executes the nested body. Same as <#nested> in FTL, except
             // that we use our own writer instead of the current output writer.
             body.render(new UpperCaseFilterWriter(env.getOut()));
         } else {
             throw new RuntimeException("missing body");
         }
     }

     /**
      * A {@link Writer} that transforms the character stream to upper case
      * and forwards it to another {@link Writer}.
      */
     private static class UpperCaseFilterWriter extends Writer {

         private final Writer out;

         UpperCaseFilterWriter (Writer out) {
             this.out = out;
         }

         public void write(char[] cbuf, int off, int len)
                 throws IOException {
             char[] transformedCbuf = new char[len];
             for (int i = 0; i < len; i++) {
                 transformedCbuf[i] = Character.toUpperCase(cbuf[i + off]);
             }
             out.write(transformedCbuf);
         }

         public void flush() throws IOException {
             out.flush();
         }

         public void close() throws IOException {
             out.close();
         }
     }

 }

root.put("upper", new com.example.UpperDirective());

 <#-- Maybe you have directives that you have implemented in FTL -->
 <#macro something>
   ...
 </#macro>

 <#-- Now you can't use <#macro upper>, but instead you can: -->
 <#assign upper = "com.example.UpperDirective"?new()>

 <#assign x = 1>

 <@repeat count=4>
   Test ${x}
   <#assign x++>
 </@repeat>

 <@repeat count=3 hr=true>
   Test
 </@repeat>

 <@repeat count=3; cnt>
   ${cnt}. Test
 </@repeat>

 Test 1
  Test 2
  Test 3
  Test 4

  Test
<hr>  Test
<hr>  Test

  1. Test
  2. Test
  3. Test

 package com.example;
 import java.io.IOException;
 import java.io.Writer;
 import java.util.Iterator;
 import java.util.Map;

 import freemarker.core.Environment;
 import freemarker.template.SimpleNumber;
 import freemarker.template.TemplateBooleanModel;
 import freemarker.template.TemplateDirectiveBody;
 import freemarker.template.TemplateDirectiveModel;
 import freemarker.template.TemplateException;
 import freemarker.template.TemplateModel;
 import freemarker.template.TemplateModelException;
 import freemarker.template.TemplateNumberModel;

 /**
  * FreeMarker user-defined directive for repeating a section of a template,
  * optionally with separating the output of the repetations with
  * <tt>&lt;hr></tt>-s.
  *
  *
  * <p><b>Directive info</b></p>
  *
  * <p>Parameters:
  * <ul>
  *   <li><code>count</code>: The number of repetations. Required!
  *       Must be a non-negative number. If it is not a whole number then it will
  *       be rounded <em>down</em>.
  *   <li><code>hr</code>: Tells if a HTML "hr" element could be printed between
  *       repetations. Boolean. Optional, defaults to <code>false</code>.
  * </ul>
  *
  * <p>Loop variables: One, optional. It gives the number of the current
  *    repetation, starting from 1.
  *
  * <p>Nested content: Yes
  */
 public class RepeatDirective implements TemplateDirectiveModel {

     private static final String PARAM_NAME_COUNT = "count";
     private static final String PARAM_NAME_HR = "hr";

     public void execute(Environment env,
             Map params, TemplateModel[] loopVars,
             TemplateDirectiveBody body)
             throws TemplateException, IOException {

         // ---------------------------------------------------------------------
         // Processing the parameters:

         int countParam = 0;
         boolean countParamSet = false;
         boolean hrParam = false;

         Iterator paramIter = params.entrySet().iterator();
         while (paramIter.hasNext()) {
             Map.Entry ent = (Map.Entry) paramIter.next();

             String paramName = (String) ent.getKey();
             TemplateModel paramValue = (TemplateModel) ent.getValue();

             if (paramName.equals(PARAM_NAME_COUNT)) {
                 if (!(paramValue instanceof TemplateNumberModel)) {
                     throw new TemplateModelException(
                             "The \"" + PARAM_NAME_HR + "\" parameter "
                             + "must be a number.");
                 }
                 countParam = ((TemplateNumberModel) paramValue)
                         .getAsNumber().intValue();
                 countParamSet = true;
                 if (countParam < 0) {
                     throw new TemplateModelException(
                             "The \"" + PARAM_NAME_HR + "\" parameter "
                             + "can't be negative.");
                 }
             } else if (paramName.equals(PARAM_NAME_HR)) {
                 if (!(paramValue instanceof TemplateBooleanModel)) {
                     throw new TemplateModelException(
                             "The \"" + PARAM_NAME_HR + "\" parameter "
                             + "must be a boolean.");
                 }
                 hrParam = ((TemplateBooleanModel) paramValue)
                         .getAsBoolean();
             } else {
                 throw new TemplateModelException(
                         "Unsupported parameter: " + paramName);
             }
         }
         if (!countParamSet) {
                 throw new TemplateModelException(
                         "The required \"" + PARAM_NAME_COUNT + "\" paramter"
                         + "is missing.");
         }

         if (loopVars.length > 1) {
                 throw new TemplateModelException(
                         "At most one loop variable is allowed.");
         }

         // Yeah, it was long and boring...

         // ---------------------------------------------------------------------
         // Do the actual directive execution:

         Writer out = env.getOut();
         if (body != null) {
             for (int i = 0; i < countParam; i++) {
                 // Prints a <hr> between all repetations if the "hr" parameter
                 // was true:
                 if (hrParam && i != 0) {
                     out.write("<hr>");
                 }

                 // Set the loop variable, if there is one:
                 if (loopVars.length > 0) {
                     loopVars[0] = new SimpleNumber(i + 1);
                 }

                 // Executes the nested body (same as <#nested> in FTL). In this
                 // case we don't provide a special writer as the parameter:
                 body.render(env.getOut());
             }
         }
     }

 }

 package com.example.myapp;

 public class Tupple<E1, E2> {
     public Tupple(E1 e1, E2 e2) { ... }
     public E1 getE1() { ... }
     public E2 getE2() { ... }
 }

 package com.example.myapp.freemarker;

 ...

 public class TuppleAdapter extends WrappingTemplateModel implements TemplateSequenceModel,
         AdapterTemplateModel {

     private final Tupple<?, ?> tupple;

     public TuppleAdapter(Tupple<?, ?> tupple, ObjectWrapper ow) {
         super(ow);  // coming from WrappingTemplateModel
         this.tupple = tupple;
     }

     @Override  // coming from TemplateSequenceModel
     public int size() throws TemplateModelException {
         return 2;
     }

     @Override  // coming from TemplateSequenceModel
     public TemplateModel get(int index) throws TemplateModelException {
         switch (index) {
         case 0: return wrap(tupple.getE1());
         case 1: return wrap(tupple.getE2());
         default: return null;
         }
     }

     @Override  // coming from AdapterTemplateModel
     public Object getAdaptedObject(Class hint) {
         return tupple;
     }

 }

 package com.example.myapp.freemarker;

 ...

 public class MyAppObjectWrapper extends DefaultObjectWrapper {

     public MyAppObjectWrapper(Version incompatibleImprovements) {
         super(incompatibleImprovements);
     }

     @Override
     protected TemplateModel handleUnknownType(final Object obj) throws TemplateModelException {
         if (obj instanceof Tupple) {
             return new TuppleAdapter((Tupple<?, ?>) obj, this);
         }

         return super.handleUnknownType(obj);
     }

 }

 // Where you initialize the cfg *singleton* (happens just once in the application life-cycle):
 cfg = new Configuration(Configuration.VERSION_2_3_22);
 ...
 cfg.setObjectWrapper(new MyAppObjectWrapper(cfg.getIncompatibleImprovements()));

object_wrapper=com.example.myapp.freemarker.MyAppObjectWrapper(2.3.22)